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 CHAINCHECKS_SWITCH_TIME = 1379635200; // Fri, 20 Sep 2013 00:00:00 GMT
44 static const unsigned int STAKECURVE_SWITCH_TIME = 1382227200; // Sun, 20 Oct 2013 00:00:00 GMT
45 static const unsigned int STAKEWEIGHT_SWITCH_TIME = 1388534400; // Wed, 01 Jan 2014 00:00:00 GMT
48 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
49 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
50 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
53 static const int fHaveUPnP = true;
55 static const int fHaveUPnP = false;
58 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
59 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
61 static const int64 nMaxClockDrift = 2 * 60 * 60; // two hours
63 extern CScript COINBASE_FLAGS;
66 extern CCriticalSection cs_main;
67 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
68 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
69 extern CBlockIndex* pindexGenesisBlock;
70 extern unsigned int nStakeMinAge;
71 extern unsigned int nNodeLifespan;
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 unsigned int ComputeMinStake(unsigned int nBase, int64 nTime, unsigned int nBlockTime);
124 int GetNumBlocksOfPeers();
125 bool IsInitialBlockDownload();
126 std::string GetWarnings(std::string strFor);
127 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
128 uint256 WantedByOrphan(const CBlock* pblockOrphan);
129 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
130 void BitcoinMiner(CWallet *pwallet, bool fProofOfStake);
131 void ResendWalletTransactions();
142 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
144 /** Position on disk for a particular transaction. */
149 unsigned int nBlockPos;
157 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
160 nBlockPos = nBlockPosIn;
164 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
165 void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
166 bool IsNull() const { return (nFile == (unsigned int) -1); }
168 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
170 return (a.nFile == b.nFile &&
171 a.nBlockPos == b.nBlockPos &&
172 a.nTxPos == b.nTxPos);
175 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
181 std::string ToString() const
186 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
191 printf("%s", ToString().c_str());
197 /** An inpoint - a combination of a transaction and an index n into its vin */
204 CInPoint() { SetNull(); }
205 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
206 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
207 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
212 /** An outpoint - a combination of a transaction hash and an index n into its vout */
219 COutPoint() { SetNull(); }
220 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
221 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
222 void SetNull() { hash = 0; n = (unsigned int) -1; }
223 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
225 friend bool operator<(const COutPoint& a, const COutPoint& b)
227 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
230 friend bool operator==(const COutPoint& a, const COutPoint& b)
232 return (a.hash == b.hash && a.n == b.n);
235 friend bool operator!=(const COutPoint& a, const COutPoint& b)
240 std::string ToString() const
242 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
247 printf("%s\n", ToString().c_str());
254 /** An input of a transaction. It contains the location of the previous
255 * transaction's output that it claims and a signature that matches the
256 * output's public key.
263 unsigned int nSequence;
267 nSequence = std::numeric_limits<unsigned int>::max();
270 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
273 scriptSig = scriptSigIn;
274 nSequence = nSequenceIn;
277 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
279 prevout = COutPoint(hashPrevTx, nOut);
280 scriptSig = scriptSigIn;
281 nSequence = nSequenceIn;
287 READWRITE(scriptSig);
288 READWRITE(nSequence);
293 return (nSequence == std::numeric_limits<unsigned int>::max());
296 friend bool operator==(const CTxIn& a, const CTxIn& b)
298 return (a.prevout == b.prevout &&
299 a.scriptSig == b.scriptSig &&
300 a.nSequence == b.nSequence);
303 friend bool operator!=(const CTxIn& a, const CTxIn& b)
308 std::string ToStringShort() const
310 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
313 std::string ToString() const
317 str += prevout.ToString();
318 if (prevout.IsNull())
319 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
321 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
322 if (nSequence != std::numeric_limits<unsigned int>::max())
323 str += strprintf(", nSequence=%u", nSequence);
330 printf("%s\n", ToString().c_str());
337 /** An output of a transaction. It contains the public key that the next input
338 * must be able to sign with to claim it.
344 CScript scriptPubKey;
351 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
354 scriptPubKey = scriptPubKeyIn;
360 READWRITE(scriptPubKey);
366 scriptPubKey.clear();
371 return (nValue == -1);
377 scriptPubKey.clear();
382 return (nValue == 0 && scriptPubKey.empty());
385 uint256 GetHash() const
387 return SerializeHash(*this);
390 friend bool operator==(const CTxOut& a, const CTxOut& b)
392 return (a.nValue == b.nValue &&
393 a.scriptPubKey == b.scriptPubKey);
396 friend bool operator!=(const CTxOut& a, const CTxOut& b)
401 std::string ToStringShort() const
403 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
406 std::string ToString() const
408 if (IsEmpty()) return "CTxOut(empty)";
409 if (scriptPubKey.size() < 6)
410 return "CTxOut(error)";
411 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
416 printf("%s\n", ToString().c_str());
430 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
432 /** The basic transaction that is broadcasted on the network and contained in
433 * blocks. A transaction can contain multiple inputs and outputs.
438 static const int CURRENT_VERSION=1;
441 std::vector<CTxIn> vin;
442 std::vector<CTxOut> vout;
443 unsigned int nLockTime;
445 // Denial-of-service detection:
447 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
456 READWRITE(this->nVersion);
457 nVersion = this->nVersion;
461 READWRITE(nLockTime);
466 nVersion = CTransaction::CURRENT_VERSION;
467 nTime = GetAdjustedTime();
471 nDoS = 0; // Denial-of-service prevention
476 return (vin.empty() && vout.empty());
479 uint256 GetHash() const
481 return SerializeHash(*this);
484 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
486 // Time based nLockTime implemented in 0.1.6
489 if (nBlockHeight == 0)
490 nBlockHeight = nBestHeight;
492 nBlockTime = GetAdjustedTime();
493 if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
495 BOOST_FOREACH(const CTxIn& txin, vin)
501 bool IsNewerThan(const CTransaction& old) const
503 if (vin.size() != old.vin.size())
505 for (unsigned int i = 0; i < vin.size(); i++)
506 if (vin[i].prevout != old.vin[i].prevout)
510 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
511 for (unsigned int i = 0; i < vin.size(); i++)
513 if (vin[i].nSequence != old.vin[i].nSequence)
515 if (vin[i].nSequence <= nLowest)
518 nLowest = vin[i].nSequence;
520 if (old.vin[i].nSequence < nLowest)
523 nLowest = old.vin[i].nSequence;
530 bool IsCoinBase() const
532 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
535 bool IsCoinStake() const
537 // ppcoin: the coin stake transaction is marked with the first output empty
538 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
541 /** Check for standard transaction types
542 @return True if all outputs (scriptPubKeys) use only standard transaction forms
544 bool IsStandard() const;
546 /** Check for standard transaction types
547 @param[in] mapInputs Map of previous transactions that have outputs we're spending
548 @return True if all inputs (scriptSigs) use only standard transaction forms
549 @see CTransaction::FetchInputs
551 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
553 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
554 @return number of sigops this transaction's outputs will produce when spent
555 @see CTransaction::FetchInputs
557 unsigned int GetLegacySigOpCount() const;
559 /** Count ECDSA signature operations in pay-to-script-hash inputs.
561 @param[in] mapInputs Map of previous transactions that have outputs we're spending
562 @return maximum number of sigops required to validate this transaction's inputs
563 @see CTransaction::FetchInputs
565 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
567 /** Amount of bitcoins spent by this transaction.
568 @return sum of all outputs (note: does not include fees)
570 int64 GetValueOut() const
573 BOOST_FOREACH(const CTxOut& txout, vout)
575 nValueOut += txout.nValue;
576 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
577 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
582 /** Amount of bitcoins coming in to this transaction
583 Note that lightweight clients may not know anything besides the hash of previous transactions,
584 so may not be able to calculate this.
586 @param[in] mapInputs Map of previous transactions that have outputs we're spending
587 @return Sum of value of all inputs (scriptSigs)
588 @see CTransaction::FetchInputs
590 int64 GetValueIn(const MapPrevTx& mapInputs) const;
592 static bool AllowFree(double dPriority)
594 // Large (in bytes) low-priority (new, small-coin) transactions
596 return dPriority > COIN * 144 / 250;
599 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK) const;
601 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
603 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
605 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
608 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
609 return error("CTransaction::ReadFromDisk() : fseek failed");
614 catch (std::exception &e) {
615 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
618 // Return file pointer
621 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
622 return error("CTransaction::ReadFromDisk() : second fseek failed");
623 *pfileRet = filein.release();
628 friend bool operator==(const CTransaction& a, const CTransaction& b)
630 return (a.nVersion == b.nVersion &&
631 a.nTime == b.nTime &&
634 a.nLockTime == b.nLockTime);
637 friend bool operator!=(const CTransaction& a, const CTransaction& b)
642 std::string ToStringShort() const
645 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
649 std::string ToString() const
652 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
653 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%d)\n",
654 GetHash().ToString().substr(0,10).c_str(),
660 for (unsigned int i = 0; i < vin.size(); i++)
661 str += " " + vin[i].ToString() + "\n";
662 for (unsigned int i = 0; i < vout.size(); i++)
663 str += " " + vout[i].ToString() + "\n";
669 printf("%s", ToString().c_str());
673 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
674 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
675 bool ReadFromDisk(COutPoint prevout);
676 bool DisconnectInputs(CTxDB& txdb);
678 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
680 @param[in] txdb Transaction database
681 @param[in] mapTestPool List of pending changes to the transaction index database
682 @param[in] fBlock True if being called to add a new best-block to the chain
683 @param[in] fMiner True if being called by CreateNewBlock
684 @param[out] inputsRet Pointers to this transaction's inputs
685 @param[out] fInvalid returns true if transaction is invalid
686 @return Returns true if all inputs are in txdb or mapTestPool
688 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
689 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
691 /** Sanity check previous transactions, then, if all checks succeed,
692 mark them as spent by this transaction.
694 @param[in] inputs Previous transactions (from FetchInputs)
695 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
696 @param[in] posThisTx Position of this transaction on disk
697 @param[in] pindexBlock
698 @param[in] fBlock true if called from ConnectBlock
699 @param[in] fMiner true if called from CreateNewBlock
700 @param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
701 @return Returns true if all checks succeed
703 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs,
704 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
705 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
706 bool ClientConnectInputs();
707 bool CheckTransaction() const;
708 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
709 bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const; // ppcoin: get transaction coin age
712 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
719 /** A transaction with a merkle branch linking it to the block chain. */
720 class CMerkleTx : public CTransaction
724 std::vector<uint256> vMerkleBranch;
728 mutable bool fMerkleVerified;
736 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
745 fMerkleVerified = false;
751 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
752 nVersion = this->nVersion;
753 READWRITE(hashBlock);
754 READWRITE(vMerkleBranch);
759 int SetMerkleBranch(const CBlock* pblock=NULL);
760 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
761 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
762 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
763 int GetBlocksToMaturity() const;
764 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
765 bool AcceptToMemoryPool();
771 /** A txdb record that contains the disk location of a transaction and the
772 * locations of transactions that spend its outputs. vSpent is really only
773 * used as a flag, but having the location is very helpful for debugging.
779 std::vector<CDiskTxPos> vSpent;
786 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
789 vSpent.resize(nOutputs);
794 if (!(nType & SER_GETHASH))
811 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
813 return (a.pos == b.pos &&
814 a.vSpent == b.vSpent);
817 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
821 int GetDepthInMainChain() const;
829 /** Nodes collect new transactions into a block, hash them into a hash tree,
830 * and scan through nonce values to make the block's hash satisfy proof-of-work
831 * requirements. When they solve the proof-of-work, they broadcast the block
832 * to everyone and the block is added to the block chain. The first transaction
833 * in the block is a special one that creates a new coin owned by the creator
836 * Blocks are appended to blk0001.dat files on disk. Their location on disk
837 * is indexed by CBlockIndex objects in memory.
843 static const int CURRENT_VERSION=6;
845 uint256 hashPrevBlock;
846 uint256 hashMerkleRoot;
852 std::vector<CTransaction> vtx;
854 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
855 std::vector<unsigned char> vchBlockSig;
858 mutable std::vector<uint256> vMerkleTree;
860 // Denial-of-service detection:
862 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
871 READWRITE(this->nVersion);
872 nVersion = this->nVersion;
873 READWRITE(hashPrevBlock);
874 READWRITE(hashMerkleRoot);
879 // ConnectBlock depends on vtx following header to generate CDiskTxPos
880 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
883 READWRITE(vchBlockSig);
887 const_cast<CBlock*>(this)->vtx.clear();
888 const_cast<CBlock*>(this)->vchBlockSig.clear();
894 nVersion = CBlock::CURRENT_VERSION;
911 uint256 GetHash() const
914 void * scratchbuff = scrypt_buffer_alloc();
916 scrypt_hash(CVOIDBEGIN(nVersion), sizeof(block_header), UINTBEGIN(thash), scratchbuff);
918 scrypt_buffer_free(scratchbuff);
923 int64 GetBlockTime() const
928 void UpdateTime(const CBlockIndex* pindexPrev);
930 // ppcoin: entropy bit for stake modifier if chosen by modifier
931 unsigned int GetStakeEntropyBit(unsigned int nTime) const
933 // Protocol switch to support p2pool at novacoin block #9689
934 if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
936 // Take last bit of block hash as entropy bit
937 unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
938 if (fDebug && GetBoolArg("-printstakemodifier"))
939 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
942 // Before novacoin block #9689 - old protocol
943 uint160 hashSig = Hash160(vchBlockSig);
944 if (fDebug && GetBoolArg("-printstakemodifier"))
945 printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
946 hashSig >>= 159; // take the first bit of the hash
947 if (fDebug && GetBoolArg("-printstakemodifier"))
948 printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
949 return hashSig.Get64();
952 // ppcoin: two types of block: proof-of-work or proof-of-stake
953 bool IsProofOfStake() const
955 return (vtx.size() > 1 && vtx[1].IsCoinStake());
958 bool IsProofOfWork() const
960 return !IsProofOfStake();
963 std::pair<COutPoint, unsigned int> GetProofOfStake() const
965 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
968 // ppcoin: get max transaction timestamp
969 int64 GetMaxTransactionTime() const
971 int64 maxTransactionTime = 0;
972 BOOST_FOREACH(const CTransaction& tx, vtx)
973 maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
974 return maxTransactionTime;
977 uint256 BuildMerkleTree() const
980 BOOST_FOREACH(const CTransaction& tx, vtx)
981 vMerkleTree.push_back(tx.GetHash());
983 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
985 for (int i = 0; i < nSize; i += 2)
987 int i2 = std::min(i+1, nSize-1);
988 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
989 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
993 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
996 std::vector<uint256> GetMerkleBranch(int nIndex) const
998 if (vMerkleTree.empty())
1000 std::vector<uint256> vMerkleBranch;
1002 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1004 int i = std::min(nIndex^1, nSize-1);
1005 vMerkleBranch.push_back(vMerkleTree[j+i]);
1009 return vMerkleBranch;
1012 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1016 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1019 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1021 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1028 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1030 // Open history file to append
1031 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1033 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1035 // Write index header
1036 unsigned int nSize = fileout.GetSerializeSize(*this);
1037 fileout << FLATDATA(pchMessageStart) << nSize;
1040 long fileOutPos = ftell(fileout);
1042 return error("CBlock::WriteToDisk() : ftell failed");
1043 nBlockPosRet = fileOutPos;
1046 // Flush stdio buffers and commit to disk before returning
1048 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1049 FileCommit(fileout);
1054 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1058 // Open history file to read
1059 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1061 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1062 if (!fReadTransactions)
1063 filein.nType |= SER_BLOCKHEADERONLY;
1069 catch (std::exception &e) {
1070 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1074 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1075 return error("CBlock::ReadFromDisk() : errors in block header");
1084 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1085 GetHash().ToString().c_str(),
1087 hashPrevBlock.ToString().c_str(),
1088 hashMerkleRoot.ToString().c_str(),
1089 nTime, nBits, nNonce,
1091 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1092 for (unsigned int i = 0; i < vtx.size(); i++)
1097 printf(" vMerkleTree: ");
1098 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1099 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1104 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1105 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1106 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1107 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1108 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1109 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1111 bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1112 bool SignBlock(const CKeyStore& keystore);
1113 bool CheckBlockSignature(bool fProofOfStake) const;
1116 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1124 /** The block chain is a tree shaped structure starting with the
1125 * genesis block at the root, with each block potentially having multiple
1126 * candidates to be the next block. pprev and pnext link a path through the
1127 * main/longest chain. A blockindex may have multiple pprev pointing back
1128 * to it, but pnext will only point forward to the longest branch, or will
1129 * be null if the block is not part of the longest chain.
1134 const uint256* phashBlock;
1138 unsigned int nBlockPos;
1139 uint256 nChainTrust; // ppcoin: trust score of block chain
1145 unsigned int nFlags; // ppcoin: block index flags
1148 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1149 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1150 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1153 uint64 nStakeModifier; // hash modifier for proof-of-stake
1154 unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1156 // proof-of-stake specific fields
1157 COutPoint prevoutStake;
1158 unsigned int nStakeTime;
1159 uint256 hashProofOfStake;
1163 uint256 hashMerkleRoot;
1166 unsigned int nNonce;
1181 nStakeModifierChecksum = 0;
1182 hashProofOfStake = 0;
1183 prevoutStake.SetNull();
1193 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1199 nBlockPos = nBlockPosIn;
1206 nStakeModifierChecksum = 0;
1207 hashProofOfStake = 0;
1208 if (block.IsProofOfStake())
1211 prevoutStake = block.vtx[1].vin[0].prevout;
1212 nStakeTime = block.vtx[1].nTime;
1216 prevoutStake.SetNull();
1220 nVersion = block.nVersion;
1221 hashMerkleRoot = block.hashMerkleRoot;
1222 nTime = block.nTime;
1223 nBits = block.nBits;
1224 nNonce = block.nNonce;
1227 CBlock GetBlockHeader() const
1230 block.nVersion = nVersion;
1232 block.hashPrevBlock = pprev->GetBlockHash();
1233 block.hashMerkleRoot = hashMerkleRoot;
1234 block.nTime = nTime;
1235 block.nBits = nBits;
1236 block.nNonce = nNonce;
1240 uint256 GetBlockHash() const
1245 int64 GetBlockTime() const
1247 return (int64)nTime;
1250 uint256 GetBlockTrust() const;
1252 bool IsInMainChain() const
1254 return (pnext || this == pindexBest);
1257 bool CheckIndex() const
1262 enum { nMedianTimeSpan=11 };
1264 int64 GetMedianTimePast() const
1266 int64 pmedian[nMedianTimeSpan];
1267 int64* pbegin = &pmedian[nMedianTimeSpan];
1268 int64* pend = &pmedian[nMedianTimeSpan];
1270 const CBlockIndex* pindex = this;
1271 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1272 *(--pbegin) = pindex->GetBlockTime();
1274 std::sort(pbegin, pend);
1275 return pbegin[(pend - pbegin)/2];
1278 int64 GetMedianTime() const
1280 const CBlockIndex* pindex = this;
1281 for (int i = 0; i < nMedianTimeSpan/2; i++)
1284 return GetBlockTime();
1285 pindex = pindex->pnext;
1287 return pindex->GetMedianTimePast();
1291 * Returns true if there are nRequired or more blocks of minVersion or above
1292 * in the last nToCheck blocks, starting at pstart and going backwards.
1294 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1295 unsigned int nRequired, unsigned int nToCheck);
1298 bool IsProofOfWork() const
1300 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1303 bool IsProofOfStake() const
1305 return (nFlags & BLOCK_PROOF_OF_STAKE);
1308 void SetProofOfStake()
1310 nFlags |= BLOCK_PROOF_OF_STAKE;
1313 unsigned int GetStakeEntropyBit() const
1315 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1318 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1320 if (nEntropyBit > 1)
1322 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1326 bool GeneratedStakeModifier() const
1328 return (nFlags & BLOCK_STAKE_MODIFIER);
1331 void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1333 nStakeModifier = nModifier;
1334 if (fGeneratedStakeModifier)
1335 nFlags |= BLOCK_STAKE_MODIFIER;
1338 std::string ToString() const
1340 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)",
1341 pprev, pnext, nFile, nBlockPos, nHeight,
1342 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1343 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1344 nStakeModifier, nStakeModifierChecksum,
1345 hashProofOfStake.ToString().c_str(),
1346 prevoutStake.ToString().c_str(), nStakeTime,
1347 hashMerkleRoot.ToString().c_str(),
1348 GetBlockHash().ToString().c_str());
1353 printf("%s\n", ToString().c_str());
1359 /** Used to marshal pointers into hashes for db storage. */
1360 class CDiskBlockIndex : public CBlockIndex
1372 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1374 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1375 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1380 if (!(nType & SER_GETHASH))
1381 READWRITE(nVersion);
1383 READWRITE(hashNext);
1385 READWRITE(nBlockPos);
1388 READWRITE(nMoneySupply);
1390 READWRITE(nStakeModifier);
1391 if (IsProofOfStake())
1393 READWRITE(prevoutStake);
1394 READWRITE(nStakeTime);
1395 READWRITE(hashProofOfStake);
1399 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1400 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1401 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1405 READWRITE(this->nVersion);
1406 READWRITE(hashPrev);
1407 READWRITE(hashMerkleRoot);
1413 uint256 GetBlockHash() const
1416 block.nVersion = nVersion;
1417 block.hashPrevBlock = hashPrev;
1418 block.hashMerkleRoot = hashMerkleRoot;
1419 block.nTime = nTime;
1420 block.nBits = nBits;
1421 block.nNonce = nNonce;
1422 return block.GetHash();
1426 std::string ToString() const
1428 std::string str = "CDiskBlockIndex(";
1429 str += CBlockIndex::ToString();
1430 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1431 GetBlockHash().ToString().c_str(),
1432 hashPrev.ToString().c_str(),
1433 hashNext.ToString().c_str());
1439 printf("%s\n", ToString().c_str());
1450 /** Describes a place in the block chain to another node such that if the
1451 * other node doesn't have the same branch, it can find a recent common trunk.
1452 * The further back it is, the further before the fork it may be.
1457 std::vector<uint256> vHave;
1464 explicit CBlockLocator(const CBlockIndex* pindex)
1469 explicit CBlockLocator(uint256 hashBlock)
1471 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1472 if (mi != mapBlockIndex.end())
1476 CBlockLocator(const std::vector<uint256>& vHaveIn)
1483 if (!(nType & SER_GETHASH))
1484 READWRITE(nVersion);
1495 return vHave.empty();
1498 void Set(const CBlockIndex* pindex)
1504 vHave.push_back(pindex->GetBlockHash());
1506 // Exponentially larger steps back
1507 for (int i = 0; pindex && i < nStep; i++)
1508 pindex = pindex->pprev;
1509 if (vHave.size() > 10)
1512 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1515 int GetDistanceBack()
1517 // Retrace how far back it was in the sender's branch
1520 BOOST_FOREACH(const uint256& hash, vHave)
1522 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1523 if (mi != mapBlockIndex.end())
1525 CBlockIndex* pindex = (*mi).second;
1526 if (pindex->IsInMainChain())
1536 CBlockIndex* GetBlockIndex()
1538 // Find the first block the caller has in the main chain
1539 BOOST_FOREACH(const uint256& hash, vHave)
1541 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1542 if (mi != mapBlockIndex.end())
1544 CBlockIndex* pindex = (*mi).second;
1545 if (pindex->IsInMainChain())
1549 return pindexGenesisBlock;
1552 uint256 GetBlockHash()
1554 // Find the first block the caller has in the main chain
1555 BOOST_FOREACH(const uint256& hash, vHave)
1557 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1558 if (mi != mapBlockIndex.end())
1560 CBlockIndex* pindex = (*mi).second;
1561 if (pindex->IsInMainChain())
1565 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1570 CBlockIndex* pindex = GetBlockIndex();
1573 return pindex->nHeight;
1587 mutable CCriticalSection cs;
1588 std::map<uint256, CTransaction> mapTx;
1589 std::map<COutPoint, CInPoint> mapNextTx;
1591 bool accept(CTxDB& txdb, CTransaction &tx,
1592 bool fCheckInputs, bool* pfMissingInputs);
1593 bool addUnchecked(const uint256& hash, CTransaction &tx);
1594 bool remove(CTransaction &tx);
1596 void queryHashes(std::vector<uint256>& vtxid);
1598 unsigned long size()
1601 return mapTx.size();
1604 bool exists(uint256 hash)
1606 return (mapTx.count(hash) != 0);
1609 CTransaction& lookup(uint256 hash)
1615 extern CTxMemPool mempool;