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.
13 #include "zerocoin/Zerocoin.h"
26 class CRequestTracker;
29 static const unsigned int MAX_BLOCK_SIZE = 1000000;
30 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
31 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
32 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
33 static const unsigned int MAX_INV_SZ = 50000;
34 static const int64 MIN_TX_FEE = CENT;
35 static const int64 MIN_RELAY_TX_FEE = CENT;
36 static const int64 MAX_MONEY = 2000000000 * COIN;
37 static const int64 MAX_MINT_PROOF_OF_WORK = 100 * COIN;
38 static const int64 MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
39 static const int64 MIN_TXOUT_AMOUNT = MIN_TX_FEE;
41 static const unsigned int ENTROPY_SWITCH_TIME = 1362791041; // Sat, 09 Mar 2013 01:04:01 GMT
42 static const unsigned int STAKE_SWITCH_TIME = 1371686400; // Thu, 20 Jun 2013 00:00:00 GMT
43 static const unsigned int TARGETS_SWITCH_TIME = 1374278400; // Sat, 20 Jul 2013 00:00:00 GMT
44 static const unsigned int CHAINCHECKS_SWITCH_TIME = 1379635200; // Fri, 20 Sep 2013 00:00:00 GMT
45 static const unsigned int STAKECURVE_SWITCH_TIME = 1382227200; // Sun, 20 Oct 2013 00:00:00 GMT
46 static const unsigned int STAKEWEIGHT_SWITCH_TIME = 1388534400; // Wed, 01 Jan 2014 00:00:00 GMT
49 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
50 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
51 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
54 static const int fHaveUPnP = true;
56 static const int fHaveUPnP = false;
59 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
60 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
61 static const int64 nMaxClockDrift = 2 * 60 * 60; // two hours
63 extern libzerocoin::Params* ZCParams;
64 extern CScript COINBASE_FLAGS;
65 extern CCriticalSection cs_main;
66 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
67 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
68 extern CBlockIndex* pindexGenesisBlock;
69 extern unsigned int nStakeMinAge;
70 extern unsigned int nNodeLifespan;
71 extern int nCoinbaseMaturity;
72 extern int nBestHeight;
73 extern uint256 nBestChainTrust;
74 extern uint256 nBestInvalidTrust;
75 extern uint256 hashBestChain;
76 extern CBlockIndex* pindexBest;
77 extern unsigned int nTransactionsUpdated;
78 extern uint64 nLastBlockTx;
79 extern uint64 nLastBlockSize;
80 extern int64 nLastCoinStakeSearchInterval;
81 extern const std::string strMessageMagic;
82 extern int64 nTimeBestReceived;
83 extern CCriticalSection cs_setpwalletRegistered;
84 extern std::set<CWallet*> setpwalletRegistered;
85 extern unsigned char pchMessageStart[4];
86 extern std::map<uint256, CBlock*> mapOrphanBlocks;
89 extern int64 nTransactionFee;
90 extern int64 nMinimumInputValue;
91 extern bool fUseFastIndex;
92 extern unsigned int nDerivationMethodIndex;
94 // Minimum disk space required - used in CheckDiskSpace()
95 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);
115 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
116 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
117 int64 GetProofOfWorkReward(unsigned int nBits);
118 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
119 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
120 unsigned int ComputeMinStake(unsigned int nBase, int64 nTime, unsigned int nBlockTime);
121 int GetNumBlocksOfPeers();
122 bool IsInitialBlockDownload();
123 std::string GetWarnings(std::string strFor);
124 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
125 uint256 WantedByOrphan(const CBlock* pblockOrphan);
126 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
127 void StakeMiner(CWallet *pwallet);
128 void ResendWalletTransactions();
139 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
141 /** Position on disk for a particular transaction. */
146 unsigned int nBlockPos;
154 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
157 nBlockPos = nBlockPosIn;
161 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
162 void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
163 bool IsNull() const { return (nFile == (unsigned int) -1); }
165 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
167 return (a.nFile == b.nFile &&
168 a.nBlockPos == b.nBlockPos &&
169 a.nTxPos == b.nTxPos);
172 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
178 std::string ToString() const
183 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
188 printf("%s", ToString().c_str());
194 /** An inpoint - a combination of a transaction and an index n into its vin */
201 CInPoint() { SetNull(); }
202 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
203 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
204 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
209 /** An outpoint - a combination of a transaction hash and an index n into its vout */
216 COutPoint() { SetNull(); }
217 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
218 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
219 void SetNull() { hash = 0; n = (unsigned int) -1; }
220 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
222 friend bool operator<(const COutPoint& a, const COutPoint& b)
224 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
227 friend bool operator==(const COutPoint& a, const COutPoint& b)
229 return (a.hash == b.hash && a.n == b.n);
232 friend bool operator!=(const COutPoint& a, const COutPoint& b)
237 std::string ToString() const
239 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
244 printf("%s\n", ToString().c_str());
251 /** An input of a transaction. It contains the location of the previous
252 * transaction's output that it claims and a signature that matches the
253 * output's public key.
260 unsigned int nSequence;
264 nSequence = std::numeric_limits<unsigned int>::max();
267 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
270 scriptSig = scriptSigIn;
271 nSequence = nSequenceIn;
274 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
276 prevout = COutPoint(hashPrevTx, nOut);
277 scriptSig = scriptSigIn;
278 nSequence = nSequenceIn;
284 READWRITE(scriptSig);
285 READWRITE(nSequence);
290 return (nSequence == std::numeric_limits<unsigned int>::max());
293 friend bool operator==(const CTxIn& a, const CTxIn& b)
295 return (a.prevout == b.prevout &&
296 a.scriptSig == b.scriptSig &&
297 a.nSequence == b.nSequence);
300 friend bool operator!=(const CTxIn& a, const CTxIn& b)
305 std::string ToStringShort() const
307 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
310 std::string ToString() const
314 str += prevout.ToString();
315 if (prevout.IsNull())
316 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
318 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
319 if (nSequence != std::numeric_limits<unsigned int>::max())
320 str += strprintf(", nSequence=%u", nSequence);
327 printf("%s\n", ToString().c_str());
334 /** An output of a transaction. It contains the public key that the next input
335 * must be able to sign with to claim it.
341 CScript scriptPubKey;
348 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
351 scriptPubKey = scriptPubKeyIn;
357 READWRITE(scriptPubKey);
363 scriptPubKey.clear();
368 return (nValue == -1);
374 scriptPubKey.clear();
379 return (nValue == 0 && scriptPubKey.empty());
382 uint256 GetHash() const
384 return SerializeHash(*this);
387 friend bool operator==(const CTxOut& a, const CTxOut& b)
389 return (a.nValue == b.nValue &&
390 a.scriptPubKey == b.scriptPubKey);
393 friend bool operator!=(const CTxOut& a, const CTxOut& b)
398 std::string ToStringShort() const
400 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
403 std::string ToString() const
405 if (IsEmpty()) return "CTxOut(empty)";
406 if (scriptPubKey.size() < 6)
407 return "CTxOut(error)";
408 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
413 printf("%s\n", ToString().c_str());
427 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
429 /** The basic transaction that is broadcasted on the network and contained in
430 * blocks. A transaction can contain multiple inputs and outputs.
435 static const int CURRENT_VERSION=1;
438 std::vector<CTxIn> vin;
439 std::vector<CTxOut> vout;
440 unsigned int nLockTime;
442 // Denial-of-service detection:
444 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
453 READWRITE(this->nVersion);
454 nVersion = this->nVersion;
458 READWRITE(nLockTime);
463 nVersion = CTransaction::CURRENT_VERSION;
464 nTime = GetAdjustedTime();
468 nDoS = 0; // Denial-of-service prevention
473 return (vin.empty() && vout.empty());
476 uint256 GetHash() const
478 return SerializeHash(*this);
481 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
483 // Time based nLockTime implemented in 0.1.6
486 if (nBlockHeight == 0)
487 nBlockHeight = nBestHeight;
489 nBlockTime = GetAdjustedTime();
490 if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
492 BOOST_FOREACH(const CTxIn& txin, vin)
498 bool IsNewerThan(const CTransaction& old) const
500 if (vin.size() != old.vin.size())
502 for (unsigned int i = 0; i < vin.size(); i++)
503 if (vin[i].prevout != old.vin[i].prevout)
507 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
508 for (unsigned int i = 0; i < vin.size(); i++)
510 if (vin[i].nSequence != old.vin[i].nSequence)
512 if (vin[i].nSequence <= nLowest)
515 nLowest = vin[i].nSequence;
517 if (old.vin[i].nSequence < nLowest)
520 nLowest = old.vin[i].nSequence;
527 bool IsCoinBase() const
529 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
532 bool IsCoinStake() const
534 // ppcoin: the coin stake transaction is marked with the first output empty
535 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
538 /** Check for standard transaction types
539 @return True if all outputs (scriptPubKeys) use only standard transaction forms
541 bool IsStandard() const;
543 /** Check for standard transaction types
544 @param[in] mapInputs Map of previous transactions that have outputs we're spending
545 @return True if all inputs (scriptSigs) use only standard transaction forms
546 @see CTransaction::FetchInputs
548 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
550 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
551 @return number of sigops this transaction's outputs will produce when spent
552 @see CTransaction::FetchInputs
554 unsigned int GetLegacySigOpCount() const;
556 /** Count ECDSA signature operations in pay-to-script-hash inputs.
558 @param[in] mapInputs Map of previous transactions that have outputs we're spending
559 @return maximum number of sigops required to validate this transaction's inputs
560 @see CTransaction::FetchInputs
562 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
564 /** Amount of bitcoins spent by this transaction.
565 @return sum of all outputs (note: does not include fees)
567 int64 GetValueOut() const
570 BOOST_FOREACH(const CTxOut& txout, vout)
572 nValueOut += txout.nValue;
573 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
574 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
579 /** Amount of bitcoins coming in to this transaction
580 Note that lightweight clients may not know anything besides the hash of previous transactions,
581 so may not be able to calculate this.
583 @param[in] mapInputs Map of previous transactions that have outputs we're spending
584 @return Sum of value of all inputs (scriptSigs)
585 @see CTransaction::FetchInputs
587 int64 GetValueIn(const MapPrevTx& mapInputs) const;
589 static bool AllowFree(double dPriority)
591 // Large (in bytes) low-priority (new, small-coin) transactions
593 return dPriority > COIN * 144 / 250;
596 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
598 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
600 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
602 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
605 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
606 return error("CTransaction::ReadFromDisk() : fseek failed");
611 catch (std::exception &e) {
612 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
615 // Return file pointer
618 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
619 return error("CTransaction::ReadFromDisk() : second fseek failed");
620 *pfileRet = filein.release();
625 friend bool operator==(const CTransaction& a, const CTransaction& b)
627 return (a.nVersion == b.nVersion &&
628 a.nTime == b.nTime &&
631 a.nLockTime == b.nLockTime);
634 friend bool operator!=(const CTransaction& a, const CTransaction& b)
639 std::string ToStringShort() const
642 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
646 std::string ToString() const
649 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
650 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%d)\n",
651 GetHash().ToString().substr(0,10).c_str(),
657 for (unsigned int i = 0; i < vin.size(); i++)
658 str += " " + vin[i].ToString() + "\n";
659 for (unsigned int i = 0; i < vout.size(); i++)
660 str += " " + vout[i].ToString() + "\n";
666 printf("%s", ToString().c_str());
670 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
671 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
672 bool ReadFromDisk(COutPoint prevout);
673 bool DisconnectInputs(CTxDB& txdb);
675 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
677 @param[in] txdb Transaction database
678 @param[in] mapTestPool List of pending changes to the transaction index database
679 @param[in] fBlock True if being called to add a new best-block to the chain
680 @param[in] fMiner True if being called by CreateNewBlock
681 @param[out] inputsRet Pointers to this transaction's inputs
682 @param[out] fInvalid returns true if transaction is invalid
683 @return Returns true if all inputs are in txdb or mapTestPool
685 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
686 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
688 /** Sanity check previous transactions, then, if all checks succeed,
689 mark them as spent by this transaction.
691 @param[in] inputs Previous transactions (from FetchInputs)
692 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
693 @param[in] posThisTx Position of this transaction on disk
694 @param[in] pindexBlock
695 @param[in] fBlock true if called from ConnectBlock
696 @param[in] fMiner true if called from CreateNewBlock
697 @param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
698 @return Returns true if all checks succeed
700 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs,
701 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
702 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
703 bool ClientConnectInputs();
704 bool CheckTransaction() const;
705 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
706 bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const; // ppcoin: get transaction coin age
709 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
716 /** A transaction with a merkle branch linking it to the block chain. */
717 class CMerkleTx : public CTransaction
721 std::vector<uint256> vMerkleBranch;
725 mutable bool fMerkleVerified;
733 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
742 fMerkleVerified = false;
748 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
749 nVersion = this->nVersion;
750 READWRITE(hashBlock);
751 READWRITE(vMerkleBranch);
756 int SetMerkleBranch(const CBlock* pblock=NULL);
757 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
758 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
759 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
760 int GetBlocksToMaturity() const;
761 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
762 bool AcceptToMemoryPool();
768 /** A txdb record that contains the disk location of a transaction and the
769 * locations of transactions that spend its outputs. vSpent is really only
770 * used as a flag, but having the location is very helpful for debugging.
776 std::vector<CDiskTxPos> vSpent;
783 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
786 vSpent.resize(nOutputs);
791 if (!(nType & SER_GETHASH))
808 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
810 return (a.pos == b.pos &&
811 a.vSpent == b.vSpent);
814 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
818 int GetDepthInMainChain() const;
826 /** Nodes collect new transactions into a block, hash them into a hash tree,
827 * and scan through nonce values to make the block's hash satisfy proof-of-work
828 * requirements. When they solve the proof-of-work, they broadcast the block
829 * to everyone and the block is added to the block chain. The first transaction
830 * in the block is a special one that creates a new coin owned by the creator
833 * Blocks are appended to blk0001.dat files on disk. Their location on disk
834 * is indexed by CBlockIndex objects in memory.
840 static const int CURRENT_VERSION=6;
842 uint256 hashPrevBlock;
843 uint256 hashMerkleRoot;
849 std::vector<CTransaction> vtx;
851 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
852 std::vector<unsigned char> vchBlockSig;
855 mutable std::vector<uint256> vMerkleTree;
857 // Denial-of-service detection:
859 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
868 READWRITE(this->nVersion);
869 nVersion = this->nVersion;
870 READWRITE(hashPrevBlock);
871 READWRITE(hashMerkleRoot);
876 // ConnectBlock depends on vtx following header to generate CDiskTxPos
877 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
880 READWRITE(vchBlockSig);
884 const_cast<CBlock*>(this)->vtx.clear();
885 const_cast<CBlock*>(this)->vchBlockSig.clear();
891 nVersion = CBlock::CURRENT_VERSION;
908 uint256 GetHash() const
910 return scrypt_blockhash(CVOIDBEGIN(nVersion));
913 int64 GetBlockTime() const
918 void UpdateTime(const CBlockIndex* pindexPrev);
920 // ppcoin: entropy bit for stake modifier if chosen by modifier
921 unsigned int GetStakeEntropyBit(unsigned int nTime) const
923 // Protocol switch to support p2pool at novacoin block #9689
924 if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
926 // Take last bit of block hash as entropy bit
927 unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
928 if (fDebug && GetBoolArg("-printstakemodifier"))
929 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
932 // Before novacoin block #9689 - old protocol
933 uint160 hashSig = Hash160(vchBlockSig);
934 if (fDebug && GetBoolArg("-printstakemodifier"))
935 printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
936 hashSig >>= 159; // take the first bit of the hash
937 if (fDebug && GetBoolArg("-printstakemodifier"))
938 printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
939 return hashSig.Get64();
942 // ppcoin: two types of block: proof-of-work or proof-of-stake
943 bool IsProofOfStake() const
945 return (vtx.size() > 1 && vtx[1].IsCoinStake());
948 bool IsProofOfWork() const
950 return !IsProofOfStake();
953 std::pair<COutPoint, unsigned int> GetProofOfStake() const
955 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
958 // ppcoin: get max transaction timestamp
959 int64 GetMaxTransactionTime() const
961 int64 maxTransactionTime = 0;
962 BOOST_FOREACH(const CTransaction& tx, vtx)
963 maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
964 return maxTransactionTime;
967 uint256 BuildMerkleTree() const
970 BOOST_FOREACH(const CTransaction& tx, vtx)
971 vMerkleTree.push_back(tx.GetHash());
973 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
975 for (int i = 0; i < nSize; i += 2)
977 int i2 = std::min(i+1, nSize-1);
978 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
979 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
983 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
986 std::vector<uint256> GetMerkleBranch(int nIndex) const
988 if (vMerkleTree.empty())
990 std::vector<uint256> vMerkleBranch;
992 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
994 int i = std::min(nIndex^1, nSize-1);
995 vMerkleBranch.push_back(vMerkleTree[j+i]);
999 return vMerkleBranch;
1002 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1006 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1009 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1011 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1018 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1020 // Open history file to append
1021 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1023 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1025 // Write index header
1026 unsigned int nSize = fileout.GetSerializeSize(*this);
1027 fileout << FLATDATA(pchMessageStart) << nSize;
1030 long fileOutPos = ftell(fileout);
1032 return error("CBlock::WriteToDisk() : ftell failed");
1033 nBlockPosRet = fileOutPos;
1036 // Flush stdio buffers and commit to disk before returning
1038 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1039 FileCommit(fileout);
1044 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1048 // Open history file to read
1049 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1051 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1052 if (!fReadTransactions)
1053 filein.nType |= SER_BLOCKHEADERONLY;
1059 catch (std::exception &e) {
1060 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1064 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1065 return error("CBlock::ReadFromDisk() : errors in block header");
1074 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1075 GetHash().ToString().c_str(),
1077 hashPrevBlock.ToString().c_str(),
1078 hashMerkleRoot.ToString().c_str(),
1079 nTime, nBits, nNonce,
1081 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1082 for (unsigned int i = 0; i < vtx.size(); i++)
1087 printf(" vMerkleTree: ");
1088 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1089 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1094 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1095 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1096 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1097 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1098 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1099 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1101 bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1102 bool SignBlock(const CKeyStore& keystore);
1103 bool CheckBlockSignature(bool fProofOfStake) const;
1106 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1114 /** The block chain is a tree shaped structure starting with the
1115 * genesis block at the root, with each block potentially having multiple
1116 * candidates to be the next block. pprev and pnext link a path through the
1117 * main/longest chain. A blockindex may have multiple pprev pointing back
1118 * to it, but pnext will only point forward to the longest branch, or will
1119 * be null if the block is not part of the longest chain.
1124 const uint256* phashBlock;
1128 unsigned int nBlockPos;
1129 uint256 nChainTrust; // ppcoin: trust score of block chain
1135 unsigned int nFlags; // ppcoin: block index flags
1138 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1139 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1140 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1143 uint64 nStakeModifier; // hash modifier for proof-of-stake
1144 unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1146 // proof-of-stake specific fields
1147 COutPoint prevoutStake;
1148 unsigned int nStakeTime;
1149 uint256 hashProofOfStake;
1153 uint256 hashMerkleRoot;
1156 unsigned int nNonce;
1171 nStakeModifierChecksum = 0;
1172 hashProofOfStake = 0;
1173 prevoutStake.SetNull();
1183 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1189 nBlockPos = nBlockPosIn;
1196 nStakeModifierChecksum = 0;
1197 hashProofOfStake = 0;
1198 if (block.IsProofOfStake())
1201 prevoutStake = block.vtx[1].vin[0].prevout;
1202 nStakeTime = block.vtx[1].nTime;
1206 prevoutStake.SetNull();
1210 nVersion = block.nVersion;
1211 hashMerkleRoot = block.hashMerkleRoot;
1212 nTime = block.nTime;
1213 nBits = block.nBits;
1214 nNonce = block.nNonce;
1217 CBlock GetBlockHeader() const
1220 block.nVersion = nVersion;
1222 block.hashPrevBlock = pprev->GetBlockHash();
1223 block.hashMerkleRoot = hashMerkleRoot;
1224 block.nTime = nTime;
1225 block.nBits = nBits;
1226 block.nNonce = nNonce;
1230 uint256 GetBlockHash() const
1235 int64 GetBlockTime() const
1237 return (int64)nTime;
1240 uint256 GetBlockTrust() const;
1242 bool IsInMainChain() const
1244 return (pnext || this == pindexBest);
1247 bool CheckIndex() const
1252 enum { nMedianTimeSpan=11 };
1254 int64 GetMedianTimePast() const
1256 int64 pmedian[nMedianTimeSpan];
1257 int64* pbegin = &pmedian[nMedianTimeSpan];
1258 int64* pend = &pmedian[nMedianTimeSpan];
1260 const CBlockIndex* pindex = this;
1261 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1262 *(--pbegin) = pindex->GetBlockTime();
1264 std::sort(pbegin, pend);
1265 return pbegin[(pend - pbegin)/2];
1268 int64 GetMedianTime() const
1270 const CBlockIndex* pindex = this;
1271 for (int i = 0; i < nMedianTimeSpan/2; i++)
1274 return GetBlockTime();
1275 pindex = pindex->pnext;
1277 return pindex->GetMedianTimePast();
1281 * Returns true if there are nRequired or more blocks of minVersion or above
1282 * in the last nToCheck blocks, starting at pstart and going backwards.
1284 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1285 unsigned int nRequired, unsigned int nToCheck);
1288 bool IsProofOfWork() const
1290 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1293 bool IsProofOfStake() const
1295 return (nFlags & BLOCK_PROOF_OF_STAKE);
1298 void SetProofOfStake()
1300 nFlags |= BLOCK_PROOF_OF_STAKE;
1303 unsigned int GetStakeEntropyBit() const
1305 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1308 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1310 if (nEntropyBit > 1)
1312 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1316 bool GeneratedStakeModifier() const
1318 return (nFlags & BLOCK_STAKE_MODIFIER);
1321 void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1323 nStakeModifier = nModifier;
1324 if (fGeneratedStakeModifier)
1325 nFlags |= BLOCK_STAKE_MODIFIER;
1328 std::string ToString() const
1330 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)",
1331 pprev, pnext, nFile, nBlockPos, nHeight,
1332 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1333 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1334 nStakeModifier, nStakeModifierChecksum,
1335 hashProofOfStake.ToString().c_str(),
1336 prevoutStake.ToString().c_str(), nStakeTime,
1337 hashMerkleRoot.ToString().c_str(),
1338 GetBlockHash().ToString().c_str());
1343 printf("%s\n", ToString().c_str());
1349 /** Used to marshal pointers into hashes for db storage. */
1350 class CDiskBlockIndex : public CBlockIndex
1366 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1368 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1369 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1374 if (!(nType & SER_GETHASH))
1375 READWRITE(nVersion);
1377 READWRITE(hashNext);
1379 READWRITE(nBlockPos);
1382 READWRITE(nMoneySupply);
1384 READWRITE(nStakeModifier);
1385 if (IsProofOfStake())
1387 READWRITE(prevoutStake);
1388 READWRITE(nStakeTime);
1389 READWRITE(hashProofOfStake);
1393 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1394 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1395 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1399 READWRITE(this->nVersion);
1400 READWRITE(hashPrev);
1401 READWRITE(hashMerkleRoot);
1405 READWRITE(blockHash);
1408 uint256 GetBlockHash() const
1410 if (fUseFastIndex && (nTime < GetAdjustedTime() - 12 * nMaxClockDrift) && blockHash != 0)
1414 block.nVersion = nVersion;
1415 block.hashPrevBlock = hashPrev;
1416 block.hashMerkleRoot = hashMerkleRoot;
1417 block.nTime = nTime;
1418 block.nBits = nBits;
1419 block.nNonce = nNonce;
1421 const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1426 std::string ToString() const
1428 std::string str = "CDiskBlockIndex(";
1429 str += CBlockIndex::ToString();
1430 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1431 GetBlockHash().ToString().c_str(),
1432 hashPrev.ToString().c_str(),
1433 hashNext.ToString().c_str());
1439 printf("%s\n", ToString().c_str());
1450 /** Describes a place in the block chain to another node such that if the
1451 * other node doesn't have the same branch, it can find a recent common trunk.
1452 * The further back it is, the further before the fork it may be.
1457 std::vector<uint256> vHave;
1464 explicit CBlockLocator(const CBlockIndex* pindex)
1469 explicit CBlockLocator(uint256 hashBlock)
1471 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1472 if (mi != mapBlockIndex.end())
1476 CBlockLocator(const std::vector<uint256>& vHaveIn)
1483 if (!(nType & SER_GETHASH))
1484 READWRITE(nVersion);
1495 return vHave.empty();
1498 void Set(const CBlockIndex* pindex)
1504 vHave.push_back(pindex->GetBlockHash());
1506 // Exponentially larger steps back
1507 for (int i = 0; pindex && i < nStep; i++)
1508 pindex = pindex->pprev;
1509 if (vHave.size() > 10)
1512 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1515 int GetDistanceBack()
1517 // Retrace how far back it was in the sender's branch
1520 BOOST_FOREACH(const uint256& hash, vHave)
1522 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1523 if (mi != mapBlockIndex.end())
1525 CBlockIndex* pindex = (*mi).second;
1526 if (pindex->IsInMainChain())
1536 CBlockIndex* GetBlockIndex()
1538 // Find the first block the caller has in the main chain
1539 BOOST_FOREACH(const uint256& hash, vHave)
1541 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1542 if (mi != mapBlockIndex.end())
1544 CBlockIndex* pindex = (*mi).second;
1545 if (pindex->IsInMainChain())
1549 return pindexGenesisBlock;
1552 uint256 GetBlockHash()
1554 // Find the first block the caller has in the main chain
1555 BOOST_FOREACH(const uint256& hash, vHave)
1557 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1558 if (mi != mapBlockIndex.end())
1560 CBlockIndex* pindex = (*mi).second;
1561 if (pindex->IsInMainChain())
1565 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1570 CBlockIndex* pindex = GetBlockIndex();
1573 return pindex->nHeight;
1587 mutable CCriticalSection cs;
1588 std::map<uint256, CTransaction> mapTx;
1589 std::map<COutPoint, CInPoint> mapNextTx;
1591 bool accept(CTxDB& txdb, CTransaction &tx,
1592 bool fCheckInputs, bool* pfMissingInputs);
1593 bool addUnchecked(const uint256& hash, CTransaction &tx);
1594 bool remove(CTransaction &tx);
1596 void queryHashes(std::vector<uint256>& vtxid);
1598 unsigned long size()
1601 return mapTx.size();
1604 bool exists(uint256 hash)
1606 return (mapTx.count(hash) != 0);
1609 CTransaction& lookup(uint256 hash)
1615 extern CTxMemPool mempool;