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;
93 extern bool fStakeUsePooledKeys;
95 // Minimum disk space required - used in CheckDiskSpace()
96 static const uint64 nMinDiskSpace = 52428800;
103 void RegisterWallet(CWallet* pwalletIn);
104 void UnregisterWallet(CWallet* pwalletIn);
105 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
106 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
107 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
108 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
109 FILE* AppendBlockFile(unsigned int& nFileRet);
110 bool LoadBlockIndex(bool fAllowNew=true);
111 void PrintBlockTree();
112 CBlockIndex* FindBlockByHeight(int nHeight);
113 bool ProcessMessages(CNode* pfrom);
114 bool SendMessages(CNode* pto, bool fSendTrickle);
115 bool LoadExternalBlockFile(FILE* fileIn);
116 CBlock* CreateNewBlock(CWallet* pwallet, bool fProofOfStake=false);
117 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
118 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
119 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
120 bool CheckStake(CBlock* pblock, CWallet& wallet);
121 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
122 int64 GetProofOfWorkReward(unsigned int nBits);
123 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
124 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
125 unsigned int ComputeMinStake(unsigned int nBase, int64 nTime, unsigned int nBlockTime);
126 int GetNumBlocksOfPeers();
127 bool IsInitialBlockDownload();
128 std::string GetWarnings(std::string strFor);
129 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
130 uint256 WantedByOrphan(const CBlock* pblockOrphan);
131 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
132 void StakeMiner(CWallet *pwallet);
133 void ResendWalletTransactions();
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) 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 fStrictPayToScriptHash=true);
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;
721 /** A transaction with a merkle branch linking it to the block chain. */
722 class CMerkleTx : public CTransaction
726 std::vector<uint256> vMerkleBranch;
730 mutable bool fMerkleVerified;
738 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
747 fMerkleVerified = false;
753 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
754 nVersion = this->nVersion;
755 READWRITE(hashBlock);
756 READWRITE(vMerkleBranch);
761 int SetMerkleBranch(const CBlock* pblock=NULL);
762 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
763 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
764 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
765 int GetBlocksToMaturity() const;
766 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
767 bool AcceptToMemoryPool();
773 /** A txdb record that contains the disk location of a transaction and the
774 * locations of transactions that spend its outputs. vSpent is really only
775 * used as a flag, but having the location is very helpful for debugging.
781 std::vector<CDiskTxPos> vSpent;
788 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
791 vSpent.resize(nOutputs);
796 if (!(nType & SER_GETHASH))
813 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
815 return (a.pos == b.pos &&
816 a.vSpent == b.vSpent);
819 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
823 int GetDepthInMainChain() const;
831 /** Nodes collect new transactions into a block, hash them into a hash tree,
832 * and scan through nonce values to make the block's hash satisfy proof-of-work
833 * requirements. When they solve the proof-of-work, they broadcast the block
834 * to everyone and the block is added to the block chain. The first transaction
835 * in the block is a special one that creates a new coin owned by the creator
838 * Blocks are appended to blk0001.dat files on disk. Their location on disk
839 * is indexed by CBlockIndex objects in memory.
845 static const int CURRENT_VERSION=6;
847 uint256 hashPrevBlock;
848 uint256 hashMerkleRoot;
854 std::vector<CTransaction> vtx;
856 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
857 std::vector<unsigned char> vchBlockSig;
860 mutable std::vector<uint256> vMerkleTree;
862 // Denial-of-service detection:
864 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
873 READWRITE(this->nVersion);
874 nVersion = this->nVersion;
875 READWRITE(hashPrevBlock);
876 READWRITE(hashMerkleRoot);
881 // ConnectBlock depends on vtx following header to generate CDiskTxPos
882 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
885 READWRITE(vchBlockSig);
889 const_cast<CBlock*>(this)->vtx.clear();
890 const_cast<CBlock*>(this)->vchBlockSig.clear();
896 nVersion = CBlock::CURRENT_VERSION;
913 uint256 GetHash() const
916 void * scratchbuff = scrypt_buffer_alloc();
918 scrypt_hash(CVOIDBEGIN(nVersion), sizeof(block_header), UINTBEGIN(thash), scratchbuff);
920 scrypt_buffer_free(scratchbuff);
925 int64 GetBlockTime() const
930 void UpdateTime(const CBlockIndex* pindexPrev);
932 // ppcoin: entropy bit for stake modifier if chosen by modifier
933 unsigned int GetStakeEntropyBit(unsigned int nTime) const
935 // Protocol switch to support p2pool at novacoin block #9689
936 if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
938 // Take last bit of block hash as entropy bit
939 unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
940 if (fDebug && GetBoolArg("-printstakemodifier"))
941 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
944 // Before novacoin block #9689 - old protocol
945 uint160 hashSig = Hash160(vchBlockSig);
946 if (fDebug && GetBoolArg("-printstakemodifier"))
947 printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
948 hashSig >>= 159; // take the first bit of the hash
949 if (fDebug && GetBoolArg("-printstakemodifier"))
950 printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
951 return hashSig.Get64();
954 // ppcoin: two types of block: proof-of-work or proof-of-stake
955 bool IsProofOfStake() const
957 return (vtx.size() > 1 && vtx[1].IsCoinStake());
960 bool IsProofOfWork() const
962 return !IsProofOfStake();
965 std::pair<COutPoint, unsigned int> GetProofOfStake() const
967 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
970 // ppcoin: get max transaction timestamp
971 int64 GetMaxTransactionTime() const
973 int64 maxTransactionTime = 0;
974 BOOST_FOREACH(const CTransaction& tx, vtx)
975 maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
976 return maxTransactionTime;
979 uint256 BuildMerkleTree() const
982 BOOST_FOREACH(const CTransaction& tx, vtx)
983 vMerkleTree.push_back(tx.GetHash());
985 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
987 for (int i = 0; i < nSize; i += 2)
989 int i2 = std::min(i+1, nSize-1);
990 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
991 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
995 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
998 std::vector<uint256> GetMerkleBranch(int nIndex) const
1000 if (vMerkleTree.empty())
1002 std::vector<uint256> vMerkleBranch;
1004 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1006 int i = std::min(nIndex^1, nSize-1);
1007 vMerkleBranch.push_back(vMerkleTree[j+i]);
1011 return vMerkleBranch;
1014 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1018 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1021 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1023 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1030 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1032 // Open history file to append
1033 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1035 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1037 // Write index header
1038 unsigned int nSize = fileout.GetSerializeSize(*this);
1039 fileout << FLATDATA(pchMessageStart) << nSize;
1042 long fileOutPos = ftell(fileout);
1044 return error("CBlock::WriteToDisk() : ftell failed");
1045 nBlockPosRet = fileOutPos;
1048 // Flush stdio buffers and commit to disk before returning
1050 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1051 FileCommit(fileout);
1056 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1060 // Open history file to read
1061 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1063 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1064 if (!fReadTransactions)
1065 filein.nType |= SER_BLOCKHEADERONLY;
1071 catch (std::exception &e) {
1072 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1076 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1077 return error("CBlock::ReadFromDisk() : errors in block header");
1086 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1087 GetHash().ToString().c_str(),
1089 hashPrevBlock.ToString().c_str(),
1090 hashMerkleRoot.ToString().c_str(),
1091 nTime, nBits, nNonce,
1093 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1094 for (unsigned int i = 0; i < vtx.size(); i++)
1099 printf(" vMerkleTree: ");
1100 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1101 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1106 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1107 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1108 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1109 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1110 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1111 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1113 bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1114 bool SignBlock(const CKeyStore& keystore);
1115 bool CheckBlockSignature(bool fProofOfStake) const;
1118 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1126 /** The block chain is a tree shaped structure starting with the
1127 * genesis block at the root, with each block potentially having multiple
1128 * candidates to be the next block. pprev and pnext link a path through the
1129 * main/longest chain. A blockindex may have multiple pprev pointing back
1130 * to it, but pnext will only point forward to the longest branch, or will
1131 * be null if the block is not part of the longest chain.
1136 const uint256* phashBlock;
1140 unsigned int nBlockPos;
1141 uint256 nChainTrust; // ppcoin: trust score of block chain
1147 unsigned int nFlags; // ppcoin: block index flags
1150 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1151 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1152 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1155 uint64 nStakeModifier; // hash modifier for proof-of-stake
1156 unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1158 // proof-of-stake specific fields
1159 COutPoint prevoutStake;
1160 unsigned int nStakeTime;
1161 uint256 hashProofOfStake;
1165 uint256 hashMerkleRoot;
1168 unsigned int nNonce;
1183 nStakeModifierChecksum = 0;
1184 hashProofOfStake = 0;
1185 prevoutStake.SetNull();
1195 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1201 nBlockPos = nBlockPosIn;
1208 nStakeModifierChecksum = 0;
1209 hashProofOfStake = 0;
1210 if (block.IsProofOfStake())
1213 prevoutStake = block.vtx[1].vin[0].prevout;
1214 nStakeTime = block.vtx[1].nTime;
1218 prevoutStake.SetNull();
1222 nVersion = block.nVersion;
1223 hashMerkleRoot = block.hashMerkleRoot;
1224 nTime = block.nTime;
1225 nBits = block.nBits;
1226 nNonce = block.nNonce;
1229 CBlock GetBlockHeader() const
1232 block.nVersion = nVersion;
1234 block.hashPrevBlock = pprev->GetBlockHash();
1235 block.hashMerkleRoot = hashMerkleRoot;
1236 block.nTime = nTime;
1237 block.nBits = nBits;
1238 block.nNonce = nNonce;
1242 uint256 GetBlockHash() const
1247 int64 GetBlockTime() const
1249 return (int64)nTime;
1252 uint256 GetBlockTrust() const;
1254 bool IsInMainChain() const
1256 return (pnext || this == pindexBest);
1259 bool CheckIndex() const
1264 enum { nMedianTimeSpan=11 };
1266 int64 GetMedianTimePast() const
1268 int64 pmedian[nMedianTimeSpan];
1269 int64* pbegin = &pmedian[nMedianTimeSpan];
1270 int64* pend = &pmedian[nMedianTimeSpan];
1272 const CBlockIndex* pindex = this;
1273 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1274 *(--pbegin) = pindex->GetBlockTime();
1276 std::sort(pbegin, pend);
1277 return pbegin[(pend - pbegin)/2];
1280 int64 GetMedianTime() const
1282 const CBlockIndex* pindex = this;
1283 for (int i = 0; i < nMedianTimeSpan/2; i++)
1286 return GetBlockTime();
1287 pindex = pindex->pnext;
1289 return pindex->GetMedianTimePast();
1293 * Returns true if there are nRequired or more blocks of minVersion or above
1294 * in the last nToCheck blocks, starting at pstart and going backwards.
1296 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1297 unsigned int nRequired, unsigned int nToCheck);
1300 bool IsProofOfWork() const
1302 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1305 bool IsProofOfStake() const
1307 return (nFlags & BLOCK_PROOF_OF_STAKE);
1310 void SetProofOfStake()
1312 nFlags |= BLOCK_PROOF_OF_STAKE;
1315 unsigned int GetStakeEntropyBit() const
1317 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1320 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1322 if (nEntropyBit > 1)
1324 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1328 bool GeneratedStakeModifier() const
1330 return (nFlags & BLOCK_STAKE_MODIFIER);
1333 void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1335 nStakeModifier = nModifier;
1336 if (fGeneratedStakeModifier)
1337 nFlags |= BLOCK_STAKE_MODIFIER;
1340 std::string ToString() const
1342 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)",
1343 pprev, pnext, nFile, nBlockPos, nHeight,
1344 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1345 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1346 nStakeModifier, nStakeModifierChecksum,
1347 hashProofOfStake.ToString().c_str(),
1348 prevoutStake.ToString().c_str(), nStakeTime,
1349 hashMerkleRoot.ToString().c_str(),
1350 GetBlockHash().ToString().c_str());
1355 printf("%s\n", ToString().c_str());
1361 /** Used to marshal pointers into hashes for db storage. */
1362 class CDiskBlockIndex : public CBlockIndex
1374 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1376 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1377 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1382 if (!(nType & SER_GETHASH))
1383 READWRITE(nVersion);
1385 READWRITE(hashNext);
1387 READWRITE(nBlockPos);
1390 READWRITE(nMoneySupply);
1392 READWRITE(nStakeModifier);
1393 if (IsProofOfStake())
1395 READWRITE(prevoutStake);
1396 READWRITE(nStakeTime);
1397 READWRITE(hashProofOfStake);
1401 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1402 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1403 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1407 READWRITE(this->nVersion);
1408 READWRITE(hashPrev);
1409 READWRITE(hashMerkleRoot);
1415 uint256 GetBlockHash() const
1418 block.nVersion = nVersion;
1419 block.hashPrevBlock = hashPrev;
1420 block.hashMerkleRoot = hashMerkleRoot;
1421 block.nTime = nTime;
1422 block.nBits = nBits;
1423 block.nNonce = nNonce;
1424 return block.GetHash();
1428 std::string ToString() const
1430 std::string str = "CDiskBlockIndex(";
1431 str += CBlockIndex::ToString();
1432 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1433 GetBlockHash().ToString().c_str(),
1434 hashPrev.ToString().c_str(),
1435 hashNext.ToString().c_str());
1441 printf("%s\n", ToString().c_str());
1452 /** Describes a place in the block chain to another node such that if the
1453 * other node doesn't have the same branch, it can find a recent common trunk.
1454 * The further back it is, the further before the fork it may be.
1459 std::vector<uint256> vHave;
1466 explicit CBlockLocator(const CBlockIndex* pindex)
1471 explicit CBlockLocator(uint256 hashBlock)
1473 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1474 if (mi != mapBlockIndex.end())
1478 CBlockLocator(const std::vector<uint256>& vHaveIn)
1485 if (!(nType & SER_GETHASH))
1486 READWRITE(nVersion);
1497 return vHave.empty();
1500 void Set(const CBlockIndex* pindex)
1506 vHave.push_back(pindex->GetBlockHash());
1508 // Exponentially larger steps back
1509 for (int i = 0; pindex && i < nStep; i++)
1510 pindex = pindex->pprev;
1511 if (vHave.size() > 10)
1514 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1517 int GetDistanceBack()
1519 // Retrace how far back it was in the sender's branch
1522 BOOST_FOREACH(const uint256& hash, vHave)
1524 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1525 if (mi != mapBlockIndex.end())
1527 CBlockIndex* pindex = (*mi).second;
1528 if (pindex->IsInMainChain())
1538 CBlockIndex* GetBlockIndex()
1540 // Find the first block the caller has in the main chain
1541 BOOST_FOREACH(const uint256& hash, vHave)
1543 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1544 if (mi != mapBlockIndex.end())
1546 CBlockIndex* pindex = (*mi).second;
1547 if (pindex->IsInMainChain())
1551 return pindexGenesisBlock;
1554 uint256 GetBlockHash()
1556 // Find the first block the caller has in the main chain
1557 BOOST_FOREACH(const uint256& hash, vHave)
1559 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1560 if (mi != mapBlockIndex.end())
1562 CBlockIndex* pindex = (*mi).second;
1563 if (pindex->IsInMainChain())
1567 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1572 CBlockIndex* pindex = GetBlockIndex();
1575 return pindex->nHeight;
1589 mutable CCriticalSection cs;
1590 std::map<uint256, CTransaction> mapTx;
1591 std::map<COutPoint, CInPoint> mapNextTx;
1593 bool accept(CTxDB& txdb, CTransaction &tx,
1594 bool fCheckInputs, bool* pfMissingInputs);
1595 bool addUnchecked(const uint256& hash, CTransaction &tx);
1596 bool remove(CTransaction &tx);
1598 void queryHashes(std::vector<uint256>& vtxid);
1600 unsigned long size()
1603 return mapTx.size();
1606 bool exists(uint256 hash)
1608 return (mapTx.count(hash) != 0);
1611 CTransaction& lookup(uint256 hash)
1617 extern CTxMemPool mempool;