1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2012 The Bitcoin developers
3 // Copyright (c) 2011-2013 The PPCoin developers
4 // Distributed under the MIT/X11 software license, see the accompanying
5 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
12 #include "scrypt_mine.h"
15 #include <io.h> /* for _commit */
29 class CRequestTracker;
32 static const unsigned int MAX_BLOCK_SIZE = 1000000;
33 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
34 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
35 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
36 static const int64 MIN_TX_FEE = CENT;
37 static const int64 MIN_RELAY_TX_FEE = CENT;
38 static const int64 MAX_MONEY = 2000000000 * COIN;
39 static const int64 MAX_MINT_PROOF_OF_WORK = 100 * COIN;
40 static const int64 MIN_TXOUT_AMOUNT = MIN_TX_FEE;
41 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
42 static const int COINBASE_MATURITY_PPC = 500;
43 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
44 static const int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
45 static const int STAKE_TARGET_SPACING = 10 * 60; // 10-minute block spacing
46 static const int STAKE_MIN_AGE = 60 * 60 * 24 * 30; // minimum age for coin age
47 static const int STAKE_MAX_AGE = 60 * 60 * 24 * 90; // stake age of full weight
50 static const int fHaveUPnP = true;
52 static const int fHaveUPnP = false;
55 static const uint256 hashGenesisBlockOfficial("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
56 static const uint256 hashGenesisBlockTestNet("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
58 static const int64 nMaxClockDrift = 2 * 60 * 60; // two hours
60 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 uint256 hashGenesisBlock;
71 extern unsigned int nStakeMinAge;
72 extern int nCoinbaseMaturity;
73 extern CBlockIndex* pindexGenesisBlock;
74 extern int nBestHeight;
75 extern CBigNum bnBestChainTrust;
76 extern CBigNum bnBestInvalidTrust;
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 double dHashesPerSec;
85 extern int64 nHPSTimerStart;
86 extern int64 nTimeBestReceived;
87 extern CCriticalSection cs_setpwalletRegistered;
88 extern std::set<CWallet*> setpwalletRegistered;
89 extern std::map<uint256, CBlock*> mapOrphanBlocks;
92 extern int64 nTransactionFee;
102 void RegisterWallet(CWallet* pwalletIn);
103 void UnregisterWallet(CWallet* pwalletIn);
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 bool ProcessMessages(CNode* pfrom);
111 bool SendMessages(CNode* pto, bool fSendTrickle);
112 void GenerateBitcoins(bool fGenerate, CWallet* pwallet);
113 CBlock* CreateNewBlock(CWallet* pwallet, bool fProofOfStake=false);
114 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
115 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
116 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
117 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
118 int64 GetProofOfWorkReward(unsigned int nBits);
119 int64 GetProofOfStakeReward(int64 nCoinAge);
120 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
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 BitcoinMiner(CWallet *pwallet, bool fProofOfStake);
128 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 = -1; nBlockPos = 0; nTxPos = 0; }
160 bool IsNull() const { return (nFile == -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)
174 std::string ToString() const
179 return strprintf("(nFile=%d, nBlockPos=%d, nTxPos=%d)", nFile, nBlockPos, nTxPos);
184 printf("%s", ToString().c_str());
190 /** An inpoint - a combination of a transaction and an index n into its vin */
197 CInPoint() { SetNull(); }
198 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
199 void SetNull() { ptx = NULL; n = -1; }
200 bool IsNull() const { return (ptx == NULL && n == -1); }
205 /** An outpoint - a combination of a transaction hash and an index n into its vout */
212 COutPoint() { SetNull(); }
213 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
214 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
215 void SetNull() { hash = 0; n = -1; }
216 bool IsNull() const { return (hash == 0 && n == -1); }
218 friend bool operator<(const COutPoint& a, const COutPoint& b)
220 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
223 friend bool operator==(const COutPoint& a, const COutPoint& b)
225 return (a.hash == b.hash && a.n == b.n);
228 friend bool operator!=(const COutPoint& a, const COutPoint& b)
233 std::string ToString() const
235 return strprintf("COutPoint(%s, %d)", hash.ToString().substr(0,10).c_str(), n);
240 printf("%s\n", ToString().c_str());
247 /** An input of a transaction. It contains the location of the previous
248 * transaction's output that it claims and a signature that matches the
249 * output's public key.
256 unsigned int nSequence;
260 nSequence = std::numeric_limits<unsigned int>::max();
263 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
266 scriptSig = scriptSigIn;
267 nSequence = nSequenceIn;
270 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
272 prevout = COutPoint(hashPrevTx, nOut);
273 scriptSig = scriptSigIn;
274 nSequence = nSequenceIn;
280 READWRITE(scriptSig);
281 READWRITE(nSequence);
286 return (nSequence == std::numeric_limits<unsigned int>::max());
289 friend bool operator==(const CTxIn& a, const CTxIn& b)
291 return (a.prevout == b.prevout &&
292 a.scriptSig == b.scriptSig &&
293 a.nSequence == b.nSequence);
296 friend bool operator!=(const CTxIn& a, const CTxIn& b)
301 std::string ToStringShort() const
303 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
306 std::string ToString() const
310 str += prevout.ToString();
311 if (prevout.IsNull())
312 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
314 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
315 if (nSequence != std::numeric_limits<unsigned int>::max())
316 str += strprintf(", nSequence=%u", nSequence);
323 printf("%s\n", ToString().c_str());
330 /** An output of a transaction. It contains the public key that the next input
331 * must be able to sign with to claim it.
337 CScript scriptPubKey;
344 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
347 scriptPubKey = scriptPubKeyIn;
353 READWRITE(scriptPubKey);
359 scriptPubKey.clear();
364 return (nValue == -1);
370 scriptPubKey.clear();
375 return (nValue == 0 && scriptPubKey.empty());
378 uint256 GetHash() const
380 return SerializeHash(*this);
383 friend bool operator==(const CTxOut& a, const CTxOut& b)
385 return (a.nValue == b.nValue &&
386 a.scriptPubKey == b.scriptPubKey);
389 friend bool operator!=(const CTxOut& a, const CTxOut& b)
394 std::string ToStringShort() const
396 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
399 std::string ToString() const
401 if (IsEmpty()) return "CTxOut(empty)";
402 if (scriptPubKey.size() < 6)
403 return "CTxOut(error)";
404 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
409 printf("%s\n", ToString().c_str());
423 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
425 /** The basic transaction that is broadcasted on the network and contained in
426 * blocks. A transaction can contain multiple inputs and outputs.
433 std::vector<CTxIn> vin;
434 std::vector<CTxOut> vout;
435 unsigned int nLockTime;
437 // Denial-of-service detection:
439 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
448 READWRITE(this->nVersion);
449 nVersion = this->nVersion;
453 READWRITE(nLockTime);
459 nTime = GetAdjustedTime();
463 nDoS = 0; // Denial-of-service prevention
468 return (vin.empty() && vout.empty());
471 uint256 GetHash() const
473 return SerializeHash(*this);
476 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
478 // Time based nLockTime implemented in 0.1.6
481 if (nBlockHeight == 0)
482 nBlockHeight = nBestHeight;
484 nBlockTime = GetAdjustedTime();
485 if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
487 BOOST_FOREACH(const CTxIn& txin, vin)
493 bool IsNewerThan(const CTransaction& old) const
495 if (vin.size() != old.vin.size())
497 for (unsigned int i = 0; i < vin.size(); i++)
498 if (vin[i].prevout != old.vin[i].prevout)
502 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
503 for (unsigned int i = 0; i < vin.size(); i++)
505 if (vin[i].nSequence != old.vin[i].nSequence)
507 if (vin[i].nSequence <= nLowest)
510 nLowest = vin[i].nSequence;
512 if (old.vin[i].nSequence < nLowest)
515 nLowest = old.vin[i].nSequence;
522 bool IsCoinBase() const
524 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
527 bool IsCoinStake() const
529 // ppcoin: the coin stake transaction is marked with the first output empty
530 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
533 /** Check for standard transaction types
534 @return True if all outputs (scriptPubKeys) use only standard transaction forms
536 bool IsStandard() const;
538 /** Check for standard transaction types
539 @param[in] mapInputs Map of previous transactions that have outputs we're spending
540 @return True if all inputs (scriptSigs) use only standard transaction forms
541 @see CTransaction::FetchInputs
543 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
545 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
546 @return number of sigops this transaction's outputs will produce when spent
547 @see CTransaction::FetchInputs
549 unsigned int GetLegacySigOpCount() const;
551 /** Count ECDSA signature operations in pay-to-script-hash inputs.
553 @param[in] mapInputs Map of previous transactions that have outputs we're spending
554 @return maximum number of sigops required to validate this transaction's inputs
555 @see CTransaction::FetchInputs
557 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
559 /** Amount of bitcoins spent by this transaction.
560 @return sum of all outputs (note: does not include fees)
562 int64 GetValueOut() const
565 BOOST_FOREACH(const CTxOut& txout, vout)
567 nValueOut += txout.nValue;
568 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
569 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
574 /** Amount of bitcoins coming in to this transaction
575 Note that lightweight clients may not know anything besides the hash of previous transactions,
576 so may not be able to calculate this.
578 @param[in] mapInputs Map of previous transactions that have outputs we're spending
579 @return Sum of value of all inputs (scriptSigs)
580 @see CTransaction::FetchInputs
582 int64 GetValueIn(const MapPrevTx& mapInputs) const;
584 static bool AllowFree(double dPriority)
586 // Large (in bytes) low-priority (new, small-coin) transactions
588 return dPriority > COIN * 144 / 250;
591 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK) const
593 // Base fee is either MIN_TX_FEE or MIN_RELAY_TX_FEE
594 int64 nBaseFee = (mode == GMF_RELAY) ? MIN_RELAY_TX_FEE : MIN_TX_FEE;
596 unsigned int nBytes = ::GetSerializeSize(*this, SER_NETWORK, PROTOCOL_VERSION);
597 unsigned int nNewBlockSize = nBlockSize + nBytes;
598 int64 nMinFee = (1 + (int64)nBytes / 1000) * nBaseFee;
604 // Transactions under 10K are free
605 // (about 4500bc if made of 50bc inputs)
611 // Free transaction area
612 if (nNewBlockSize < 27000)
617 // To limit dust spam, require MIN_TX_FEE/MIN_RELAY_TX_FEE if any output is less than 0.01
618 if (nMinFee < nBaseFee)
620 BOOST_FOREACH(const CTxOut& txout, vout)
621 if (txout.nValue < CENT)
625 // Raise the price as the block approaches full
626 if (nBlockSize != 1 && nNewBlockSize >= MAX_BLOCK_SIZE_GEN/2)
628 if (nNewBlockSize >= MAX_BLOCK_SIZE_GEN)
630 nMinFee *= MAX_BLOCK_SIZE_GEN / (MAX_BLOCK_SIZE_GEN - nNewBlockSize);
633 if (!MoneyRange(nMinFee))
639 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
641 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
643 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
646 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
647 return error("CTransaction::ReadFromDisk() : fseek failed");
652 catch (std::exception &e) {
653 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
656 // Return file pointer
659 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
660 return error("CTransaction::ReadFromDisk() : second fseek failed");
661 *pfileRet = filein.release();
666 friend bool operator==(const CTransaction& a, const CTransaction& b)
668 return (a.nVersion == b.nVersion &&
669 a.nTime == b.nTime &&
672 a.nLockTime == b.nLockTime);
675 friend bool operator!=(const CTransaction& a, const CTransaction& b)
681 std::string ToStringShort() const
684 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
688 std::string ToString() const
691 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
692 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%d, vout.size=%d, nLockTime=%d)\n",
693 GetHash().ToString().substr(0,10).c_str(),
699 for (unsigned int i = 0; i < vin.size(); i++)
700 str += " " + vin[i].ToString() + "\n";
701 for (unsigned int i = 0; i < vout.size(); i++)
702 str += " " + vout[i].ToString() + "\n";
708 printf("%s", ToString().c_str());
712 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
713 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
714 bool ReadFromDisk(COutPoint prevout);
715 bool DisconnectInputs(CTxDB& txdb);
717 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
719 @param[in] txdb Transaction database
720 @param[in] mapTestPool List of pending changes to the transaction index database
721 @param[in] fBlock True if being called to add a new best-block to the chain
722 @param[in] fMiner True if being called by CreateNewBlock
723 @param[out] inputsRet Pointers to this transaction's inputs
724 @param[out] fInvalid returns true if transaction is invalid
725 @return Returns true if all inputs are in txdb or mapTestPool
727 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
728 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
730 /** Sanity check previous transactions, then, if all checks succeed,
731 mark them as spent by this transaction.
733 @param[in] inputs Previous transactions (from FetchInputs)
734 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
735 @param[in] posThisTx Position of this transaction on disk
736 @param[in] pindexBlock
737 @param[in] fBlock true if called from ConnectBlock
738 @param[in] fMiner true if called from CreateNewBlock
739 @param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
740 @return Returns true if all checks succeed
742 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs,
743 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
744 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
745 bool ClientConnectInputs();
746 bool CheckTransaction() const;
747 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
748 bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const; // ppcoin: get transaction coin age
751 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
758 /** A transaction with a merkle branch linking it to the block chain. */
759 class CMerkleTx : public CTransaction
763 std::vector<uint256> vMerkleBranch;
767 mutable bool fMerkleVerified;
775 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
784 fMerkleVerified = false;
790 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
791 nVersion = this->nVersion;
792 READWRITE(hashBlock);
793 READWRITE(vMerkleBranch);
798 int SetMerkleBranch(const CBlock* pblock=NULL);
799 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
800 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
801 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
802 int GetBlocksToMaturity() const;
803 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
804 bool AcceptToMemoryPool();
810 /** A txdb record that contains the disk location of a transaction and the
811 * locations of transactions that spend its outputs. vSpent is really only
812 * used as a flag, but having the location is very helpful for debugging.
818 std::vector<CDiskTxPos> vSpent;
825 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
828 vSpent.resize(nOutputs);
833 if (!(nType & SER_GETHASH))
850 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
852 return (a.pos == b.pos &&
853 a.vSpent == b.vSpent);
856 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
860 int GetDepthInMainChain() const;
867 /** Nodes collect new transactions into a block, hash them into a hash tree,
868 * and scan through nonce values to make the block's hash satisfy proof-of-work
869 * requirements. When they solve the proof-of-work, they broadcast the block
870 * to everyone and the block is added to the block chain. The first transaction
871 * in the block is a special one that creates a new coin owned by the creator
874 * Blocks are appended to blk0001.dat files on disk. Their location on disk
875 * is indexed by CBlockIndex objects in memory.
882 uint256 hashPrevBlock;
883 uint256 hashMerkleRoot;
889 std::vector<CTransaction> vtx;
891 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
892 std::vector<unsigned char> vchBlockSig;
895 mutable std::vector<uint256> vMerkleTree;
897 // Denial-of-service detection:
899 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
908 READWRITE(this->nVersion);
909 nVersion = this->nVersion;
910 READWRITE(hashPrevBlock);
911 READWRITE(hashMerkleRoot);
916 // ConnectBlock depends on vtx following header to generate CDiskTxPos
917 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
920 READWRITE(vchBlockSig);
924 const_cast<CBlock*>(this)->vtx.clear();
925 const_cast<CBlock*>(this)->vchBlockSig.clear();
948 uint256 GetHash() const
951 void * scratchbuff = scrypt_buffer_alloc();
953 scrypt_hash(CVOIDBEGIN(nVersion), sizeof(block_header), UINTBEGIN(thash), scratchbuff);
955 scrypt_buffer_free(scratchbuff);
961 int64 GetBlockTime() const
966 void UpdateTime(const CBlockIndex* pindexPrev);
968 // ppcoin: entropy bit for stake modifier if chosen by modifier
969 unsigned int GetStakeEntropyBit() const
971 uint160 hashSig = Hash160(vchBlockSig);
972 if (fDebug && GetBoolArg("-printstakemodifier"))
973 printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
974 hashSig >>= 159; // take the first bit of the hash
975 if (fDebug && GetBoolArg("-printstakemodifier"))
976 printf(" entropybit=%d\n", hashSig.Get64());
977 return hashSig.Get64();
980 // ppcoin: two types of block: proof-of-work or proof-of-stake
981 bool IsProofOfStake() const
983 return (vtx.size() > 1 && vtx[1].IsCoinStake());
986 bool IsProofOfWork() const
988 return !IsProofOfStake();
991 std::pair<COutPoint, unsigned int> GetProofOfStake() const
993 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
996 // ppcoin: get max transaction timestamp
997 int64 GetMaxTransactionTime() const
999 int64 maxTransactionTime = 0;
1000 BOOST_FOREACH(const CTransaction& tx, vtx)
1001 maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
1002 return maxTransactionTime;
1005 uint256 BuildMerkleTree() const
1007 vMerkleTree.clear();
1008 BOOST_FOREACH(const CTransaction& tx, vtx)
1009 vMerkleTree.push_back(tx.GetHash());
1011 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1013 for (int i = 0; i < nSize; i += 2)
1015 int i2 = std::min(i+1, nSize-1);
1016 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
1017 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
1021 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
1024 std::vector<uint256> GetMerkleBranch(int nIndex) const
1026 if (vMerkleTree.empty())
1028 std::vector<uint256> vMerkleBranch;
1030 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1032 int i = std::min(nIndex^1, nSize-1);
1033 vMerkleBranch.push_back(vMerkleTree[j+i]);
1037 return vMerkleBranch;
1040 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1044 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1047 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1049 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1056 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1058 // Open history file to append
1059 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1061 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1063 // Write index header
1064 unsigned char pchMessageStart[4];
1065 GetMessageStart(pchMessageStart, true);
1066 unsigned int nSize = fileout.GetSerializeSize(*this);
1067 fileout << FLATDATA(pchMessageStart) << nSize;
1070 long fileOutPos = ftell(fileout);
1072 return error("CBlock::WriteToDisk() : ftell failed");
1073 nBlockPosRet = fileOutPos;
1076 // Flush stdio buffers and commit to disk before returning
1078 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1081 _commit(_fileno(fileout));
1083 fsync(fileno(fileout));
1090 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1094 // Open history file to read
1095 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1097 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1098 if (!fReadTransactions)
1099 filein.nType |= SER_BLOCKHEADERONLY;
1105 catch (std::exception &e) {
1106 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1110 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1111 return error("CBlock::ReadFromDisk() : errors in block header");
1120 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d, vchBlockSig=%s)\n",
1121 GetHash().ToString().substr(0,20).c_str(),
1123 hashPrevBlock.ToString().substr(0,20).c_str(),
1124 hashMerkleRoot.ToString().substr(0,10).c_str(),
1125 nTime, nBits, nNonce,
1127 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1128 for (unsigned int i = 0; i < vtx.size(); i++)
1133 printf(" vMerkleTree: ");
1134 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1135 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1140 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1141 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1142 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1143 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1144 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1145 bool CheckBlock() const;
1147 bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1148 bool SignBlock(const CKeyStore& keystore);
1149 bool CheckBlockSignature() const;
1152 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1160 /** The block chain is a tree shaped structure starting with the
1161 * genesis block at the root, with each block potentially having multiple
1162 * candidates to be the next block. pprev and pnext link a path through the
1163 * main/longest chain. A blockindex may have multiple pprev pointing back
1164 * to it, but pnext will only point forward to the longest branch, or will
1165 * be null if the block is not part of the longest chain.
1170 const uint256* phashBlock;
1174 unsigned int nBlockPos;
1175 CBigNum bnChainTrust; // ppcoin: trust score of block chain
1180 unsigned int nFlags; // ppcoin: block index flags
1183 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1184 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1185 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1188 uint64 nStakeModifier; // hash modifier for proof-of-stake
1189 unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1191 // proof-of-stake specific fields
1192 COutPoint prevoutStake;
1193 unsigned int nStakeTime;
1194 uint256 hashProofOfStake;
1198 uint256 hashMerkleRoot;
1201 unsigned int nNonce;
1217 nStakeModifierChecksum = 0;
1218 hashProofOfStake = 0;
1219 prevoutStake.SetNull();
1229 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1235 nBlockPos = nBlockPosIn;
1242 nStakeModifierChecksum = 0;
1243 hashProofOfStake = 0;
1244 if (block.IsProofOfStake())
1247 prevoutStake = block.vtx[1].vin[0].prevout;
1248 nStakeTime = block.vtx[1].nTime;
1252 prevoutStake.SetNull();
1256 nVersion = block.nVersion;
1257 hashMerkleRoot = block.hashMerkleRoot;
1258 nTime = block.nTime;
1259 nBits = block.nBits;
1260 nNonce = block.nNonce;
1263 CBlock GetBlockHeader() const
1266 block.nVersion = nVersion;
1268 block.hashPrevBlock = pprev->GetBlockHash();
1269 block.hashMerkleRoot = hashMerkleRoot;
1270 block.nTime = nTime;
1271 block.nBits = nBits;
1272 block.nNonce = nNonce;
1276 uint256 GetBlockHash() const
1281 int64 GetBlockTime() const
1283 return (int64)nTime;
1286 CBigNum GetBlockTrust() const
1289 bnTarget.SetCompact(nBits);
1292 return (IsProofOfStake()? (CBigNum(1)<<256) / (bnTarget+1) : 1);
1295 bool IsInMainChain() const
1297 return (pnext || this == pindexBest);
1300 bool CheckIndex() const
1305 bool EraseBlockFromDisk()
1307 // Open history file
1308 CAutoFile fileout = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb+"), SER_DISK, CLIENT_VERSION);
1312 // Overwrite with empty null block
1320 enum { nMedianTimeSpan=11 };
1322 int64 GetMedianTimePast() const
1324 int64 pmedian[nMedianTimeSpan];
1325 int64* pbegin = &pmedian[nMedianTimeSpan];
1326 int64* pend = &pmedian[nMedianTimeSpan];
1328 const CBlockIndex* pindex = this;
1329 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1330 *(--pbegin) = pindex->GetBlockTime();
1332 std::sort(pbegin, pend);
1333 return pbegin[(pend - pbegin)/2];
1336 int64 GetMedianTime() const
1338 const CBlockIndex* pindex = this;
1339 for (int i = 0; i < nMedianTimeSpan/2; i++)
1342 return GetBlockTime();
1343 pindex = pindex->pnext;
1345 return pindex->GetMedianTimePast();
1348 bool IsProofOfWork() const
1350 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1353 bool IsProofOfStake() const
1355 return (nFlags & BLOCK_PROOF_OF_STAKE);
1358 void SetProofOfStake()
1360 nFlags |= BLOCK_PROOF_OF_STAKE;
1363 unsigned int GetStakeEntropyBit() const
1365 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1368 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1370 if (nEntropyBit > 1)
1372 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1376 bool GeneratedStakeModifier() const
1378 return (nFlags & BLOCK_STAKE_MODIFIER);
1381 void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1383 nStakeModifier = nModifier;
1384 if (fGeneratedStakeModifier)
1385 nFlags |= BLOCK_STAKE_MODIFIER;
1388 std::string ToString() const
1390 return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, 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)",
1391 pprev, pnext, nFile, nBlockPos, nHeight,
1392 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1393 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1394 nStakeModifier, nStakeModifierChecksum,
1395 hashProofOfStake.ToString().c_str(),
1396 prevoutStake.ToString().c_str(), nStakeTime,
1397 hashMerkleRoot.ToString().substr(0,10).c_str(),
1398 GetBlockHash().ToString().substr(0,20).c_str());
1403 printf("%s\n", ToString().c_str());
1409 /** Used to marshal pointers into hashes for db storage. */
1410 class CDiskBlockIndex : public CBlockIndex
1422 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1424 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1425 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1430 if (!(nType & SER_GETHASH))
1431 READWRITE(nVersion);
1433 READWRITE(hashNext);
1435 READWRITE(nBlockPos);
1438 READWRITE(nMoneySupply);
1440 READWRITE(nStakeModifier);
1441 if (IsProofOfStake())
1443 READWRITE(prevoutStake);
1444 READWRITE(nStakeTime);
1445 READWRITE(hashProofOfStake);
1449 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1450 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1451 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1455 READWRITE(this->nVersion);
1456 READWRITE(hashPrev);
1457 READWRITE(hashMerkleRoot);
1463 uint256 GetBlockHash() const
1466 block.nVersion = nVersion;
1467 block.hashPrevBlock = hashPrev;
1468 block.hashMerkleRoot = hashMerkleRoot;
1469 block.nTime = nTime;
1470 block.nBits = nBits;
1471 block.nNonce = nNonce;
1472 return block.GetHash();
1476 std::string ToString() const
1478 std::string str = "CDiskBlockIndex(";
1479 str += CBlockIndex::ToString();
1480 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1481 GetBlockHash().ToString().c_str(),
1482 hashPrev.ToString().substr(0,20).c_str(),
1483 hashNext.ToString().substr(0,20).c_str());
1489 printf("%s\n", ToString().c_str());
1500 /** Describes a place in the block chain to another node such that if the
1501 * other node doesn't have the same branch, it can find a recent common trunk.
1502 * The further back it is, the further before the fork it may be.
1507 std::vector<uint256> vHave;
1514 explicit CBlockLocator(const CBlockIndex* pindex)
1519 explicit CBlockLocator(uint256 hashBlock)
1521 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1522 if (mi != mapBlockIndex.end())
1526 CBlockLocator(const std::vector<uint256>& vHaveIn)
1533 if (!(nType & SER_GETHASH))
1534 READWRITE(nVersion);
1545 return vHave.empty();
1548 void Set(const CBlockIndex* pindex)
1554 vHave.push_back(pindex->GetBlockHash());
1556 // Exponentially larger steps back
1557 for (int i = 0; pindex && i < nStep; i++)
1558 pindex = pindex->pprev;
1559 if (vHave.size() > 10)
1562 vHave.push_back(hashGenesisBlock);
1565 int GetDistanceBack()
1567 // Retrace how far back it was in the sender's branch
1570 BOOST_FOREACH(const uint256& hash, vHave)
1572 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1573 if (mi != mapBlockIndex.end())
1575 CBlockIndex* pindex = (*mi).second;
1576 if (pindex->IsInMainChain())
1586 CBlockIndex* GetBlockIndex()
1588 // Find the first block the caller has in the main chain
1589 BOOST_FOREACH(const uint256& hash, vHave)
1591 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1592 if (mi != mapBlockIndex.end())
1594 CBlockIndex* pindex = (*mi).second;
1595 if (pindex->IsInMainChain())
1599 return pindexGenesisBlock;
1602 uint256 GetBlockHash()
1604 // Find the first block the caller has in the main chain
1605 BOOST_FOREACH(const uint256& hash, vHave)
1607 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1608 if (mi != mapBlockIndex.end())
1610 CBlockIndex* pindex = (*mi).second;
1611 if (pindex->IsInMainChain())
1615 return hashGenesisBlock;
1620 CBlockIndex* pindex = GetBlockIndex();
1623 return pindex->nHeight;
1635 /** Alerts are for notifying old versions if they become too obsolete and
1636 * need to upgrade. The message is displayed in the status bar.
1637 * Alert messages are broadcast as a vector of signed data. Unserializing may
1638 * not read the entire buffer if the alert is for a newer version, but older
1639 * versions can still relay the original data.
1641 class CUnsignedAlert
1645 int64 nRelayUntil; // when newer nodes stop relaying to newer nodes
1649 std::set<int> setCancel;
1650 int nMinVer; // lowest version inclusive
1651 int nMaxVer; // highest version inclusive
1652 std::set<std::string> setSubVer; // empty matches all
1656 std::string strComment;
1657 std::string strStatusBar;
1658 std::string strReserved;
1662 READWRITE(this->nVersion);
1663 nVersion = this->nVersion;
1664 READWRITE(nRelayUntil);
1665 READWRITE(nExpiration);
1668 READWRITE(setCancel);
1671 READWRITE(setSubVer);
1672 READWRITE(nPriority);
1674 READWRITE(strComment);
1675 READWRITE(strStatusBar);
1676 READWRITE(strReserved);
1693 strStatusBar.clear();
1694 strReserved.clear();
1697 std::string ToString() const
1699 std::string strSetCancel;
1700 BOOST_FOREACH(int n, setCancel)
1701 strSetCancel += strprintf("%d ", n);
1702 std::string strSetSubVer;
1703 BOOST_FOREACH(std::string str, setSubVer)
1704 strSetSubVer += "\"" + str + "\" ";
1708 " nRelayUntil = %"PRI64d"\n"
1709 " nExpiration = %"PRI64d"\n"
1717 " strComment = \"%s\"\n"
1718 " strStatusBar = \"%s\"\n"
1725 strSetCancel.c_str(),
1728 strSetSubVer.c_str(),
1731 strStatusBar.c_str());
1736 printf("%s", ToString().c_str());
1740 /** An alert is a combination of a serialized CUnsignedAlert and a signature. */
1741 class CAlert : public CUnsignedAlert
1744 std::vector<unsigned char> vchMsg;
1745 std::vector<unsigned char> vchSig;
1760 CUnsignedAlert::SetNull();
1767 return (nExpiration == 0);
1770 uint256 GetHash() const
1772 return SerializeHash(*this);
1775 bool IsInEffect() const
1777 return (GetAdjustedTime() < nExpiration);
1780 bool Cancels(const CAlert& alert) const
1783 return false; // this was a no-op before 31403
1784 return (alert.nID <= nCancel || setCancel.count(alert.nID));
1787 bool AppliesTo(int nVersion, std::string strSubVerIn) const
1789 // TODO: rework for client-version-embedded-in-strSubVer ?
1790 return (IsInEffect() &&
1791 nMinVer <= nVersion && nVersion <= nMaxVer &&
1792 (setSubVer.empty() || setSubVer.count(strSubVerIn)));
1795 bool AppliesToMe() const
1797 return AppliesTo(PROTOCOL_VERSION, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<std::string>()));
1800 bool RelayTo(CNode* pnode) const
1804 // returns true if wasn't already contained in the set
1805 if (pnode->setKnown.insert(GetHash()).second)
1807 if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
1809 GetAdjustedTime() < nRelayUntil)
1811 pnode->PushMessage("alert", *this);
1818 bool CheckSignature()
1821 if (!key.SetPubKey(ParseHex("043fa441fd4203d03f5df2b75ea14e36f20d39f43e7a61aa7552ab9bcd7ecb0e77a3be4585b13fcdaa22ef6e51f1ff6f2929bec2494385b086fb86610e33193195")))
1822 return error("CAlert::CheckSignature() : SetPubKey failed");
1823 if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
1824 return error("CAlert::CheckSignature() : verify signature failed");
1826 // Now unserialize the data
1827 CDataStream sMsg(vchMsg, SER_NETWORK, PROTOCOL_VERSION);
1828 sMsg >> *(CUnsignedAlert*)this;
1832 bool ProcessAlert();
1838 mutable CCriticalSection cs;
1839 std::map<uint256, CTransaction> mapTx;
1840 std::map<COutPoint, CInPoint> mapNextTx;
1842 bool accept(CTxDB& txdb, CTransaction &tx,
1843 bool fCheckInputs, bool* pfMissingInputs);
1844 bool addUnchecked(CTransaction &tx);
1845 bool remove(CTransaction &tx);
1847 unsigned long size()
1850 return mapTx.size();
1853 bool exists(uint256 hash)
1855 return (mapTx.count(hash) != 0);
1858 CTransaction& lookup(uint256 hash)
1864 extern CTxMemPool mempool;