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 int64 nTimeBestReceived;
84 extern CCriticalSection cs_setpwalletRegistered;
85 extern std::set<CWallet*> setpwalletRegistered;
86 extern unsigned char pchMessageStart[4];
87 extern std::map<uint256, CBlock*> mapOrphanBlocks;
90 extern int64 nTransactionFee;
91 extern bool fStakeUsePooledKeys;
93 // Minimum disk space required - used in CheckDiskSpace()
94 static const uint64 nMinDiskSpace = 52428800;
101 void RegisterWallet(CWallet* pwalletIn);
102 void UnregisterWallet(CWallet* pwalletIn);
103 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
104 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
105 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
106 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
107 FILE* AppendBlockFile(unsigned int& nFileRet);
108 bool LoadBlockIndex(bool fAllowNew=true);
109 void PrintBlockTree();
110 CBlockIndex* FindBlockByHeight(int nHeight);
111 bool ProcessMessages(CNode* pfrom);
112 bool SendMessages(CNode* pto, bool fSendTrickle);
113 bool LoadExternalBlockFile(FILE* fileIn);
114 CBlock* CreateNewBlock(CWallet* pwallet, bool fProofOfStake=false);
115 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
116 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
117 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
118 bool CheckStake(CBlock* pblock, CWallet& wallet);
119 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
120 int64 GetProofOfWorkReward(unsigned int nBits);
121 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
122 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
123 unsigned int ComputeMinStake(unsigned int nBase, int64 nTime, unsigned int nBlockTime);
124 int GetNumBlocksOfPeers();
125 bool IsInitialBlockDownload();
126 std::string GetWarnings(std::string strFor);
127 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
128 uint256 WantedByOrphan(const CBlock* pblockOrphan);
129 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
130 void StakeMiner(CWallet *pwallet);
131 void ResendWalletTransactions();
142 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
144 /** Position on disk for a particular transaction. */
149 unsigned int nBlockPos;
157 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
160 nBlockPos = nBlockPosIn;
164 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
165 void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
166 bool IsNull() const { return (nFile == (unsigned int) -1); }
168 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
170 return (a.nFile == b.nFile &&
171 a.nBlockPos == b.nBlockPos &&
172 a.nTxPos == b.nTxPos);
175 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
181 std::string ToString() const
186 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
191 printf("%s", ToString().c_str());
197 /** An inpoint - a combination of a transaction and an index n into its vin */
204 CInPoint() { SetNull(); }
205 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
206 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
207 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
212 /** An outpoint - a combination of a transaction hash and an index n into its vout */
219 COutPoint() { SetNull(); }
220 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
221 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
222 void SetNull() { hash = 0; n = (unsigned int) -1; }
223 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
225 friend bool operator<(const COutPoint& a, const COutPoint& b)
227 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
230 friend bool operator==(const COutPoint& a, const COutPoint& b)
232 return (a.hash == b.hash && a.n == b.n);
235 friend bool operator!=(const COutPoint& a, const COutPoint& b)
240 std::string ToString() const
242 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
247 printf("%s\n", ToString().c_str());
254 /** An input of a transaction. It contains the location of the previous
255 * transaction's output that it claims and a signature that matches the
256 * output's public key.
263 unsigned int nSequence;
267 nSequence = std::numeric_limits<unsigned int>::max();
270 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
273 scriptSig = scriptSigIn;
274 nSequence = nSequenceIn;
277 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
279 prevout = COutPoint(hashPrevTx, nOut);
280 scriptSig = scriptSigIn;
281 nSequence = nSequenceIn;
287 READWRITE(scriptSig);
288 READWRITE(nSequence);
293 return (nSequence == std::numeric_limits<unsigned int>::max());
296 friend bool operator==(const CTxIn& a, const CTxIn& b)
298 return (a.prevout == b.prevout &&
299 a.scriptSig == b.scriptSig &&
300 a.nSequence == b.nSequence);
303 friend bool operator!=(const CTxIn& a, const CTxIn& b)
308 std::string ToStringShort() const
310 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
313 std::string ToString() const
317 str += prevout.ToString();
318 if (prevout.IsNull())
319 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
321 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
322 if (nSequence != std::numeric_limits<unsigned int>::max())
323 str += strprintf(", nSequence=%u", nSequence);
330 printf("%s\n", ToString().c_str());
337 /** An output of a transaction. It contains the public key that the next input
338 * must be able to sign with to claim it.
344 CScript scriptPubKey;
351 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
354 scriptPubKey = scriptPubKeyIn;
360 READWRITE(scriptPubKey);
366 scriptPubKey.clear();
371 return (nValue == -1);
377 scriptPubKey.clear();
382 return (nValue == 0 && scriptPubKey.empty());
385 uint256 GetHash() const
387 return SerializeHash(*this);
390 friend bool operator==(const CTxOut& a, const CTxOut& b)
392 return (a.nValue == b.nValue &&
393 a.scriptPubKey == b.scriptPubKey);
396 friend bool operator!=(const CTxOut& a, const CTxOut& b)
401 std::string ToStringShort() const
403 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
406 std::string ToString() const
408 if (IsEmpty()) return "CTxOut(empty)";
409 if (scriptPubKey.size() < 6)
410 return "CTxOut(error)";
411 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
416 printf("%s\n", ToString().c_str());
430 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
432 /** The basic transaction that is broadcasted on the network and contained in
433 * blocks. A transaction can contain multiple inputs and outputs.
438 static const int CURRENT_VERSION=1;
441 std::vector<CTxIn> vin;
442 std::vector<CTxOut> vout;
443 unsigned int nLockTime;
445 // Denial-of-service detection:
447 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
456 READWRITE(this->nVersion);
457 nVersion = this->nVersion;
461 READWRITE(nLockTime);
466 nVersion = CTransaction::CURRENT_VERSION;
467 nTime = GetAdjustedTime();
471 nDoS = 0; // Denial-of-service prevention
476 return (vin.empty() && vout.empty());
479 uint256 GetHash() const
481 return SerializeHash(*this);
484 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
486 // Time based nLockTime implemented in 0.1.6
489 if (nBlockHeight == 0)
490 nBlockHeight = nBestHeight;
492 nBlockTime = GetAdjustedTime();
493 if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
495 BOOST_FOREACH(const CTxIn& txin, vin)
501 bool IsNewerThan(const CTransaction& old) const
503 if (vin.size() != old.vin.size())
505 for (unsigned int i = 0; i < vin.size(); i++)
506 if (vin[i].prevout != old.vin[i].prevout)
510 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
511 for (unsigned int i = 0; i < vin.size(); i++)
513 if (vin[i].nSequence != old.vin[i].nSequence)
515 if (vin[i].nSequence <= nLowest)
518 nLowest = vin[i].nSequence;
520 if (old.vin[i].nSequence < nLowest)
523 nLowest = old.vin[i].nSequence;
530 bool IsCoinBase() const
532 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
535 bool IsCoinStake() const
537 // ppcoin: the coin stake transaction is marked with the first output empty
538 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
541 /** Check for standard transaction types
542 @return True if all outputs (scriptPubKeys) use only standard transaction forms
544 bool IsStandard() const;
546 /** Check for standard transaction types
547 @param[in] mapInputs Map of previous transactions that have outputs we're spending
548 @return True if all inputs (scriptSigs) use only standard transaction forms
549 @see CTransaction::FetchInputs
551 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
553 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
554 @return number of sigops this transaction's outputs will produce when spent
555 @see CTransaction::FetchInputs
557 unsigned int GetLegacySigOpCount() const;
559 /** Count ECDSA signature operations in pay-to-script-hash inputs.
561 @param[in] mapInputs Map of previous transactions that have outputs we're spending
562 @return maximum number of sigops required to validate this transaction's inputs
563 @see CTransaction::FetchInputs
565 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
567 /** Amount of bitcoins spent by this transaction.
568 @return sum of all outputs (note: does not include fees)
570 int64 GetValueOut() const
573 BOOST_FOREACH(const CTxOut& txout, vout)
575 nValueOut += txout.nValue;
576 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
577 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
582 /** Amount of bitcoins coming in to this transaction
583 Note that lightweight clients may not know anything besides the hash of previous transactions,
584 so may not be able to calculate this.
586 @param[in] mapInputs Map of previous transactions that have outputs we're spending
587 @return Sum of value of all inputs (scriptSigs)
588 @see CTransaction::FetchInputs
590 int64 GetValueIn(const MapPrevTx& mapInputs) const;
592 static bool AllowFree(double dPriority)
594 // Large (in bytes) low-priority (new, small-coin) transactions
596 return dPriority > COIN * 144 / 250;
599 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK) const;
601 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
603 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
605 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
608 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
609 return error("CTransaction::ReadFromDisk() : fseek failed");
614 catch (std::exception &e) {
615 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
618 // Return file pointer
621 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
622 return error("CTransaction::ReadFromDisk() : second fseek failed");
623 *pfileRet = filein.release();
628 friend bool operator==(const CTransaction& a, const CTransaction& b)
630 return (a.nVersion == b.nVersion &&
631 a.nTime == b.nTime &&
634 a.nLockTime == b.nLockTime);
637 friend bool operator!=(const CTransaction& a, const CTransaction& b)
642 std::string ToStringShort() const
645 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
649 std::string ToString() const
652 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
653 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%d)\n",
654 GetHash().ToString().substr(0,10).c_str(),
660 for (unsigned int i = 0; i < vin.size(); i++)
661 str += " " + vin[i].ToString() + "\n";
662 for (unsigned int i = 0; i < vout.size(); i++)
663 str += " " + vout[i].ToString() + "\n";
669 printf("%s", ToString().c_str());
673 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
674 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
675 bool ReadFromDisk(COutPoint prevout);
676 bool DisconnectInputs(CTxDB& txdb);
678 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
680 @param[in] txdb Transaction database
681 @param[in] mapTestPool List of pending changes to the transaction index database
682 @param[in] fBlock True if being called to add a new best-block to the chain
683 @param[in] fMiner True if being called by CreateNewBlock
684 @param[out] inputsRet Pointers to this transaction's inputs
685 @param[out] fInvalid returns true if transaction is invalid
686 @return Returns true if all inputs are in txdb or mapTestPool
688 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
689 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
691 /** Sanity check previous transactions, then, if all checks succeed,
692 mark them as spent by this transaction.
694 @param[in] inputs Previous transactions (from FetchInputs)
695 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
696 @param[in] posThisTx Position of this transaction on disk
697 @param[in] pindexBlock
698 @param[in] fBlock true if called from ConnectBlock
699 @param[in] fMiner true if called from CreateNewBlock
700 @param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
701 @return Returns true if all checks succeed
703 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs,
704 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
705 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
706 bool ClientConnectInputs();
707 bool CheckTransaction() const;
708 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
709 bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const; // ppcoin: get transaction coin age
712 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
719 /** A transaction with a merkle branch linking it to the block chain. */
720 class CMerkleTx : public CTransaction
724 std::vector<uint256> vMerkleBranch;
728 mutable bool fMerkleVerified;
736 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
745 fMerkleVerified = false;
751 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
752 nVersion = this->nVersion;
753 READWRITE(hashBlock);
754 READWRITE(vMerkleBranch);
759 int SetMerkleBranch(const CBlock* pblock=NULL);
760 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
761 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
762 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
763 int GetBlocksToMaturity() const;
764 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
765 bool AcceptToMemoryPool();
771 /** A txdb record that contains the disk location of a transaction and the
772 * locations of transactions that spend its outputs. vSpent is really only
773 * used as a flag, but having the location is very helpful for debugging.
779 std::vector<CDiskTxPos> vSpent;
786 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
789 vSpent.resize(nOutputs);
794 if (!(nType & SER_GETHASH))
811 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
813 return (a.pos == b.pos &&
814 a.vSpent == b.vSpent);
817 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
821 int GetDepthInMainChain() const;
829 /** Nodes collect new transactions into a block, hash them into a hash tree,
830 * and scan through nonce values to make the block's hash satisfy proof-of-work
831 * requirements. When they solve the proof-of-work, they broadcast the block
832 * to everyone and the block is added to the block chain. The first transaction
833 * in the block is a special one that creates a new coin owned by the creator
836 * Blocks are appended to blk0001.dat files on disk. Their location on disk
837 * is indexed by CBlockIndex objects in memory.
843 static const int CURRENT_VERSION=6;
845 uint256 hashPrevBlock;
846 uint256 hashMerkleRoot;
852 std::vector<CTransaction> vtx;
854 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
855 std::vector<unsigned char> vchBlockSig;
858 mutable std::vector<uint256> vMerkleTree;
861 // Denial-of-service detection:
863 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
872 READWRITE(this->nVersion);
873 nVersion = this->nVersion;
874 READWRITE(hashPrevBlock);
875 READWRITE(hashMerkleRoot);
880 // ConnectBlock depends on vtx following header to generate CDiskTxPos
881 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
884 READWRITE(vchBlockSig);
888 const_cast<CBlock*>(this)->vtx.clear();
889 const_cast<CBlock*>(this)->vchBlockSig.clear();
895 nVersion = CBlock::CURRENT_VERSION;
913 uint256 GetHash(bool fRehash=false) const
915 return scrypt_blockhash(CVOIDBEGIN(nVersion));
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 nTime) const
928 // Protocol switch to support p2pool at novacoin block #9689
929 if (nTime >= ENTROPY_SWITCH_TIME || 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: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, 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, bool fCheckSig=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(bool fProofOfStake) 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 uint256 nChainTrust; // 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 uint256 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;