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
43 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
44 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
45 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
48 static const int fHaveUPnP = true;
50 static const int fHaveUPnP = false;
53 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
54 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
56 static const int64 nMaxClockDrift = 2 * 60 * 60; // two hours
58 extern CScript COINBASE_FLAGS;
61 extern CCriticalSection cs_main;
62 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
63 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
64 extern CBlockIndex* pindexGenesisBlock;
65 extern unsigned int nStakeMinAge;
66 extern int nCoinbaseMaturity;
67 extern int nBestHeight;
68 extern CBigNum bnBestChainTrust;
69 extern CBigNum bnBestInvalidTrust;
70 extern uint256 hashBestChain;
71 extern CBlockIndex* pindexBest;
72 extern unsigned int nTransactionsUpdated;
73 extern uint64 nLastBlockTx;
74 extern uint64 nLastBlockSize;
75 extern int64 nLastCoinStakeSearchInterval;
76 extern const std::string strMessageMagic;
77 extern double dHashesPerSec;
78 extern int64 nHPSTimerStart;
79 extern int64 nTimeBestReceived;
80 extern CCriticalSection cs_setpwalletRegistered;
81 extern std::set<CWallet*> setpwalletRegistered;
82 extern unsigned char pchMessageStart[4];
83 extern std::map<uint256, CBlock*> mapOrphanBlocks;
86 extern int64 nTransactionFee;
88 // Minimum disk space required - used in CheckDiskSpace()
89 static const uint64 nMinDiskSpace = 52428800;
96 void RegisterWallet(CWallet* pwalletIn);
97 void UnregisterWallet(CWallet* pwalletIn);
98 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
99 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
100 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
101 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
102 FILE* AppendBlockFile(unsigned int& nFileRet);
103 bool LoadBlockIndex(bool fAllowNew=true);
104 void PrintBlockTree();
105 CBlockIndex* FindBlockByHeight(int nHeight);
106 bool ProcessMessages(CNode* pfrom);
107 bool SendMessages(CNode* pto, bool fSendTrickle);
108 bool LoadExternalBlockFile(FILE* fileIn);
109 void GenerateBitcoins(bool fGenerate, CWallet* pwallet);
110 CBlock* CreateNewBlock(CWallet* pwallet, bool fProofOfStake=false);
111 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
112 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
113 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
114 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
115 int64 GetProofOfWorkReward(unsigned int nBits);
116 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime);
117 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
118 int GetNumBlocksOfPeers();
119 bool IsInitialBlockDownload();
120 std::string GetWarnings(std::string strFor);
121 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
122 uint256 WantedByOrphan(const CBlock* pblockOrphan);
123 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
124 void BitcoinMiner(CWallet *pwallet, bool fProofOfStake);
125 void ResendWalletTransactions();
136 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
138 /** Position on disk for a particular transaction. */
143 unsigned int nBlockPos;
151 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
154 nBlockPos = nBlockPosIn;
158 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
159 void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
160 bool IsNull() const { return (nFile == (unsigned int) -1); }
162 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
164 return (a.nFile == b.nFile &&
165 a.nBlockPos == b.nBlockPos &&
166 a.nTxPos == b.nTxPos);
169 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
175 std::string ToString() const
180 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
185 printf("%s", ToString().c_str());
191 /** An inpoint - a combination of a transaction and an index n into its vin */
198 CInPoint() { SetNull(); }
199 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
200 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
201 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
206 /** An outpoint - a combination of a transaction hash and an index n into its vout */
213 COutPoint() { SetNull(); }
214 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
215 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
216 void SetNull() { hash = 0; n = (unsigned int) -1; }
217 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
219 friend bool operator<(const COutPoint& a, const COutPoint& b)
221 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
224 friend bool operator==(const COutPoint& a, const COutPoint& b)
226 return (a.hash == b.hash && a.n == b.n);
229 friend bool operator!=(const COutPoint& a, const COutPoint& b)
234 std::string ToString() const
236 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
241 printf("%s\n", ToString().c_str());
248 /** An input of a transaction. It contains the location of the previous
249 * transaction's output that it claims and a signature that matches the
250 * output's public key.
257 unsigned int nSequence;
261 nSequence = std::numeric_limits<unsigned int>::max();
264 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
267 scriptSig = scriptSigIn;
268 nSequence = nSequenceIn;
271 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
273 prevout = COutPoint(hashPrevTx, nOut);
274 scriptSig = scriptSigIn;
275 nSequence = nSequenceIn;
281 READWRITE(scriptSig);
282 READWRITE(nSequence);
287 return (nSequence == std::numeric_limits<unsigned int>::max());
290 friend bool operator==(const CTxIn& a, const CTxIn& b)
292 return (a.prevout == b.prevout &&
293 a.scriptSig == b.scriptSig &&
294 a.nSequence == b.nSequence);
297 friend bool operator!=(const CTxIn& a, const CTxIn& b)
302 std::string ToStringShort() const
304 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
307 std::string ToString() const
311 str += prevout.ToString();
312 if (prevout.IsNull())
313 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
315 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
316 if (nSequence != std::numeric_limits<unsigned int>::max())
317 str += strprintf(", nSequence=%u", nSequence);
324 printf("%s\n", ToString().c_str());
331 /** An output of a transaction. It contains the public key that the next input
332 * must be able to sign with to claim it.
338 CScript scriptPubKey;
345 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
348 scriptPubKey = scriptPubKeyIn;
354 READWRITE(scriptPubKey);
360 scriptPubKey.clear();
365 return (nValue == -1);
371 scriptPubKey.clear();
376 return (nValue == 0 && scriptPubKey.empty());
379 uint256 GetHash() const
381 return SerializeHash(*this);
384 friend bool operator==(const CTxOut& a, const CTxOut& b)
386 return (a.nValue == b.nValue &&
387 a.scriptPubKey == b.scriptPubKey);
390 friend bool operator!=(const CTxOut& a, const CTxOut& b)
395 std::string ToStringShort() const
397 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
400 std::string ToString() const
402 if (IsEmpty()) return "CTxOut(empty)";
403 if (scriptPubKey.size() < 6)
404 return "CTxOut(error)";
405 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
410 printf("%s\n", ToString().c_str());
424 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
426 /** The basic transaction that is broadcasted on the network and contained in
427 * blocks. A transaction can contain multiple inputs and outputs.
432 static const int CURRENT_VERSION=1;
435 std::vector<CTxIn> vin;
436 std::vector<CTxOut> vout;
437 unsigned int nLockTime;
439 // Denial-of-service detection:
441 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
450 READWRITE(this->nVersion);
451 nVersion = this->nVersion;
455 READWRITE(nLockTime);
460 nVersion = CTransaction::CURRENT_VERSION;
461 nTime = GetAdjustedTime();
465 nDoS = 0; // Denial-of-service prevention
470 return (vin.empty() && vout.empty());
473 uint256 GetHash() const
475 return SerializeHash(*this);
478 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
480 // Time based nLockTime implemented in 0.1.6
483 if (nBlockHeight == 0)
484 nBlockHeight = nBestHeight;
486 nBlockTime = GetAdjustedTime();
487 if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
489 BOOST_FOREACH(const CTxIn& txin, vin)
495 bool IsNewerThan(const CTransaction& old) const
497 if (vin.size() != old.vin.size())
499 for (unsigned int i = 0; i < vin.size(); i++)
500 if (vin[i].prevout != old.vin[i].prevout)
504 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
505 for (unsigned int i = 0; i < vin.size(); i++)
507 if (vin[i].nSequence != old.vin[i].nSequence)
509 if (vin[i].nSequence <= nLowest)
512 nLowest = vin[i].nSequence;
514 if (old.vin[i].nSequence < nLowest)
517 nLowest = old.vin[i].nSequence;
524 bool IsCoinBase() const
526 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
529 bool IsCoinStake() const
531 // ppcoin: the coin stake transaction is marked with the first output empty
532 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
535 /** Check for standard transaction types
536 @return True if all outputs (scriptPubKeys) use only standard transaction forms
538 bool IsStandard() const;
540 /** Check for standard transaction types
541 @param[in] mapInputs Map of previous transactions that have outputs we're spending
542 @return True if all inputs (scriptSigs) use only standard transaction forms
543 @see CTransaction::FetchInputs
545 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
547 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
548 @return number of sigops this transaction's outputs will produce when spent
549 @see CTransaction::FetchInputs
551 unsigned int GetLegacySigOpCount() const;
553 /** Count ECDSA signature operations in pay-to-script-hash inputs.
555 @param[in] mapInputs Map of previous transactions that have outputs we're spending
556 @return maximum number of sigops required to validate this transaction's inputs
557 @see CTransaction::FetchInputs
559 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
561 /** Amount of bitcoins spent by this transaction.
562 @return sum of all outputs (note: does not include fees)
564 int64 GetValueOut() const
567 BOOST_FOREACH(const CTxOut& txout, vout)
569 nValueOut += txout.nValue;
570 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
571 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
576 /** Amount of bitcoins coming in to this transaction
577 Note that lightweight clients may not know anything besides the hash of previous transactions,
578 so may not be able to calculate this.
580 @param[in] mapInputs Map of previous transactions that have outputs we're spending
581 @return Sum of value of all inputs (scriptSigs)
582 @see CTransaction::FetchInputs
584 int64 GetValueIn(const MapPrevTx& mapInputs) const;
586 static bool AllowFree(double dPriority)
588 // Large (in bytes) low-priority (new, small-coin) transactions
590 return dPriority > COIN * 144 / 250;
593 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK) const;
595 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
597 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
599 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
602 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
603 return error("CTransaction::ReadFromDisk() : fseek failed");
608 catch (std::exception &e) {
609 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
612 // Return file pointer
615 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
616 return error("CTransaction::ReadFromDisk() : second fseek failed");
617 *pfileRet = filein.release();
622 friend bool operator==(const CTransaction& a, const CTransaction& b)
624 return (a.nVersion == b.nVersion &&
625 a.nTime == b.nTime &&
628 a.nLockTime == b.nLockTime);
631 friend bool operator!=(const CTransaction& a, const CTransaction& b)
636 std::string ToStringShort() const
639 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
643 std::string ToString() const
646 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
647 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%d)\n",
648 GetHash().ToString().substr(0,10).c_str(),
654 for (unsigned int i = 0; i < vin.size(); i++)
655 str += " " + vin[i].ToString() + "\n";
656 for (unsigned int i = 0; i < vout.size(); i++)
657 str += " " + vout[i].ToString() + "\n";
663 printf("%s", ToString().c_str());
667 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
668 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
669 bool ReadFromDisk(COutPoint prevout);
670 bool DisconnectInputs(CTxDB& txdb);
672 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
674 @param[in] txdb Transaction database
675 @param[in] mapTestPool List of pending changes to the transaction index database
676 @param[in] fBlock True if being called to add a new best-block to the chain
677 @param[in] fMiner True if being called by CreateNewBlock
678 @param[out] inputsRet Pointers to this transaction's inputs
679 @param[out] fInvalid returns true if transaction is invalid
680 @return Returns true if all inputs are in txdb or mapTestPool
682 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
683 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
685 /** Sanity check previous transactions, then, if all checks succeed,
686 mark them as spent by this transaction.
688 @param[in] inputs Previous transactions (from FetchInputs)
689 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
690 @param[in] posThisTx Position of this transaction on disk
691 @param[in] pindexBlock
692 @param[in] fBlock true if called from ConnectBlock
693 @param[in] fMiner true if called from CreateNewBlock
694 @param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
695 @return Returns true if all checks succeed
697 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs,
698 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
699 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
700 bool ClientConnectInputs();
701 bool CheckTransaction() const;
702 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
703 bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const; // ppcoin: get transaction coin age
706 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
713 /** A transaction with a merkle branch linking it to the block chain. */
714 class CMerkleTx : public CTransaction
718 std::vector<uint256> vMerkleBranch;
722 mutable bool fMerkleVerified;
730 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
739 fMerkleVerified = false;
745 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
746 nVersion = this->nVersion;
747 READWRITE(hashBlock);
748 READWRITE(vMerkleBranch);
753 int SetMerkleBranch(const CBlock* pblock=NULL);
754 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
755 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
756 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
757 int GetBlocksToMaturity() const;
758 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
759 bool AcceptToMemoryPool();
765 /** A txdb record that contains the disk location of a transaction and the
766 * locations of transactions that spend its outputs. vSpent is really only
767 * used as a flag, but having the location is very helpful for debugging.
773 std::vector<CDiskTxPos> vSpent;
780 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
783 vSpent.resize(nOutputs);
788 if (!(nType & SER_GETHASH))
805 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
807 return (a.pos == b.pos &&
808 a.vSpent == b.vSpent);
811 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
815 int GetDepthInMainChain() const;
823 /** Nodes collect new transactions into a block, hash them into a hash tree,
824 * and scan through nonce values to make the block's hash satisfy proof-of-work
825 * requirements. When they solve the proof-of-work, they broadcast the block
826 * to everyone and the block is added to the block chain. The first transaction
827 * in the block is a special one that creates a new coin owned by the creator
830 * Blocks are appended to blk0001.dat files on disk. Their location on disk
831 * is indexed by CBlockIndex objects in memory.
837 static const int CURRENT_VERSION=5;
839 uint256 hashPrevBlock;
840 uint256 hashMerkleRoot;
846 std::vector<CTransaction> vtx;
848 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
849 std::vector<unsigned char> vchBlockSig;
852 mutable std::vector<uint256> vMerkleTree;
854 // Denial-of-service detection:
856 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
865 READWRITE(this->nVersion);
866 nVersion = this->nVersion;
867 READWRITE(hashPrevBlock);
868 READWRITE(hashMerkleRoot);
873 // ConnectBlock depends on vtx following header to generate CDiskTxPos
874 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
877 READWRITE(vchBlockSig);
881 const_cast<CBlock*>(this)->vtx.clear();
882 const_cast<CBlock*>(this)->vchBlockSig.clear();
888 nVersion = CBlock::CURRENT_VERSION;
905 uint256 GetHash() const
908 void * scratchbuff = scrypt_buffer_alloc();
910 scrypt_hash(CVOIDBEGIN(nVersion), sizeof(block_header), UINTBEGIN(thash), scratchbuff);
912 scrypt_buffer_free(scratchbuff);
917 int64 GetBlockTime() const
922 void UpdateTime(const CBlockIndex* pindexPrev);
924 // ppcoin: entropy bit for stake modifier if chosen by modifier
925 unsigned int GetStakeEntropyBit(unsigned int nHeight) const
927 // Protocol switch to support p2pool at novacoin block #9689
928 if (nHeight >= 9689 || fTestNet)
930 // Take last bit of block hash as entropy bit
931 unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
932 if (fDebug && GetBoolArg("-printstakemodifier"))
933 printf("GetStakeEntropyBit: nHeight=%u hashBlock=%s nEntropyBit=%u\n", nHeight, GetHash().ToString().c_str(), nEntropyBit);
936 // Before novacoin block #9689 - old protocol
937 uint160 hashSig = Hash160(vchBlockSig);
938 if (fDebug && GetBoolArg("-printstakemodifier"))
939 printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
940 hashSig >>= 159; // take the first bit of the hash
941 if (fDebug && GetBoolArg("-printstakemodifier"))
942 printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
943 return hashSig.Get64();
946 // ppcoin: two types of block: proof-of-work or proof-of-stake
947 bool IsProofOfStake() const
949 return (vtx.size() > 1 && vtx[1].IsCoinStake());
952 bool IsProofOfWork() const
954 return !IsProofOfStake();
957 std::pair<COutPoint, unsigned int> GetProofOfStake() const
959 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
962 // ppcoin: get max transaction timestamp
963 int64 GetMaxTransactionTime() const
965 int64 maxTransactionTime = 0;
966 BOOST_FOREACH(const CTransaction& tx, vtx)
967 maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
968 return maxTransactionTime;
971 uint256 BuildMerkleTree() const
974 BOOST_FOREACH(const CTransaction& tx, vtx)
975 vMerkleTree.push_back(tx.GetHash());
977 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
979 for (int i = 0; i < nSize; i += 2)
981 int i2 = std::min(i+1, nSize-1);
982 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
983 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
987 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
990 std::vector<uint256> GetMerkleBranch(int nIndex) const
992 if (vMerkleTree.empty())
994 std::vector<uint256> vMerkleBranch;
996 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
998 int i = std::min(nIndex^1, nSize-1);
999 vMerkleBranch.push_back(vMerkleTree[j+i]);
1003 return vMerkleBranch;
1006 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1010 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1013 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1015 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1022 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1024 // Open history file to append
1025 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1027 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1029 // Write index header
1030 unsigned int nSize = fileout.GetSerializeSize(*this);
1031 fileout << FLATDATA(pchMessageStart) << nSize;
1034 long fileOutPos = ftell(fileout);
1036 return error("CBlock::WriteToDisk() : ftell failed");
1037 nBlockPosRet = fileOutPos;
1040 // Flush stdio buffers and commit to disk before returning
1042 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1043 FileCommit(fileout);
1048 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1052 // Open history file to read
1053 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1055 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1056 if (!fReadTransactions)
1057 filein.nType |= SER_BLOCKHEADERONLY;
1063 catch (std::exception &e) {
1064 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1068 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1069 return error("CBlock::ReadFromDisk() : errors in block header");
1078 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1079 GetHash().ToString().c_str(),
1081 hashPrevBlock.ToString().c_str(),
1082 hashMerkleRoot.ToString().c_str(),
1083 nTime, nBits, nNonce,
1085 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1086 for (unsigned int i = 0; i < vtx.size(); i++)
1091 printf(" vMerkleTree: ");
1092 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1093 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1098 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1099 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1100 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1101 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1102 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1103 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true) const;
1105 bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1106 bool SignBlock(const CKeyStore& keystore);
1107 bool CheckBlockSignature() const;
1110 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1118 /** The block chain is a tree shaped structure starting with the
1119 * genesis block at the root, with each block potentially having multiple
1120 * candidates to be the next block. pprev and pnext link a path through the
1121 * main/longest chain. A blockindex may have multiple pprev pointing back
1122 * to it, but pnext will only point forward to the longest branch, or will
1123 * be null if the block is not part of the longest chain.
1128 const uint256* phashBlock;
1132 unsigned int nBlockPos;
1133 CBigNum bnChainTrust; // ppcoin: trust score of block chain
1139 unsigned int nFlags; // ppcoin: block index flags
1142 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1143 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1144 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1147 uint64 nStakeModifier; // hash modifier for proof-of-stake
1148 unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1150 // proof-of-stake specific fields
1151 COutPoint prevoutStake;
1152 unsigned int nStakeTime;
1153 uint256 hashProofOfStake;
1157 uint256 hashMerkleRoot;
1160 unsigned int nNonce;
1175 nStakeModifierChecksum = 0;
1176 hashProofOfStake = 0;
1177 prevoutStake.SetNull();
1187 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1193 nBlockPos = nBlockPosIn;
1200 nStakeModifierChecksum = 0;
1201 hashProofOfStake = 0;
1202 if (block.IsProofOfStake())
1205 prevoutStake = block.vtx[1].vin[0].prevout;
1206 nStakeTime = block.vtx[1].nTime;
1210 prevoutStake.SetNull();
1214 nVersion = block.nVersion;
1215 hashMerkleRoot = block.hashMerkleRoot;
1216 nTime = block.nTime;
1217 nBits = block.nBits;
1218 nNonce = block.nNonce;
1221 CBlock GetBlockHeader() const
1224 block.nVersion = nVersion;
1226 block.hashPrevBlock = pprev->GetBlockHash();
1227 block.hashMerkleRoot = hashMerkleRoot;
1228 block.nTime = nTime;
1229 block.nBits = nBits;
1230 block.nNonce = nNonce;
1234 uint256 GetBlockHash() const
1239 int64 GetBlockTime() const
1241 return (int64)nTime;
1244 CBigNum GetBlockTrust() const
1247 bnTarget.SetCompact(nBits);
1250 return (IsProofOfStake()? (CBigNum(1)<<256) / (bnTarget+1) : 1);
1253 bool IsInMainChain() const
1255 return (pnext || this == pindexBest);
1258 bool CheckIndex() const
1263 enum { nMedianTimeSpan=11 };
1265 int64 GetMedianTimePast() const
1267 int64 pmedian[nMedianTimeSpan];
1268 int64* pbegin = &pmedian[nMedianTimeSpan];
1269 int64* pend = &pmedian[nMedianTimeSpan];
1271 const CBlockIndex* pindex = this;
1272 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1273 *(--pbegin) = pindex->GetBlockTime();
1275 std::sort(pbegin, pend);
1276 return pbegin[(pend - pbegin)/2];
1279 int64 GetMedianTime() const
1281 const CBlockIndex* pindex = this;
1282 for (int i = 0; i < nMedianTimeSpan/2; i++)
1285 return GetBlockTime();
1286 pindex = pindex->pnext;
1288 return pindex->GetMedianTimePast();
1292 * Returns true if there are nRequired or more blocks of minVersion or above
1293 * in the last nToCheck blocks, starting at pstart and going backwards.
1295 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1296 unsigned int nRequired, unsigned int nToCheck);
1299 bool IsProofOfWork() const
1301 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1304 bool IsProofOfStake() const
1306 return (nFlags & BLOCK_PROOF_OF_STAKE);
1309 void SetProofOfStake()
1311 nFlags |= BLOCK_PROOF_OF_STAKE;
1314 unsigned int GetStakeEntropyBit() const
1316 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1319 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1321 if (nEntropyBit > 1)
1323 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1327 bool GeneratedStakeModifier() const
1329 return (nFlags & BLOCK_STAKE_MODIFIER);
1332 void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1334 nStakeModifier = nModifier;
1335 if (fGeneratedStakeModifier)
1336 nFlags |= BLOCK_STAKE_MODIFIER;
1339 std::string ToString() const
1341 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)",
1342 pprev, pnext, nFile, nBlockPos, nHeight,
1343 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1344 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1345 nStakeModifier, nStakeModifierChecksum,
1346 hashProofOfStake.ToString().c_str(),
1347 prevoutStake.ToString().c_str(), nStakeTime,
1348 hashMerkleRoot.ToString().c_str(),
1349 GetBlockHash().ToString().c_str());
1354 printf("%s\n", ToString().c_str());
1360 /** Used to marshal pointers into hashes for db storage. */
1361 class CDiskBlockIndex : public CBlockIndex
1373 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1375 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1376 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1381 if (!(nType & SER_GETHASH))
1382 READWRITE(nVersion);
1384 READWRITE(hashNext);
1386 READWRITE(nBlockPos);
1389 READWRITE(nMoneySupply);
1391 READWRITE(nStakeModifier);
1392 if (IsProofOfStake())
1394 READWRITE(prevoutStake);
1395 READWRITE(nStakeTime);
1396 READWRITE(hashProofOfStake);
1400 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1401 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1402 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1406 READWRITE(this->nVersion);
1407 READWRITE(hashPrev);
1408 READWRITE(hashMerkleRoot);
1414 uint256 GetBlockHash() const
1417 block.nVersion = nVersion;
1418 block.hashPrevBlock = hashPrev;
1419 block.hashMerkleRoot = hashMerkleRoot;
1420 block.nTime = nTime;
1421 block.nBits = nBits;
1422 block.nNonce = nNonce;
1423 return block.GetHash();
1427 std::string ToString() const
1429 std::string str = "CDiskBlockIndex(";
1430 str += CBlockIndex::ToString();
1431 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1432 GetBlockHash().ToString().c_str(),
1433 hashPrev.ToString().c_str(),
1434 hashNext.ToString().c_str());
1440 printf("%s\n", ToString().c_str());
1451 /** Describes a place in the block chain to another node such that if the
1452 * other node doesn't have the same branch, it can find a recent common trunk.
1453 * The further back it is, the further before the fork it may be.
1458 std::vector<uint256> vHave;
1465 explicit CBlockLocator(const CBlockIndex* pindex)
1470 explicit CBlockLocator(uint256 hashBlock)
1472 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1473 if (mi != mapBlockIndex.end())
1477 CBlockLocator(const std::vector<uint256>& vHaveIn)
1484 if (!(nType & SER_GETHASH))
1485 READWRITE(nVersion);
1496 return vHave.empty();
1499 void Set(const CBlockIndex* pindex)
1505 vHave.push_back(pindex->GetBlockHash());
1507 // Exponentially larger steps back
1508 for (int i = 0; pindex && i < nStep; i++)
1509 pindex = pindex->pprev;
1510 if (vHave.size() > 10)
1513 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1516 int GetDistanceBack()
1518 // Retrace how far back it was in the sender's branch
1521 BOOST_FOREACH(const uint256& hash, vHave)
1523 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1524 if (mi != mapBlockIndex.end())
1526 CBlockIndex* pindex = (*mi).second;
1527 if (pindex->IsInMainChain())
1537 CBlockIndex* GetBlockIndex()
1539 // Find the first block the caller has in the main chain
1540 BOOST_FOREACH(const uint256& hash, vHave)
1542 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1543 if (mi != mapBlockIndex.end())
1545 CBlockIndex* pindex = (*mi).second;
1546 if (pindex->IsInMainChain())
1550 return pindexGenesisBlock;
1553 uint256 GetBlockHash()
1555 // Find the first block the caller has in the main chain
1556 BOOST_FOREACH(const uint256& hash, vHave)
1558 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1559 if (mi != mapBlockIndex.end())
1561 CBlockIndex* pindex = (*mi).second;
1562 if (pindex->IsInMainChain())
1566 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1571 CBlockIndex* pindex = GetBlockIndex();
1574 return pindex->nHeight;
1588 mutable CCriticalSection cs;
1589 std::map<uint256, CTransaction> mapTx;
1590 std::map<COutPoint, CInPoint> mapNextTx;
1592 bool accept(CTxDB& txdb, CTransaction &tx,
1593 bool fCheckInputs, bool* pfMissingInputs);
1594 bool addUnchecked(const uint256& hash, CTransaction &tx);
1595 bool remove(CTransaction &tx);
1597 void queryHashes(std::vector<uint256>& vtxid);
1599 unsigned long size()
1602 return mapTx.size();
1605 bool exists(uint256 hash)
1607 return (mapTx.count(hash) != 0);
1610 CTransaction& lookup(uint256 hash)
1616 extern CTxMemPool mempool;