src/main.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2011 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file license.txt 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 "net.h"
  10 #include "key.h"
  11 #include "script.h"
  12 #include "db.h"
  13
  14 #include <list>
  15
  16 class CBlock;
  17 class CBlockIndex;
  18 class CWalletTx;
  19 class CWallet;
  20 class CKeyItem;
  21 class CReserveKey;
  22 class CWalletDB;
  23
  24 class CAddress;
  25 class CInv;
  26 class CRequestTracker;
  27 class CNode;
  28 class CBlockIndex;
  29
  30 static const int CLIENT_VERSION = 59900;
  31 static const bool VERSION_IS_BETA = true;
  32 extern const std::string CLIENT_NAME;
  33
  34 static const unsigned int MAX_BLOCK_SIZE = 1000000;
  35 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
  36 static const int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
  37 static const int64 COIN = 100000000;
  38 static const int64 CENT = 1000000;
  39 static const int64 MIN_TX_FEE = 50000;
  40 static const int64 MIN_RELAY_TX_FEE = 10000;
  41 static const int64 MAX_MONEY = 21000000 * COIN;
  42 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
  43 static const int COINBASE_MATURITY = 100;
  44 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
  45 static const int LOCKTIME_THRESHOLD = 500000000; // Tue Nov  5 00:53:20 1985 UTC
  46 #ifdef USE_UPNP
  47 static const int fHaveUPnP = true;
  48 #else
  49 static const int fHaveUPnP = false;
  50 #endif
  51
  52
  53
  54
  55
  56
  57 extern CCriticalSection cs_main;
  58 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
  59 extern uint256 hashGenesisBlock;
  60 extern CBlockIndex* pindexGenesisBlock;
  61 extern int nBestHeight;
  62 extern CBigNum bnBestChainWork;
  63 extern CBigNum bnBestInvalidWork;
  64 extern uint256 hashBestChain;
  65 extern CBlockIndex* pindexBest;
  66 extern unsigned int nTransactionsUpdated;
  67 extern double dHashesPerSec;
  68 extern int64 nHPSTimerStart;
  69 extern int64 nTimeBestReceived;
  70 extern CCriticalSection cs_setpwalletRegistered;
  71 extern std::set<CWallet*> setpwalletRegistered;
  72
  73 // Settings
  74 extern int fGenerateBitcoins;
  75 extern int64 nTransactionFee;
  76 extern int fLimitProcessors;
  77 extern int nLimitProcessors;
  78 extern int fMinimizeToTray;
  79 extern int fMinimizeOnClose;
  80 extern int fUseUPnP;
  81
  82
  83
  84
  85
  86 class CReserveKey;
  87 class CTxDB;
  88 class CTxIndex;
  89
  90 void RegisterWallet(CWallet* pwalletIn);
  91 void UnregisterWallet(CWallet* pwalletIn);
  92 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
  93 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
  94 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
  95 FILE* AppendBlockFile(unsigned int& nFileRet);
  96 bool LoadBlockIndex(bool fAllowNew=true);
  97 void PrintBlockTree();
  98 bool ProcessMessages(CNode* pfrom);
  99 bool SendMessages(CNode* pto, bool fSendTrickle);
 100 void GenerateBitcoins(bool fGenerate, CWallet* pwallet);
 101 CBlock* CreateNewBlock(CReserveKey& reservekey);
 102 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
 103 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
 104 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
 105 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
 106 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
 107 int GetNumBlocksOfPeers();
 108 bool IsInitialBlockDownload();
 109 std::string GetWarnings(std::string strFor);
 110
 111
 112
 113
 114
 115
 116
 117
 118
 119
 120
 121
 122 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
 123
 124 template<typename T>
 125 bool WriteSetting(const std::string& strKey, const T& value)
 126 {
 127     bool fOk = false;
 128     BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
 129     {
 130         std::string strWalletFile;
 131         if (!GetWalletFile(pwallet, strWalletFile))
 132             continue;
 133         fOk |= CWalletDB(strWalletFile).WriteSetting(strKey, value);
 134     }
 135     return fOk;
 136 }
 137
 138
 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 = -1; nBlockPos = 0; nTxPos = 0; }
 160     bool IsNull() const { return (nFile == -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     std::string ToString() const
 175     {
 176         if (IsNull())
 177             return strprintf("null");
 178         else
 179             return strprintf("(nFile=%d, nBlockPos=%d, nTxPos=%d)", nFile, nBlockPos, nTxPos);
 180     }
 181
 182     void print() const
 183     {
 184         printf("%s", ToString().c_str());
 185     }
 186 };
 187
 188
 189
 190
 191 class CInPoint
 192 {
 193 public:
 194     CTransaction* ptx;
 195     unsigned int n;
 196
 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); }
 201 };
 202
 203
 204
 205
 206 class COutPoint
 207 {
 208 public:
 209     uint256 hash;
 210     unsigned int n;
 211
 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); }
 217
 218     friend bool operator<(const COutPoint& a, const COutPoint& b)
 219     {
 220         return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
 221     }
 222
 223     friend bool operator==(const COutPoint& a, const COutPoint& b)
 224     {
 225         return (a.hash == b.hash && a.n == b.n);
 226     }
 227
 228     friend bool operator!=(const COutPoint& a, const COutPoint& b)
 229     {
 230         return !(a == b);
 231     }
 232
 233     std::string ToString() const
 234     {
 235         return strprintf("COutPoint(%s, %d)", hash.ToString().substr(0,10).c_str(), n);
 236     }
 237
 238     void print() const
 239     {
 240         printf("%s\n", ToString().c_str());
 241     }
 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 = UINT_MAX;
 262     }
 263
 264     explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=UINT_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=UINT_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 == UINT_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 ToString() const
 303     {
 304         std::string str;
 305         str += strprintf("CTxIn(");
 306         str += prevout.ToString();
 307         if (prevout.IsNull())
 308             str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
 309         else
 310             str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
 311         if (nSequence != UINT_MAX)
 312             str += strprintf(", nSequence=%u", nSequence);
 313         str += ")";
 314         return str;
 315     }
 316
 317     void print() const
 318     {
 319         printf("%s\n", ToString().c_str());
 320     }
 321 };
 322
 323
 324
 325
 326 //
 327 // An output of a transaction.  It contains the public key that the next input
 328 // must be able to sign with to claim it.
 329 //
 330 class CTxOut
 331 {
 332 public:
 333     int64 nValue;
 334     CScript scriptPubKey;
 335
 336     CTxOut()
 337     {
 338         SetNull();
 339     }
 340
 341     CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
 342     {
 343         nValue = nValueIn;
 344         scriptPubKey = scriptPubKeyIn;
 345     }
 346
 347     IMPLEMENT_SERIALIZE
 348     (
 349         READWRITE(nValue);
 350         READWRITE(scriptPubKey);
 351     )
 352
 353     void SetNull()
 354     {
 355         nValue = -1;
 356         scriptPubKey.clear();
 357     }
 358
 359     bool IsNull()
 360     {
 361         return (nValue == -1);
 362     }
 363
 364     uint256 GetHash() const
 365     {
 366         return SerializeHash(*this);
 367     }
 368
 369     friend bool operator==(const CTxOut& a, const CTxOut& b)
 370     {
 371         return (a.nValue       == b.nValue &&
 372                 a.scriptPubKey == b.scriptPubKey);
 373     }
 374
 375     friend bool operator!=(const CTxOut& a, const CTxOut& b)
 376     {
 377         return !(a == b);
 378     }
 379
 380     std::string ToString() const
 381     {
 382         if (scriptPubKey.size() < 6)
 383             return "CTxOut(error)";
 384         return strprintf("CTxOut(nValue=%"PRI64d".%08"PRI64d", scriptPubKey=%s)", nValue / COIN, nValue % COIN, scriptPubKey.ToString().substr(0,30).c_str());
 385     }
 386
 387     void print() const
 388     {
 389         printf("%s\n", ToString().c_str());
 390     }
 391 };
 392
 393
 394
 395
 396 //
 397 // The basic transaction that is broadcasted on the network and contained in
 398 // blocks.  A transaction can contain multiple inputs and outputs.
 399 //
 400 class CTransaction
 401 {
 402 public:
 403     int nVersion;
 404     std::vector<CTxIn> vin;
 405     std::vector<CTxOut> vout;
 406     unsigned int nLockTime;
 407
 408     // Denial-of-service detection:
 409     mutable int nDoS;
 410     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
 411
 412     CTransaction()
 413     {
 414         SetNull();
 415     }
 416
 417     IMPLEMENT_SERIALIZE
 418     (
 419         READWRITE(this->nVersion);
 420         nVersion = this->nVersion;
 421         READWRITE(vin);
 422         READWRITE(vout);
 423         READWRITE(nLockTime);
 424     )
 425
 426     void SetNull()
 427     {
 428         nVersion = 1;
 429         vin.clear();
 430         vout.clear();
 431         nLockTime = 0;
 432         nDoS = 0;  // Denial-of-service prevention
 433     }
 434
 435     bool IsNull() const
 436     {
 437         return (vin.empty() && vout.empty());
 438     }
 439
 440     uint256 GetHash() const
 441     {
 442         return SerializeHash(*this);
 443     }
 444
 445     bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
 446     {
 447         // Time based nLockTime implemented in 0.1.6
 448         if (nLockTime == 0)
 449             return true;
 450         if (nBlockHeight == 0)
 451             nBlockHeight = nBestHeight;
 452         if (nBlockTime == 0)
 453             nBlockTime = GetAdjustedTime();
 454         if ((int64)nLockTime < (nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
 455             return true;
 456         BOOST_FOREACH(const CTxIn& txin, vin)
 457             if (!txin.IsFinal())
 458                 return false;
 459         return true;
 460     }
 461
 462     bool IsNewerThan(const CTransaction& old) const
 463     {
 464         if (vin.size() != old.vin.size())
 465             return false;
 466         for (int i = 0; i < vin.size(); i++)
 467             if (vin[i].prevout != old.vin[i].prevout)
 468                 return false;
 469
 470         bool fNewer = false;
 471         unsigned int nLowest = UINT_MAX;
 472         for (int i = 0; i < vin.size(); i++)
 473         {
 474             if (vin[i].nSequence != old.vin[i].nSequence)
 475             {
 476                 if (vin[i].nSequence <= nLowest)
 477                 {
 478                     fNewer = false;
 479                     nLowest = vin[i].nSequence;
 480                 }
 481                 if (old.vin[i].nSequence < nLowest)
 482                 {
 483                     fNewer = true;
 484                     nLowest = old.vin[i].nSequence;
 485                 }
 486             }
 487         }
 488         return fNewer;
 489     }
 490
 491     bool IsCoinBase() const
 492     {
 493         return (vin.size() == 1 && vin[0].prevout.IsNull());
 494     }
 495
 496     bool IsStandard() const;
 497     bool AreInputsStandard(std::map<uint256, std::pair<CTxIndex, CTransaction> > mapInputs) const;
 498
 499     int64 GetValueOut() const
 500     {
 501         int64 nValueOut = 0;
 502         BOOST_FOREACH(const CTxOut& txout, vout)
 503         {
 504             nValueOut += txout.nValue;
 505             if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
 506                 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
 507         }
 508         return nValueOut;
 509     }
 510
 511     static bool AllowFree(double dPriority)
 512     {
 513         // Large (in bytes) low-priority (new, small-coin) transactions
 514         // need a fee.
 515         return dPriority > COIN * 144 / 250;
 516     }
 517
 518     int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=true, bool fForRelay=false) const
 519     {
 520         // Base fee is either MIN_TX_FEE or MIN_RELAY_TX_FEE
 521         int64 nBaseFee = fForRelay ? MIN_RELAY_TX_FEE : MIN_TX_FEE;
 522
 523         unsigned int nBytes = ::GetSerializeSize(*this, SER_NETWORK);
 524         unsigned int nNewBlockSize = nBlockSize + nBytes;
 525         int64 nMinFee = (1 + (int64)nBytes / 1000) * nBaseFee;
 526
 527         if (fAllowFree)
 528         {
 529             if (nBlockSize == 1)
 530             {
 531                 // Transactions under 10K are free
 532                 // (about 4500bc if made of 50bc inputs)
 533                 if (nBytes < 10000)
 534                     nMinFee = 0;
 535             }
 536             else
 537             {
 538                 // Free transaction area
 539                 if (nNewBlockSize < 27000)
 540                     nMinFee = 0;
 541             }
 542         }
 543
 544         // To limit dust spam, require MIN_TX_FEE/MIN_RELAY_TX_FEE if any output is less than 0.01
 545         if (nMinFee < nBaseFee)
 546             BOOST_FOREACH(const CTxOut& txout, vout)
 547                 if (txout.nValue < CENT)
 548                     nMinFee = nBaseFee;
 549
 550         // Raise the price as the block approaches full
 551         if (nBlockSize != 1 && nNewBlockSize >= MAX_BLOCK_SIZE_GEN/2)
 552         {
 553             if (nNewBlockSize >= MAX_BLOCK_SIZE_GEN)
 554                 return MAX_MONEY;
 555             nMinFee *= MAX_BLOCK_SIZE_GEN / (MAX_BLOCK_SIZE_GEN - nNewBlockSize);
 556         }
 557
 558         if (!MoneyRange(nMinFee))
 559             nMinFee = MAX_MONEY;
 560         return nMinFee;
 561     }
 562
 563
 564     bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
 565     {
 566         CAutoFile filein = OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb");
 567         if (!filein)
 568             return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
 569
 570         // Read transaction
 571         if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
 572             return error("CTransaction::ReadFromDisk() : fseek failed");
 573         filein >> *this;
 574
 575         // Return file pointer
 576         if (pfileRet)
 577         {
 578             if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
 579                 return error("CTransaction::ReadFromDisk() : second fseek failed");
 580             *pfileRet = filein.release();
 581         }
 582         return true;
 583     }
 584
 585     friend bool operator==(const CTransaction& a, const CTransaction& b)
 586     {
 587         return (a.nVersion  == b.nVersion &&
 588                 a.vin       == b.vin &&
 589                 a.vout      == b.vout &&
 590                 a.nLockTime == b.nLockTime);
 591     }
 592
 593     friend bool operator!=(const CTransaction& a, const CTransaction& b)
 594     {
 595         return !(a == b);
 596     }
 597
 598
 599     std::string ToString() const
 600     {
 601         std::string str;
 602         str += strprintf("CTransaction(hash=%s, ver=%d, vin.size=%d, vout.size=%d, nLockTime=%d)\n",
 603             GetHash().ToString().substr(0,10).c_str(),
 604             nVersion,
 605             vin.size(),
 606             vout.size(),
 607             nLockTime);
 608         for (int i = 0; i < vin.size(); i++)
 609             str += "    " + vin[i].ToString() + "\n";
 610         for (int i = 0; i < vout.size(); i++)
 611             str += "    " + vout[i].ToString() + "\n";
 612         return str;
 613     }
 614
 615     void print() const
 616     {
 617         printf("%s", ToString().c_str());
 618     }
 619
 620
 621     bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
 622     bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
 623     bool ReadFromDisk(COutPoint prevout);
 624     bool DisconnectInputs(CTxDB& txdb);
 625
 626     // Fetch from memory and/or disk. inputsRet keys are transaction hashes.
 627     bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
 628                      bool fBlock, bool fMiner, std::map<uint256, std::pair<CTxIndex, CTransaction> >& inputsRet);
 629     bool ConnectInputs(std::map<uint256, std::pair<CTxIndex, CTransaction> > inputs,
 630                        std::map<uint256, CTxIndex>& mapTestPool, CDiskTxPos posThisTx,
 631                        CBlockIndex* pindexBlock, int64& nFees, bool fBlock, bool fMiner, int& nSigOpsRet, int64 nMinFee=0);
 632     bool ClientConnectInputs();
 633     bool CheckTransaction() const;
 634     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
 635     bool AcceptToMemoryPool(bool fCheckInputs=true, bool* pfMissingInputs=NULL);
 636 protected:
 637     bool AddToMemoryPoolUnchecked();
 638 public:
 639     bool RemoveFromMemoryPool();
 640 };
 641
 642
 643
 644
 645
 646 //
 647 // A transaction with a merkle branch linking it to the block chain
 648 //
 649 class CMerkleTx : public CTransaction
 650 {
 651 public:
 652     uint256 hashBlock;
 653     std::vector<uint256> vMerkleBranch;
 654     int nIndex;
 655
 656     // memory only
 657     mutable char fMerkleVerified;
 658
 659
 660     CMerkleTx()
 661     {
 662         Init();
 663     }
 664
 665     CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
 666     {
 667         Init();
 668     }
 669
 670     void Init()
 671     {
 672         hashBlock = 0;
 673         nIndex = -1;
 674         fMerkleVerified = false;
 675     }
 676
 677
 678     IMPLEMENT_SERIALIZE
 679     (
 680         nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
 681         nVersion = this->nVersion;
 682         READWRITE(hashBlock);
 683         READWRITE(vMerkleBranch);
 684         READWRITE(nIndex);
 685     )
 686
 687
 688     int SetMerkleBranch(const CBlock* pblock=NULL);
 689     int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
 690     int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
 691     bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
 692     int GetBlocksToMaturity() const;
 693     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
 694     bool AcceptToMemoryPool();
 695 };
 696
 697
 698
 699
 700 //
 701 // A txdb record that contains the disk location of a transaction and the
 702 // locations of transactions that spend its outputs.  vSpent is really only
 703 // used as a flag, but having the location is very helpful for debugging.
 704 //
 705 class CTxIndex
 706 {
 707 public:
 708     CDiskTxPos pos;
 709     std::vector<CDiskTxPos> vSpent;
 710
 711     CTxIndex()
 712     {
 713         SetNull();
 714     }
 715
 716     CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
 717     {
 718         pos = posIn;
 719         vSpent.resize(nOutputs);
 720     }
 721
 722     IMPLEMENT_SERIALIZE
 723     (
 724         if (!(nType & SER_GETHASH))
 725             READWRITE(nVersion);
 726         READWRITE(pos);
 727         READWRITE(vSpent);
 728     )
 729
 730     void SetNull()
 731     {
 732         pos.SetNull();
 733         vSpent.clear();
 734     }
 735
 736     bool IsNull()
 737     {
 738         return pos.IsNull();
 739     }
 740
 741     friend bool operator==(const CTxIndex& a, const CTxIndex& b)
 742     {
 743         return (a.pos    == b.pos &&
 744                 a.vSpent == b.vSpent);
 745     }
 746
 747     friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
 748     {
 749         return !(a == b);
 750     }
 751     int GetDepthInMainChain() const;
 752
 753 };
 754
 755
 756
 757
 758
 759 //
 760 // Nodes collect new transactions into a block, hash them into a hash tree,
 761 // and scan through nonce values to make the block's hash satisfy proof-of-work
 762 // requirements.  When they solve the proof-of-work, they broadcast the block
 763 // to everyone and the block is added to the block chain.  The first transaction
 764 // in the block is a special one that creates a new coin owned by the creator
 765 // of the block.
 766 //
 767 // Blocks are appended to blk0001.dat files on disk.  Their location on disk
 768 // is indexed by CBlockIndex objects in memory.
 769 //
 770 class CBlock
 771 {
 772 public:
 773     // header
 774     int nVersion;
 775     uint256 hashPrevBlock;
 776     uint256 hashMerkleRoot;
 777     unsigned int nTime;
 778     unsigned int nBits;
 779     unsigned int nNonce;
 780
 781     // network and disk
 782     std::vector<CTransaction> vtx;
 783
 784     // memory only
 785     mutable std::vector<uint256> vMerkleTree;
 786
 787     // Denial-of-service detection:
 788     mutable int nDoS;
 789     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
 790
 791     CBlock()
 792     {
 793         SetNull();
 794     }
 795
 796     IMPLEMENT_SERIALIZE
 797     (
 798         READWRITE(this->nVersion);
 799         nVersion = this->nVersion;
 800         READWRITE(hashPrevBlock);
 801         READWRITE(hashMerkleRoot);
 802         READWRITE(nTime);
 803         READWRITE(nBits);
 804         READWRITE(nNonce);
 805
 806         // ConnectBlock depends on vtx being last so it can calculate offset
 807         if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
 808             READWRITE(vtx);
 809         else if (fRead)
 810             const_cast<CBlock*>(this)->vtx.clear();
 811     )
 812
 813     void SetNull()
 814     {
 815         nVersion = 1;
 816         hashPrevBlock = 0;
 817         hashMerkleRoot = 0;
 818         nTime = 0;
 819         nBits = 0;
 820         nNonce = 0;
 821         vtx.clear();
 822         vMerkleTree.clear();
 823         nDoS = 0;
 824     }
 825
 826     bool IsNull() const
 827     {
 828         return (nBits == 0);
 829     }
 830
 831     uint256 GetHash() const
 832     {
 833         return Hash(BEGIN(nVersion), END(nNonce));
 834     }
 835
 836     int64 GetBlockTime() const
 837     {
 838         return (int64)nTime;
 839     }
 840
 841
 842
 843     uint256 BuildMerkleTree() const
 844     {
 845         vMerkleTree.clear();
 846         BOOST_FOREACH(const CTransaction& tx, vtx)
 847             vMerkleTree.push_back(tx.GetHash());
 848         int j = 0;
 849         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
 850         {
 851             for (int i = 0; i < nSize; i += 2)
 852             {
 853                 int i2 = std::min(i+1, nSize-1);
 854                 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]),  END(vMerkleTree[j+i]),
 855                                            BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
 856             }
 857             j += nSize;
 858         }
 859         return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
 860     }
 861
 862     std::vector<uint256> GetMerkleBranch(int nIndex) const
 863     {
 864         if (vMerkleTree.empty())
 865             BuildMerkleTree();
 866         std::vector<uint256> vMerkleBranch;
 867         int j = 0;
 868         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
 869         {
 870             int i = std::min(nIndex^1, nSize-1);
 871             vMerkleBranch.push_back(vMerkleTree[j+i]);
 872             nIndex >>= 1;
 873             j += nSize;
 874         }
 875         return vMerkleBranch;
 876     }
 877
 878     static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
 879     {
 880         if (nIndex == -1)
 881             return 0;
 882         BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
 883         {
 884             if (nIndex & 1)
 885                 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
 886             else
 887                 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
 888             nIndex >>= 1;
 889         }
 890         return hash;
 891     }
 892
 893
 894     bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
 895     {
 896         // Open history file to append
 897         CAutoFile fileout = AppendBlockFile(nFileRet);
 898         if (!fileout)
 899             return error("CBlock::WriteToDisk() : AppendBlockFile failed");
 900
 901         // Write index header
 902         unsigned int nSize = fileout.GetSerializeSize(*this);
 903         fileout << FLATDATA(pchMessageStart) << nSize;
 904
 905         // Write block
 906         nBlockPosRet = ftell(fileout);
 907         if (nBlockPosRet == -1)
 908             return error("CBlock::WriteToDisk() : ftell failed");
 909         fileout << *this;
 910
 911         // Flush stdio buffers and commit to disk before returning
 912         fflush(fileout);
 913         if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
 914         {
 915 #ifdef WIN32
 916             _commit(_fileno(fileout));
 917 #else
 918             fsync(fileno(fileout));
 919 #endif
 920         }
 921
 922         return true;
 923     }
 924
 925     bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
 926     {
 927         SetNull();
 928
 929         // Open history file to read
 930         CAutoFile filein = OpenBlockFile(nFile, nBlockPos, "rb");
 931         if (!filein)
 932             return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
 933         if (!fReadTransactions)
 934             filein.nType |= SER_BLOCKHEADERONLY;
 935
 936         // Read block
 937         filein >> *this;
 938
 939         // Check the header
 940         if (!CheckProofOfWork(GetHash(), nBits))
 941             return error("CBlock::ReadFromDisk() : errors in block header");
 942
 943         return true;
 944     }
 945
 946
 947
 948     void print() const
 949     {
 950         printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d)\n",
 951             GetHash().ToString().substr(0,20).c_str(),
 952             nVersion,
 953             hashPrevBlock.ToString().substr(0,20).c_str(),
 954             hashMerkleRoot.ToString().substr(0,10).c_str(),
 955             nTime, nBits, nNonce,
 956             vtx.size());
 957         for (int i = 0; i < vtx.size(); i++)
 958         {
 959             printf("  ");
 960             vtx[i].print();
 961         }
 962         printf("  vMerkleTree: ");
 963         for (int i = 0; i < vMerkleTree.size(); i++)
 964             printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
 965         printf("\n");
 966     }
 967
 968
 969     bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
 970     bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex);
 971     bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
 972     bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
 973     bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
 974     bool CheckBlock() const;
 975     bool AcceptBlock();
 976 };
 977
 978
 979
 980
 981
 982
 983 //
 984 // The block chain is a tree shaped structure starting with the
 985 // genesis block at the root, with each block potentially having multiple
 986 // candidates to be the next block.  pprev and pnext link a path through the
 987 // main/longest chain.  A blockindex may have multiple pprev pointing back
 988 // to it, but pnext will only point forward to the longest branch, or will
 989 // be null if the block is not part of the longest chain.
 990 //
 991 class CBlockIndex
 992 {
 993 public:
 994     const uint256* phashBlock;
 995     CBlockIndex* pprev;
 996     CBlockIndex* pnext;
 997     unsigned int nFile;
 998     unsigned int nBlockPos;
 999     int nHeight;
1000     CBigNum bnChainWork;
1001
1002     // block header
1003     int nVersion;
1004     uint256 hashMerkleRoot;
1005     unsigned int nTime;
1006     unsigned int nBits;
1007     unsigned int nNonce;
1008
1009
1010     CBlockIndex()
1011     {
1012         phashBlock = NULL;
1013         pprev = NULL;
1014         pnext = NULL;
1015         nFile = 0;
1016         nBlockPos = 0;
1017         nHeight = 0;
1018         bnChainWork = 0;
1019
1020         nVersion       = 0;
1021         hashMerkleRoot = 0;
1022         nTime          = 0;
1023         nBits          = 0;
1024         nNonce         = 0;
1025     }
1026
1027     CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1028     {
1029         phashBlock = NULL;
1030         pprev = NULL;
1031         pnext = NULL;
1032         nFile = nFileIn;
1033         nBlockPos = nBlockPosIn;
1034         nHeight = 0;
1035         bnChainWork = 0;
1036
1037         nVersion       = block.nVersion;
1038         hashMerkleRoot = block.hashMerkleRoot;
1039         nTime          = block.nTime;
1040         nBits          = block.nBits;
1041         nNonce         = block.nNonce;
1042     }
1043
1044     CBlock GetBlockHeader() const
1045     {
1046         CBlock block;
1047         block.nVersion       = nVersion;
1048         if (pprev)
1049             block.hashPrevBlock = pprev->GetBlockHash();
1050         block.hashMerkleRoot = hashMerkleRoot;
1051         block.nTime          = nTime;
1052         block.nBits          = nBits;
1053         block.nNonce         = nNonce;
1054         return block;
1055     }
1056
1057     uint256 GetBlockHash() const
1058     {
1059         return *phashBlock;
1060     }
1061
1062     int64 GetBlockTime() const
1063     {
1064         return (int64)nTime;
1065     }
1066
1067     CBigNum GetBlockWork() const
1068     {
1069         CBigNum bnTarget;
1070         bnTarget.SetCompact(nBits);
1071         if (bnTarget <= 0)
1072             return 0;
1073         return (CBigNum(1)<<256) / (bnTarget+1);
1074     }
1075
1076     bool IsInMainChain() const
1077     {
1078         return (pnext || this == pindexBest);
1079     }
1080
1081     bool CheckIndex() const
1082     {
1083         return CheckProofOfWork(GetBlockHash(), nBits);
1084     }
1085
1086     bool EraseBlockFromDisk()
1087     {
1088         // Open history file
1089         CAutoFile fileout = OpenBlockFile(nFile, nBlockPos, "rb+");
1090         if (!fileout)
1091             return false;
1092
1093         // Overwrite with empty null block
1094         CBlock block;
1095         block.SetNull();
1096         fileout << block;
1097
1098         return true;
1099     }
1100
1101     enum { nMedianTimeSpan=11 };
1102
1103     int64 GetMedianTimePast() const
1104     {
1105         int64 pmedian[nMedianTimeSpan];
1106         int64* pbegin = &pmedian[nMedianTimeSpan];
1107         int64* pend = &pmedian[nMedianTimeSpan];
1108
1109         const CBlockIndex* pindex = this;
1110         for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1111             *(--pbegin) = pindex->GetBlockTime();
1112
1113         std::sort(pbegin, pend);
1114         return pbegin[(pend - pbegin)/2];
1115     }
1116
1117     int64 GetMedianTime() const
1118     {
1119         const CBlockIndex* pindex = this;
1120         for (int i = 0; i < nMedianTimeSpan/2; i++)
1121         {
1122             if (!pindex->pnext)
1123                 return GetBlockTime();
1124             pindex = pindex->pnext;
1125         }
1126         return pindex->GetMedianTimePast();
1127     }
1128
1129
1130
1131     std::string ToString() const
1132     {
1133         return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, nBlockPos=%-6d nHeight=%d, merkle=%s, hashBlock=%s)",
1134             pprev, pnext, nFile, nBlockPos, nHeight,
1135             hashMerkleRoot.ToString().substr(0,10).c_str(),
1136             GetBlockHash().ToString().substr(0,20).c_str());
1137     }
1138
1139     void print() const
1140     {
1141         printf("%s\n", ToString().c_str());
1142     }
1143 };
1144
1145
1146
1147 //
1148 // Used to marshal pointers into hashes for db storage.
1149 //
1150 class CDiskBlockIndex : public CBlockIndex
1151 {
1152 public:
1153     uint256 hashPrev;
1154     uint256 hashNext;
1155
1156     CDiskBlockIndex()
1157     {
1158         hashPrev = 0;
1159         hashNext = 0;
1160     }
1161
1162     explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1163     {
1164         hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1165         hashNext = (pnext ? pnext->GetBlockHash() : 0);
1166     }
1167
1168     IMPLEMENT_SERIALIZE
1169     (
1170         if (!(nType & SER_GETHASH))
1171             READWRITE(nVersion);
1172
1173         READWRITE(hashNext);
1174         READWRITE(nFile);
1175         READWRITE(nBlockPos);
1176         READWRITE(nHeight);
1177
1178         // block header
1179         READWRITE(this->nVersion);
1180         READWRITE(hashPrev);
1181         READWRITE(hashMerkleRoot);
1182         READWRITE(nTime);
1183         READWRITE(nBits);
1184         READWRITE(nNonce);
1185     )
1186
1187     uint256 GetBlockHash() const
1188     {
1189         CBlock block;
1190         block.nVersion        = nVersion;
1191         block.hashPrevBlock   = hashPrev;
1192         block.hashMerkleRoot  = hashMerkleRoot;
1193         block.nTime           = nTime;
1194         block.nBits           = nBits;
1195         block.nNonce          = nNonce;
1196         return block.GetHash();
1197     }
1198
1199
1200     std::string ToString() const
1201     {
1202         std::string str = "CDiskBlockIndex(";
1203         str += CBlockIndex::ToString();
1204         str += strprintf("\n                hashBlock=%s, hashPrev=%s, hashNext=%s)",
1205             GetBlockHash().ToString().c_str(),
1206             hashPrev.ToString().substr(0,20).c_str(),
1207             hashNext.ToString().substr(0,20).c_str());
1208         return str;
1209     }
1210
1211     void print() const
1212     {
1213         printf("%s\n", ToString().c_str());
1214     }
1215 };
1216
1217
1218
1219
1220
1221
1222
1223
1224 //
1225 // Describes a place in the block chain to another node such that if the
1226 // other node doesn't have the same branch, it can find a recent common trunk.
1227 // The further back it is, the further before the fork it may be.
1228 //
1229 class CBlockLocator
1230 {
1231 protected:
1232     std::vector<uint256> vHave;
1233 public:
1234
1235     CBlockLocator()
1236     {
1237     }
1238
1239     explicit CBlockLocator(const CBlockIndex* pindex)
1240     {
1241         Set(pindex);
1242     }
1243
1244     explicit CBlockLocator(uint256 hashBlock)
1245     {
1246         std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1247         if (mi != mapBlockIndex.end())
1248             Set((*mi).second);
1249     }
1250
1251     CBlockLocator(const std::vector<uint256>& vHaveIn)
1252     {
1253         vHave = vHaveIn;
1254     }
1255
1256     IMPLEMENT_SERIALIZE
1257     (
1258         if (!(nType & SER_GETHASH))
1259             READWRITE(nVersion);
1260         READWRITE(vHave);
1261     )
1262
1263     void SetNull()
1264     {
1265         vHave.clear();
1266     }
1267
1268     bool IsNull()
1269     {
1270         return vHave.empty();
1271     }
1272
1273     void Set(const CBlockIndex* pindex)
1274     {
1275         vHave.clear();
1276         int nStep = 1;
1277         while (pindex)
1278         {
1279             vHave.push_back(pindex->GetBlockHash());
1280
1281             // Exponentially larger steps back
1282             for (int i = 0; pindex && i < nStep; i++)
1283                 pindex = pindex->pprev;
1284             if (vHave.size() > 10)
1285                 nStep *= 2;
1286         }
1287         vHave.push_back(hashGenesisBlock);
1288     }
1289
1290     int GetDistanceBack()
1291     {
1292         // Retrace how far back it was in the sender's branch
1293         int nDistance = 0;
1294         int nStep = 1;
1295         BOOST_FOREACH(const uint256& hash, vHave)
1296         {
1297             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1298             if (mi != mapBlockIndex.end())
1299             {
1300                 CBlockIndex* pindex = (*mi).second;
1301                 if (pindex->IsInMainChain())
1302                     return nDistance;
1303             }
1304             nDistance += nStep;
1305             if (nDistance > 10)
1306                 nStep *= 2;
1307         }
1308         return nDistance;
1309     }
1310
1311     CBlockIndex* GetBlockIndex()
1312     {
1313         // Find the first block the caller has in the main chain
1314         BOOST_FOREACH(const uint256& hash, vHave)
1315         {
1316             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1317             if (mi != mapBlockIndex.end())
1318             {
1319                 CBlockIndex* pindex = (*mi).second;
1320                 if (pindex->IsInMainChain())
1321                     return pindex;
1322             }
1323         }
1324         return pindexGenesisBlock;
1325     }
1326
1327     uint256 GetBlockHash()
1328     {
1329         // Find the first block the caller has in the main chain
1330         BOOST_FOREACH(const uint256& hash, vHave)
1331         {
1332             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1333             if (mi != mapBlockIndex.end())
1334             {
1335                 CBlockIndex* pindex = (*mi).second;
1336                 if (pindex->IsInMainChain())
1337                     return hash;
1338             }
1339         }
1340         return hashGenesisBlock;
1341     }
1342
1343     int GetHeight()
1344     {
1345         CBlockIndex* pindex = GetBlockIndex();
1346         if (!pindex)
1347             return 0;
1348         return pindex->nHeight;
1349     }
1350 };
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360 //
1361 // Alerts are for notifying old versions if they become too obsolete and
1362 // need to upgrade.  The message is displayed in the status bar.
1363 // Alert messages are broadcast as a vector of signed data.  Unserializing may
1364 // not read the entire buffer if the alert is for a newer version, but older
1365 // versions can still relay the original data.
1366 //
1367 class CUnsignedAlert
1368 {
1369 public:
1370     int nVersion;
1371     int64 nRelayUntil;      // when newer nodes stop relaying to newer nodes
1372     int64 nExpiration;
1373     int nID;
1374     int nCancel;
1375     std::set<int> setCancel;
1376     int nMinVer;            // lowest version inclusive
1377     int nMaxVer;            // highest version inclusive
1378     std::set<std::string> setSubVer;  // empty matches all
1379     int nPriority;
1380
1381     // Actions
1382     std::string strComment;
1383     std::string strStatusBar;
1384     std::string strReserved;
1385
1386     IMPLEMENT_SERIALIZE
1387     (
1388         READWRITE(this->nVersion);
1389         nVersion = this->nVersion;
1390         READWRITE(nRelayUntil);
1391         READWRITE(nExpiration);
1392         READWRITE(nID);
1393         READWRITE(nCancel);
1394         READWRITE(setCancel);
1395         READWRITE(nMinVer);
1396         READWRITE(nMaxVer);
1397         READWRITE(setSubVer);
1398         READWRITE(nPriority);
1399
1400         READWRITE(strComment);
1401         READWRITE(strStatusBar);
1402         READWRITE(strReserved);
1403     )
1404
1405     void SetNull()
1406     {
1407         nVersion = 1;
1408         nRelayUntil = 0;
1409         nExpiration = 0;
1410         nID = 0;
1411         nCancel = 0;
1412         setCancel.clear();
1413         nMinVer = 0;
1414         nMaxVer = 0;
1415         setSubVer.clear();
1416         nPriority = 0;
1417
1418         strComment.clear();
1419         strStatusBar.clear();
1420         strReserved.clear();
1421     }
1422
1423     std::string ToString() const
1424     {
1425         std::string strSetCancel;
1426         BOOST_FOREACH(int n, setCancel)
1427             strSetCancel += strprintf("%d ", n);
1428         std::string strSetSubVer;
1429         BOOST_FOREACH(std::string str, setSubVer)
1430             strSetSubVer += "\"" + str + "\" ";
1431         return strprintf(
1432                 "CAlert(\n"
1433                 "    nVersion     = %d\n"
1434                 "    nRelayUntil  = %"PRI64d"\n"
1435                 "    nExpiration  = %"PRI64d"\n"
1436                 "    nID          = %d\n"
1437                 "    nCancel      = %d\n"
1438                 "    setCancel    = %s\n"
1439                 "    nMinVer      = %d\n"
1440                 "    nMaxVer      = %d\n"
1441                 "    setSubVer    = %s\n"
1442                 "    nPriority    = %d\n"
1443                 "    strComment   = \"%s\"\n"
1444                 "    strStatusBar = \"%s\"\n"
1445                 ")\n",
1446             nVersion,
1447             nRelayUntil,
1448             nExpiration,
1449             nID,
1450             nCancel,
1451             strSetCancel.c_str(),
1452             nMinVer,
1453             nMaxVer,
1454             strSetSubVer.c_str(),
1455             nPriority,
1456             strComment.c_str(),
1457             strStatusBar.c_str());
1458     }
1459
1460     void print() const
1461     {
1462         printf("%s", ToString().c_str());
1463     }
1464 };
1465
1466 class CAlert : public CUnsignedAlert
1467 {
1468 public:
1469     std::vector<unsigned char> vchMsg;
1470     std::vector<unsigned char> vchSig;
1471
1472     CAlert()
1473     {
1474         SetNull();
1475     }
1476
1477     IMPLEMENT_SERIALIZE
1478     (
1479         READWRITE(vchMsg);
1480         READWRITE(vchSig);
1481     )
1482
1483     void SetNull()
1484     {
1485         CUnsignedAlert::SetNull();
1486         vchMsg.clear();
1487         vchSig.clear();
1488     }
1489
1490     bool IsNull() const
1491     {
1492         return (nExpiration == 0);
1493     }
1494
1495     uint256 GetHash() const
1496     {
1497         return SerializeHash(*this);
1498     }
1499
1500     bool IsInEffect() const
1501     {
1502         return (GetAdjustedTime() < nExpiration);
1503     }
1504
1505     bool Cancels(const CAlert& alert) const
1506     {
1507         if (!IsInEffect())
1508             return false; // this was a no-op before 31403
1509         return (alert.nID <= nCancel || setCancel.count(alert.nID));
1510     }
1511
1512     bool AppliesTo(int nVersion, std::string strSubVerIn) const
1513     {
1514         // TODO: rework for client-version-embedded-in-strSubVer ?
1515         return (IsInEffect() &&
1516                 nMinVer <= nVersion && nVersion <= nMaxVer &&
1517                 (setSubVer.empty() || setSubVer.count(strSubVerIn)));
1518     }
1519
1520     bool AppliesToMe() const
1521     {
1522         return AppliesTo(PROTOCOL_VERSION, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<std::string>()));
1523     }
1524
1525     bool RelayTo(CNode* pnode) const
1526     {
1527         if (!IsInEffect())
1528             return false;
1529         // returns true if wasn't already contained in the set
1530         if (pnode->setKnown.insert(GetHash()).second)
1531         {
1532             if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
1533                 AppliesToMe() ||
1534                 GetAdjustedTime() < nRelayUntil)
1535             {
1536                 pnode->PushMessage("alert", *this);
1537                 return true;
1538             }
1539         }
1540         return false;
1541     }
1542
1543     bool CheckSignature()
1544     {
1545         CKey key;
1546         if (!key.SetPubKey(ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284")))
1547             return error("CAlert::CheckSignature() : SetPubKey failed");
1548         if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
1549             return error("CAlert::CheckSignature() : verify signature failed");
1550
1551         // Now unserialize the data
1552         CDataStream sMsg(vchMsg);
1553         sMsg >> *(CUnsignedAlert*)this;
1554         return true;
1555     }
1556
1557     bool ProcessAlert();
1558 };
1559
1560 #endif