update to 0.4.2
[novacoin.git] / src / main.h
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.
5 #ifndef BITCOIN_MAIN_H
6 #define BITCOIN_MAIN_H
7
8 #include "bignum.h"
9 #include "sync.h"
10 #include "net.h"
11 #include "script.h"
12 #include "scrypt_mine.h"
13
14 #include <list>
15
16 class CWallet;
17 class CBlock;
18 class CBlockIndex;
19 class CKeyItem;
20 class CReserveKey;
21 class COutPoint;
22
23 class CAddress;
24 class CInv;
25 class CRequestTracker;
26 class CNode;
27
28 static const unsigned int MAX_BLOCK_SIZE = 1000000;
29 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
30 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
31 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
32 static const unsigned int MAX_INV_SZ = 50000;
33 static const int64 MIN_TX_FEE = CENT;
34 static const int64 MIN_RELAY_TX_FEE = CENT;
35 static const int64 MAX_MONEY = 2000000000 * COIN;
36 static const int64 MAX_MINT_PROOF_OF_WORK = 100 * COIN;
37 static const int64 MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
38 static const int64 MIN_TXOUT_AMOUNT = MIN_TX_FEE;
39 static const unsigned int STAKE_SWITCH_TIME = 1371686400; // 20 Jun 2013 00:00:00
40 static const unsigned int TARGETS_SWITCH_TIME = 1374278400; // 20 Jul 2013 00:00:00
41 static const unsigned int LOCKS_SWITCH_TIME = 1376956800; // 20 Aug 2013 00:00:00
42
43 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
44 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
45 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov  5 00:53:20 1985 UTC
46
47 #ifdef USE_UPNP
48 static const int fHaveUPnP = true;
49 #else
50 static const int fHaveUPnP = false;
51 #endif
52
53 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
54 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
55
56 static const int64 nMaxClockDrift = 2 * 60 * 60;        // two hours
57
58 extern CScript COINBASE_FLAGS;
59
60
61 extern CCriticalSection cs_main;
62 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
63 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
64 extern CBlockIndex* pindexGenesisBlock;
65 extern unsigned int nStakeMinAge;
66 extern int nCoinbaseMaturity;
67 extern int nBestHeight;
68 extern CBigNum bnBestChainTrust;
69 extern CBigNum bnBestInvalidTrust;
70 extern uint256 hashBestChain;
71 extern CBlockIndex* pindexBest;
72 extern unsigned int nTransactionsUpdated;
73 extern uint64 nLastBlockTx;
74 extern uint64 nLastBlockSize;
75 extern int64 nLastCoinStakeSearchInterval;
76 extern const std::string strMessageMagic;
77 extern double dHashesPerSec;
78 extern int64 nHPSTimerStart;
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;
84
85 // Settings
86 extern int64 nTransactionFee;
87
88 // Minimum disk space required - used in CheckDiskSpace()
89 static const uint64 nMinDiskSpace = 52428800;
90
91
92 class CReserveKey;
93 class CTxDB;
94 class CTxIndex;
95
96 void RegisterWallet(CWallet* pwalletIn);
97 void UnregisterWallet(CWallet* pwalletIn);
98 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
99 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
100 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
101 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
102 FILE* AppendBlockFile(unsigned int& nFileRet);
103 bool LoadBlockIndex(bool fAllowNew=true);
104 void PrintBlockTree();
105 CBlockIndex* FindBlockByHeight(int nHeight);
106 bool ProcessMessages(CNode* pfrom);
107 bool SendMessages(CNode* pto, bool fSendTrickle);
108 bool LoadExternalBlockFile(FILE* fileIn);
109 void GenerateBitcoins(bool fGenerate, CWallet* pwallet);
110 CBlock* CreateNewBlock(CWallet* pwallet, bool fProofOfStake=false);
111 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
112 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
113 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
114 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
115 int64 GetProofOfWorkReward(unsigned int nBits);
116 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime);
117 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
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 BitcoinMiner(CWallet *pwallet, bool fProofOfStake);
125 void ResendWalletTransactions();
126
127
128
129
130
131
132
133
134
135
136 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
137
138 /** Position on disk for a particular transaction. */
139 class CDiskTxPos
140 {
141 public:
142     unsigned int nFile;
143     unsigned int nBlockPos;
144     unsigned int nTxPos;
145
146     CDiskTxPos()
147     {
148         SetNull();
149     }
150
151     CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
152     {
153         nFile = nFileIn;
154         nBlockPos = nBlockPosIn;
155         nTxPos = nTxPosIn;
156     }
157
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); }
161
162     friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
163     {
164         return (a.nFile     == b.nFile &&
165                 a.nBlockPos == b.nBlockPos &&
166                 a.nTxPos    == b.nTxPos);
167     }
168
169     friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
170     {
171         return !(a == b);
172     }
173
174
175     std::string ToString() const
176     {
177         if (IsNull())
178             return "null";
179         else
180             return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
181     }
182
183     void print() const
184     {
185         printf("%s", ToString().c_str());
186     }
187 };
188
189
190
191 /** An inpoint - a combination of a transaction and an index n into its vin */
192 class CInPoint
193 {
194 public:
195     CTransaction* ptx;
196     unsigned int n;
197
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); }
202 };
203
204
205
206 /** An outpoint - a combination of a transaction hash and an index n into its vout */
207 class COutPoint
208 {
209 public:
210     uint256 hash;
211     unsigned int n;
212
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); }
218
219     friend bool operator<(const COutPoint& a, const COutPoint& b)
220     {
221         return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
222     }
223
224     friend bool operator==(const COutPoint& a, const COutPoint& b)
225     {
226         return (a.hash == b.hash && a.n == b.n);
227     }
228
229     friend bool operator!=(const COutPoint& a, const COutPoint& b)
230     {
231         return !(a == b);
232     }
233
234     std::string ToString() const
235     {
236         return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
237     }
238
239     void print() const
240     {
241         printf("%s\n", ToString().c_str());
242     }
243 };
244
245
246
247
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.
251  */
252 class CTxIn
253 {
254 public:
255     COutPoint prevout;
256     CScript scriptSig;
257     unsigned int nSequence;
258
259     CTxIn()
260     {
261         nSequence = std::numeric_limits<unsigned int>::max();
262     }
263
264     explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
265     {
266         prevout = prevoutIn;
267         scriptSig = scriptSigIn;
268         nSequence = nSequenceIn;
269     }
270
271     CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
272     {
273         prevout = COutPoint(hashPrevTx, nOut);
274         scriptSig = scriptSigIn;
275         nSequence = nSequenceIn;
276     }
277
278     IMPLEMENT_SERIALIZE
279     (
280         READWRITE(prevout);
281         READWRITE(scriptSig);
282         READWRITE(nSequence);
283     )
284
285     bool IsFinal() const
286     {
287         return (nSequence == std::numeric_limits<unsigned int>::max());
288     }
289
290     friend bool operator==(const CTxIn& a, const CTxIn& b)
291     {
292         return (a.prevout   == b.prevout &&
293                 a.scriptSig == b.scriptSig &&
294                 a.nSequence == b.nSequence);
295     }
296
297     friend bool operator!=(const CTxIn& a, const CTxIn& b)
298     {
299         return !(a == b);
300     }
301
302     std::string ToStringShort() const
303     {
304         return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
305     }
306
307     std::string ToString() const
308     {
309         std::string str;
310         str += "CTxIn(";
311         str += prevout.ToString();
312         if (prevout.IsNull())
313             str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
314         else
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);
318         str += ")";
319         return str;
320     }
321
322     void print() const
323     {
324         printf("%s\n", ToString().c_str());
325     }
326 };
327
328
329
330
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.
333  */
334 class CTxOut
335 {
336 public:
337     int64 nValue;
338     CScript scriptPubKey;
339
340     CTxOut()
341     {
342         SetNull();
343     }
344
345     CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
346     {
347         nValue = nValueIn;
348         scriptPubKey = scriptPubKeyIn;
349     }
350
351     IMPLEMENT_SERIALIZE
352     (
353         READWRITE(nValue);
354         READWRITE(scriptPubKey);
355     )
356
357     void SetNull()
358     {
359         nValue = -1;
360         scriptPubKey.clear();
361     }
362
363     bool IsNull()
364     {
365         return (nValue == -1);
366     }
367
368     void SetEmpty()
369     {
370         nValue = 0;
371         scriptPubKey.clear();
372     }
373
374     bool IsEmpty() const
375     {
376         return (nValue == 0 && scriptPubKey.empty());
377     }
378
379     uint256 GetHash() const
380     {
381         return SerializeHash(*this);
382     }
383
384     friend bool operator==(const CTxOut& a, const CTxOut& b)
385     {
386         return (a.nValue       == b.nValue &&
387                 a.scriptPubKey == b.scriptPubKey);
388     }
389
390     friend bool operator!=(const CTxOut& a, const CTxOut& b)
391     {
392         return !(a == b);
393     }
394
395     std::string ToStringShort() const
396     {
397         return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
398     }
399
400     std::string ToString() const
401     {
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());
406     }
407
408     void print() const
409     {
410         printf("%s\n", ToString().c_str());
411     }
412 };
413
414
415
416
417 enum GetMinFee_mode
418 {
419     GMF_BLOCK,
420     GMF_RELAY,
421     GMF_SEND,
422 };
423
424 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
425
426 /** The basic transaction that is broadcasted on the network and contained in
427  * blocks.  A transaction can contain multiple inputs and outputs.
428  */
429 class CTransaction
430 {
431 public:
432     static const int CURRENT_VERSION=1;
433     int nVersion;
434     unsigned int nTime;
435     std::vector<CTxIn> vin;
436     std::vector<CTxOut> vout;
437     unsigned int nLockTime;
438
439     // Denial-of-service detection:
440     mutable int nDoS;
441     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
442
443     CTransaction()
444     {
445         SetNull();
446     }
447
448     IMPLEMENT_SERIALIZE
449     (
450         READWRITE(this->nVersion);
451         nVersion = this->nVersion;
452         READWRITE(nTime);
453         READWRITE(vin);
454         READWRITE(vout);
455         READWRITE(nLockTime);
456     )
457
458     void SetNull()
459     {
460         nVersion = CTransaction::CURRENT_VERSION;
461         nTime = GetAdjustedTime();
462         vin.clear();
463         vout.clear();
464         nLockTime = 0;
465         nDoS = 0;  // Denial-of-service prevention
466     }
467
468     bool IsNull() const
469     {
470         return (vin.empty() && vout.empty());
471     }
472
473     uint256 GetHash() const
474     {
475         return SerializeHash(*this);
476     }
477
478     bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
479     {
480         // Time based nLockTime implemented in 0.1.6
481         if (nLockTime == 0)
482             return true;
483         if (nBlockHeight == 0)
484             nBlockHeight = nBestHeight;
485         if (nBlockTime == 0)
486             nBlockTime = GetAdjustedTime();
487         if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
488             return true;
489         BOOST_FOREACH(const CTxIn& txin, vin)
490             if (!txin.IsFinal())
491                 return false;
492         return true;
493     }
494
495     bool IsNewerThan(const CTransaction& old) const
496     {
497         if (vin.size() != old.vin.size())
498             return false;
499         for (unsigned int i = 0; i < vin.size(); i++)
500             if (vin[i].prevout != old.vin[i].prevout)
501                 return false;
502
503         bool fNewer = false;
504         unsigned int nLowest = std::numeric_limits<unsigned int>::max();
505         for (unsigned int i = 0; i < vin.size(); i++)
506         {
507             if (vin[i].nSequence != old.vin[i].nSequence)
508             {
509                 if (vin[i].nSequence <= nLowest)
510                 {
511                     fNewer = false;
512                     nLowest = vin[i].nSequence;
513                 }
514                 if (old.vin[i].nSequence < nLowest)
515                 {
516                     fNewer = true;
517                     nLowest = old.vin[i].nSequence;
518                 }
519             }
520         }
521         return fNewer;
522     }
523
524     bool IsCoinBase() const
525     {
526         return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
527     }
528
529     bool IsCoinStake() const
530     {
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());
533     }
534
535     /** Check for standard transaction types
536         @return True if all outputs (scriptPubKeys) use only standard transaction forms
537     */
538     bool IsStandard() const;
539
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
544     */
545     bool AreInputsStandard(const MapPrevTx& mapInputs) const;
546
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
550     */
551     unsigned int GetLegacySigOpCount() const;
552
553     /** Count ECDSA signature operations in pay-to-script-hash inputs.
554
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
558      */
559     unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
560
561     /** Amount of bitcoins spent by this transaction.
562         @return sum of all outputs (note: does not include fees)
563      */
564     int64 GetValueOut() const
565     {
566         int64 nValueOut = 0;
567         BOOST_FOREACH(const CTxOut& txout, vout)
568         {
569             nValueOut += txout.nValue;
570             if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
571                 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
572         }
573         return nValueOut;
574     }
575
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.
579
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
583      */
584     int64 GetValueIn(const MapPrevTx& mapInputs) const;
585
586     static bool AllowFree(double dPriority)
587     {
588         // Large (in bytes) low-priority (new, small-coin) transactions
589         // need a fee.
590         return dPriority > COIN * 144 / 250;
591     }
592
593     int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK) const;
594
595     bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
596     {
597         CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
598         if (!filein)
599             return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
600
601         // Read transaction
602         if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
603             return error("CTransaction::ReadFromDisk() : fseek failed");
604
605         try {
606             filein >> *this;
607         }
608         catch (std::exception &e) {
609             return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
610         }
611
612         // Return file pointer
613         if (pfileRet)
614         {
615             if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
616                 return error("CTransaction::ReadFromDisk() : second fseek failed");
617             *pfileRet = filein.release();
618         }
619         return true;
620     }
621
622     friend bool operator==(const CTransaction& a, const CTransaction& b)
623     {
624         return (a.nVersion  == b.nVersion &&
625                 a.nTime     == b.nTime &&
626                 a.vin       == b.vin &&
627                 a.vout      == b.vout &&
628                 a.nLockTime == b.nLockTime);
629     }
630
631     friend bool operator!=(const CTransaction& a, const CTransaction& b)
632     {
633         return !(a == b);
634     }
635
636     std::string ToStringShort() const
637     {
638         std::string str;
639         str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
640         return str;
641     }
642
643     std::string ToString() const
644     {
645         std::string str;
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(),
649             nTime,
650             nVersion,
651             vin.size(),
652             vout.size(),
653             nLockTime);
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";
658         return str;
659     }
660
661     void print() const
662     {
663         printf("%s", ToString().c_str());
664     }
665
666
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);
671
672     /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
673
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
681      */
682     bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
683                      bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
684
685     /** Sanity check previous transactions, then, if all checks succeed,
686         mark them as spent by this transaction.
687
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
696      */
697     bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs,
698                        std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
699                        const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
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
704
705 protected:
706     const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
707 };
708
709
710
711
712
713 /** A transaction with a merkle branch linking it to the block chain. */
714 class CMerkleTx : public CTransaction
715 {
716 public:
717     uint256 hashBlock;
718     std::vector<uint256> vMerkleBranch;
719     int nIndex;
720
721     // memory only
722     mutable bool fMerkleVerified;
723
724
725     CMerkleTx()
726     {
727         Init();
728     }
729
730     CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
731     {
732         Init();
733     }
734
735     void Init()
736     {
737         hashBlock = 0;
738         nIndex = -1;
739         fMerkleVerified = false;
740     }
741
742
743     IMPLEMENT_SERIALIZE
744     (
745         nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
746         nVersion = this->nVersion;
747         READWRITE(hashBlock);
748         READWRITE(vMerkleBranch);
749         READWRITE(nIndex);
750     )
751
752
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();
760 };
761
762
763
764
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.
768  */
769 class CTxIndex
770 {
771 public:
772     CDiskTxPos pos;
773     std::vector<CDiskTxPos> vSpent;
774
775     CTxIndex()
776     {
777         SetNull();
778     }
779
780     CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
781     {
782         pos = posIn;
783         vSpent.resize(nOutputs);
784     }
785
786     IMPLEMENT_SERIALIZE
787     (
788         if (!(nType & SER_GETHASH))
789             READWRITE(nVersion);
790         READWRITE(pos);
791         READWRITE(vSpent);
792     )
793
794     void SetNull()
795     {
796         pos.SetNull();
797         vSpent.clear();
798     }
799
800     bool IsNull()
801     {
802         return pos.IsNull();
803     }
804
805     friend bool operator==(const CTxIndex& a, const CTxIndex& b)
806     {
807         return (a.pos    == b.pos &&
808                 a.vSpent == b.vSpent);
809     }
810
811     friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
812     {
813         return !(a == b);
814     }
815     int GetDepthInMainChain() const;
816
817 };
818
819
820
821
822
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
828  * of the block.
829  *
830  * Blocks are appended to blk0001.dat files on disk.  Their location on disk
831  * is indexed by CBlockIndex objects in memory.
832  */
833 class CBlock
834 {
835 public:
836     // header
837     static const int CURRENT_VERSION=5;
838     int nVersion;
839     uint256 hashPrevBlock;
840     uint256 hashMerkleRoot;
841     unsigned int nTime;
842     unsigned int nBits;
843     unsigned int nNonce;
844
845     // network and disk
846     std::vector<CTransaction> vtx;
847
848     // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
849     std::vector<unsigned char> vchBlockSig;
850
851     // memory only
852     mutable std::vector<uint256> vMerkleTree;
853
854     // Denial-of-service detection:
855     mutable int nDoS;
856     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
857
858     CBlock()
859     {
860         SetNull();
861     }
862
863     IMPLEMENT_SERIALIZE
864     (
865         READWRITE(this->nVersion);
866         nVersion = this->nVersion;
867         READWRITE(hashPrevBlock);
868         READWRITE(hashMerkleRoot);
869         READWRITE(nTime);
870         READWRITE(nBits);
871         READWRITE(nNonce);
872
873         // ConnectBlock depends on vtx following header to generate CDiskTxPos
874         if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
875         {
876             READWRITE(vtx);
877             READWRITE(vchBlockSig);
878         }
879         else if (fRead)
880         {
881             const_cast<CBlock*>(this)->vtx.clear();
882             const_cast<CBlock*>(this)->vchBlockSig.clear();
883         }
884     )
885
886     void SetNull()
887     {
888         nVersion = CBlock::CURRENT_VERSION;
889         hashPrevBlock = 0;
890         hashMerkleRoot = 0;
891         nTime = 0;
892         nBits = 0;
893         nNonce = 0;
894         vtx.clear();
895         vchBlockSig.clear();
896         vMerkleTree.clear();
897         nDoS = 0;
898     }
899
900     bool IsNull() const
901     {
902         return (nBits == 0);
903     }
904
905     uint256 GetHash() const
906     {
907         uint256 thash;
908         void * scratchbuff = scrypt_buffer_alloc();
909
910         scrypt_hash(CVOIDBEGIN(nVersion), sizeof(block_header), UINTBEGIN(thash), scratchbuff);
911
912         scrypt_buffer_free(scratchbuff);
913
914         return thash;
915     }
916
917     int64 GetBlockTime() const
918     {
919         return (int64)nTime;
920     }
921
922     void UpdateTime(const CBlockIndex* pindexPrev);
923
924     // ppcoin: entropy bit for stake modifier if chosen by modifier
925     unsigned int GetStakeEntropyBit(unsigned int nHeight) const
926     {
927         // Protocol switch to support p2pool at novacoin block #9689
928         if (nHeight >= 9689 || fTestNet)
929         {
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: nHeight=%u hashBlock=%s nEntropyBit=%u\n", nHeight, GetHash().ToString().c_str(), nEntropyBit);
934             return nEntropyBit;
935         }
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();
944     }
945
946     // ppcoin: two types of block: proof-of-work or proof-of-stake
947     bool IsProofOfStake() const
948     {
949         return (vtx.size() > 1 && vtx[1].IsCoinStake());
950     }
951
952     bool IsProofOfWork() const
953     {
954         return !IsProofOfStake();
955     }
956
957     std::pair<COutPoint, unsigned int> GetProofOfStake() const
958     {
959         return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
960     }
961
962     // ppcoin: get max transaction timestamp
963     int64 GetMaxTransactionTime() const
964     {
965         int64 maxTransactionTime = 0;
966         BOOST_FOREACH(const CTransaction& tx, vtx)
967             maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
968         return maxTransactionTime;
969     }
970
971     uint256 BuildMerkleTree() const
972     {
973         vMerkleTree.clear();
974         BOOST_FOREACH(const CTransaction& tx, vtx)
975             vMerkleTree.push_back(tx.GetHash());
976         int j = 0;
977         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
978         {
979             for (int i = 0; i < nSize; i += 2)
980             {
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])));
984             }
985             j += nSize;
986         }
987         return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
988     }
989
990     std::vector<uint256> GetMerkleBranch(int nIndex) const
991     {
992         if (vMerkleTree.empty())
993             BuildMerkleTree();
994         std::vector<uint256> vMerkleBranch;
995         int j = 0;
996         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
997         {
998             int i = std::min(nIndex^1, nSize-1);
999             vMerkleBranch.push_back(vMerkleTree[j+i]);
1000             nIndex >>= 1;
1001             j += nSize;
1002         }
1003         return vMerkleBranch;
1004     }
1005
1006     static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1007     {
1008         if (nIndex == -1)
1009             return 0;
1010         BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1011         {
1012             if (nIndex & 1)
1013                 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1014             else
1015                 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1016             nIndex >>= 1;
1017         }
1018         return hash;
1019     }
1020
1021
1022     bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1023     {
1024         // Open history file to append
1025         CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1026         if (!fileout)
1027             return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1028
1029         // Write index header
1030         unsigned int nSize = fileout.GetSerializeSize(*this);
1031         fileout << FLATDATA(pchMessageStart) << nSize;
1032
1033         // Write block
1034         long fileOutPos = ftell(fileout);
1035         if (fileOutPos < 0)
1036             return error("CBlock::WriteToDisk() : ftell failed");
1037         nBlockPosRet = fileOutPos;
1038         fileout << *this;
1039
1040         // Flush stdio buffers and commit to disk before returning
1041         fflush(fileout);
1042         if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1043             FileCommit(fileout);
1044
1045         return true;
1046     }
1047
1048     bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1049     {
1050         SetNull();
1051
1052         // Open history file to read
1053         CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1054         if (!filein)
1055             return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1056         if (!fReadTransactions)
1057             filein.nType |= SER_BLOCKHEADERONLY;
1058
1059         // Read block
1060         try {
1061             filein >> *this;
1062         }
1063         catch (std::exception &e) {
1064             return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1065         }
1066
1067         // Check the header
1068         if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1069             return error("CBlock::ReadFromDisk() : errors in block header");
1070
1071         return true;
1072     }
1073
1074
1075
1076     void print() const
1077     {
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(),
1080             nVersion,
1081             hashPrevBlock.ToString().c_str(),
1082             hashMerkleRoot.ToString().c_str(),
1083             nTime, nBits, nNonce,
1084             vtx.size(),
1085             HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1086         for (unsigned int i = 0; i < vtx.size(); i++)
1087         {
1088             printf("  ");
1089             vtx[i].print();
1090         }
1091         printf("  vMerkleTree: ");
1092         for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1093             printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1094         printf("\n");
1095     }
1096
1097
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) const;
1104     bool AcceptBlock();
1105     bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1106     bool SignBlock(const CKeyStore& keystore);
1107     bool CheckBlockSignature() const;
1108
1109 private:
1110     bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1111 };
1112
1113
1114
1115
1116
1117
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.
1124  */
1125 class CBlockIndex
1126 {
1127 public:
1128     const uint256* phashBlock;
1129     CBlockIndex* pprev;
1130     CBlockIndex* pnext;
1131     unsigned int nFile;
1132     unsigned int nBlockPos;
1133     CBigNum bnChainTrust; // ppcoin: trust score of block chain
1134     int nHeight;
1135
1136     int64 nMint;
1137     int64 nMoneySupply;
1138
1139     unsigned int nFlags;  // ppcoin: block index flags
1140     enum  
1141     {
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
1145     };
1146
1147     uint64 nStakeModifier; // hash modifier for proof-of-stake
1148     unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1149
1150     // proof-of-stake specific fields
1151     COutPoint prevoutStake;
1152     unsigned int nStakeTime;
1153     uint256 hashProofOfStake;
1154
1155     // block header
1156     int nVersion;
1157     uint256 hashMerkleRoot;
1158     unsigned int nTime;
1159     unsigned int nBits;
1160     unsigned int nNonce;
1161
1162     CBlockIndex()
1163     {
1164         phashBlock = NULL;
1165         pprev = NULL;
1166         pnext = NULL;
1167         nFile = 0;
1168         nBlockPos = 0;
1169         nHeight = 0;
1170         bnChainTrust = 0;
1171         nMint = 0;
1172         nMoneySupply = 0;
1173         nFlags = 0;
1174         nStakeModifier = 0;
1175         nStakeModifierChecksum = 0;
1176         hashProofOfStake = 0;
1177         prevoutStake.SetNull();
1178         nStakeTime = 0;
1179
1180         nVersion       = 0;
1181         hashMerkleRoot = 0;
1182         nTime          = 0;
1183         nBits          = 0;
1184         nNonce         = 0;
1185     }
1186
1187     CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1188     {
1189         phashBlock = NULL;
1190         pprev = NULL;
1191         pnext = NULL;
1192         nFile = nFileIn;
1193         nBlockPos = nBlockPosIn;
1194         nHeight = 0;
1195         bnChainTrust = 0;
1196         nMint = 0;
1197         nMoneySupply = 0;
1198         nFlags = 0;
1199         nStakeModifier = 0;
1200         nStakeModifierChecksum = 0;
1201         hashProofOfStake = 0;
1202         if (block.IsProofOfStake())
1203         {
1204             SetProofOfStake();
1205             prevoutStake = block.vtx[1].vin[0].prevout;
1206             nStakeTime = block.vtx[1].nTime;
1207         }
1208         else
1209         {
1210             prevoutStake.SetNull();
1211             nStakeTime = 0;
1212         }
1213
1214         nVersion       = block.nVersion;
1215         hashMerkleRoot = block.hashMerkleRoot;
1216         nTime          = block.nTime;
1217         nBits          = block.nBits;
1218         nNonce         = block.nNonce;
1219     }
1220
1221     CBlock GetBlockHeader() const
1222     {
1223         CBlock block;
1224         block.nVersion       = nVersion;
1225         if (pprev)
1226             block.hashPrevBlock = pprev->GetBlockHash();
1227         block.hashMerkleRoot = hashMerkleRoot;
1228         block.nTime          = nTime;
1229         block.nBits          = nBits;
1230         block.nNonce         = nNonce;
1231         return block;
1232     }
1233
1234     uint256 GetBlockHash() const
1235     {
1236         return *phashBlock;
1237     }
1238
1239     int64 GetBlockTime() const
1240     {
1241         return (int64)nTime;
1242     }
1243
1244     CBigNum GetBlockTrust() const
1245     {
1246         CBigNum bnTarget;
1247         bnTarget.SetCompact(nBits);
1248         if (bnTarget <= 0)
1249             return 0;
1250         return (IsProofOfStake()? (CBigNum(1)<<256) / (bnTarget+1) : 1);
1251     }
1252
1253     bool IsInMainChain() const
1254     {
1255         return (pnext || this == pindexBest);
1256     }
1257
1258     bool CheckIndex() const
1259     {
1260         return true;
1261     }
1262
1263     enum { nMedianTimeSpan=11 };
1264
1265     int64 GetMedianTimePast() const
1266     {
1267         int64 pmedian[nMedianTimeSpan];
1268         int64* pbegin = &pmedian[nMedianTimeSpan];
1269         int64* pend = &pmedian[nMedianTimeSpan];
1270
1271         const CBlockIndex* pindex = this;
1272         for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1273             *(--pbegin) = pindex->GetBlockTime();
1274
1275         std::sort(pbegin, pend);
1276         return pbegin[(pend - pbegin)/2];
1277     }
1278
1279     int64 GetMedianTime() const
1280     {
1281         const CBlockIndex* pindex = this;
1282         for (int i = 0; i < nMedianTimeSpan/2; i++)
1283         {
1284             if (!pindex->pnext)
1285                 return GetBlockTime();
1286             pindex = pindex->pnext;
1287         }
1288         return pindex->GetMedianTimePast();
1289     }
1290
1291     /**
1292      * Returns true if there are nRequired or more blocks of minVersion or above
1293      * in the last nToCheck blocks, starting at pstart and going backwards.
1294      */
1295     static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1296                                 unsigned int nRequired, unsigned int nToCheck);
1297
1298
1299     bool IsProofOfWork() const
1300     {
1301         return !(nFlags & BLOCK_PROOF_OF_STAKE);
1302     }
1303
1304     bool IsProofOfStake() const
1305     {
1306         return (nFlags & BLOCK_PROOF_OF_STAKE);
1307     }
1308
1309     void SetProofOfStake()
1310     {
1311         nFlags |= BLOCK_PROOF_OF_STAKE;
1312     }
1313
1314     unsigned int GetStakeEntropyBit() const
1315     {
1316         return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1317     }
1318
1319     bool SetStakeEntropyBit(unsigned int nEntropyBit)
1320     {
1321         if (nEntropyBit > 1)
1322             return false;
1323         nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1324         return true;
1325     }
1326
1327     bool GeneratedStakeModifier() const
1328     {
1329         return (nFlags & BLOCK_STAKE_MODIFIER);
1330     }
1331
1332     void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1333     {
1334         nStakeModifier = nModifier;
1335         if (fGeneratedStakeModifier)
1336             nFlags |= BLOCK_STAKE_MODIFIER;
1337     }
1338
1339     std::string ToString() const
1340     {
1341         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)",
1342             pprev, pnext, nFile, nBlockPos, nHeight,
1343             FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1344             GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1345             nStakeModifier, nStakeModifierChecksum, 
1346             hashProofOfStake.ToString().c_str(),
1347             prevoutStake.ToString().c_str(), nStakeTime,
1348             hashMerkleRoot.ToString().c_str(),
1349             GetBlockHash().ToString().c_str());
1350     }
1351
1352     void print() const
1353     {
1354         printf("%s\n", ToString().c_str());
1355     }
1356 };
1357
1358
1359
1360 /** Used to marshal pointers into hashes for db storage. */
1361 class CDiskBlockIndex : public CBlockIndex
1362 {
1363 public:
1364     uint256 hashPrev;
1365     uint256 hashNext;
1366
1367     CDiskBlockIndex()
1368     {
1369         hashPrev = 0;
1370         hashNext = 0;
1371     }
1372
1373     explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1374     {
1375         hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1376         hashNext = (pnext ? pnext->GetBlockHash() : 0);
1377     }
1378
1379     IMPLEMENT_SERIALIZE
1380     (
1381         if (!(nType & SER_GETHASH))
1382             READWRITE(nVersion);
1383
1384         READWRITE(hashNext);
1385         READWRITE(nFile);
1386         READWRITE(nBlockPos);
1387         READWRITE(nHeight);
1388         READWRITE(nMint);
1389         READWRITE(nMoneySupply);
1390         READWRITE(nFlags);
1391         READWRITE(nStakeModifier);
1392         if (IsProofOfStake())
1393         {
1394             READWRITE(prevoutStake);
1395             READWRITE(nStakeTime);
1396             READWRITE(hashProofOfStake);
1397         }
1398         else if (fRead)
1399         {
1400             const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1401             const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1402             const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1403         }
1404
1405         // block header
1406         READWRITE(this->nVersion);
1407         READWRITE(hashPrev);
1408         READWRITE(hashMerkleRoot);
1409         READWRITE(nTime);
1410         READWRITE(nBits);
1411         READWRITE(nNonce);
1412     )
1413
1414     uint256 GetBlockHash() const
1415     {
1416         CBlock block;
1417         block.nVersion        = nVersion;
1418         block.hashPrevBlock   = hashPrev;
1419         block.hashMerkleRoot  = hashMerkleRoot;
1420         block.nTime           = nTime;
1421         block.nBits           = nBits;
1422         block.nNonce          = nNonce;
1423         return block.GetHash();
1424     }
1425
1426
1427     std::string ToString() const
1428     {
1429         std::string str = "CDiskBlockIndex(";
1430         str += CBlockIndex::ToString();
1431         str += strprintf("\n                hashBlock=%s, hashPrev=%s, hashNext=%s)",
1432             GetBlockHash().ToString().c_str(),
1433             hashPrev.ToString().c_str(),
1434             hashNext.ToString().c_str());
1435         return str;
1436     }
1437
1438     void print() const
1439     {
1440         printf("%s\n", ToString().c_str());
1441     }
1442 };
1443
1444
1445
1446
1447
1448
1449
1450
1451 /** Describes a place in the block chain to another node such that if the
1452  * other node doesn't have the same branch, it can find a recent common trunk.
1453  * The further back it is, the further before the fork it may be.
1454  */
1455 class CBlockLocator
1456 {
1457 protected:
1458     std::vector<uint256> vHave;
1459 public:
1460
1461     CBlockLocator()
1462     {
1463     }
1464
1465     explicit CBlockLocator(const CBlockIndex* pindex)
1466     {
1467         Set(pindex);
1468     }
1469
1470     explicit CBlockLocator(uint256 hashBlock)
1471     {
1472         std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1473         if (mi != mapBlockIndex.end())
1474             Set((*mi).second);
1475     }
1476
1477     CBlockLocator(const std::vector<uint256>& vHaveIn)
1478     {
1479         vHave = vHaveIn;
1480     }
1481
1482     IMPLEMENT_SERIALIZE
1483     (
1484         if (!(nType & SER_GETHASH))
1485             READWRITE(nVersion);
1486         READWRITE(vHave);
1487     )
1488
1489     void SetNull()
1490     {
1491         vHave.clear();
1492     }
1493
1494     bool IsNull()
1495     {
1496         return vHave.empty();
1497     }
1498
1499     void Set(const CBlockIndex* pindex)
1500     {
1501         vHave.clear();
1502         int nStep = 1;
1503         while (pindex)
1504         {
1505             vHave.push_back(pindex->GetBlockHash());
1506
1507             // Exponentially larger steps back
1508             for (int i = 0; pindex && i < nStep; i++)
1509                 pindex = pindex->pprev;
1510             if (vHave.size() > 10)
1511                 nStep *= 2;
1512         }
1513         vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1514     }
1515
1516     int GetDistanceBack()
1517     {
1518         // Retrace how far back it was in the sender's branch
1519         int nDistance = 0;
1520         int nStep = 1;
1521         BOOST_FOREACH(const uint256& hash, vHave)
1522         {
1523             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1524             if (mi != mapBlockIndex.end())
1525             {
1526                 CBlockIndex* pindex = (*mi).second;
1527                 if (pindex->IsInMainChain())
1528                     return nDistance;
1529             }
1530             nDistance += nStep;
1531             if (nDistance > 10)
1532                 nStep *= 2;
1533         }
1534         return nDistance;
1535     }
1536
1537     CBlockIndex* GetBlockIndex()
1538     {
1539         // Find the first block the caller has in the main chain
1540         BOOST_FOREACH(const uint256& hash, vHave)
1541         {
1542             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1543             if (mi != mapBlockIndex.end())
1544             {
1545                 CBlockIndex* pindex = (*mi).second;
1546                 if (pindex->IsInMainChain())
1547                     return pindex;
1548             }
1549         }
1550         return pindexGenesisBlock;
1551     }
1552
1553     uint256 GetBlockHash()
1554     {
1555         // Find the first block the caller has in the main chain
1556         BOOST_FOREACH(const uint256& hash, vHave)
1557         {
1558             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1559             if (mi != mapBlockIndex.end())
1560             {
1561                 CBlockIndex* pindex = (*mi).second;
1562                 if (pindex->IsInMainChain())
1563                     return hash;
1564             }
1565         }
1566         return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1567     }
1568
1569     int GetHeight()
1570     {
1571         CBlockIndex* pindex = GetBlockIndex();
1572         if (!pindex)
1573             return 0;
1574         return pindex->nHeight;
1575     }
1576 };
1577
1578
1579
1580
1581
1582
1583
1584
1585 class CTxMemPool
1586 {
1587 public:
1588     mutable CCriticalSection cs;
1589     std::map<uint256, CTransaction> mapTx;
1590     std::map<COutPoint, CInPoint> mapNextTx;
1591
1592     bool accept(CTxDB& txdb, CTransaction &tx,
1593                 bool fCheckInputs, bool* pfMissingInputs);
1594     bool addUnchecked(const uint256& hash, CTransaction &tx);
1595     bool remove(CTransaction &tx);
1596     void clear();
1597     void queryHashes(std::vector<uint256>& vtxid);
1598
1599     unsigned long size()
1600     {
1601         LOCK(cs);
1602         return mapTx.size();
1603     }
1604
1605     bool exists(uint256 hash)
1606     {
1607         return (mapTx.count(hash) != 0);
1608     }
1609
1610     CTransaction& lookup(uint256 hash)
1611     {
1612         return mapTx[hash];
1613     }
1614 };
1615
1616 extern CTxMemPool mempool;
1617
1618 #endif