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.
12 #include "scrypt_mine.h"
25 class CRequestTracker;
28 static const unsigned int MAX_BLOCK_SIZE = 1000000;
29 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
30 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
31 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
32 static const unsigned int MAX_INV_SZ = 50000;
33 static const int64 MIN_TX_FEE = CENT;
34 static const int64 MIN_RELAY_TX_FEE = CENT;
35 static const int64 MAX_MONEY = 2000000000 * COIN;
36 static const int64 MAX_MINT_PROOF_OF_WORK = 100 * COIN;
37 static const int64 MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
38 static const int64 MIN_TXOUT_AMOUNT = MIN_TX_FEE;
40 static const unsigned int ENTROPY_SWITCH_TIME = 1362791041; // Sat, 09 Mar 2013 01:04:01 GMT
41 static const unsigned int STAKE_SWITCH_TIME = 1371686400; // Thu, 20 Jun 2013 00:00:00 GMT
42 static const unsigned int TARGETS_SWITCH_TIME = 1374278400; // Sat, 20 Jul 2013 00:00:00 GMT
43 static const unsigned int LOCKS_SWITCH_TIME = 1376956800; // Tue, 20 Aug 2013 00:00:00 GMT
44 static const unsigned int CHAINCHECKS_SWITCH_TIME = 1379635200; // Fri, 20 Sep 2013 00:00:00 GMT
45 static const unsigned int STAKECURVE_SWITCH_TIME = 1382227200; // Sun, 20 Oct 2013 00:00:00 GMT
46 static const unsigned int STAKEWEIGHT_SWITCH_TIME = 1388534400; // Wed, 01 Jan 2014 00:00:00 GMT
49 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
50 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
51 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
54 static const int fHaveUPnP = true;
56 static const int fHaveUPnP = false;
59 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
60 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
62 static const int64 nMaxClockDrift = 2 * 60 * 60; // two hours
64 extern CScript COINBASE_FLAGS;
67 extern CCriticalSection cs_main;
68 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
69 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
70 extern CBlockIndex* pindexGenesisBlock;
71 extern unsigned int nStakeMinAge;
72 extern int nCoinbaseMaturity;
73 extern int nBestHeight;
74 extern uint256 nBestChainTrust;
75 extern uint256 nBestInvalidTrust;
76 extern uint256 hashBestChain;
77 extern CBlockIndex* pindexBest;
78 extern unsigned int nTransactionsUpdated;
79 extern uint64 nLastBlockTx;
80 extern uint64 nLastBlockSize;
81 extern int64 nLastCoinStakeSearchInterval;
82 extern const std::string strMessageMagic;
83 extern double dHashesPerSec;
84 extern int64 nHPSTimerStart;
85 extern int64 nTimeBestReceived;
86 extern CCriticalSection cs_setpwalletRegistered;
87 extern std::set<CWallet*> setpwalletRegistered;
88 extern unsigned char pchMessageStart[4];
89 extern std::map<uint256, CBlock*> mapOrphanBlocks;
92 extern int64 nTransactionFee;
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);
115 CBlock* CreateNewBlock(CWallet* pwallet, bool fProofOfStake=false);
116 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
117 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
118 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
119 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
120 int64 GetProofOfWorkReward(unsigned int nBits);
121 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
122 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
123 int GetNumBlocksOfPeers();
124 bool IsInitialBlockDownload();
125 std::string GetWarnings(std::string strFor);
126 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
127 uint256 WantedByOrphan(const CBlock* pblockOrphan);
128 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
129 void BitcoinMiner(CWallet *pwallet, bool fProofOfStake);
130 void ResendWalletTransactions();
141 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
143 /** Position on disk for a particular transaction. */
148 unsigned int nBlockPos;
156 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
159 nBlockPos = nBlockPosIn;
163 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
164 void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
165 bool IsNull() const { return (nFile == (unsigned int) -1); }
167 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
169 return (a.nFile == b.nFile &&
170 a.nBlockPos == b.nBlockPos &&
171 a.nTxPos == b.nTxPos);
174 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
180 std::string ToString() const
185 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
190 printf("%s", ToString().c_str());
196 /** An inpoint - a combination of a transaction and an index n into its vin */
203 CInPoint() { SetNull(); }
204 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
205 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
206 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
211 /** An outpoint - a combination of a transaction hash and an index n into its vout */
218 COutPoint() { SetNull(); }
219 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
220 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
221 void SetNull() { hash = 0; n = (unsigned int) -1; }
222 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
224 friend bool operator<(const COutPoint& a, const COutPoint& b)
226 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
229 friend bool operator==(const COutPoint& a, const COutPoint& b)
231 return (a.hash == b.hash && a.n == b.n);
234 friend bool operator!=(const COutPoint& a, const COutPoint& b)
239 std::string ToString() const
241 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
246 printf("%s\n", ToString().c_str());
253 /** An input of a transaction. It contains the location of the previous
254 * transaction's output that it claims and a signature that matches the
255 * output's public key.
262 unsigned int nSequence;
266 nSequence = std::numeric_limits<unsigned int>::max();
269 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
272 scriptSig = scriptSigIn;
273 nSequence = nSequenceIn;
276 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
278 prevout = COutPoint(hashPrevTx, nOut);
279 scriptSig = scriptSigIn;
280 nSequence = nSequenceIn;
286 READWRITE(scriptSig);
287 READWRITE(nSequence);
292 return (nSequence == std::numeric_limits<unsigned int>::max());
295 friend bool operator==(const CTxIn& a, const CTxIn& b)
297 return (a.prevout == b.prevout &&
298 a.scriptSig == b.scriptSig &&
299 a.nSequence == b.nSequence);
302 friend bool operator!=(const CTxIn& a, const CTxIn& b)
307 std::string ToStringShort() const
309 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
312 std::string ToString() const
316 str += prevout.ToString();
317 if (prevout.IsNull())
318 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
320 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
321 if (nSequence != std::numeric_limits<unsigned int>::max())
322 str += strprintf(", nSequence=%u", nSequence);
329 printf("%s\n", ToString().c_str());
336 /** An output of a transaction. It contains the public key that the next input
337 * must be able to sign with to claim it.
343 CScript scriptPubKey;
350 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
353 scriptPubKey = scriptPubKeyIn;
359 READWRITE(scriptPubKey);
365 scriptPubKey.clear();
370 return (nValue == -1);
376 scriptPubKey.clear();
381 return (nValue == 0 && scriptPubKey.empty());
384 uint256 GetHash() const
386 return SerializeHash(*this);
389 friend bool operator==(const CTxOut& a, const CTxOut& b)
391 return (a.nValue == b.nValue &&
392 a.scriptPubKey == b.scriptPubKey);
395 friend bool operator!=(const CTxOut& a, const CTxOut& b)
400 std::string ToStringShort() const
402 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
405 std::string ToString() const
407 if (IsEmpty()) return "CTxOut(empty)";
408 if (scriptPubKey.size() < 6)
409 return "CTxOut(error)";
410 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
415 printf("%s\n", ToString().c_str());
429 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
431 /** The basic transaction that is broadcasted on the network and contained in
432 * blocks. A transaction can contain multiple inputs and outputs.
437 static const int CURRENT_VERSION=1;
440 std::vector<CTxIn> vin;
441 std::vector<CTxOut> vout;
442 unsigned int nLockTime;
444 // Denial-of-service detection:
446 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
455 READWRITE(this->nVersion);
456 nVersion = this->nVersion;
460 READWRITE(nLockTime);
465 nVersion = CTransaction::CURRENT_VERSION;
466 nTime = GetAdjustedTime();
470 nDoS = 0; // Denial-of-service prevention
475 return (vin.empty() && vout.empty());
478 uint256 GetHash() const
480 return SerializeHash(*this);
483 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
485 // Time based nLockTime implemented in 0.1.6
488 if (nBlockHeight == 0)
489 nBlockHeight = nBestHeight;
491 nBlockTime = GetAdjustedTime();
492 if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
494 BOOST_FOREACH(const CTxIn& txin, vin)
500 bool IsNewerThan(const CTransaction& old) const
502 if (vin.size() != old.vin.size())
504 for (unsigned int i = 0; i < vin.size(); i++)
505 if (vin[i].prevout != old.vin[i].prevout)
509 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
510 for (unsigned int i = 0; i < vin.size(); i++)
512 if (vin[i].nSequence != old.vin[i].nSequence)
514 if (vin[i].nSequence <= nLowest)
517 nLowest = vin[i].nSequence;
519 if (old.vin[i].nSequence < nLowest)
522 nLowest = old.vin[i].nSequence;
529 bool IsCoinBase() const
531 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
534 bool IsCoinStake() const
536 // ppcoin: the coin stake transaction is marked with the first output empty
537 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
540 /** Check for standard transaction types
541 @return True if all outputs (scriptPubKeys) use only standard transaction forms
543 bool IsStandard() const;
545 /** Check for standard transaction types
546 @param[in] mapInputs Map of previous transactions that have outputs we're spending
547 @return True if all inputs (scriptSigs) use only standard transaction forms
548 @see CTransaction::FetchInputs
550 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
552 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
553 @return number of sigops this transaction's outputs will produce when spent
554 @see CTransaction::FetchInputs
556 unsigned int GetLegacySigOpCount() const;
558 /** Count ECDSA signature operations in pay-to-script-hash inputs.
560 @param[in] mapInputs Map of previous transactions that have outputs we're spending
561 @return maximum number of sigops required to validate this transaction's inputs
562 @see CTransaction::FetchInputs
564 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
566 /** Amount of bitcoins spent by this transaction.
567 @return sum of all outputs (note: does not include fees)
569 int64 GetValueOut() const
572 BOOST_FOREACH(const CTxOut& txout, vout)
574 nValueOut += txout.nValue;
575 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
576 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
581 /** Amount of bitcoins coming in to this transaction
582 Note that lightweight clients may not know anything besides the hash of previous transactions,
583 so may not be able to calculate this.
585 @param[in] mapInputs Map of previous transactions that have outputs we're spending
586 @return Sum of value of all inputs (scriptSigs)
587 @see CTransaction::FetchInputs
589 int64 GetValueIn(const MapPrevTx& mapInputs) const;
591 static bool AllowFree(double dPriority)
593 // Large (in bytes) low-priority (new, small-coin) transactions
595 return dPriority > COIN * 144 / 250;
598 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK) const;
600 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
602 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
604 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
607 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
608 return error("CTransaction::ReadFromDisk() : fseek failed");
613 catch (std::exception &e) {
614 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
617 // Return file pointer
620 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
621 return error("CTransaction::ReadFromDisk() : second fseek failed");
622 *pfileRet = filein.release();
627 friend bool operator==(const CTransaction& a, const CTransaction& b)
629 return (a.nVersion == b.nVersion &&
630 a.nTime == b.nTime &&
633 a.nLockTime == b.nLockTime);
636 friend bool operator!=(const CTransaction& a, const CTransaction& b)
641 std::string ToStringShort() const
644 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
648 std::string ToString() const
651 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
652 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%d)\n",
653 GetHash().ToString().substr(0,10).c_str(),
659 for (unsigned int i = 0; i < vin.size(); i++)
660 str += " " + vin[i].ToString() + "\n";
661 for (unsigned int i = 0; i < vout.size(); i++)
662 str += " " + vout[i].ToString() + "\n";
668 printf("%s", ToString().c_str());
672 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
673 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
674 bool ReadFromDisk(COutPoint prevout);
675 bool DisconnectInputs(CTxDB& txdb);
677 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
679 @param[in] txdb Transaction database
680 @param[in] mapTestPool List of pending changes to the transaction index database
681 @param[in] fBlock True if being called to add a new best-block to the chain
682 @param[in] fMiner True if being called by CreateNewBlock
683 @param[out] inputsRet Pointers to this transaction's inputs
684 @param[out] fInvalid returns true if transaction is invalid
685 @return Returns true if all inputs are in txdb or mapTestPool
687 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
688 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
690 /** Sanity check previous transactions, then, if all checks succeed,
691 mark them as spent by this transaction.
693 @param[in] inputs Previous transactions (from FetchInputs)
694 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
695 @param[in] posThisTx Position of this transaction on disk
696 @param[in] pindexBlock
697 @param[in] fBlock true if called from ConnectBlock
698 @param[in] fMiner true if called from CreateNewBlock
699 @param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
700 @return Returns true if all checks succeed
702 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs,
703 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
704 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
705 bool ClientConnectInputs();
706 bool CheckTransaction() const;
707 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
708 bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const; // ppcoin: get transaction coin age
711 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
718 /** A transaction with a merkle branch linking it to the block chain. */
719 class CMerkleTx : public CTransaction
723 std::vector<uint256> vMerkleBranch;
727 mutable bool fMerkleVerified;
735 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
744 fMerkleVerified = false;
750 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
751 nVersion = this->nVersion;
752 READWRITE(hashBlock);
753 READWRITE(vMerkleBranch);
758 int SetMerkleBranch(const CBlock* pblock=NULL);
759 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
760 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
761 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
762 int GetBlocksToMaturity() const;
763 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
764 bool AcceptToMemoryPool();
770 /** A txdb record that contains the disk location of a transaction and the
771 * locations of transactions that spend its outputs. vSpent is really only
772 * used as a flag, but having the location is very helpful for debugging.
778 std::vector<CDiskTxPos> vSpent;
785 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
788 vSpent.resize(nOutputs);
793 if (!(nType & SER_GETHASH))
810 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
812 return (a.pos == b.pos &&
813 a.vSpent == b.vSpent);
816 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
820 int GetDepthInMainChain() const;
828 /** Nodes collect new transactions into a block, hash them into a hash tree,
829 * and scan through nonce values to make the block's hash satisfy proof-of-work
830 * requirements. When they solve the proof-of-work, they broadcast the block
831 * to everyone and the block is added to the block chain. The first transaction
832 * in the block is a special one that creates a new coin owned by the creator
835 * Blocks are appended to blk0001.dat files on disk. Their location on disk
836 * is indexed by CBlockIndex objects in memory.
842 static const int CURRENT_VERSION=6;
844 uint256 hashPrevBlock;
845 uint256 hashMerkleRoot;
851 std::vector<CTransaction> vtx;
853 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
854 std::vector<unsigned char> vchBlockSig;
857 mutable std::vector<uint256> vMerkleTree;
859 // Denial-of-service detection:
861 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
870 READWRITE(this->nVersion);
871 nVersion = this->nVersion;
872 READWRITE(hashPrevBlock);
873 READWRITE(hashMerkleRoot);
878 // ConnectBlock depends on vtx following header to generate CDiskTxPos
879 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
882 READWRITE(vchBlockSig);
886 const_cast<CBlock*>(this)->vtx.clear();
887 const_cast<CBlock*>(this)->vchBlockSig.clear();
893 nVersion = CBlock::CURRENT_VERSION;
910 uint256 GetHash() const
913 void * scratchbuff = scrypt_buffer_alloc();
915 scrypt_hash(CVOIDBEGIN(nVersion), sizeof(block_header), UINTBEGIN(thash), scratchbuff);
917 scrypt_buffer_free(scratchbuff);
922 int64 GetBlockTime() const
927 void UpdateTime(const CBlockIndex* pindexPrev);
929 // ppcoin: entropy bit for stake modifier if chosen by modifier
930 unsigned int GetStakeEntropyBit(unsigned int nTime) const
932 // Protocol switch to support p2pool at novacoin block #9689
933 if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
935 // Take last bit of block hash as entropy bit
936 unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
937 if (fDebug && GetBoolArg("-printstakemodifier"))
938 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
941 // Before novacoin block #9689 - old protocol
942 uint160 hashSig = Hash160(vchBlockSig);
943 if (fDebug && GetBoolArg("-printstakemodifier"))
944 printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
945 hashSig >>= 159; // take the first bit of the hash
946 if (fDebug && GetBoolArg("-printstakemodifier"))
947 printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
948 return hashSig.Get64();
951 // ppcoin: two types of block: proof-of-work or proof-of-stake
952 bool IsProofOfStake() const
954 return (vtx.size() > 1 && vtx[1].IsCoinStake());
957 bool IsProofOfWork() const
959 return !IsProofOfStake();
962 std::pair<COutPoint, unsigned int> GetProofOfStake() const
964 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
967 // ppcoin: get max transaction timestamp
968 int64 GetMaxTransactionTime() const
970 int64 maxTransactionTime = 0;
971 BOOST_FOREACH(const CTransaction& tx, vtx)
972 maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
973 return maxTransactionTime;
976 uint256 BuildMerkleTree() const
979 BOOST_FOREACH(const CTransaction& tx, vtx)
980 vMerkleTree.push_back(tx.GetHash());
982 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
984 for (int i = 0; i < nSize; i += 2)
986 int i2 = std::min(i+1, nSize-1);
987 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
988 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
992 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
995 std::vector<uint256> GetMerkleBranch(int nIndex) const
997 if (vMerkleTree.empty())
999 std::vector<uint256> vMerkleBranch;
1001 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1003 int i = std::min(nIndex^1, nSize-1);
1004 vMerkleBranch.push_back(vMerkleTree[j+i]);
1008 return vMerkleBranch;
1011 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1015 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1018 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1020 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1027 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1029 // Open history file to append
1030 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1032 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1034 // Write index header
1035 unsigned int nSize = fileout.GetSerializeSize(*this);
1036 fileout << FLATDATA(pchMessageStart) << nSize;
1039 long fileOutPos = ftell(fileout);
1041 return error("CBlock::WriteToDisk() : ftell failed");
1042 nBlockPosRet = fileOutPos;
1045 // Flush stdio buffers and commit to disk before returning
1047 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1048 FileCommit(fileout);
1053 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1057 // Open history file to read
1058 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1060 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1061 if (!fReadTransactions)
1062 filein.nType |= SER_BLOCKHEADERONLY;
1068 catch (std::exception &e) {
1069 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1073 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1074 return error("CBlock::ReadFromDisk() : errors in block header");
1083 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1084 GetHash().ToString().c_str(),
1086 hashPrevBlock.ToString().c_str(),
1087 hashMerkleRoot.ToString().c_str(),
1088 nTime, nBits, nNonce,
1090 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1091 for (unsigned int i = 0; i < vtx.size(); i++)
1096 printf(" vMerkleTree: ");
1097 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1098 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1103 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1104 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1105 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1106 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1107 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1108 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1110 bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1111 bool SignBlock(const CKeyStore& keystore);
1112 bool CheckBlockSignature(bool fProofOfStake) const;
1115 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1123 /** The block chain is a tree shaped structure starting with the
1124 * genesis block at the root, with each block potentially having multiple
1125 * candidates to be the next block. pprev and pnext link a path through the
1126 * main/longest chain. A blockindex may have multiple pprev pointing back
1127 * to it, but pnext will only point forward to the longest branch, or will
1128 * be null if the block is not part of the longest chain.
1133 const uint256* phashBlock;
1137 unsigned int nBlockPos;
1138 uint256 nChainTrust; // ppcoin: trust score of block chain
1144 unsigned int nFlags; // ppcoin: block index flags
1147 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1148 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1149 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1152 uint64 nStakeModifier; // hash modifier for proof-of-stake
1153 unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1155 // proof-of-stake specific fields
1156 COutPoint prevoutStake;
1157 unsigned int nStakeTime;
1158 uint256 hashProofOfStake;
1162 uint256 hashMerkleRoot;
1165 unsigned int nNonce;
1180 nStakeModifierChecksum = 0;
1181 hashProofOfStake = 0;
1182 prevoutStake.SetNull();
1192 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1198 nBlockPos = nBlockPosIn;
1205 nStakeModifierChecksum = 0;
1206 hashProofOfStake = 0;
1207 if (block.IsProofOfStake())
1210 prevoutStake = block.vtx[1].vin[0].prevout;
1211 nStakeTime = block.vtx[1].nTime;
1215 prevoutStake.SetNull();
1219 nVersion = block.nVersion;
1220 hashMerkleRoot = block.hashMerkleRoot;
1221 nTime = block.nTime;
1222 nBits = block.nBits;
1223 nNonce = block.nNonce;
1226 CBlock GetBlockHeader() const
1229 block.nVersion = nVersion;
1231 block.hashPrevBlock = pprev->GetBlockHash();
1232 block.hashMerkleRoot = hashMerkleRoot;
1233 block.nTime = nTime;
1234 block.nBits = nBits;
1235 block.nNonce = nNonce;
1239 uint256 GetBlockHash() const
1244 int64 GetBlockTime() const
1246 return (int64)nTime;
1249 uint256 GetBlockTrust() const;
1251 bool IsInMainChain() const
1253 return (pnext || this == pindexBest);
1256 bool CheckIndex() const
1261 enum { nMedianTimeSpan=11 };
1263 int64 GetMedianTimePast() const
1265 int64 pmedian[nMedianTimeSpan];
1266 int64* pbegin = &pmedian[nMedianTimeSpan];
1267 int64* pend = &pmedian[nMedianTimeSpan];
1269 const CBlockIndex* pindex = this;
1270 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1271 *(--pbegin) = pindex->GetBlockTime();
1273 std::sort(pbegin, pend);
1274 return pbegin[(pend - pbegin)/2];
1277 int64 GetMedianTime() const
1279 const CBlockIndex* pindex = this;
1280 for (int i = 0; i < nMedianTimeSpan/2; i++)
1283 return GetBlockTime();
1284 pindex = pindex->pnext;
1286 return pindex->GetMedianTimePast();
1290 * Returns true if there are nRequired or more blocks of minVersion or above
1291 * in the last nToCheck blocks, starting at pstart and going backwards.
1293 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1294 unsigned int nRequired, unsigned int nToCheck);
1297 bool IsProofOfWork() const
1299 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1302 bool IsProofOfStake() const
1304 return (nFlags & BLOCK_PROOF_OF_STAKE);
1307 void SetProofOfStake()
1309 nFlags |= BLOCK_PROOF_OF_STAKE;
1312 unsigned int GetStakeEntropyBit() const
1314 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1317 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1319 if (nEntropyBit > 1)
1321 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1325 bool GeneratedStakeModifier() const
1327 return (nFlags & BLOCK_STAKE_MODIFIER);
1330 void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1332 nStakeModifier = nModifier;
1333 if (fGeneratedStakeModifier)
1334 nFlags |= BLOCK_STAKE_MODIFIER;
1337 std::string ToString() const
1339 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)",
1340 pprev, pnext, nFile, nBlockPos, nHeight,
1341 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1342 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1343 nStakeModifier, nStakeModifierChecksum,
1344 hashProofOfStake.ToString().c_str(),
1345 prevoutStake.ToString().c_str(), nStakeTime,
1346 hashMerkleRoot.ToString().c_str(),
1347 GetBlockHash().ToString().c_str());
1352 printf("%s\n", ToString().c_str());
1358 /** Used to marshal pointers into hashes for db storage. */
1359 class CDiskBlockIndex : public CBlockIndex
1371 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1373 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1374 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1379 if (!(nType & SER_GETHASH))
1380 READWRITE(nVersion);
1382 READWRITE(hashNext);
1384 READWRITE(nBlockPos);
1387 READWRITE(nMoneySupply);
1389 READWRITE(nStakeModifier);
1390 if (IsProofOfStake())
1392 READWRITE(prevoutStake);
1393 READWRITE(nStakeTime);
1394 READWRITE(hashProofOfStake);
1398 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1399 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1400 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1404 READWRITE(this->nVersion);
1405 READWRITE(hashPrev);
1406 READWRITE(hashMerkleRoot);
1412 uint256 GetBlockHash() const
1415 block.nVersion = nVersion;
1416 block.hashPrevBlock = hashPrev;
1417 block.hashMerkleRoot = hashMerkleRoot;
1418 block.nTime = nTime;
1419 block.nBits = nBits;
1420 block.nNonce = nNonce;
1421 return block.GetHash();
1425 std::string ToString() const
1427 std::string str = "CDiskBlockIndex(";
1428 str += CBlockIndex::ToString();
1429 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1430 GetBlockHash().ToString().c_str(),
1431 hashPrev.ToString().c_str(),
1432 hashNext.ToString().c_str());
1438 printf("%s\n", ToString().c_str());
1449 /** Describes a place in the block chain to another node such that if the
1450 * other node doesn't have the same branch, it can find a recent common trunk.
1451 * The further back it is, the further before the fork it may be.
1456 std::vector<uint256> vHave;
1463 explicit CBlockLocator(const CBlockIndex* pindex)
1468 explicit CBlockLocator(uint256 hashBlock)
1470 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1471 if (mi != mapBlockIndex.end())
1475 CBlockLocator(const std::vector<uint256>& vHaveIn)
1482 if (!(nType & SER_GETHASH))
1483 READWRITE(nVersion);
1494 return vHave.empty();
1497 void Set(const CBlockIndex* pindex)
1503 vHave.push_back(pindex->GetBlockHash());
1505 // Exponentially larger steps back
1506 for (int i = 0; pindex && i < nStep; i++)
1507 pindex = pindex->pprev;
1508 if (vHave.size() > 10)
1511 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1514 int GetDistanceBack()
1516 // Retrace how far back it was in the sender's branch
1519 BOOST_FOREACH(const uint256& hash, vHave)
1521 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1522 if (mi != mapBlockIndex.end())
1524 CBlockIndex* pindex = (*mi).second;
1525 if (pindex->IsInMainChain())
1535 CBlockIndex* GetBlockIndex()
1537 // Find the first block the caller has in the main chain
1538 BOOST_FOREACH(const uint256& hash, vHave)
1540 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1541 if (mi != mapBlockIndex.end())
1543 CBlockIndex* pindex = (*mi).second;
1544 if (pindex->IsInMainChain())
1548 return pindexGenesisBlock;
1551 uint256 GetBlockHash()
1553 // Find the first block the caller has in the main chain
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())
1564 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1569 CBlockIndex* pindex = GetBlockIndex();
1572 return pindex->nHeight;
1586 mutable CCriticalSection cs;
1587 std::map<uint256, CTransaction> mapTx;
1588 std::map<COutPoint, CInPoint> mapNextTx;
1590 bool accept(CTxDB& txdb, CTransaction &tx,
1591 bool fCheckInputs, bool* pfMissingInputs);
1592 bool addUnchecked(const uint256& hash, CTransaction &tx);
1593 bool remove(CTransaction &tx);
1595 void queryHashes(std::vector<uint256>& vtxid);
1597 unsigned long size()
1600 return mapTx.size();
1603 bool exists(uint256 hash)
1605 return (mapTx.count(hash) != 0);
1608 CTransaction& lookup(uint256 hash)
1614 extern CTxMemPool mempool;