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;
39 static const unsigned int STAKE_SWITCH_TIME = 1371686400; // 20 Jun 2013 00:00:00
40 static const unsigned int TARGETS_SWITCH_TIME = 1374278400; // 20 Jul 2013 00:00:00
41 static const unsigned int LOCKS_SWITCH_TIME = 1376956800; // 20 Aug 2013 00:00:00
42 static const unsigned int CHAINCHECKS_SWITCH_TIME = 1379635200; // 20 Sep 2013 00:00:00
44 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
45 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
46 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
49 static const int fHaveUPnP = true;
51 static const int fHaveUPnP = false;
54 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
55 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
57 static const int64 nMaxClockDrift = 2 * 60 * 60; // two hours
59 extern CScript COINBASE_FLAGS;
62 extern CCriticalSection cs_main;
63 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
64 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
65 extern CBlockIndex* pindexGenesisBlock;
66 extern unsigned int nStakeMinAge;
67 extern int nCoinbaseMaturity;
68 extern int nBestHeight;
69 extern CBigNum bnBestChainTrust;
70 extern CBigNum bnBestInvalidTrust;
71 extern uint256 hashBestChain;
72 extern CBlockIndex* pindexBest;
73 extern unsigned int nTransactionsUpdated;
74 extern uint64 nLastBlockTx;
75 extern uint64 nLastBlockSize;
76 extern int64 nLastCoinStakeSearchInterval;
77 extern const std::string strMessageMagic;
78 extern double dHashesPerSec;
79 extern int64 nHPSTimerStart;
80 extern int64 nTimeBestReceived;
81 extern CCriticalSection cs_setpwalletRegistered;
82 extern std::set<CWallet*> setpwalletRegistered;
83 extern unsigned char pchMessageStart[4];
84 extern std::map<uint256, CBlock*> mapOrphanBlocks;
87 extern int64 nTransactionFee;
89 // Minimum disk space required - used in CheckDiskSpace()
90 static const uint64 nMinDiskSpace = 52428800;
97 void RegisterWallet(CWallet* pwalletIn);
98 void UnregisterWallet(CWallet* pwalletIn);
99 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
100 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
101 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
102 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
103 FILE* AppendBlockFile(unsigned int& nFileRet);
104 bool LoadBlockIndex(bool fAllowNew=true);
105 void PrintBlockTree();
106 CBlockIndex* FindBlockByHeight(int nHeight);
107 bool ProcessMessages(CNode* pfrom);
108 bool SendMessages(CNode* pto, bool fSendTrickle);
109 bool LoadExternalBlockFile(FILE* fileIn);
110 void GenerateBitcoins(bool fGenerate, CWallet* pwallet);
111 CBlock* CreateNewBlock(CWallet* pwallet, bool fProofOfStake=false);
112 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
113 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
114 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
115 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
116 int64 GetProofOfWorkReward(unsigned int nBits);
117 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime);
118 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
119 int GetNumBlocksOfPeers();
120 bool IsInitialBlockDownload();
121 std::string GetWarnings(std::string strFor);
122 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
123 uint256 WantedByOrphan(const CBlock* pblockOrphan);
124 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
125 void BitcoinMiner(CWallet *pwallet, bool fProofOfStake);
126 void ResendWalletTransactions();
137 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
139 /** Position on disk for a particular transaction. */
144 unsigned int nBlockPos;
152 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
155 nBlockPos = nBlockPosIn;
159 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
160 void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
161 bool IsNull() const { return (nFile == (unsigned int) -1); }
163 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
165 return (a.nFile == b.nFile &&
166 a.nBlockPos == b.nBlockPos &&
167 a.nTxPos == b.nTxPos);
170 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
176 std::string ToString() const
181 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
186 printf("%s", ToString().c_str());
192 /** An inpoint - a combination of a transaction and an index n into its vin */
199 CInPoint() { SetNull(); }
200 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
201 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
202 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
207 /** An outpoint - a combination of a transaction hash and an index n into its vout */
214 COutPoint() { SetNull(); }
215 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
216 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
217 void SetNull() { hash = 0; n = (unsigned int) -1; }
218 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
220 friend bool operator<(const COutPoint& a, const COutPoint& b)
222 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
225 friend bool operator==(const COutPoint& a, const COutPoint& b)
227 return (a.hash == b.hash && a.n == b.n);
230 friend bool operator!=(const COutPoint& a, const COutPoint& b)
235 std::string ToString() const
237 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
242 printf("%s\n", ToString().c_str());
249 /** An input of a transaction. It contains the location of the previous
250 * transaction's output that it claims and a signature that matches the
251 * output's public key.
258 unsigned int nSequence;
262 nSequence = std::numeric_limits<unsigned int>::max();
265 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
268 scriptSig = scriptSigIn;
269 nSequence = nSequenceIn;
272 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
274 prevout = COutPoint(hashPrevTx, nOut);
275 scriptSig = scriptSigIn;
276 nSequence = nSequenceIn;
282 READWRITE(scriptSig);
283 READWRITE(nSequence);
288 return (nSequence == std::numeric_limits<unsigned int>::max());
291 friend bool operator==(const CTxIn& a, const CTxIn& b)
293 return (a.prevout == b.prevout &&
294 a.scriptSig == b.scriptSig &&
295 a.nSequence == b.nSequence);
298 friend bool operator!=(const CTxIn& a, const CTxIn& b)
303 std::string ToStringShort() const
305 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
308 std::string ToString() const
312 str += prevout.ToString();
313 if (prevout.IsNull())
314 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
316 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
317 if (nSequence != std::numeric_limits<unsigned int>::max())
318 str += strprintf(", nSequence=%u", nSequence);
325 printf("%s\n", ToString().c_str());
332 /** An output of a transaction. It contains the public key that the next input
333 * must be able to sign with to claim it.
339 CScript scriptPubKey;
346 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
349 scriptPubKey = scriptPubKeyIn;
355 READWRITE(scriptPubKey);
361 scriptPubKey.clear();
366 return (nValue == -1);
372 scriptPubKey.clear();
377 return (nValue == 0 && scriptPubKey.empty());
380 uint256 GetHash() const
382 return SerializeHash(*this);
385 friend bool operator==(const CTxOut& a, const CTxOut& b)
387 return (a.nValue == b.nValue &&
388 a.scriptPubKey == b.scriptPubKey);
391 friend bool operator!=(const CTxOut& a, const CTxOut& b)
396 std::string ToStringShort() const
398 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
401 std::string ToString() const
403 if (IsEmpty()) return "CTxOut(empty)";
404 if (scriptPubKey.size() < 6)
405 return "CTxOut(error)";
406 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
411 printf("%s\n", ToString().c_str());
425 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
427 /** The basic transaction that is broadcasted on the network and contained in
428 * blocks. A transaction can contain multiple inputs and outputs.
433 static const int CURRENT_VERSION=1;
436 std::vector<CTxIn> vin;
437 std::vector<CTxOut> vout;
438 unsigned int nLockTime;
440 // Denial-of-service detection:
442 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
451 READWRITE(this->nVersion);
452 nVersion = this->nVersion;
456 READWRITE(nLockTime);
461 nVersion = CTransaction::CURRENT_VERSION;
462 nTime = GetAdjustedTime();
466 nDoS = 0; // Denial-of-service prevention
471 return (vin.empty() && vout.empty());
474 uint256 GetHash() const
476 return SerializeHash(*this);
479 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
481 // Time based nLockTime implemented in 0.1.6
484 if (nBlockHeight == 0)
485 nBlockHeight = nBestHeight;
487 nBlockTime = GetAdjustedTime();
488 if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
490 BOOST_FOREACH(const CTxIn& txin, vin)
496 bool IsNewerThan(const CTransaction& old) const
498 if (vin.size() != old.vin.size())
500 for (unsigned int i = 0; i < vin.size(); i++)
501 if (vin[i].prevout != old.vin[i].prevout)
505 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
506 for (unsigned int i = 0; i < vin.size(); i++)
508 if (vin[i].nSequence != old.vin[i].nSequence)
510 if (vin[i].nSequence <= nLowest)
513 nLowest = vin[i].nSequence;
515 if (old.vin[i].nSequence < nLowest)
518 nLowest = old.vin[i].nSequence;
525 bool IsCoinBase() const
527 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
530 bool IsCoinStake() const
532 // ppcoin: the coin stake transaction is marked with the first output empty
533 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
536 /** Check for standard transaction types
537 @return True if all outputs (scriptPubKeys) use only standard transaction forms
539 bool IsStandard() const;
541 /** Check for standard transaction types
542 @param[in] mapInputs Map of previous transactions that have outputs we're spending
543 @return True if all inputs (scriptSigs) use only standard transaction forms
544 @see CTransaction::FetchInputs
546 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
548 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
549 @return number of sigops this transaction's outputs will produce when spent
550 @see CTransaction::FetchInputs
552 unsigned int GetLegacySigOpCount() const;
554 /** Count ECDSA signature operations in pay-to-script-hash inputs.
556 @param[in] mapInputs Map of previous transactions that have outputs we're spending
557 @return maximum number of sigops required to validate this transaction's inputs
558 @see CTransaction::FetchInputs
560 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
562 /** Amount of bitcoins spent by this transaction.
563 @return sum of all outputs (note: does not include fees)
565 int64 GetValueOut() const
568 BOOST_FOREACH(const CTxOut& txout, vout)
570 nValueOut += txout.nValue;
571 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
572 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
577 /** Amount of bitcoins coming in to this transaction
578 Note that lightweight clients may not know anything besides the hash of previous transactions,
579 so may not be able to calculate this.
581 @param[in] mapInputs Map of previous transactions that have outputs we're spending
582 @return Sum of value of all inputs (scriptSigs)
583 @see CTransaction::FetchInputs
585 int64 GetValueIn(const MapPrevTx& mapInputs) const;
587 static bool AllowFree(double dPriority)
589 // Large (in bytes) low-priority (new, small-coin) transactions
591 return dPriority > COIN * 144 / 250;
594 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK) const;
596 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
598 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
600 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
603 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
604 return error("CTransaction::ReadFromDisk() : fseek failed");
609 catch (std::exception &e) {
610 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
613 // Return file pointer
616 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
617 return error("CTransaction::ReadFromDisk() : second fseek failed");
618 *pfileRet = filein.release();
623 friend bool operator==(const CTransaction& a, const CTransaction& b)
625 return (a.nVersion == b.nVersion &&
626 a.nTime == b.nTime &&
629 a.nLockTime == b.nLockTime);
632 friend bool operator!=(const CTransaction& a, const CTransaction& b)
637 std::string ToStringShort() const
640 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
644 std::string ToString() const
647 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
648 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%d)\n",
649 GetHash().ToString().substr(0,10).c_str(),
655 for (unsigned int i = 0; i < vin.size(); i++)
656 str += " " + vin[i].ToString() + "\n";
657 for (unsigned int i = 0; i < vout.size(); i++)
658 str += " " + vout[i].ToString() + "\n";
664 printf("%s", ToString().c_str());
668 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
669 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
670 bool ReadFromDisk(COutPoint prevout);
671 bool DisconnectInputs(CTxDB& txdb);
673 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
675 @param[in] txdb Transaction database
676 @param[in] mapTestPool List of pending changes to the transaction index database
677 @param[in] fBlock True if being called to add a new best-block to the chain
678 @param[in] fMiner True if being called by CreateNewBlock
679 @param[out] inputsRet Pointers to this transaction's inputs
680 @param[out] fInvalid returns true if transaction is invalid
681 @return Returns true if all inputs are in txdb or mapTestPool
683 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
684 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
686 /** Sanity check previous transactions, then, if all checks succeed,
687 mark them as spent by this transaction.
689 @param[in] inputs Previous transactions (from FetchInputs)
690 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
691 @param[in] posThisTx Position of this transaction on disk
692 @param[in] pindexBlock
693 @param[in] fBlock true if called from ConnectBlock
694 @param[in] fMiner true if called from CreateNewBlock
695 @param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
696 @return Returns true if all checks succeed
698 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs,
699 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
700 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
701 bool ClientConnectInputs();
702 bool CheckTransaction() const;
703 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
704 bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const; // ppcoin: get transaction coin age
707 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
714 /** A transaction with a merkle branch linking it to the block chain. */
715 class CMerkleTx : public CTransaction
719 std::vector<uint256> vMerkleBranch;
723 mutable bool fMerkleVerified;
731 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
740 fMerkleVerified = false;
746 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
747 nVersion = this->nVersion;
748 READWRITE(hashBlock);
749 READWRITE(vMerkleBranch);
754 int SetMerkleBranch(const CBlock* pblock=NULL);
755 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
756 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
757 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
758 int GetBlocksToMaturity() const;
759 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
760 bool AcceptToMemoryPool();
766 /** A txdb record that contains the disk location of a transaction and the
767 * locations of transactions that spend its outputs. vSpent is really only
768 * used as a flag, but having the location is very helpful for debugging.
774 std::vector<CDiskTxPos> vSpent;
781 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
784 vSpent.resize(nOutputs);
789 if (!(nType & SER_GETHASH))
806 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
808 return (a.pos == b.pos &&
809 a.vSpent == b.vSpent);
812 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
816 int GetDepthInMainChain() const;
824 /** Nodes collect new transactions into a block, hash them into a hash tree,
825 * and scan through nonce values to make the block's hash satisfy proof-of-work
826 * requirements. When they solve the proof-of-work, they broadcast the block
827 * to everyone and the block is added to the block chain. The first transaction
828 * in the block is a special one that creates a new coin owned by the creator
831 * Blocks are appended to blk0001.dat files on disk. Their location on disk
832 * is indexed by CBlockIndex objects in memory.
838 static const int CURRENT_VERSION=5;
840 uint256 hashPrevBlock;
841 uint256 hashMerkleRoot;
847 std::vector<CTransaction> vtx;
849 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
850 std::vector<unsigned char> vchBlockSig;
853 mutable std::vector<uint256> vMerkleTree;
855 // Denial-of-service detection:
857 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
866 READWRITE(this->nVersion);
867 nVersion = this->nVersion;
868 READWRITE(hashPrevBlock);
869 READWRITE(hashMerkleRoot);
874 // ConnectBlock depends on vtx following header to generate CDiskTxPos
875 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
878 READWRITE(vchBlockSig);
882 const_cast<CBlock*>(this)->vtx.clear();
883 const_cast<CBlock*>(this)->vchBlockSig.clear();
889 nVersion = CBlock::CURRENT_VERSION;
906 uint256 GetHash() const
909 void * scratchbuff = scrypt_buffer_alloc();
911 scrypt_hash(CVOIDBEGIN(nVersion), sizeof(block_header), UINTBEGIN(thash), scratchbuff);
913 scrypt_buffer_free(scratchbuff);
918 int64 GetBlockTime() const
923 void UpdateTime(const CBlockIndex* pindexPrev);
925 // ppcoin: entropy bit for stake modifier if chosen by modifier
926 unsigned int GetStakeEntropyBit(unsigned int nHeight) const
928 // Protocol switch to support p2pool at novacoin block #9689
929 if (nHeight >= 9689 || fTestNet)
931 // Take last bit of block hash as entropy bit
932 unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
933 if (fDebug && GetBoolArg("-printstakemodifier"))
934 printf("GetStakeEntropyBit: nHeight=%u hashBlock=%s nEntropyBit=%u\n", nHeight, GetHash().ToString().c_str(), nEntropyBit);
937 // Before novacoin block #9689 - old protocol
938 uint160 hashSig = Hash160(vchBlockSig);
939 if (fDebug && GetBoolArg("-printstakemodifier"))
940 printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
941 hashSig >>= 159; // take the first bit of the hash
942 if (fDebug && GetBoolArg("-printstakemodifier"))
943 printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
944 return hashSig.Get64();
947 // ppcoin: two types of block: proof-of-work or proof-of-stake
948 bool IsProofOfStake() const
950 return (vtx.size() > 1 && vtx[1].IsCoinStake());
953 bool IsProofOfWork() const
955 return !IsProofOfStake();
958 std::pair<COutPoint, unsigned int> GetProofOfStake() const
960 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
963 // ppcoin: get max transaction timestamp
964 int64 GetMaxTransactionTime() const
966 int64 maxTransactionTime = 0;
967 BOOST_FOREACH(const CTransaction& tx, vtx)
968 maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
969 return maxTransactionTime;
972 uint256 BuildMerkleTree() const
975 BOOST_FOREACH(const CTransaction& tx, vtx)
976 vMerkleTree.push_back(tx.GetHash());
978 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
980 for (int i = 0; i < nSize; i += 2)
982 int i2 = std::min(i+1, nSize-1);
983 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
984 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
988 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
991 std::vector<uint256> GetMerkleBranch(int nIndex) const
993 if (vMerkleTree.empty())
995 std::vector<uint256> vMerkleBranch;
997 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
999 int i = std::min(nIndex^1, nSize-1);
1000 vMerkleBranch.push_back(vMerkleTree[j+i]);
1004 return vMerkleBranch;
1007 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1011 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1014 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1016 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1023 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1025 // Open history file to append
1026 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1028 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1030 // Write index header
1031 unsigned int nSize = fileout.GetSerializeSize(*this);
1032 fileout << FLATDATA(pchMessageStart) << nSize;
1035 long fileOutPos = ftell(fileout);
1037 return error("CBlock::WriteToDisk() : ftell failed");
1038 nBlockPosRet = fileOutPos;
1041 // Flush stdio buffers and commit to disk before returning
1043 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1044 FileCommit(fileout);
1049 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1053 // Open history file to read
1054 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1056 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1057 if (!fReadTransactions)
1058 filein.nType |= SER_BLOCKHEADERONLY;
1064 catch (std::exception &e) {
1065 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1069 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1070 return error("CBlock::ReadFromDisk() : errors in block header");
1079 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1080 GetHash().ToString().c_str(),
1082 hashPrevBlock.ToString().c_str(),
1083 hashMerkleRoot.ToString().c_str(),
1084 nTime, nBits, nNonce,
1086 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1087 for (unsigned int i = 0; i < vtx.size(); i++)
1092 printf(" vMerkleTree: ");
1093 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1094 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1099 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1100 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1101 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1102 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1103 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1104 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true) const;
1106 bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1107 bool SignBlock(const CKeyStore& keystore);
1108 bool CheckBlockSignature() const;
1111 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1119 /** The block chain is a tree shaped structure starting with the
1120 * genesis block at the root, with each block potentially having multiple
1121 * candidates to be the next block. pprev and pnext link a path through the
1122 * main/longest chain. A blockindex may have multiple pprev pointing back
1123 * to it, but pnext will only point forward to the longest branch, or will
1124 * be null if the block is not part of the longest chain.
1129 const uint256* phashBlock;
1133 unsigned int nBlockPos;
1134 CBigNum bnChainTrust; // ppcoin: trust score of block chain
1140 unsigned int nFlags; // ppcoin: block index flags
1143 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1144 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1145 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1148 uint64 nStakeModifier; // hash modifier for proof-of-stake
1149 unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1151 // proof-of-stake specific fields
1152 COutPoint prevoutStake;
1153 unsigned int nStakeTime;
1154 uint256 hashProofOfStake;
1158 uint256 hashMerkleRoot;
1161 unsigned int nNonce;
1176 nStakeModifierChecksum = 0;
1177 hashProofOfStake = 0;
1178 prevoutStake.SetNull();
1188 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1194 nBlockPos = nBlockPosIn;
1201 nStakeModifierChecksum = 0;
1202 hashProofOfStake = 0;
1203 if (block.IsProofOfStake())
1206 prevoutStake = block.vtx[1].vin[0].prevout;
1207 nStakeTime = block.vtx[1].nTime;
1211 prevoutStake.SetNull();
1215 nVersion = block.nVersion;
1216 hashMerkleRoot = block.hashMerkleRoot;
1217 nTime = block.nTime;
1218 nBits = block.nBits;
1219 nNonce = block.nNonce;
1222 CBlock GetBlockHeader() const
1225 block.nVersion = nVersion;
1227 block.hashPrevBlock = pprev->GetBlockHash();
1228 block.hashMerkleRoot = hashMerkleRoot;
1229 block.nTime = nTime;
1230 block.nBits = nBits;
1231 block.nNonce = nNonce;
1235 uint256 GetBlockHash() const
1240 int64 GetBlockTime() const
1242 return (int64)nTime;
1245 CBigNum GetBlockTrust() const;
1247 bool IsInMainChain() const
1249 return (pnext || this == pindexBest);
1252 bool CheckIndex() const
1257 enum { nMedianTimeSpan=11 };
1259 int64 GetMedianTimePast() const
1261 int64 pmedian[nMedianTimeSpan];
1262 int64* pbegin = &pmedian[nMedianTimeSpan];
1263 int64* pend = &pmedian[nMedianTimeSpan];
1265 const CBlockIndex* pindex = this;
1266 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1267 *(--pbegin) = pindex->GetBlockTime();
1269 std::sort(pbegin, pend);
1270 return pbegin[(pend - pbegin)/2];
1273 int64 GetMedianTime() const
1275 const CBlockIndex* pindex = this;
1276 for (int i = 0; i < nMedianTimeSpan/2; i++)
1279 return GetBlockTime();
1280 pindex = pindex->pnext;
1282 return pindex->GetMedianTimePast();
1286 * Returns true if there are nRequired or more blocks of minVersion or above
1287 * in the last nToCheck blocks, starting at pstart and going backwards.
1289 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1290 unsigned int nRequired, unsigned int nToCheck);
1293 bool IsProofOfWork() const
1295 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1298 bool IsProofOfStake() const
1300 return (nFlags & BLOCK_PROOF_OF_STAKE);
1303 void SetProofOfStake()
1305 nFlags |= BLOCK_PROOF_OF_STAKE;
1308 unsigned int GetStakeEntropyBit() const
1310 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1313 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1315 if (nEntropyBit > 1)
1317 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1321 bool GeneratedStakeModifier() const
1323 return (nFlags & BLOCK_STAKE_MODIFIER);
1326 void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1328 nStakeModifier = nModifier;
1329 if (fGeneratedStakeModifier)
1330 nFlags |= BLOCK_STAKE_MODIFIER;
1333 std::string ToString() const
1335 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)",
1336 pprev, pnext, nFile, nBlockPos, nHeight,
1337 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1338 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1339 nStakeModifier, nStakeModifierChecksum,
1340 hashProofOfStake.ToString().c_str(),
1341 prevoutStake.ToString().c_str(), nStakeTime,
1342 hashMerkleRoot.ToString().c_str(),
1343 GetBlockHash().ToString().c_str());
1348 printf("%s\n", ToString().c_str());
1354 /** Used to marshal pointers into hashes for db storage. */
1355 class CDiskBlockIndex : public CBlockIndex
1367 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1369 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1370 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1375 if (!(nType & SER_GETHASH))
1376 READWRITE(nVersion);
1378 READWRITE(hashNext);
1380 READWRITE(nBlockPos);
1383 READWRITE(nMoneySupply);
1385 READWRITE(nStakeModifier);
1386 if (IsProofOfStake())
1388 READWRITE(prevoutStake);
1389 READWRITE(nStakeTime);
1390 READWRITE(hashProofOfStake);
1394 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1395 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1396 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1400 READWRITE(this->nVersion);
1401 READWRITE(hashPrev);
1402 READWRITE(hashMerkleRoot);
1408 uint256 GetBlockHash() const
1411 block.nVersion = nVersion;
1412 block.hashPrevBlock = hashPrev;
1413 block.hashMerkleRoot = hashMerkleRoot;
1414 block.nTime = nTime;
1415 block.nBits = nBits;
1416 block.nNonce = nNonce;
1417 return block.GetHash();
1421 std::string ToString() const
1423 std::string str = "CDiskBlockIndex(";
1424 str += CBlockIndex::ToString();
1425 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1426 GetBlockHash().ToString().c_str(),
1427 hashPrev.ToString().c_str(),
1428 hashNext.ToString().c_str());
1434 printf("%s\n", ToString().c_str());
1445 /** Describes a place in the block chain to another node such that if the
1446 * other node doesn't have the same branch, it can find a recent common trunk.
1447 * The further back it is, the further before the fork it may be.
1452 std::vector<uint256> vHave;
1459 explicit CBlockLocator(const CBlockIndex* pindex)
1464 explicit CBlockLocator(uint256 hashBlock)
1466 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1467 if (mi != mapBlockIndex.end())
1471 CBlockLocator(const std::vector<uint256>& vHaveIn)
1478 if (!(nType & SER_GETHASH))
1479 READWRITE(nVersion);
1490 return vHave.empty();
1493 void Set(const CBlockIndex* pindex)
1499 vHave.push_back(pindex->GetBlockHash());
1501 // Exponentially larger steps back
1502 for (int i = 0; pindex && i < nStep; i++)
1503 pindex = pindex->pprev;
1504 if (vHave.size() > 10)
1507 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1510 int GetDistanceBack()
1512 // Retrace how far back it was in the sender's branch
1515 BOOST_FOREACH(const uint256& hash, vHave)
1517 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1518 if (mi != mapBlockIndex.end())
1520 CBlockIndex* pindex = (*mi).second;
1521 if (pindex->IsInMainChain())
1531 CBlockIndex* GetBlockIndex()
1533 // Find the first block the caller has in the main chain
1534 BOOST_FOREACH(const uint256& hash, vHave)
1536 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1537 if (mi != mapBlockIndex.end())
1539 CBlockIndex* pindex = (*mi).second;
1540 if (pindex->IsInMainChain())
1544 return pindexGenesisBlock;
1547 uint256 GetBlockHash()
1549 // Find the first block the caller has in the main chain
1550 BOOST_FOREACH(const uint256& hash, vHave)
1552 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1553 if (mi != mapBlockIndex.end())
1555 CBlockIndex* pindex = (*mi).second;
1556 if (pindex->IsInMainChain())
1560 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1565 CBlockIndex* pindex = GetBlockIndex();
1568 return pindex->nHeight;
1582 mutable CCriticalSection cs;
1583 std::map<uint256, CTransaction> mapTx;
1584 std::map<COutPoint, CInPoint> mapNextTx;
1586 bool accept(CTxDB& txdb, CTransaction &tx,
1587 bool fCheckInputs, bool* pfMissingInputs);
1588 bool addUnchecked(const uint256& hash, CTransaction &tx);
1589 bool remove(CTransaction &tx);
1591 void queryHashes(std::vector<uint256>& vtxid);
1593 unsigned long size()
1596 return mapTx.size();
1599 bool exists(uint256 hash)
1601 return (mapTx.count(hash) != 0);
1604 CTransaction& lookup(uint256 hash)
1610 extern CTxMemPool mempool;