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