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.
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;
92 extern unsigned int nDerivationMethodIndex;
94 // Minimum disk space required - used in CheckDiskSpace()
95 static const uint64 nMinDiskSpace = 52428800;
102 void RegisterWallet(CWallet* pwalletIn);
103 void UnregisterWallet(CWallet* pwalletIn);
104 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
105 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
106 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
107 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
108 FILE* AppendBlockFile(unsigned int& nFileRet);
109 bool LoadBlockIndex(bool fAllowNew=true);
110 void PrintBlockTree();
111 CBlockIndex* FindBlockByHeight(int nHeight);
112 bool ProcessMessages(CNode* pfrom);
113 bool SendMessages(CNode* pto, bool fSendTrickle);
115 // Processes a blk*.dat file and fires the given signal to indicate how far
116 // through the file the load has reached, if provided.
117 typedef boost::signals2::signal<void (unsigned int bytesRead)> ExternalBlockFileProgress;
118 bool LoadExternalBlockFile(FILE* fileIn, ExternalBlockFileProgress *progress=NULL);
120 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
121 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
122 int64 GetProofOfWorkReward(unsigned int nBits);
123 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
124 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
125 unsigned int ComputeMinStake(unsigned int nBase, int64 nTime, unsigned int nBlockTime);
126 int GetNumBlocksOfPeers();
127 bool IsInitialBlockDownload();
128 std::string GetWarnings(std::string strFor);
129 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
130 uint256 WantedByOrphan(const CBlock* pblockOrphan);
131 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
132 void StakeMiner(CWallet *pwallet);
133 void ResendWalletTransactions();
144 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
146 /** Position on disk for a particular transaction. */
151 unsigned int nBlockPos;
159 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
162 nBlockPos = nBlockPosIn;
166 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
167 void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
168 bool IsNull() const { return (nFile == (unsigned int) -1); }
170 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
172 return (a.nFile == b.nFile &&
173 a.nBlockPos == b.nBlockPos &&
174 a.nTxPos == b.nTxPos);
177 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
183 std::string ToString() const
188 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
193 printf("%s", ToString().c_str());
199 /** An inpoint - a combination of a transaction and an index n into its vin */
206 CInPoint() { SetNull(); }
207 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
208 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
209 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
214 /** An outpoint - a combination of a transaction hash and an index n into its vout */
221 COutPoint() { SetNull(); }
222 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
223 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
224 void SetNull() { hash = 0; n = (unsigned int) -1; }
225 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
227 friend bool operator<(const COutPoint& a, const COutPoint& b)
229 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
232 friend bool operator==(const COutPoint& a, const COutPoint& b)
234 return (a.hash == b.hash && a.n == b.n);
237 friend bool operator!=(const COutPoint& a, const COutPoint& b)
242 std::string ToString() const
244 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
249 printf("%s\n", ToString().c_str());
256 /** An input of a transaction. It contains the location of the previous
257 * transaction's output that it claims and a signature that matches the
258 * output's public key.
265 unsigned int nSequence;
269 nSequence = std::numeric_limits<unsigned int>::max();
272 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
275 scriptSig = scriptSigIn;
276 nSequence = nSequenceIn;
279 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
281 prevout = COutPoint(hashPrevTx, nOut);
282 scriptSig = scriptSigIn;
283 nSequence = nSequenceIn;
289 READWRITE(scriptSig);
290 READWRITE(nSequence);
295 return (nSequence == std::numeric_limits<unsigned int>::max());
298 friend bool operator==(const CTxIn& a, const CTxIn& b)
300 return (a.prevout == b.prevout &&
301 a.scriptSig == b.scriptSig &&
302 a.nSequence == b.nSequence);
305 friend bool operator!=(const CTxIn& a, const CTxIn& b)
310 std::string ToStringShort() const
312 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
315 std::string ToString() const
319 str += prevout.ToString();
320 if (prevout.IsNull())
321 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
323 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
324 if (nSequence != std::numeric_limits<unsigned int>::max())
325 str += strprintf(", nSequence=%u", nSequence);
332 printf("%s\n", ToString().c_str());
339 /** An output of a transaction. It contains the public key that the next input
340 * must be able to sign with to claim it.
346 CScript scriptPubKey;
353 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
356 scriptPubKey = scriptPubKeyIn;
362 READWRITE(scriptPubKey);
368 scriptPubKey.clear();
373 return (nValue == -1);
379 scriptPubKey.clear();
384 return (nValue == 0 && scriptPubKey.empty());
387 uint256 GetHash() const
389 return SerializeHash(*this);
392 friend bool operator==(const CTxOut& a, const CTxOut& b)
394 return (a.nValue == b.nValue &&
395 a.scriptPubKey == b.scriptPubKey);
398 friend bool operator!=(const CTxOut& a, const CTxOut& b)
403 std::string ToStringShort() const
405 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
408 std::string ToString() const
410 if (IsEmpty()) return "CTxOut(empty)";
411 if (scriptPubKey.size() < 6)
412 return "CTxOut(error)";
413 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
418 printf("%s\n", ToString().c_str());
432 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
434 /** The basic transaction that is broadcasted on the network and contained in
435 * blocks. A transaction can contain multiple inputs and outputs.
440 static const int CURRENT_VERSION=1;
443 std::vector<CTxIn> vin;
444 std::vector<CTxOut> vout;
445 unsigned int nLockTime;
447 // Denial-of-service detection:
449 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
458 READWRITE(this->nVersion);
459 nVersion = this->nVersion;
463 READWRITE(nLockTime);
468 nVersion = CTransaction::CURRENT_VERSION;
469 nTime = GetAdjustedTime();
473 nDoS = 0; // Denial-of-service prevention
478 return (vin.empty() && vout.empty());
481 uint256 GetHash() const
483 return SerializeHash(*this);
486 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
488 // Time based nLockTime implemented in 0.1.6
491 if (nBlockHeight == 0)
492 nBlockHeight = nBestHeight;
494 nBlockTime = GetAdjustedTime();
495 if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
497 BOOST_FOREACH(const CTxIn& txin, vin)
503 bool IsNewerThan(const CTransaction& old) const
505 if (vin.size() != old.vin.size())
507 for (unsigned int i = 0; i < vin.size(); i++)
508 if (vin[i].prevout != old.vin[i].prevout)
512 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
513 for (unsigned int i = 0; i < vin.size(); i++)
515 if (vin[i].nSequence != old.vin[i].nSequence)
517 if (vin[i].nSequence <= nLowest)
520 nLowest = vin[i].nSequence;
522 if (old.vin[i].nSequence < nLowest)
525 nLowest = old.vin[i].nSequence;
532 bool IsCoinBase() const
534 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
537 bool IsCoinStake() const
539 // ppcoin: the coin stake transaction is marked with the first output empty
540 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
543 /** Check for standard transaction types
544 @return True if all outputs (scriptPubKeys) use only standard transaction forms
546 bool IsStandard() const;
548 /** Check for standard transaction types
549 @param[in] mapInputs Map of previous transactions that have outputs we're spending
550 @return True if all inputs (scriptSigs) use only standard transaction forms
551 @see CTransaction::FetchInputs
553 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
555 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
556 @return number of sigops this transaction's outputs will produce when spent
557 @see CTransaction::FetchInputs
559 unsigned int GetLegacySigOpCount() const;
561 /** Count ECDSA signature operations in pay-to-script-hash inputs.
563 @param[in] mapInputs Map of previous transactions that have outputs we're spending
564 @return maximum number of sigops required to validate this transaction's inputs
565 @see CTransaction::FetchInputs
567 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
569 /** Amount of bitcoins spent by this transaction.
570 @return sum of all outputs (note: does not include fees)
572 int64 GetValueOut() const
575 BOOST_FOREACH(const CTxOut& txout, vout)
577 nValueOut += txout.nValue;
578 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
579 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
584 /** Amount of bitcoins coming in to this transaction
585 Note that lightweight clients may not know anything besides the hash of previous transactions,
586 so may not be able to calculate this.
588 @param[in] mapInputs Map of previous transactions that have outputs we're spending
589 @return Sum of value of all inputs (scriptSigs)
590 @see CTransaction::FetchInputs
592 int64 GetValueIn(const MapPrevTx& mapInputs) const;
594 static bool AllowFree(double dPriority)
596 // Large (in bytes) low-priority (new, small-coin) transactions
598 return dPriority > COIN * 144 / 250;
601 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK) const;
603 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
605 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
607 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
610 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
611 return error("CTransaction::ReadFromDisk() : fseek failed");
616 catch (std::exception &e) {
617 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
620 // Return file pointer
623 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
624 return error("CTransaction::ReadFromDisk() : second fseek failed");
625 *pfileRet = filein.release();
630 friend bool operator==(const CTransaction& a, const CTransaction& b)
632 return (a.nVersion == b.nVersion &&
633 a.nTime == b.nTime &&
636 a.nLockTime == b.nLockTime);
639 friend bool operator!=(const CTransaction& a, const CTransaction& b)
644 std::string ToStringShort() const
647 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
651 std::string ToString() const
654 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
655 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%d)\n",
656 GetHash().ToString().substr(0,10).c_str(),
662 for (unsigned int i = 0; i < vin.size(); i++)
663 str += " " + vin[i].ToString() + "\n";
664 for (unsigned int i = 0; i < vout.size(); i++)
665 str += " " + vout[i].ToString() + "\n";
671 printf("%s", ToString().c_str());
675 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
676 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
677 bool ReadFromDisk(COutPoint prevout);
678 bool DisconnectInputs(CTxDB& txdb);
680 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
682 @param[in] txdb Transaction database
683 @param[in] mapTestPool List of pending changes to the transaction index database
684 @param[in] fBlock True if being called to add a new best-block to the chain
685 @param[in] fMiner True if being called by CreateNewBlock
686 @param[out] inputsRet Pointers to this transaction's inputs
687 @param[out] fInvalid returns true if transaction is invalid
688 @return Returns true if all inputs are in txdb or mapTestPool
690 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
691 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
693 /** Sanity check previous transactions, then, if all checks succeed,
694 mark them as spent by this transaction.
696 @param[in] inputs Previous transactions (from FetchInputs)
697 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
698 @param[in] posThisTx Position of this transaction on disk
699 @param[in] pindexBlock
700 @param[in] fBlock true if called from ConnectBlock
701 @param[in] fMiner true if called from CreateNewBlock
702 @param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
703 @return Returns true if all checks succeed
705 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs,
706 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
707 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
708 bool ClientConnectInputs();
709 bool CheckTransaction() const;
710 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
711 bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const; // ppcoin: get transaction coin age
714 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
721 /** A transaction with a merkle branch linking it to the block chain. */
722 class CMerkleTx : public CTransaction
726 std::vector<uint256> vMerkleBranch;
730 mutable bool fMerkleVerified;
738 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
747 fMerkleVerified = false;
753 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
754 nVersion = this->nVersion;
755 READWRITE(hashBlock);
756 READWRITE(vMerkleBranch);
761 int SetMerkleBranch(const CBlock* pblock=NULL);
762 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
763 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
764 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
765 int GetBlocksToMaturity() const;
766 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
767 bool AcceptToMemoryPool();
773 /** A txdb record that contains the disk location of a transaction and the
774 * locations of transactions that spend its outputs. vSpent is really only
775 * used as a flag, but having the location is very helpful for debugging.
781 std::vector<CDiskTxPos> vSpent;
788 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
791 vSpent.resize(nOutputs);
796 if (!(nType & SER_GETHASH))
813 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
815 return (a.pos == b.pos &&
816 a.vSpent == b.vSpent);
819 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
823 int GetDepthInMainChain() const;
831 /** Nodes collect new transactions into a block, hash them into a hash tree,
832 * and scan through nonce values to make the block's hash satisfy proof-of-work
833 * requirements. When they solve the proof-of-work, they broadcast the block
834 * to everyone and the block is added to the block chain. The first transaction
835 * in the block is a special one that creates a new coin owned by the creator
838 * Blocks are appended to blk0001.dat files on disk. Their location on disk
839 * is indexed by CBlockIndex objects in memory.
845 static const int CURRENT_VERSION=6;
847 uint256 hashPrevBlock;
848 uint256 hashMerkleRoot;
854 std::vector<CTransaction> vtx;
856 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
857 std::vector<unsigned char> vchBlockSig;
860 mutable std::vector<uint256> vMerkleTree;
862 // Denial-of-service detection:
864 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
873 READWRITE(this->nVersion);
874 nVersion = this->nVersion;
875 READWRITE(hashPrevBlock);
876 READWRITE(hashMerkleRoot);
881 // ConnectBlock depends on vtx following header to generate CDiskTxPos
882 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
885 READWRITE(vchBlockSig);
889 const_cast<CBlock*>(this)->vtx.clear();
890 const_cast<CBlock*>(this)->vchBlockSig.clear();
896 nVersion = CBlock::CURRENT_VERSION;
913 uint256 GetHash() const
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;