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 OUTPUT_SWITCH_TIME = 1398916800; // Thu, 01 May 2014 04: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");
62 inline int64 PastDrift(int64 nTime) { return nTime - 2 * 60 * 60; } // up to 2 hours from the past
63 inline int64 FutureDrift(int64 nTime) { return nTime + 2 * 60 * 60; } // up to 2 hours from the future
65 extern libzerocoin::Params* ZCParams;
66 extern CScript COINBASE_FLAGS;
67 extern CCriticalSection cs_main;
68 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
69 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
70 extern CBlockIndex* pindexGenesisBlock;
71 extern unsigned int nStakeMinAge;
72 extern unsigned int nNodeLifespan;
73 extern int nCoinbaseMaturity;
74 extern int nBestHeight;
75 extern uint256 nBestChainTrust;
76 extern uint256 nBestInvalidTrust;
77 extern uint256 hashBestChain;
78 extern CBlockIndex* pindexBest;
79 extern unsigned int nTransactionsUpdated;
80 extern uint64 nLastBlockTx;
81 extern uint64 nLastBlockSize;
82 extern int64 nLastCoinStakeSearchInterval;
83 extern const std::string strMessageMagic;
84 extern int64 nTimeBestReceived;
85 extern CCriticalSection cs_setpwalletRegistered;
86 extern std::set<CWallet*> setpwalletRegistered;
87 extern unsigned char pchMessageStart[4];
88 extern std::map<uint256, CBlock*> mapOrphanBlocks;
91 extern int64 nTransactionFee;
92 extern int64 nMinimumInputValue;
93 extern bool fUseFastIndex;
94 extern unsigned int nDerivationMethodIndex;
96 extern bool fEnforceCanonical;
98 // Minimum disk space required - used in CheckDiskSpace()
99 static const uint64 nMinDiskSpace = 52428800;
105 void RegisterWallet(CWallet* pwalletIn);
106 void UnregisterWallet(CWallet* pwalletIn);
107 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
108 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
109 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
110 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
111 FILE* AppendBlockFile(unsigned int& nFileRet);
112 bool LoadBlockIndex(bool fAllowNew=true);
113 void PrintBlockTree();
114 CBlockIndex* FindBlockByHeight(int nHeight);
115 bool ProcessMessages(CNode* pfrom);
116 bool SendMessages(CNode* pto, bool fSendTrickle);
117 bool LoadExternalBlockFile(FILE* fileIn);
119 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
120 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
121 int64 GetProofOfWorkReward(unsigned int nBits);
122 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
123 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
124 unsigned int ComputeMinStake(unsigned int nBase, int64 nTime, unsigned int nBlockTime);
125 int GetNumBlocksOfPeers();
126 bool IsInitialBlockDownload();
127 std::string GetWarnings(std::string strFor);
128 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
129 uint256 WantedByOrphan(const CBlock* pblockOrphan);
130 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
131 void StakeMiner(CWallet *pwallet);
132 void ResendWalletTransactions();
143 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
145 /** Position on disk for a particular transaction. */
150 unsigned int nBlockPos;
158 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
161 nBlockPos = nBlockPosIn;
165 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
166 void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
167 bool IsNull() const { return (nFile == (unsigned int) -1); }
169 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
171 return (a.nFile == b.nFile &&
172 a.nBlockPos == b.nBlockPos &&
173 a.nTxPos == b.nTxPos);
176 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
182 std::string ToString() const
187 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
192 printf("%s", ToString().c_str());
198 /** An inpoint - a combination of a transaction and an index n into its vin */
205 CInPoint() { SetNull(); }
206 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
207 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
208 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
213 /** An outpoint - a combination of a transaction hash and an index n into its vout */
220 COutPoint() { SetNull(); }
221 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
222 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
223 void SetNull() { hash = 0; n = (unsigned int) -1; }
224 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
226 friend bool operator<(const COutPoint& a, const COutPoint& b)
228 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
231 friend bool operator==(const COutPoint& a, const COutPoint& b)
233 return (a.hash == b.hash && a.n == b.n);
236 friend bool operator!=(const COutPoint& a, const COutPoint& b)
241 std::string ToString() const
243 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
248 printf("%s\n", ToString().c_str());
255 /** An input of a transaction. It contains the location of the previous
256 * transaction's output that it claims and a signature that matches the
257 * output's public key.
264 unsigned int nSequence;
268 nSequence = std::numeric_limits<unsigned int>::max();
271 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
274 scriptSig = scriptSigIn;
275 nSequence = nSequenceIn;
278 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
280 prevout = COutPoint(hashPrevTx, nOut);
281 scriptSig = scriptSigIn;
282 nSequence = nSequenceIn;
288 READWRITE(scriptSig);
289 READWRITE(nSequence);
294 return (nSequence == std::numeric_limits<unsigned int>::max());
297 friend bool operator==(const CTxIn& a, const CTxIn& b)
299 return (a.prevout == b.prevout &&
300 a.scriptSig == b.scriptSig &&
301 a.nSequence == b.nSequence);
304 friend bool operator!=(const CTxIn& a, const CTxIn& b)
309 std::string ToStringShort() const
311 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
314 std::string ToString() const
318 str += prevout.ToString();
319 if (prevout.IsNull())
320 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
322 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
323 if (nSequence != std::numeric_limits<unsigned int>::max())
324 str += strprintf(", nSequence=%u", nSequence);
331 printf("%s\n", ToString().c_str());
338 /** An output of a transaction. It contains the public key that the next input
339 * must be able to sign with to claim it.
345 CScript scriptPubKey;
352 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
355 scriptPubKey = scriptPubKeyIn;
361 READWRITE(scriptPubKey);
367 scriptPubKey.clear();
372 return (nValue == -1);
378 scriptPubKey.clear();
383 return (nValue == 0 && scriptPubKey.empty());
386 uint256 GetHash() const
388 return SerializeHash(*this);
391 friend bool operator==(const CTxOut& a, const CTxOut& b)
393 return (a.nValue == b.nValue &&
394 a.scriptPubKey == b.scriptPubKey);
397 friend bool operator!=(const CTxOut& a, const CTxOut& b)
402 std::string ToStringShort() const
404 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
407 std::string ToString() const
409 if (IsEmpty()) return "CTxOut(empty)";
410 if (scriptPubKey.size() < 6)
411 return "CTxOut(error)";
412 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
417 printf("%s\n", ToString().c_str());
431 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
433 /** The basic transaction that is broadcasted on the network and contained in
434 * blocks. A transaction can contain multiple inputs and outputs.
439 static const int CURRENT_VERSION=1;
442 std::vector<CTxIn> vin;
443 std::vector<CTxOut> vout;
444 unsigned int nLockTime;
446 // Denial-of-service detection:
448 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
457 READWRITE(this->nVersion);
458 nVersion = this->nVersion;
462 READWRITE(nLockTime);
467 nVersion = CTransaction::CURRENT_VERSION;
468 nTime = GetAdjustedTime();
472 nDoS = 0; // Denial-of-service prevention
477 return (vin.empty() && vout.empty());
480 uint256 GetHash() const
482 return SerializeHash(*this);
485 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
487 // Time based nLockTime implemented in 0.1.6
490 if (nBlockHeight == 0)
491 nBlockHeight = nBestHeight;
493 nBlockTime = GetAdjustedTime();
494 if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
496 BOOST_FOREACH(const CTxIn& txin, vin)
502 bool IsNewerThan(const CTransaction& old) const
504 if (vin.size() != old.vin.size())
506 for (unsigned int i = 0; i < vin.size(); i++)
507 if (vin[i].prevout != old.vin[i].prevout)
511 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
512 for (unsigned int i = 0; i < vin.size(); i++)
514 if (vin[i].nSequence != old.vin[i].nSequence)
516 if (vin[i].nSequence <= nLowest)
519 nLowest = vin[i].nSequence;
521 if (old.vin[i].nSequence < nLowest)
524 nLowest = old.vin[i].nSequence;
531 bool IsCoinBase() const
533 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
536 bool IsCoinStake() const
538 // ppcoin: the coin stake transaction is marked with the first output empty
539 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
542 /** Check for standard transaction types
543 @return True if all outputs (scriptPubKeys) use only standard transaction forms
545 bool IsStandard() const;
547 /** Check for standard transaction types
548 @param[in] mapInputs Map of previous transactions that have outputs we're spending
549 @return True if all inputs (scriptSigs) use only standard transaction forms
550 @see CTransaction::FetchInputs
552 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
554 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
555 @return number of sigops this transaction's outputs will produce when spent
556 @see CTransaction::FetchInputs
558 unsigned int GetLegacySigOpCount() const;
560 /** Count ECDSA signature operations in pay-to-script-hash inputs.
562 @param[in] mapInputs Map of previous transactions that have outputs we're spending
563 @return maximum number of sigops required to validate this transaction's inputs
564 @see CTransaction::FetchInputs
566 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
568 /** Amount of bitcoins spent by this transaction.
569 @return sum of all outputs (note: does not include fees)
571 int64 GetValueOut() const
574 BOOST_FOREACH(const CTxOut& txout, vout)
576 nValueOut += txout.nValue;
577 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
578 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
583 /** Amount of bitcoins coming in to this transaction
584 Note that lightweight clients may not know anything besides the hash of previous transactions,
585 so may not be able to calculate this.
587 @param[in] mapInputs Map of previous transactions that have outputs we're spending
588 @return Sum of value of all inputs (scriptSigs)
589 @see CTransaction::FetchInputs
591 int64 GetValueIn(const MapPrevTx& mapInputs) const;
593 static bool AllowFree(double dPriority)
595 // Large (in bytes) low-priority (new, small-coin) transactions
597 return dPriority > COIN * 144 / 250;
600 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
602 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
604 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
606 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
609 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
610 return error("CTransaction::ReadFromDisk() : fseek failed");
615 catch (std::exception &e) {
616 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
619 // Return file pointer
622 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
623 return error("CTransaction::ReadFromDisk() : second fseek failed");
624 *pfileRet = filein.release();
629 friend bool operator==(const CTransaction& a, const CTransaction& b)
631 return (a.nVersion == b.nVersion &&
632 a.nTime == b.nTime &&
635 a.nLockTime == b.nLockTime);
638 friend bool operator!=(const CTransaction& a, const CTransaction& b)
643 std::string ToStringShort() const
646 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
650 std::string ToString() const
653 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
654 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%d)\n",
655 GetHash().ToString().substr(0,10).c_str(),
661 for (unsigned int i = 0; i < vin.size(); i++)
662 str += " " + vin[i].ToString() + "\n";
663 for (unsigned int i = 0; i < vout.size(); i++)
664 str += " " + vout[i].ToString() + "\n";
670 printf("%s", ToString().c_str());
674 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
675 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
676 bool ReadFromDisk(COutPoint prevout);
677 bool DisconnectInputs(CTxDB& txdb);
679 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
681 @param[in] txdb Transaction database
682 @param[in] mapTestPool List of pending changes to the transaction index database
683 @param[in] fBlock True if being called to add a new best-block to the chain
684 @param[in] fMiner True if being called by CreateNewBlock
685 @param[out] inputsRet Pointers to this transaction's inputs
686 @param[out] fInvalid returns true if transaction is invalid
687 @return Returns true if all inputs are in txdb or mapTestPool
689 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
690 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
692 /** Sanity check previous transactions, then, if all checks succeed,
693 mark them as spent by this transaction.
695 @param[in] inputs Previous transactions (from FetchInputs)
696 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
697 @param[in] posThisTx Position of this transaction on disk
698 @param[in] pindexBlock
699 @param[in] fBlock true if called from ConnectBlock
700 @param[in] fMiner true if called from CreateNewBlock
701 @param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
702 @return Returns true if all checks succeed
704 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs,
705 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
706 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
707 bool ClientConnectInputs();
708 bool CheckTransaction() const;
709 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
710 bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const; // ppcoin: get transaction coin age
713 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
720 /** A transaction with a merkle branch linking it to the block chain. */
721 class CMerkleTx : public CTransaction
725 std::vector<uint256> vMerkleBranch;
729 mutable bool fMerkleVerified;
737 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
746 fMerkleVerified = false;
752 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
753 nVersion = this->nVersion;
754 READWRITE(hashBlock);
755 READWRITE(vMerkleBranch);
760 int SetMerkleBranch(const CBlock* pblock=NULL);
761 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
762 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
763 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
764 int GetBlocksToMaturity() const;
765 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
766 bool AcceptToMemoryPool();
772 /** A txdb record that contains the disk location of a transaction and the
773 * locations of transactions that spend its outputs. vSpent is really only
774 * used as a flag, but having the location is very helpful for debugging.
780 std::vector<CDiskTxPos> vSpent;
787 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
790 vSpent.resize(nOutputs);
795 if (!(nType & SER_GETHASH))
812 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
814 return (a.pos == b.pos &&
815 a.vSpent == b.vSpent);
818 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
822 int GetDepthInMainChain() const;
830 /** Nodes collect new transactions into a block, hash them into a hash tree,
831 * and scan through nonce values to make the block's hash satisfy proof-of-work
832 * requirements. When they solve the proof-of-work, they broadcast the block
833 * to everyone and the block is added to the block chain. The first transaction
834 * in the block is a special one that creates a new coin owned by the creator
837 * Blocks are appended to blk0001.dat files on disk. Their location on disk
838 * is indexed by CBlockIndex objects in memory.
844 static const int CURRENT_VERSION=6;
846 uint256 hashPrevBlock;
847 uint256 hashMerkleRoot;
853 std::vector<CTransaction> vtx;
855 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
856 std::vector<unsigned char> vchBlockSig;
859 mutable std::vector<uint256> vMerkleTree;
861 // Denial-of-service detection:
863 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
872 READWRITE(this->nVersion);
873 nVersion = this->nVersion;
874 READWRITE(hashPrevBlock);
875 READWRITE(hashMerkleRoot);
880 // ConnectBlock depends on vtx following header to generate CDiskTxPos
881 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
884 READWRITE(vchBlockSig);
888 const_cast<CBlock*>(this)->vtx.clear();
889 const_cast<CBlock*>(this)->vchBlockSig.clear();
895 nVersion = CBlock::CURRENT_VERSION;
912 uint256 GetHash() const
914 return scrypt_blockhash(CVOIDBEGIN(nVersion));
917 int64 GetBlockTime() const
922 void UpdateTime(const CBlockIndex* pindexPrev);
924 // ppcoin: entropy bit for stake modifier if chosen by modifier
925 unsigned int GetStakeEntropyBit(unsigned int nTime) const
927 // Protocol switch to support p2pool at novacoin block #9689
928 if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
930 // Take last bit of block hash as entropy bit
931 unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
932 if (fDebug && GetBoolArg("-printstakemodifier"))
933 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
936 // Before novacoin block #9689 - old protocol
937 uint160 hashSig = Hash160(vchBlockSig);
938 if (fDebug && GetBoolArg("-printstakemodifier"))
939 printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
940 hashSig >>= 159; // take the first bit of the hash
941 if (fDebug && GetBoolArg("-printstakemodifier"))
942 printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
943 return hashSig.Get64();
946 // ppcoin: two types of block: proof-of-work or proof-of-stake
947 bool IsProofOfStake() const
949 return (vtx.size() > 1 && vtx[1].IsCoinStake());
952 bool IsProofOfWork() const
954 return !IsProofOfStake();
957 std::pair<COutPoint, unsigned int> GetProofOfStake() const
959 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
962 // ppcoin: get max transaction timestamp
963 int64 GetMaxTransactionTime() const
965 int64 maxTransactionTime = 0;
966 BOOST_FOREACH(const CTransaction& tx, vtx)
967 maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
968 return maxTransactionTime;
971 uint256 BuildMerkleTree() const
974 BOOST_FOREACH(const CTransaction& tx, vtx)
975 vMerkleTree.push_back(tx.GetHash());
977 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
979 for (int i = 0; i < nSize; i += 2)
981 int i2 = std::min(i+1, nSize-1);
982 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
983 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
987 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
990 std::vector<uint256> GetMerkleBranch(int nIndex) const
992 if (vMerkleTree.empty())
994 std::vector<uint256> vMerkleBranch;
996 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
998 int i = std::min(nIndex^1, nSize-1);
999 vMerkleBranch.push_back(vMerkleTree[j+i]);
1003 return vMerkleBranch;
1006 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1010 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1013 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1015 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1022 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1024 // Open history file to append
1025 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1027 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1029 // Write index header
1030 unsigned int nSize = fileout.GetSerializeSize(*this);
1031 fileout << FLATDATA(pchMessageStart) << nSize;
1034 long fileOutPos = ftell(fileout);
1036 return error("CBlock::WriteToDisk() : ftell failed");
1037 nBlockPosRet = fileOutPos;
1040 // Flush stdio buffers and commit to disk before returning
1042 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1043 FileCommit(fileout);
1048 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1052 // Open history file to read
1053 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1055 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1056 if (!fReadTransactions)
1057 filein.nType |= SER_BLOCKHEADERONLY;
1063 catch (std::exception &e) {
1064 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1068 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1069 return error("CBlock::ReadFromDisk() : errors in block header");
1078 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1079 GetHash().ToString().c_str(),
1081 hashPrevBlock.ToString().c_str(),
1082 hashMerkleRoot.ToString().c_str(),
1083 nTime, nBits, nNonce,
1085 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1086 for (unsigned int i = 0; i < vtx.size(); i++)
1091 printf(" vMerkleTree: ");
1092 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1093 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1098 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1099 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1100 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1101 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1102 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1103 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1105 bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1106 bool SignBlock(CWallet& keystore);
1107 bool CheckBlockSignature(bool fProofOfStake) const;
1110 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1118 /** The block chain is a tree shaped structure starting with the
1119 * genesis block at the root, with each block potentially having multiple
1120 * candidates to be the next block. pprev and pnext link a path through the
1121 * main/longest chain. A blockindex may have multiple pprev pointing back
1122 * to it, but pnext will only point forward to the longest branch, or will
1123 * be null if the block is not part of the longest chain.
1128 const uint256* phashBlock;
1132 unsigned int nBlockPos;
1133 uint256 nChainTrust; // ppcoin: trust score of block chain
1139 unsigned int nFlags; // ppcoin: block index flags
1142 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1143 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1144 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1147 uint64 nStakeModifier; // hash modifier for proof-of-stake
1148 unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1150 // proof-of-stake specific fields
1151 COutPoint prevoutStake;
1152 unsigned int nStakeTime;
1153 uint256 hashProofOfStake;
1157 uint256 hashMerkleRoot;
1160 unsigned int nNonce;
1175 nStakeModifierChecksum = 0;
1176 hashProofOfStake = 0;
1177 prevoutStake.SetNull();
1187 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1193 nBlockPos = nBlockPosIn;
1200 nStakeModifierChecksum = 0;
1201 hashProofOfStake = 0;
1202 if (block.IsProofOfStake())
1205 prevoutStake = block.vtx[1].vin[0].prevout;
1206 nStakeTime = block.vtx[1].nTime;
1210 prevoutStake.SetNull();
1214 nVersion = block.nVersion;
1215 hashMerkleRoot = block.hashMerkleRoot;
1216 nTime = block.nTime;
1217 nBits = block.nBits;
1218 nNonce = block.nNonce;
1221 CBlock GetBlockHeader() const
1224 block.nVersion = nVersion;
1226 block.hashPrevBlock = pprev->GetBlockHash();
1227 block.hashMerkleRoot = hashMerkleRoot;
1228 block.nTime = nTime;
1229 block.nBits = nBits;
1230 block.nNonce = nNonce;
1234 uint256 GetBlockHash() const
1239 int64 GetBlockTime() const
1241 return (int64)nTime;
1244 uint256 GetBlockTrust() const;
1246 bool IsInMainChain() const
1248 return (pnext || this == pindexBest);
1251 bool CheckIndex() const
1256 enum { nMedianTimeSpan=11 };
1258 int64 GetMedianTimePast() const
1260 int64 pmedian[nMedianTimeSpan];
1261 int64* pbegin = &pmedian[nMedianTimeSpan];
1262 int64* pend = &pmedian[nMedianTimeSpan];
1264 const CBlockIndex* pindex = this;
1265 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1266 *(--pbegin) = pindex->GetBlockTime();
1268 std::sort(pbegin, pend);
1269 return pbegin[(pend - pbegin)/2];
1272 int64 GetMedianTime() const
1274 const CBlockIndex* pindex = this;
1275 for (int i = 0; i < nMedianTimeSpan/2; i++)
1278 return GetBlockTime();
1279 pindex = pindex->pnext;
1281 return pindex->GetMedianTimePast();
1285 * Returns true if there are nRequired or more blocks of minVersion or above
1286 * in the last nToCheck blocks, starting at pstart and going backwards.
1288 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1289 unsigned int nRequired, unsigned int nToCheck);
1292 bool IsProofOfWork() const
1294 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1297 bool IsProofOfStake() const
1299 return (nFlags & BLOCK_PROOF_OF_STAKE);
1302 void SetProofOfStake()
1304 nFlags |= BLOCK_PROOF_OF_STAKE;
1307 unsigned int GetStakeEntropyBit() const
1309 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1312 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1314 if (nEntropyBit > 1)
1316 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1320 bool GeneratedStakeModifier() const
1322 return (nFlags & BLOCK_STAKE_MODIFIER);
1325 void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1327 nStakeModifier = nModifier;
1328 if (fGeneratedStakeModifier)
1329 nFlags |= BLOCK_STAKE_MODIFIER;
1332 std::string ToString() const
1334 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)",
1335 pprev, pnext, nFile, nBlockPos, nHeight,
1336 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1337 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1338 nStakeModifier, nStakeModifierChecksum,
1339 hashProofOfStake.ToString().c_str(),
1340 prevoutStake.ToString().c_str(), nStakeTime,
1341 hashMerkleRoot.ToString().c_str(),
1342 GetBlockHash().ToString().c_str());
1347 printf("%s\n", ToString().c_str());
1353 /** Used to marshal pointers into hashes for db storage. */
1354 class CDiskBlockIndex : public CBlockIndex
1370 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1372 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1373 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1378 if (!(nType & SER_GETHASH))
1379 READWRITE(nVersion);
1381 READWRITE(hashNext);
1383 READWRITE(nBlockPos);
1386 READWRITE(nMoneySupply);
1388 READWRITE(nStakeModifier);
1389 if (IsProofOfStake())
1391 READWRITE(prevoutStake);
1392 READWRITE(nStakeTime);
1393 READWRITE(hashProofOfStake);
1397 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1398 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1399 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1403 READWRITE(this->nVersion);
1404 READWRITE(hashPrev);
1405 READWRITE(hashMerkleRoot);
1409 READWRITE(blockHash);
1412 uint256 GetBlockHash() const
1414 if (fUseFastIndex && (nTime < GetAdjustedTime() - 24 * 60 * 60) && blockHash != 0)
1418 block.nVersion = nVersion;
1419 block.hashPrevBlock = hashPrev;
1420 block.hashMerkleRoot = hashMerkleRoot;
1421 block.nTime = nTime;
1422 block.nBits = nBits;
1423 block.nNonce = nNonce;
1425 const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1430 std::string ToString() const
1432 std::string str = "CDiskBlockIndex(";
1433 str += CBlockIndex::ToString();
1434 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1435 GetBlockHash().ToString().c_str(),
1436 hashPrev.ToString().c_str(),
1437 hashNext.ToString().c_str());
1443 printf("%s\n", ToString().c_str());
1454 /** Describes a place in the block chain to another node such that if the
1455 * other node doesn't have the same branch, it can find a recent common trunk.
1456 * The further back it is, the further before the fork it may be.
1461 std::vector<uint256> vHave;
1468 explicit CBlockLocator(const CBlockIndex* pindex)
1473 explicit CBlockLocator(uint256 hashBlock)
1475 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1476 if (mi != mapBlockIndex.end())
1480 CBlockLocator(const std::vector<uint256>& vHaveIn)
1487 if (!(nType & SER_GETHASH))
1488 READWRITE(nVersion);
1499 return vHave.empty();
1502 void Set(const CBlockIndex* pindex)
1508 vHave.push_back(pindex->GetBlockHash());
1510 // Exponentially larger steps back
1511 for (int i = 0; pindex && i < nStep; i++)
1512 pindex = pindex->pprev;
1513 if (vHave.size() > 10)
1516 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1519 int GetDistanceBack()
1521 // Retrace how far back it was in the sender's branch
1524 BOOST_FOREACH(const uint256& hash, vHave)
1526 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1527 if (mi != mapBlockIndex.end())
1529 CBlockIndex* pindex = (*mi).second;
1530 if (pindex->IsInMainChain())
1540 CBlockIndex* GetBlockIndex()
1542 // Find the first block the caller has in the main chain
1543 BOOST_FOREACH(const uint256& hash, vHave)
1545 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1546 if (mi != mapBlockIndex.end())
1548 CBlockIndex* pindex = (*mi).second;
1549 if (pindex->IsInMainChain())
1553 return pindexGenesisBlock;
1556 uint256 GetBlockHash()
1558 // Find the first block the caller has in the main chain
1559 BOOST_FOREACH(const uint256& hash, vHave)
1561 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1562 if (mi != mapBlockIndex.end())
1564 CBlockIndex* pindex = (*mi).second;
1565 if (pindex->IsInMainChain())
1569 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1574 CBlockIndex* pindex = GetBlockIndex();
1577 return pindex->nHeight;
1591 mutable CCriticalSection cs;
1592 std::map<uint256, CTransaction> mapTx;
1593 std::map<COutPoint, CInPoint> mapNextTx;
1595 bool accept(CTxDB& txdb, CTransaction &tx,
1596 bool fCheckInputs, bool* pfMissingInputs);
1597 bool addUnchecked(const uint256& hash, CTransaction &tx);
1598 bool remove(CTransaction &tx);
1600 void queryHashes(std::vector<uint256>& vtxid);
1602 unsigned long size()
1605 return mapTx.size();
1608 bool exists(uint256 hash)
1610 return (mapTx.count(hash) != 0);
1613 CTransaction& lookup(uint256 hash)
1619 extern CTxMemPool mempool;