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.
8 #include "timestamps.h"
14 #include "zerocoin/Zerocoin.h"
27 class CRequestTracker;
30 static const unsigned int MAX_BLOCK_SIZE = 1000000;
31 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
32 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
33 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
34 static const unsigned int MAX_INV_SZ = 50000;
36 static const int64 MIN_TX_FEE = CENT/10;
37 static const int64 MIN_RELAY_TX_FEE = CENT/50;
39 static const int64 MAX_MONEY = 2000000000 * COIN;
40 static const int64 MAX_MINT_PROOF_OF_WORK = 100 * COIN;
41 static const int64 MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
42 static const int64 MIN_TXOUT_AMOUNT = CENT/100;
44 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
45 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
46 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
49 static const int fHaveUPnP = true;
51 static const int fHaveUPnP = false;
54 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
55 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
57 inline int64 PastDrift(int64 nTime) { return nTime - 2 * 60 * 60; } // up to 2 hours from the past
58 inline int64 FutureDrift(int64 nTime) { return nTime + 2 * 60 * 60; } // up to 2 hours from the future
60 extern libzerocoin::Params* ZCParams;
61 extern CScript COINBASE_FLAGS;
62 extern CCriticalSection cs_main;
63 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
64 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
65 extern CBlockIndex* pindexGenesisBlock;
66 extern unsigned int nStakeMinAge;
67 extern unsigned int nNodeLifespan;
68 extern int nCoinbaseMaturity;
69 extern int nBestHeight;
70 extern uint256 nBestChainTrust;
71 extern uint256 nBestInvalidTrust;
72 extern uint256 hashBestChain;
73 extern CBlockIndex* pindexBest;
74 extern unsigned int nTransactionsUpdated;
75 extern uint64 nLastBlockTx;
76 extern uint64 nLastBlockSize;
77 extern int64 nLastCoinStakeSearchInterval;
78 extern const std::string strMessageMagic;
79 extern int64 nTimeBestReceived;
80 extern CCriticalSection cs_setpwalletRegistered;
81 extern std::set<CWallet*> setpwalletRegistered;
82 extern unsigned char pchMessageStart[4];
83 extern std::map<uint256, CBlock*> mapOrphanBlocks;
86 extern int64 nTransactionFee;
87 extern int64 nMinimumInputValue;
88 extern bool fUseFastIndex;
89 extern unsigned int nDerivationMethodIndex;
91 // Minimum disk space required - used in CheckDiskSpace()
92 static const uint64 nMinDiskSpace = 52428800;
98 void RegisterWallet(CWallet* pwalletIn);
99 void UnregisterWallet(CWallet* pwalletIn);
100 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
101 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
102 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
103 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
104 FILE* AppendBlockFile(unsigned int& nFileRet);
105 bool LoadBlockIndex(bool fAllowNew=true);
106 void PrintBlockTree();
107 CBlockIndex* FindBlockByHeight(int nHeight);
108 bool ProcessMessages(CNode* pfrom);
109 bool SendMessages(CNode* pto, bool fSendTrickle);
110 bool LoadExternalBlockFile(FILE* fileIn);
112 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
113 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
114 int64 GetProofOfWorkReward(unsigned int nBits, int64 nFees=0);
115 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
116 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
117 unsigned int ComputeMinStake(unsigned int nBase, int64 nTime, unsigned int nBlockTime);
118 int GetNumBlocksOfPeers();
119 bool IsInitialBlockDownload();
120 std::string GetWarnings(std::string strFor);
121 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
122 uint256 WantedByOrphan(const CBlock* pblockOrphan);
123 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
124 void StakeMiner(CWallet *pwallet);
125 void ResendWalletTransactions();
136 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
138 /** Position on disk for a particular transaction. */
143 unsigned int nBlockPos;
151 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
154 nBlockPos = nBlockPosIn;
158 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
159 void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
160 bool IsNull() const { return (nFile == (unsigned int) -1); }
162 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
164 return (a.nFile == b.nFile &&
165 a.nBlockPos == b.nBlockPos &&
166 a.nTxPos == b.nTxPos);
169 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
175 std::string ToString() const
180 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
185 printf("%s", ToString().c_str());
191 /** An inpoint - a combination of a transaction and an index n into its vin */
198 CInPoint() { SetNull(); }
199 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
200 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
201 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
206 /** An outpoint - a combination of a transaction hash and an index n into its vout */
213 COutPoint() { SetNull(); }
214 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
215 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
216 void SetNull() { hash = 0; n = (unsigned int) -1; }
217 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
219 friend bool operator<(const COutPoint& a, const COutPoint& b)
221 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
224 friend bool operator==(const COutPoint& a, const COutPoint& b)
226 return (a.hash == b.hash && a.n == b.n);
229 friend bool operator!=(const COutPoint& a, const COutPoint& b)
234 std::string ToString() const
236 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
241 printf("%s\n", ToString().c_str());
248 /** An input of a transaction. It contains the location of the previous
249 * transaction's output that it claims and a signature that matches the
250 * output's public key.
257 unsigned int nSequence;
261 nSequence = std::numeric_limits<unsigned int>::max();
264 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
267 scriptSig = scriptSigIn;
268 nSequence = nSequenceIn;
271 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
273 prevout = COutPoint(hashPrevTx, nOut);
274 scriptSig = scriptSigIn;
275 nSequence = nSequenceIn;
281 READWRITE(scriptSig);
282 READWRITE(nSequence);
287 return (nSequence == std::numeric_limits<unsigned int>::max());
290 friend bool operator==(const CTxIn& a, const CTxIn& b)
292 return (a.prevout == b.prevout &&
293 a.scriptSig == b.scriptSig &&
294 a.nSequence == b.nSequence);
297 friend bool operator!=(const CTxIn& a, const CTxIn& b)
302 std::string ToStringShort() const
304 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
307 std::string ToString() const
311 str += prevout.ToString();
312 if (prevout.IsNull())
313 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
315 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
316 if (nSequence != std::numeric_limits<unsigned int>::max())
317 str += strprintf(", nSequence=%u", nSequence);
324 printf("%s\n", ToString().c_str());
331 /** An output of a transaction. It contains the public key that the next input
332 * must be able to sign with to claim it.
338 CScript scriptPubKey;
345 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
348 scriptPubKey = scriptPubKeyIn;
354 READWRITE(scriptPubKey);
360 scriptPubKey.clear();
365 return (nValue == -1);
371 scriptPubKey.clear();
376 return (nValue == 0 && scriptPubKey.empty());
379 uint256 GetHash() const
381 return SerializeHash(*this);
384 friend bool operator==(const CTxOut& a, const CTxOut& b)
386 return (a.nValue == b.nValue &&
387 a.scriptPubKey == b.scriptPubKey);
390 friend bool operator!=(const CTxOut& a, const CTxOut& b)
395 std::string ToStringShort() const
397 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
400 std::string ToString() const
402 if (IsEmpty()) return "CTxOut(empty)";
403 if (scriptPubKey.size() < 6)
404 return "CTxOut(error)";
405 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
410 printf("%s\n", ToString().c_str());
424 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
426 /** The basic transaction that is broadcasted on the network and contained in
427 * blocks. A transaction can contain multiple inputs and outputs.
432 static const int CURRENT_VERSION=1;
435 std::vector<CTxIn> vin;
436 std::vector<CTxOut> vout;
437 unsigned int nLockTime;
439 // Denial-of-service detection:
441 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
450 READWRITE(this->nVersion);
451 nVersion = this->nVersion;
455 READWRITE(nLockTime);
460 nVersion = CTransaction::CURRENT_VERSION;
461 nTime = GetAdjustedTime();
465 nDoS = 0; // Denial-of-service prevention
470 return (vin.empty() && vout.empty());
473 uint256 GetHash() const
475 return SerializeHash(*this);
478 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
480 // Time based nLockTime implemented in 0.1.6
483 if (nBlockHeight == 0)
484 nBlockHeight = nBestHeight;
486 nBlockTime = GetAdjustedTime();
487 if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
489 BOOST_FOREACH(const CTxIn& txin, vin)
495 bool IsNewerThan(const CTransaction& old) const
497 if (vin.size() != old.vin.size())
499 for (unsigned int i = 0; i < vin.size(); i++)
500 if (vin[i].prevout != old.vin[i].prevout)
504 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
505 for (unsigned int i = 0; i < vin.size(); i++)
507 if (vin[i].nSequence != old.vin[i].nSequence)
509 if (vin[i].nSequence <= nLowest)
512 nLowest = vin[i].nSequence;
514 if (old.vin[i].nSequence < nLowest)
517 nLowest = old.vin[i].nSequence;
524 bool IsCoinBase() const
526 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
529 bool IsCoinStake() const
531 // ppcoin: the coin stake transaction is marked with the first output empty
532 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
535 /** Check for standard transaction types
536 @return True if all outputs (scriptPubKeys) use only standard transaction forms
538 bool IsStandard() const;
540 /** Check for standard transaction types
541 @param[in] mapInputs Map of previous transactions that have outputs we're spending
542 @return True if all inputs (scriptSigs) use only standard transaction forms
543 @see CTransaction::FetchInputs
545 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
547 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
548 @return number of sigops this transaction's outputs will produce when spent
549 @see CTransaction::FetchInputs
551 unsigned int GetLegacySigOpCount() const;
553 /** Count ECDSA signature operations in pay-to-script-hash inputs.
555 @param[in] mapInputs Map of previous transactions that have outputs we're spending
556 @return maximum number of sigops required to validate this transaction's inputs
557 @see CTransaction::FetchInputs
559 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
561 /** Amount of bitcoins spent by this transaction.
562 @return sum of all outputs (note: does not include fees)
564 int64 GetValueOut() const
567 BOOST_FOREACH(const CTxOut& txout, vout)
569 nValueOut += txout.nValue;
570 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
571 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
576 /** Amount of bitcoins coming in to this transaction
577 Note that lightweight clients may not know anything besides the hash of previous transactions,
578 so may not be able to calculate this.
580 @param[in] mapInputs Map of previous transactions that have outputs we're spending
581 @return Sum of value of all inputs (scriptSigs)
582 @see CTransaction::FetchInputs
584 int64 GetValueIn(const MapPrevTx& mapInputs) const;
586 static bool AllowFree(double dPriority)
588 // Large (in bytes) low-priority (new, small-coin) transactions
590 return dPriority > COIN * 144 / 250;
593 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
595 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
597 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
599 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
602 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
603 return error("CTransaction::ReadFromDisk() : fseek failed");
608 catch (std::exception &e) {
609 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
612 // Return file pointer
615 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
616 return error("CTransaction::ReadFromDisk() : second fseek failed");
617 *pfileRet = filein.release();
622 friend bool operator==(const CTransaction& a, const CTransaction& b)
624 return (a.nVersion == b.nVersion &&
625 a.nTime == b.nTime &&
628 a.nLockTime == b.nLockTime);
631 friend bool operator!=(const CTransaction& a, const CTransaction& b)
636 std::string ToStringShort() const
639 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
643 std::string ToString() const
646 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
647 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%d)\n",
648 GetHash().ToString().substr(0,10).c_str(),
654 for (unsigned int i = 0; i < vin.size(); i++)
655 str += " " + vin[i].ToString() + "\n";
656 for (unsigned int i = 0; i < vout.size(); i++)
657 str += " " + vout[i].ToString() + "\n";
663 printf("%s", ToString().c_str());
667 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
668 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
669 bool ReadFromDisk(COutPoint prevout);
670 bool DisconnectInputs(CTxDB& txdb);
672 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
674 @param[in] txdb Transaction database
675 @param[in] mapTestPool List of pending changes to the transaction index database
676 @param[in] fBlock True if being called to add a new best-block to the chain
677 @param[in] fMiner True if being called by CreateNewBlock
678 @param[out] inputsRet Pointers to this transaction's inputs
679 @param[out] fInvalid returns true if transaction is invalid
680 @return Returns true if all inputs are in txdb or mapTestPool
682 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
683 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
685 /** Sanity check previous transactions, then, if all checks succeed,
686 mark them as spent by this transaction.
688 @param[in] inputs Previous transactions (from FetchInputs)
689 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
690 @param[in] posThisTx Position of this transaction on disk
691 @param[in] pindexBlock
692 @param[in] fBlock true if called from ConnectBlock
693 @param[in] fMiner true if called from CreateNewBlock
694 @param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
695 @return Returns true if all checks succeed
697 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs,
698 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
699 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, unsigned int flags=STANDARD_SCRIPT_VERIFY_FLAGS);
700 bool ClientConnectInputs();
701 bool CheckTransaction() const;
702 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
703 bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const; // ppcoin: get transaction coin age
706 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
713 /** A transaction with a merkle branch linking it to the block chain. */
714 class CMerkleTx : public CTransaction
718 std::vector<uint256> vMerkleBranch;
722 mutable bool fMerkleVerified;
730 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
739 fMerkleVerified = false;
745 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
746 nVersion = this->nVersion;
747 READWRITE(hashBlock);
748 READWRITE(vMerkleBranch);
753 int SetMerkleBranch(const CBlock* pblock=NULL);
754 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
755 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
756 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
757 int GetBlocksToMaturity() const;
758 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
759 bool AcceptToMemoryPool();
765 /** A txdb record that contains the disk location of a transaction and the
766 * locations of transactions that spend its outputs. vSpent is really only
767 * used as a flag, but having the location is very helpful for debugging.
773 std::vector<CDiskTxPos> vSpent;
780 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
783 vSpent.resize(nOutputs);
788 if (!(nType & SER_GETHASH))
805 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
807 return (a.pos == b.pos &&
808 a.vSpent == b.vSpent);
811 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
815 int GetDepthInMainChain() const;
823 /** Nodes collect new transactions into a block, hash them into a hash tree,
824 * and scan through nonce values to make the block's hash satisfy proof-of-work
825 * requirements. When they solve the proof-of-work, they broadcast the block
826 * to everyone and the block is added to the block chain. The first transaction
827 * in the block is a special one that creates a new coin owned by the creator
830 * Blocks are appended to blk0001.dat files on disk. Their location on disk
831 * is indexed by CBlockIndex objects in memory.
837 static const int CURRENT_VERSION=6;
839 uint256 hashPrevBlock;
840 uint256 hashMerkleRoot;
846 std::vector<CTransaction> vtx;
848 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
849 std::vector<unsigned char> vchBlockSig;
852 mutable std::vector<uint256> vMerkleTree;
854 // Denial-of-service detection:
856 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
865 READWRITE(this->nVersion);
866 nVersion = this->nVersion;
867 READWRITE(hashPrevBlock);
868 READWRITE(hashMerkleRoot);
873 // ConnectBlock depends on vtx following header to generate CDiskTxPos
874 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
877 READWRITE(vchBlockSig);
881 const_cast<CBlock*>(this)->vtx.clear();
882 const_cast<CBlock*>(this)->vchBlockSig.clear();
888 nVersion = CBlock::CURRENT_VERSION;
905 uint256 GetHash() const
907 return scrypt_blockhash(CVOIDBEGIN(nVersion));
910 int64 GetBlockTime() const
915 void UpdateTime(const CBlockIndex* pindexPrev);
917 // ppcoin: entropy bit for stake modifier if chosen by modifier
918 unsigned int GetStakeEntropyBit(unsigned int nTime) const
920 // Protocol switch to support p2pool at novacoin block #9689
921 if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
923 // Take last bit of block hash as entropy bit
924 unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
925 if (fDebug && GetBoolArg("-printstakemodifier"))
926 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
929 // Before novacoin block #9689 - old protocol
930 uint160 hashSig = Hash160(vchBlockSig);
931 if (fDebug && GetBoolArg("-printstakemodifier"))
932 printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
933 hashSig >>= 159; // take the first bit of the hash
934 if (fDebug && GetBoolArg("-printstakemodifier"))
935 printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
936 return hashSig.Get64();
939 // ppcoin: two types of block: proof-of-work or proof-of-stake
940 bool IsProofOfStake() const
942 return (vtx.size() > 1 && vtx[1].IsCoinStake());
945 bool IsProofOfWork() const
947 return !IsProofOfStake();
950 std::pair<COutPoint, unsigned int> GetProofOfStake() const
952 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
955 // ppcoin: get max transaction timestamp
956 int64 GetMaxTransactionTime() const
958 int64 maxTransactionTime = 0;
959 BOOST_FOREACH(const CTransaction& tx, vtx)
960 maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
961 return maxTransactionTime;
964 uint256 BuildMerkleTree() const
967 BOOST_FOREACH(const CTransaction& tx, vtx)
968 vMerkleTree.push_back(tx.GetHash());
970 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
972 for (int i = 0; i < nSize; i += 2)
974 int i2 = std::min(i+1, nSize-1);
975 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
976 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
980 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
983 std::vector<uint256> GetMerkleBranch(int nIndex) const
985 if (vMerkleTree.empty())
987 std::vector<uint256> vMerkleBranch;
989 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
991 int i = std::min(nIndex^1, nSize-1);
992 vMerkleBranch.push_back(vMerkleTree[j+i]);
996 return vMerkleBranch;
999 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1003 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1006 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1008 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1015 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1017 // Open history file to append
1018 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1020 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1022 // Write index header
1023 unsigned int nSize = fileout.GetSerializeSize(*this);
1024 fileout << FLATDATA(pchMessageStart) << nSize;
1027 long fileOutPos = ftell(fileout);
1029 return error("CBlock::WriteToDisk() : ftell failed");
1030 nBlockPosRet = fileOutPos;
1033 // Flush stdio buffers and commit to disk before returning
1035 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1036 FileCommit(fileout);
1041 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1045 // Open history file to read
1046 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1048 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1049 if (!fReadTransactions)
1050 filein.nType |= SER_BLOCKHEADERONLY;
1056 catch (std::exception &e) {
1057 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1061 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1062 return error("CBlock::ReadFromDisk() : errors in block header");
1071 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1072 GetHash().ToString().c_str(),
1074 hashPrevBlock.ToString().c_str(),
1075 hashMerkleRoot.ToString().c_str(),
1076 nTime, nBits, nNonce,
1078 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1079 for (unsigned int i = 0; i < vtx.size(); i++)
1084 printf(" vMerkleTree: ");
1085 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1086 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1091 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1092 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1093 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1094 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1095 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1096 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1098 bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1099 bool SignBlock(CWallet& keystore);
1100 bool CheckBlockSignature(bool fProofOfStake) const;
1103 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1111 /** The block chain is a tree shaped structure starting with the
1112 * genesis block at the root, with each block potentially having multiple
1113 * candidates to be the next block. pprev and pnext link a path through the
1114 * main/longest chain. A blockindex may have multiple pprev pointing back
1115 * to it, but pnext will only point forward to the longest branch, or will
1116 * be null if the block is not part of the longest chain.
1121 const uint256* phashBlock;
1125 unsigned int nBlockPos;
1126 uint256 nChainTrust; // ppcoin: trust score of block chain
1132 unsigned int nFlags; // ppcoin: block index flags
1135 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1136 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1137 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1140 uint64 nStakeModifier; // hash modifier for proof-of-stake
1141 unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1143 // proof-of-stake specific fields
1144 COutPoint prevoutStake;
1145 unsigned int nStakeTime;
1146 uint256 hashProofOfStake;
1150 uint256 hashMerkleRoot;
1153 unsigned int nNonce;
1168 nStakeModifierChecksum = 0;
1169 hashProofOfStake = 0;
1170 prevoutStake.SetNull();
1180 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1186 nBlockPos = nBlockPosIn;
1193 nStakeModifierChecksum = 0;
1194 hashProofOfStake = 0;
1195 if (block.IsProofOfStake())
1198 prevoutStake = block.vtx[1].vin[0].prevout;
1199 nStakeTime = block.vtx[1].nTime;
1203 prevoutStake.SetNull();
1207 nVersion = block.nVersion;
1208 hashMerkleRoot = block.hashMerkleRoot;
1209 nTime = block.nTime;
1210 nBits = block.nBits;
1211 nNonce = block.nNonce;
1214 CBlock GetBlockHeader() const
1217 block.nVersion = nVersion;
1219 block.hashPrevBlock = pprev->GetBlockHash();
1220 block.hashMerkleRoot = hashMerkleRoot;
1221 block.nTime = nTime;
1222 block.nBits = nBits;
1223 block.nNonce = nNonce;
1227 uint256 GetBlockHash() const
1232 int64 GetBlockTime() const
1234 return (int64)nTime;
1237 uint256 GetBlockTrust() const;
1239 bool IsInMainChain() const
1241 return (pnext || this == pindexBest);
1244 bool CheckIndex() const
1249 enum { nMedianTimeSpan=11 };
1251 int64 GetMedianTimePast() const
1253 int64 pmedian[nMedianTimeSpan];
1254 int64* pbegin = &pmedian[nMedianTimeSpan];
1255 int64* pend = &pmedian[nMedianTimeSpan];
1257 const CBlockIndex* pindex = this;
1258 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1259 *(--pbegin) = pindex->GetBlockTime();
1261 std::sort(pbegin, pend);
1262 return pbegin[(pend - pbegin)/2];
1265 int64 GetMedianTime() const
1267 const CBlockIndex* pindex = this;
1268 for (int i = 0; i < nMedianTimeSpan/2; i++)
1271 return GetBlockTime();
1272 pindex = pindex->pnext;
1274 return pindex->GetMedianTimePast();
1278 * Returns true if there are nRequired or more blocks of minVersion or above
1279 * in the last nToCheck blocks, starting at pstart and going backwards.
1281 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1282 unsigned int nRequired, unsigned int nToCheck);
1285 bool IsProofOfWork() const
1287 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1290 bool IsProofOfStake() const
1292 return (nFlags & BLOCK_PROOF_OF_STAKE);
1295 void SetProofOfStake()
1297 nFlags |= BLOCK_PROOF_OF_STAKE;
1300 unsigned int GetStakeEntropyBit() const
1302 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1305 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1307 if (nEntropyBit > 1)
1309 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1313 bool GeneratedStakeModifier() const
1315 return (nFlags & BLOCK_STAKE_MODIFIER);
1318 void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1320 nStakeModifier = nModifier;
1321 if (fGeneratedStakeModifier)
1322 nFlags |= BLOCK_STAKE_MODIFIER;
1325 std::string ToString() const
1327 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)",
1328 pprev, pnext, nFile, nBlockPos, nHeight,
1329 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1330 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1331 nStakeModifier, nStakeModifierChecksum,
1332 hashProofOfStake.ToString().c_str(),
1333 prevoutStake.ToString().c_str(), nStakeTime,
1334 hashMerkleRoot.ToString().c_str(),
1335 GetBlockHash().ToString().c_str());
1340 printf("%s\n", ToString().c_str());
1346 /** Used to marshal pointers into hashes for db storage. */
1347 class CDiskBlockIndex : public CBlockIndex
1363 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1365 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1366 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1371 if (!(nType & SER_GETHASH))
1372 READWRITE(nVersion);
1374 READWRITE(hashNext);
1376 READWRITE(nBlockPos);
1379 READWRITE(nMoneySupply);
1381 READWRITE(nStakeModifier);
1382 if (IsProofOfStake())
1384 READWRITE(prevoutStake);
1385 READWRITE(nStakeTime);
1386 READWRITE(hashProofOfStake);
1390 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1391 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1392 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1396 READWRITE(this->nVersion);
1397 READWRITE(hashPrev);
1398 READWRITE(hashMerkleRoot);
1402 READWRITE(blockHash);
1405 uint256 GetBlockHash() const
1407 if (fUseFastIndex && (nTime < GetAdjustedTime() - 24 * 60 * 60) && blockHash != 0)
1411 block.nVersion = nVersion;
1412 block.hashPrevBlock = hashPrev;
1413 block.hashMerkleRoot = hashMerkleRoot;
1414 block.nTime = nTime;
1415 block.nBits = nBits;
1416 block.nNonce = nNonce;
1418 const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1423 std::string ToString() const
1425 std::string str = "CDiskBlockIndex(";
1426 str += CBlockIndex::ToString();
1427 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1428 GetBlockHash().ToString().c_str(),
1429 hashPrev.ToString().c_str(),
1430 hashNext.ToString().c_str());
1436 printf("%s\n", ToString().c_str());
1447 /** Describes a place in the block chain to another node such that if the
1448 * other node doesn't have the same branch, it can find a recent common trunk.
1449 * The further back it is, the further before the fork it may be.
1454 std::vector<uint256> vHave;
1461 explicit CBlockLocator(const CBlockIndex* pindex)
1466 explicit CBlockLocator(uint256 hashBlock)
1468 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1469 if (mi != mapBlockIndex.end())
1473 CBlockLocator(const std::vector<uint256>& vHaveIn)
1480 if (!(nType & SER_GETHASH))
1481 READWRITE(nVersion);
1492 return vHave.empty();
1495 void Set(const CBlockIndex* pindex)
1501 vHave.push_back(pindex->GetBlockHash());
1503 // Exponentially larger steps back
1504 for (int i = 0; pindex && i < nStep; i++)
1505 pindex = pindex->pprev;
1506 if (vHave.size() > 10)
1509 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1512 int GetDistanceBack()
1514 // Retrace how far back it was in the sender's branch
1517 BOOST_FOREACH(const uint256& hash, vHave)
1519 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1520 if (mi != mapBlockIndex.end())
1522 CBlockIndex* pindex = (*mi).second;
1523 if (pindex->IsInMainChain())
1533 CBlockIndex* GetBlockIndex()
1535 // Find the first block the caller has in the main chain
1536 BOOST_FOREACH(const uint256& hash, vHave)
1538 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1539 if (mi != mapBlockIndex.end())
1541 CBlockIndex* pindex = (*mi).second;
1542 if (pindex->IsInMainChain())
1546 return pindexGenesisBlock;
1549 uint256 GetBlockHash()
1551 // Find the first block the caller has in the main chain
1552 BOOST_FOREACH(const uint256& hash, vHave)
1554 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1555 if (mi != mapBlockIndex.end())
1557 CBlockIndex* pindex = (*mi).second;
1558 if (pindex->IsInMainChain())
1562 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1567 CBlockIndex* pindex = GetBlockIndex();
1570 return pindex->nHeight;
1584 mutable CCriticalSection cs;
1585 std::map<uint256, CTransaction> mapTx;
1586 std::map<COutPoint, CInPoint> mapNextTx;
1588 bool accept(CTxDB& txdb, CTransaction &tx,
1589 bool fCheckInputs, bool* pfMissingInputs);
1590 bool addUnchecked(const uint256& hash, CTransaction &tx);
1591 bool remove(CTransaction &tx);
1593 void queryHashes(std::vector<uint256>& vtxid);
1595 unsigned long size()
1598 return mapTx.size();
1601 bool exists(uint256 hash)
1603 return (mapTx.count(hash) != 0);
1606 CTransaction& lookup(uint256 hash)
1612 extern CTxMemPool mempool;