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;
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;
860 // Denial-of-service detection:
862 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
871 READWRITE(this->nVersion);
872 nVersion = this->nVersion;
873 READWRITE(hashPrevBlock);
874 READWRITE(hashMerkleRoot);
879 // ConnectBlock depends on vtx following header to generate CDiskTxPos
880 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
883 READWRITE(vchBlockSig);
887 const_cast<CBlock*>(this)->vtx.clear();
888 const_cast<CBlock*>(this)->vchBlockSig.clear();
894 nVersion = CBlock::CURRENT_VERSION;
911 uint256 GetHash() const
913 return scrypt_blockhash(CVOIDBEGIN(nVersion));
916 int64 GetBlockTime() const
921 void UpdateTime(const CBlockIndex* pindexPrev);
923 // ppcoin: entropy bit for stake modifier if chosen by modifier
924 unsigned int GetStakeEntropyBit(unsigned int nTime) const
926 // Protocol switch to support p2pool at novacoin block #9689
927 if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
929 // Take last bit of block hash as entropy bit
930 unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
931 if (fDebug && GetBoolArg("-printstakemodifier"))
932 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
935 // Before novacoin block #9689 - old protocol
936 uint160 hashSig = Hash160(vchBlockSig);
937 if (fDebug && GetBoolArg("-printstakemodifier"))
938 printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
939 hashSig >>= 159; // take the first bit of the hash
940 if (fDebug && GetBoolArg("-printstakemodifier"))
941 printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
942 return hashSig.Get64();
945 // ppcoin: two types of block: proof-of-work or proof-of-stake
946 bool IsProofOfStake() const
948 return (vtx.size() > 1 && vtx[1].IsCoinStake());
951 bool IsProofOfWork() const
953 return !IsProofOfStake();
956 std::pair<COutPoint, unsigned int> GetProofOfStake() const
958 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
961 // ppcoin: get max transaction timestamp
962 int64 GetMaxTransactionTime() const
964 int64 maxTransactionTime = 0;
965 BOOST_FOREACH(const CTransaction& tx, vtx)
966 maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
967 return maxTransactionTime;
970 uint256 BuildMerkleTree() const
973 BOOST_FOREACH(const CTransaction& tx, vtx)
974 vMerkleTree.push_back(tx.GetHash());
976 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
978 for (int i = 0; i < nSize; i += 2)
980 int i2 = std::min(i+1, nSize-1);
981 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
982 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
986 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
989 std::vector<uint256> GetMerkleBranch(int nIndex) const
991 if (vMerkleTree.empty())
993 std::vector<uint256> vMerkleBranch;
995 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
997 int i = std::min(nIndex^1, nSize-1);
998 vMerkleBranch.push_back(vMerkleTree[j+i]);
1002 return vMerkleBranch;
1005 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1009 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1012 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1014 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1021 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1023 // Open history file to append
1024 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1026 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1028 // Write index header
1029 unsigned int nSize = fileout.GetSerializeSize(*this);
1030 fileout << FLATDATA(pchMessageStart) << nSize;
1033 long fileOutPos = ftell(fileout);
1035 return error("CBlock::WriteToDisk() : ftell failed");
1036 nBlockPosRet = fileOutPos;
1039 // Flush stdio buffers and commit to disk before returning
1041 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1042 FileCommit(fileout);
1047 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1051 // Open history file to read
1052 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1054 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1055 if (!fReadTransactions)
1056 filein.nType |= SER_BLOCKHEADERONLY;
1062 catch (std::exception &e) {
1063 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1067 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1068 return error("CBlock::ReadFromDisk() : errors in block header");
1077 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1078 GetHash().ToString().c_str(),
1080 hashPrevBlock.ToString().c_str(),
1081 hashMerkleRoot.ToString().c_str(),
1082 nTime, nBits, nNonce,
1084 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1085 for (unsigned int i = 0; i < vtx.size(); i++)
1090 printf(" vMerkleTree: ");
1091 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1092 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1097 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1098 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1099 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1100 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1101 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1102 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1104 bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1105 bool SignBlock(const CKeyStore& keystore);
1106 bool CheckBlockSignature(bool fProofOfStake) const;
1109 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1117 /** The block chain is a tree shaped structure starting with the
1118 * genesis block at the root, with each block potentially having multiple
1119 * candidates to be the next block. pprev and pnext link a path through the
1120 * main/longest chain. A blockindex may have multiple pprev pointing back
1121 * to it, but pnext will only point forward to the longest branch, or will
1122 * be null if the block is not part of the longest chain.
1127 const uint256* phashBlock;
1131 unsigned int nBlockPos;
1132 uint256 nChainTrust; // ppcoin: trust score of block chain
1138 unsigned int nFlags; // ppcoin: block index flags
1141 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1142 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1143 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1146 uint64 nStakeModifier; // hash modifier for proof-of-stake
1147 unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1149 // proof-of-stake specific fields
1150 COutPoint prevoutStake;
1151 unsigned int nStakeTime;
1152 uint256 hashProofOfStake;
1156 uint256 hashMerkleRoot;
1159 unsigned int nNonce;
1174 nStakeModifierChecksum = 0;
1175 hashProofOfStake = 0;
1176 prevoutStake.SetNull();
1186 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1192 nBlockPos = nBlockPosIn;
1199 nStakeModifierChecksum = 0;
1200 hashProofOfStake = 0;
1201 if (block.IsProofOfStake())
1204 prevoutStake = block.vtx[1].vin[0].prevout;
1205 nStakeTime = block.vtx[1].nTime;
1209 prevoutStake.SetNull();
1213 nVersion = block.nVersion;
1214 hashMerkleRoot = block.hashMerkleRoot;
1215 nTime = block.nTime;
1216 nBits = block.nBits;
1217 nNonce = block.nNonce;
1220 CBlock GetBlockHeader() const
1223 block.nVersion = nVersion;
1225 block.hashPrevBlock = pprev->GetBlockHash();
1226 block.hashMerkleRoot = hashMerkleRoot;
1227 block.nTime = nTime;
1228 block.nBits = nBits;
1229 block.nNonce = nNonce;
1233 uint256 GetBlockHash() const
1238 int64 GetBlockTime() const
1240 return (int64)nTime;
1243 uint256 GetBlockTrust() const;
1245 bool IsInMainChain() const
1247 return (pnext || this == pindexBest);
1250 bool CheckIndex() const
1255 enum { nMedianTimeSpan=11 };
1257 int64 GetMedianTimePast() const
1259 int64 pmedian[nMedianTimeSpan];
1260 int64* pbegin = &pmedian[nMedianTimeSpan];
1261 int64* pend = &pmedian[nMedianTimeSpan];
1263 const CBlockIndex* pindex = this;
1264 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1265 *(--pbegin) = pindex->GetBlockTime();
1267 std::sort(pbegin, pend);
1268 return pbegin[(pend - pbegin)/2];
1271 int64 GetMedianTime() const
1273 const CBlockIndex* pindex = this;
1274 for (int i = 0; i < nMedianTimeSpan/2; i++)
1277 return GetBlockTime();
1278 pindex = pindex->pnext;
1280 return pindex->GetMedianTimePast();
1284 * Returns true if there are nRequired or more blocks of minVersion or above
1285 * in the last nToCheck blocks, starting at pstart and going backwards.
1287 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1288 unsigned int nRequired, unsigned int nToCheck);
1291 bool IsProofOfWork() const
1293 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1296 bool IsProofOfStake() const
1298 return (nFlags & BLOCK_PROOF_OF_STAKE);
1301 void SetProofOfStake()
1303 nFlags |= BLOCK_PROOF_OF_STAKE;
1306 unsigned int GetStakeEntropyBit() const
1308 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1311 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1313 if (nEntropyBit > 1)
1315 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1319 bool GeneratedStakeModifier() const
1321 return (nFlags & BLOCK_STAKE_MODIFIER);
1324 void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1326 nStakeModifier = nModifier;
1327 if (fGeneratedStakeModifier)
1328 nFlags |= BLOCK_STAKE_MODIFIER;
1331 std::string ToString() const
1333 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)",
1334 pprev, pnext, nFile, nBlockPos, nHeight,
1335 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1336 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1337 nStakeModifier, nStakeModifierChecksum,
1338 hashProofOfStake.ToString().c_str(),
1339 prevoutStake.ToString().c_str(), nStakeTime,
1340 hashMerkleRoot.ToString().c_str(),
1341 GetBlockHash().ToString().c_str());
1346 printf("%s\n", ToString().c_str());
1352 /** Used to marshal pointers into hashes for db storage. */
1353 class CDiskBlockIndex : public CBlockIndex
1365 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1367 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1368 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1373 if (!(nType & SER_GETHASH))
1374 READWRITE(nVersion);
1376 READWRITE(hashNext);
1378 READWRITE(nBlockPos);
1381 READWRITE(nMoneySupply);
1383 READWRITE(nStakeModifier);
1384 if (IsProofOfStake())
1386 READWRITE(prevoutStake);
1387 READWRITE(nStakeTime);
1388 READWRITE(hashProofOfStake);
1392 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1393 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1394 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1398 READWRITE(this->nVersion);
1399 READWRITE(hashPrev);
1400 READWRITE(hashMerkleRoot);
1406 uint256 GetBlockHash() const
1409 block.nVersion = nVersion;
1410 block.hashPrevBlock = hashPrev;
1411 block.hashMerkleRoot = hashMerkleRoot;
1412 block.nTime = nTime;
1413 block.nBits = nBits;
1414 block.nNonce = nNonce;
1415 return block.GetHash();
1419 std::string ToString() const
1421 std::string str = "CDiskBlockIndex(";
1422 str += CBlockIndex::ToString();
1423 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1424 GetBlockHash().ToString().c_str(),
1425 hashPrev.ToString().c_str(),
1426 hashNext.ToString().c_str());
1432 printf("%s\n", ToString().c_str());
1443 /** Describes a place in the block chain to another node such that if the
1444 * other node doesn't have the same branch, it can find a recent common trunk.
1445 * The further back it is, the further before the fork it may be.
1450 std::vector<uint256> vHave;
1457 explicit CBlockLocator(const CBlockIndex* pindex)
1462 explicit CBlockLocator(uint256 hashBlock)
1464 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1465 if (mi != mapBlockIndex.end())
1469 CBlockLocator(const std::vector<uint256>& vHaveIn)
1476 if (!(nType & SER_GETHASH))
1477 READWRITE(nVersion);
1488 return vHave.empty();
1491 void Set(const CBlockIndex* pindex)
1497 vHave.push_back(pindex->GetBlockHash());
1499 // Exponentially larger steps back
1500 for (int i = 0; pindex && i < nStep; i++)
1501 pindex = pindex->pprev;
1502 if (vHave.size() > 10)
1505 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1508 int GetDistanceBack()
1510 // Retrace how far back it was in the sender's branch
1513 BOOST_FOREACH(const uint256& hash, vHave)
1515 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1516 if (mi != mapBlockIndex.end())
1518 CBlockIndex* pindex = (*mi).second;
1519 if (pindex->IsInMainChain())
1529 CBlockIndex* GetBlockIndex()
1531 // Find the first block the caller has in the main chain
1532 BOOST_FOREACH(const uint256& hash, vHave)
1534 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1535 if (mi != mapBlockIndex.end())
1537 CBlockIndex* pindex = (*mi).second;
1538 if (pindex->IsInMainChain())
1542 return pindexGenesisBlock;
1545 uint256 GetBlockHash()
1547 // Find the first block the caller has in the main chain
1548 BOOST_FOREACH(const uint256& hash, vHave)
1550 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1551 if (mi != mapBlockIndex.end())
1553 CBlockIndex* pindex = (*mi).second;
1554 if (pindex->IsInMainChain())
1558 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1563 CBlockIndex* pindex = GetBlockIndex();
1566 return pindex->nHeight;
1580 mutable CCriticalSection cs;
1581 std::map<uint256, CTransaction> mapTx;
1582 std::map<COutPoint, CInPoint> mapNextTx;
1584 bool accept(CTxDB& txdb, CTransaction &tx,
1585 bool fCheckInputs, bool* pfMissingInputs);
1586 bool addUnchecked(const uint256& hash, CTransaction &tx);
1587 bool remove(CTransaction &tx);
1589 void queryHashes(std::vector<uint256>& vtxid);
1591 unsigned long size()
1594 return mapTx.size();
1597 bool exists(uint256 hash)
1599 return (mapTx.count(hash) != 0);
1602 CTransaction& lookup(uint256 hash)
1608 extern CTxMemPool mempool;