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 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
 390
 391
 392 //
 393 // The basic transaction that is broadcasted on the network and contained in
 394 // blocks.  A transaction can contain multiple inputs and outputs.
 395 //
 396 class CTransaction
 397 {
 398 public:
 399     int nVersion;
 400     std::vector<CTxIn> vin;
 401     std::vector<CTxOut> vout;
 402     unsigned int nLockTime;
 403
 404
 405     CTransaction()
 406     {
 407         SetNull();
 408     }
 409
 410     IMPLEMENT_SERIALIZE
 411     (
 412         READWRITE(this->nVersion);
 413         nVersion = this->nVersion;
 414         READWRITE(vin);
 415         READWRITE(vout);
 416         READWRITE(nLockTime);
 417     )
 418
 419     void SetNull()
 420     {
 421         nVersion = 1;
 422         vin.clear();
 423         vout.clear();
 424         nLockTime = 0;
 425     }
 426
 427     bool IsNull() const
 428     {
 429         return (vin.empty() && vout.empty());
 430     }
 431
 432     uint256 GetHash() const
 433     {
 434         return SerializeHash(*this);
 435     }
 436
 437     bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
 438     {
 439         // Time based nLockTime implemented in 0.1.6
 440         if (nLockTime == 0)
 441             return true;
 442         if (nBlockHeight == 0)
 443             nBlockHeight = nBestHeight;
 444         if (nBlockTime == 0)
 445             nBlockTime = GetAdjustedTime();
 446         if ((int64)nLockTime < (nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
 447             return true;
 448         BOOST_FOREACH(const CTxIn& txin, vin)
 449             if (!txin.IsFinal())
 450                 return false;
 451         return true;
 452     }
 453
 454     bool IsNewerThan(const CTransaction& old) const
 455     {
 456         if (vin.size() != old.vin.size())
 457             return false;
 458         for (unsigned int i = 0; i < vin.size(); i++)
 459             if (vin[i].prevout != old.vin[i].prevout)
 460                 return false;
 461
 462         bool fNewer = false;
 463         unsigned int nLowest = UINT_MAX;
 464         for (unsigned int i = 0; i < vin.size(); i++)
 465         {
 466             if (vin[i].nSequence != old.vin[i].nSequence)
 467             {
 468                 if (vin[i].nSequence <= nLowest)
 469                 {
 470                     fNewer = false;
 471                     nLowest = vin[i].nSequence;
 472                 }
 473                 if (old.vin[i].nSequence < nLowest)
 474                 {
 475                     fNewer = true;
 476                     nLowest = old.vin[i].nSequence;
 477                 }
 478             }
 479         }
 480         return fNewer;
 481     }
 482
 483     bool IsCoinBase() const
 484     {
 485         return (vin.size() == 1 && vin[0].prevout.IsNull());
 486     }
 487
 488     int GetSigOpCount() const
 489     {
 490         int n = 0;
 491         BOOST_FOREACH(const CTxIn& txin, vin)
 492             n += txin.scriptSig.GetSigOpCount();
 493         BOOST_FOREACH(const CTxOut& txout, vout)
 494             n += txout.scriptPubKey.GetSigOpCount();
 495         return n;
 496     }
 497
 498     /** Count ECDSA signature operations in pay-to-script-hash inputs.
 499         This is a better measure of how expensive it is to process this transaction.
 500
 501         @param[in] mapInputsMap of previous transactions that have outputs we're spending
 502         @return maximum number of sigops required to validate this transaction's inputs
 503         @see CTransaction::FetchInputs
 504     */
 505     int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
 506
 507     bool IsStandard() const
 508     {
 509         BOOST_FOREACH(const CTxIn& txin, vin)
 510             if (!txin.scriptSig.IsPushOnly())
 511                 return error("nonstandard txin: %s", txin.scriptSig.ToString().c_str());
 512         BOOST_FOREACH(const CTxOut& txout, vout)
 513             if (!::IsStandard(txout.scriptPubKey))
 514                 return error("nonstandard txout: %s", txout.scriptPubKey.ToString().c_str());
 515         return true;
 516     }
 517
 518     int64 GetValueOut() const
 519     {
 520         int64 nValueOut = 0;
 521         BOOST_FOREACH(const CTxOut& txout, vout)
 522         {
 523             nValueOut += txout.nValue;
 524             if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
 525                 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
 526         }
 527         return nValueOut;
 528     }
 529
 530     /** Amount of bitcoins coming in to this transaction
 531         Note that lightweight clients may not know anything besides the hash of previous transactions,
 532         so may not be able to calculate this.
 533
 534         @param[in] mapInputsMap of previous transactions that have outputs we're spending
 535         @returnSum of value of all inputs (scriptSigs)
 536         @see CTransaction::FetchInputs
 537     */
 538     int64 GetValueIn(const MapPrevTx& mapInputs) const;
 539
 540     static bool AllowFree(double dPriority)
 541     {
 542         // Large (in bytes) low-priority (new, small-coin) transactions
 543         // need a fee.
 544         return dPriority > COIN * 144 / 250;
 545     }
 546
 547     int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=true, bool fForRelay=false) const
 548     {
 549         // Base fee is either MIN_TX_FEE or MIN_RELAY_TX_FEE
 550         int64 nBaseFee = fForRelay ? MIN_RELAY_TX_FEE : MIN_TX_FEE;
 551
 552         unsigned int nBytes = ::GetSerializeSize(*this, SER_NETWORK);
 553         unsigned int nNewBlockSize = nBlockSize + nBytes;
 554         int64 nMinFee = (1 + (int64)nBytes / 1000) * nBaseFee;
 555
 556         if (fAllowFree)
 557         {
 558             if (nBlockSize == 1)
 559             {
 560                 // Transactions under 10K are free
 561                 // (about 4500bc if made of 50bc inputs)
 562                 if (nBytes < 10000)
 563                     nMinFee = 0;
 564             }
 565             else
 566             {
 567                 // Free transaction area
 568                 if (nNewBlockSize < 27000)
 569                     nMinFee = 0;
 570             }
 571         }
 572
 573         // To limit dust spam, require MIN_TX_FEE/MIN_RELAY_TX_FEE if any output is less than 0.01
 574         if (nMinFee < nBaseFee)
 575         {
 576             BOOST_FOREACH(const CTxOut& txout, vout)
 577                 if (txout.nValue < CENT)
 578                     nMinFee = nBaseFee;
 579         }
 580
 581         // Raise the price as the block approaches full
 582         if (nBlockSize != 1 && nNewBlockSize >= MAX_BLOCK_SIZE_GEN/2)
 583         {
 584             if (nNewBlockSize >= MAX_BLOCK_SIZE_GEN)
 585                 return MAX_MONEY;
 586             nMinFee *= MAX_BLOCK_SIZE_GEN / (MAX_BLOCK_SIZE_GEN - nNewBlockSize);
 587         }
 588
 589         if (!MoneyRange(nMinFee))
 590             nMinFee = MAX_MONEY;
 591         return nMinFee;
 592     }
 593
 594
 595     bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
 596     {
 597         CAutoFile filein = OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb");
 598         if (!filein)
 599             return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
 600
 601         // Read transaction
 602         if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
 603             return error("CTransaction::ReadFromDisk() : fseek failed");
 604         filein >> *this;
 605
 606         // Return file pointer
 607         if (pfileRet)
 608         {
 609             if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
 610                 return error("CTransaction::ReadFromDisk() : second fseek failed");
 611             *pfileRet = filein.release();
 612         }
 613         return true;
 614     }
 615
 616     friend bool operator==(const CTransaction& a, const CTransaction& b)
 617     {
 618         return (a.nVersion  == b.nVersion &&
 619                 a.vin       == b.vin &&
 620                 a.vout      == b.vout &&
 621                 a.nLockTime == b.nLockTime);
 622     }
 623
 624     friend bool operator!=(const CTransaction& a, const CTransaction& b)
 625     {
 626         return !(a == b);
 627     }
 628
 629
 630     std::string ToString() const
 631     {
 632         std::string str;
 633         str += strprintf("CTransaction(hash=%s, ver=%d, vin.size=%d, vout.size=%d, nLockTime=%d)\n",
 634             GetHash().ToString().substr(0,10).c_str(),
 635             nVersion,
 636             vin.size(),
 637             vout.size(),
 638             nLockTime);
 639         for (unsigned int i = 0; i < vin.size(); i++)
 640             str += "    " + vin[i].ToString() + "\n";
 641         for (unsigned int i = 0; i < vout.size(); i++)
 642             str += "    " + vout[i].ToString() + "\n";
 643         return str;
 644     }
 645
 646     void print() const
 647     {
 648         printf("%s", ToString().c_str());
 649     }
 650
 651
 652     bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
 653     bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
 654     bool ReadFromDisk(COutPoint prevout);
 655     bool DisconnectInputs(CTxDB& txdb);
 656
 657     /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
 658
 659      @param[in] txdb    Transaction database
 660      @param[in] mapTestPool     List of pending changes to the transaction index database
 661      @param[in] fBlock  True if being called to add a new best-block to the chain
 662      @param[in] fMiner  True if being called by CreateNewBlock
 663      @param[out] inputsRet      Pointers to this transaction's inputs
 664      @param[out] fInvalid       returns true if transaction is invalid
 665      @return    Returns true if all inputs are in txdb or mapTestPool
 666      */
 667     bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
 668                      bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
 669
 670     /** Sanity check previous transactions, then, if all checks succeed,
 671         mark them as spent by this transaction.
 672
 673         @param[in] inputsPrevious transactions (from FetchInputs)
 674         @param[out] mapTestPoolKeeps track of inputs that need to be updated on disk
 675         @param[in] posThisTxPosition of this transaction on disk
 676         @param[in] pindexBlock
 677         @param[in] fBlock  true if called from ConnectBlock
 678         @param[in] fMiner  true if called from CreateNewBlock
 679         @param[in] fStrictPayToScriptHash  true if fully validating p2sh transactions
 680         @return Returns true if all checks succeed
 681     */
 682     bool ConnectInputs(MapPrevTx inputs,
 683                        std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
 684                        const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
 685     bool ClientConnectInputs();
 686     bool CheckTransaction() const;
 687     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
 688     bool AcceptToMemoryPool(bool fCheckInputs=true, bool* pfMissingInputs=NULL);
 689 protected:
 690     const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
 691     bool AddToMemoryPoolUnchecked();
 692 public:
 693     bool RemoveFromMemoryPool();
 694 };
 695
 696
 697
 698
 699
 700 //
 701 // A transaction with a merkle branch linking it to the block chain
 702 //
 703 class CMerkleTx : public CTransaction
 704 {
 705 public:
 706     uint256 hashBlock;
 707     std::vector<uint256> vMerkleBranch;
 708     int nIndex;
 709
 710     // memory only
 711     mutable char fMerkleVerified;
 712
 713
 714     CMerkleTx()
 715     {
 716         Init();
 717     }
 718
 719     CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
 720     {
 721         Init();
 722     }
 723
 724     void Init()
 725     {
 726         hashBlock = 0;
 727         nIndex = -1;
 728         fMerkleVerified = false;
 729     }
 730
 731
 732     IMPLEMENT_SERIALIZE
 733     (
 734         nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
 735         nVersion = this->nVersion;
 736         READWRITE(hashBlock);
 737         READWRITE(vMerkleBranch);
 738         READWRITE(nIndex);
 739     )
 740
 741
 742     int SetMerkleBranch(const CBlock* pblock=NULL);
 743     int GetDepthInMainChain(int& nHeightRet) const;
 744     int GetDepthInMainChain() const { int nHeight; return GetDepthInMainChain(nHeight); }
 745     bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
 746     int GetBlocksToMaturity() const;
 747     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
 748     bool AcceptToMemoryPool();
 749 };
 750
 751
 752
 753
 754 //
 755 // A txdb record that contains the disk location of a transaction and the
 756 // locations of transactions that spend its outputs.  vSpent is really only
 757 // used as a flag, but having the location is very helpful for debugging.
 758 //
 759 class CTxIndex
 760 {
 761 public:
 762     CDiskTxPos pos;
 763     std::vector<CDiskTxPos> vSpent;
 764
 765     CTxIndex()
 766     {
 767         SetNull();
 768     }
 769
 770     CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
 771     {
 772         pos = posIn;
 773         vSpent.resize(nOutputs);
 774     }
 775
 776     IMPLEMENT_SERIALIZE
 777     (
 778         if (!(nType & SER_GETHASH))
 779             READWRITE(nVersion);
 780         READWRITE(pos);
 781         READWRITE(vSpent);
 782     )
 783
 784     void SetNull()
 785     {
 786         pos.SetNull();
 787         vSpent.clear();
 788     }
 789
 790     bool IsNull()
 791     {
 792         return pos.IsNull();
 793     }
 794
 795     friend bool operator==(const CTxIndex& a, const CTxIndex& b)
 796     {
 797         return (a.pos    == b.pos &&
 798                 a.vSpent == b.vSpent);
 799     }
 800
 801     friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
 802     {
 803         return !(a == b);
 804     }
 805     int GetDepthInMainChain() const;
 806 };
 807
 808
 809
 810
 811
 812 //
 813 // Nodes collect new transactions into a block, hash them into a hash tree,
 814 // and scan through nonce values to make the block's hash satisfy proof-of-work
 815 // requirements.  When they solve the proof-of-work, they broadcast the block
 816 // to everyone and the block is added to the block chain.  The first transaction
 817 // in the block is a special one that creates a new coin owned by the creator
 818 // of the block.
 819 //
 820 // Blocks are appended to blk0001.dat files on disk.  Their location on disk
 821 // is indexed by CBlockIndex objects in memory.
 822 //
 823 class CBlock
 824 {
 825 public:
 826     // header
 827     int nVersion;
 828     uint256 hashPrevBlock;
 829     uint256 hashMerkleRoot;
 830     unsigned int nTime;
 831     unsigned int nBits;
 832     unsigned int nNonce;
 833
 834     // network and disk
 835     std::vector<CTransaction> vtx;
 836
 837     // memory only
 838     mutable std::vector<uint256> vMerkleTree;
 839
 840
 841     CBlock()
 842     {
 843         SetNull();
 844     }
 845
 846     IMPLEMENT_SERIALIZE
 847     (
 848         READWRITE(this->nVersion);
 849         nVersion = this->nVersion;
 850         READWRITE(hashPrevBlock);
 851         READWRITE(hashMerkleRoot);
 852         READWRITE(nTime);
 853         READWRITE(nBits);
 854         READWRITE(nNonce);
 855
 856         // ConnectBlock depends on vtx being last so it can calculate offset
 857         if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
 858             READWRITE(vtx);
 859         else if (fRead)
 860             const_cast<CBlock*>(this)->vtx.clear();
 861     )
 862
 863     void SetNull()
 864     {
 865         nVersion = 1;
 866         hashPrevBlock = 0;
 867         hashMerkleRoot = 0;
 868         nTime = 0;
 869         nBits = 0;
 870         nNonce = 0;
 871         vtx.clear();
 872         vMerkleTree.clear();
 873     }
 874
 875     bool IsNull() const
 876     {
 877         return (nBits == 0);
 878     }
 879
 880     uint256 GetHash() const
 881     {
 882         return Hash(BEGIN(nVersion), END(nNonce));
 883     }
 884
 885     int64 GetBlockTime() const
 886     {
 887         return (int64)nTime;
 888     }
 889
 890     int GetSigOpCount() const
 891     {
 892         int n = 0;
 893         BOOST_FOREACH(const CTransaction& tx, vtx)
 894             n += tx.GetSigOpCount();
 895         return n;
 896     }
 897
 898     void UpdateTime(const CBlockIndex* pindexPrev);
 899
 900
 901     uint256 BuildMerkleTree() const
 902     {
 903         vMerkleTree.clear();
 904         BOOST_FOREACH(const CTransaction& tx, vtx)
 905             vMerkleTree.push_back(tx.GetHash());
 906         int j = 0;
 907         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
 908         {
 909             for (int i = 0; i < nSize; i += 2)
 910             {
 911                 int i2 = std::min(i+1, nSize-1);
 912                 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]),  END(vMerkleTree[j+i]),
 913                                            BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
 914             }
 915             j += nSize;
 916         }
 917         return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
 918     }
 919
 920     std::vector<uint256> GetMerkleBranch(int nIndex) const
 921     {
 922         if (vMerkleTree.empty())
 923             BuildMerkleTree();
 924         std::vector<uint256> vMerkleBranch;
 925         int j = 0;
 926         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
 927         {
 928             int i = std::min(nIndex^1, nSize-1);
 929             vMerkleBranch.push_back(vMerkleTree[j+i]);
 930             nIndex >>= 1;
 931             j += nSize;
 932         }
 933         return vMerkleBranch;
 934     }
 935
 936     static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
 937     {
 938         if (nIndex == -1)
 939             return 0;
 940         BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
 941         {
 942             if (nIndex & 1)
 943                 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
 944             else
 945                 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
 946             nIndex >>= 1;
 947         }
 948         return hash;
 949     }
 950
 951
 952     bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
 953     {
 954         // Open history file to append
 955         CAutoFile fileout = AppendBlockFile(nFileRet);
 956         if (!fileout)
 957             return error("CBlock::WriteToDisk() : AppendBlockFile failed");
 958
 959         // Write index header
 960         unsigned int nSize = fileout.GetSerializeSize(*this);
 961         fileout << FLATDATA(pchMessageStart) << nSize;
 962
 963         // Write block
 964         nBlockPosRet = ftell(fileout);
 965         if (nBlockPosRet == -1)
 966             return error("CBlock::WriteToDisk() : ftell failed");
 967         fileout << *this;
 968
 969         // Flush stdio buffers and commit to disk before returning
 970         fflush(fileout);
 971         if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
 972         {
 973 #ifdef __WXMSW__
 974             _commit(_fileno(fileout));
 975 #else
 976             fsync(fileno(fileout));
 977 #endif
 978         }
 979
 980         return true;
 981     }
 982
 983     bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
 984     {
 985         SetNull();
 986
 987         // Open history file to read
 988         CAutoFile filein = OpenBlockFile(nFile, nBlockPos, "rb");
 989         if (!filein)
 990             return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
 991         if (!fReadTransactions)
 992             filein.nType |= SER_BLOCKHEADERONLY;
 993
 994         // Read block
 995         filein >> *this;
 996
 997         // Check the header
 998         if (!CheckProofOfWork(GetHash(), nBits))
 999             return error("CBlock::ReadFromDisk() : errors in block header");
1000
1001         return true;
1002     }
1003
1004
1005
1006     void print() const
1007     {
1008         printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d)\n",
1009             GetHash().ToString().substr(0,20).c_str(),
1010             nVersion,
1011             hashPrevBlock.ToString().substr(0,20).c_str(),
1012             hashMerkleRoot.ToString().substr(0,10).c_str(),
1013             nTime, nBits, nNonce,
1014             vtx.size());
1015         for (unsigned int i = 0; i < vtx.size(); i++)
1016         {
1017             printf("  ");
1018             vtx[i].print();
1019         }
1020         printf("  vMerkleTree: ");
1021         for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1022             printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1023         printf("\n");
1024     }
1025
1026
1027     bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1028     bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1029     bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1030     bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1031     bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1032     bool CheckBlock() const;
1033     bool AcceptBlock();
1034 };
1035
1036
1037
1038
1039
1040
1041 //
1042 // The block chain is a tree shaped structure starting with the
1043 // genesis block at the root, with each block potentially having multiple
1044 // candidates to be the next block.  pprev and pnext link a path through the
1045 // main/longest chain.  A blockindex may have multiple pprev pointing back
1046 // to it, but pnext will only point forward to the longest branch, or will
1047 // be null if the block is not part of the longest chain.
1048 //
1049 class CBlockIndex
1050 {
1051 public:
1052     const uint256* phashBlock;
1053     CBlockIndex* pprev;
1054     CBlockIndex* pnext;
1055     unsigned int nFile;
1056     unsigned int nBlockPos;
1057     int nHeight;
1058     CBigNum bnChainWork;
1059
1060     // block header
1061     int nVersion;
1062     uint256 hashMerkleRoot;
1063     unsigned int nTime;
1064     unsigned int nBits;
1065     unsigned int nNonce;
1066
1067
1068     CBlockIndex()
1069     {
1070         phashBlock = NULL;
1071         pprev = NULL;
1072         pnext = NULL;
1073         nFile = 0;
1074         nBlockPos = 0;
1075         nHeight = 0;
1076         bnChainWork = 0;
1077
1078         nVersion       = 0;
1079         hashMerkleRoot = 0;
1080         nTime          = 0;
1081         nBits          = 0;
1082         nNonce         = 0;
1083     }
1084
1085     CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1086     {
1087         phashBlock = NULL;
1088         pprev = NULL;
1089         pnext = NULL;
1090         nFile = nFileIn;
1091         nBlockPos = nBlockPosIn;
1092         nHeight = 0;
1093         bnChainWork = 0;
1094
1095         nVersion       = block.nVersion;
1096         hashMerkleRoot = block.hashMerkleRoot;
1097         nTime          = block.nTime;
1098         nBits          = block.nBits;
1099         nNonce         = block.nNonce;
1100     }
1101
1102     CBlock GetBlockHeader() const
1103     {
1104         CBlock block;
1105         block.nVersion       = nVersion;
1106         if (pprev)
1107             block.hashPrevBlock = pprev->GetBlockHash();
1108         block.hashMerkleRoot = hashMerkleRoot;
1109         block.nTime          = nTime;
1110         block.nBits          = nBits;
1111         block.nNonce         = nNonce;
1112         return block;
1113     }
1114
1115     uint256 GetBlockHash() const
1116     {
1117         return *phashBlock;
1118     }
1119
1120     int64 GetBlockTime() const
1121     {
1122         return (int64)nTime;
1123     }
1124
1125     CBigNum GetBlockWork() const
1126     {
1127         CBigNum bnTarget;
1128         bnTarget.SetCompact(nBits);
1129         if (bnTarget <= 0)
1130             return 0;
1131         return (CBigNum(1)<<256) / (bnTarget+1);
1132     }
1133
1134     bool IsInMainChain() const
1135     {
1136         return (pnext || this == pindexBest);
1137     }
1138
1139     bool CheckIndex() const
1140     {
1141         return CheckProofOfWork(GetBlockHash(), nBits);
1142     }
1143
1144     bool EraseBlockFromDisk()
1145     {
1146         // Open history file
1147         CAutoFile fileout = OpenBlockFile(nFile, nBlockPos, "rb+");
1148         if (!fileout)
1149             return false;
1150
1151         // Overwrite with empty null block
1152         CBlock block;
1153         block.SetNull();
1154         fileout << block;
1155
1156         return true;
1157     }
1158
1159     enum { nMedianTimeSpan=11 };
1160
1161     int64 GetMedianTimePast() const
1162     {
1163         int64 pmedian[nMedianTimeSpan];
1164         int64* pbegin = &pmedian[nMedianTimeSpan];
1165         int64* pend = &pmedian[nMedianTimeSpan];
1166
1167         const CBlockIndex* pindex = this;
1168         for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1169             *(--pbegin) = pindex->GetBlockTime();
1170
1171         std::sort(pbegin, pend);
1172         return pbegin[(pend - pbegin)/2];
1173     }
1174
1175     int64 GetMedianTime() const
1176     {
1177         const CBlockIndex* pindex = this;
1178         for (int i = 0; i < nMedianTimeSpan/2; i++)
1179         {
1180             if (!pindex->pnext)
1181                 return GetBlockTime();
1182             pindex = pindex->pnext;
1183         }
1184         return pindex->GetMedianTimePast();
1185     }
1186
1187
1188
1189     std::string ToString() const
1190     {
1191         return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, nBlockPos=%-6d nHeight=%d, merkle=%s, hashBlock=%s)",
1192             pprev, pnext, nFile, nBlockPos, nHeight,
1193             hashMerkleRoot.ToString().substr(0,10).c_str(),
1194             GetBlockHash().ToString().substr(0,20).c_str());
1195     }
1196
1197     void print() const
1198     {
1199         printf("%s\n", ToString().c_str());
1200     }
1201 };
1202
1203
1204
1205 //
1206 // Used to marshal pointers into hashes for db storage.
1207 //
1208 class CDiskBlockIndex : public CBlockIndex
1209 {
1210 public:
1211     uint256 hashPrev;
1212     uint256 hashNext;
1213
1214     CDiskBlockIndex()
1215     {
1216         hashPrev = 0;
1217         hashNext = 0;
1218     }
1219
1220     explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1221     {
1222         hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1223         hashNext = (pnext ? pnext->GetBlockHash() : 0);
1224     }
1225
1226     IMPLEMENT_SERIALIZE
1227     (
1228         if (!(nType & SER_GETHASH))
1229             READWRITE(nVersion);
1230
1231         READWRITE(hashNext);
1232         READWRITE(nFile);
1233         READWRITE(nBlockPos);
1234         READWRITE(nHeight);
1235
1236         // block header
1237         READWRITE(this->nVersion);
1238         READWRITE(hashPrev);
1239         READWRITE(hashMerkleRoot);
1240         READWRITE(nTime);
1241         READWRITE(nBits);
1242         READWRITE(nNonce);
1243     )
1244
1245     uint256 GetBlockHash() const
1246     {
1247         CBlock block;
1248         block.nVersion        = nVersion;
1249         block.hashPrevBlock   = hashPrev;
1250         block.hashMerkleRoot  = hashMerkleRoot;
1251         block.nTime           = nTime;
1252         block.nBits           = nBits;
1253         block.nNonce          = nNonce;
1254         return block.GetHash();
1255     }
1256
1257
1258     std::string ToString() const
1259     {
1260         std::string str = "CDiskBlockIndex(";
1261         str += CBlockIndex::ToString();
1262         str += strprintf("\n                hashBlock=%s, hashPrev=%s, hashNext=%s)",
1263             GetBlockHash().ToString().c_str(),
1264             hashPrev.ToString().substr(0,20).c_str(),
1265             hashNext.ToString().substr(0,20).c_str());
1266         return str;
1267     }
1268
1269     void print() const
1270     {
1271         printf("%s\n", ToString().c_str());
1272     }
1273 };
1274
1275
1276
1277
1278
1279
1280
1281
1282 //
1283 // Describes a place in the block chain to another node such that if the
1284 // other node doesn't have the same branch, it can find a recent common trunk.
1285 // The further back it is, the further before the fork it may be.
1286 //
1287 class CBlockLocator
1288 {
1289 protected:
1290     std::vector<uint256> vHave;
1291 public:
1292
1293     CBlockLocator()
1294     {
1295     }
1296
1297     explicit CBlockLocator(const CBlockIndex* pindex)
1298     {
1299         Set(pindex);
1300     }
1301
1302     explicit CBlockLocator(uint256 hashBlock)
1303     {
1304         std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1305         if (mi != mapBlockIndex.end())
1306             Set((*mi).second);
1307     }
1308
1309     IMPLEMENT_SERIALIZE
1310     (
1311         if (!(nType & SER_GETHASH))
1312             READWRITE(nVersion);
1313         READWRITE(vHave);
1314     )
1315
1316     void SetNull()
1317     {
1318         vHave.clear();
1319     }
1320
1321     bool IsNull()
1322     {
1323         return vHave.empty();
1324     }
1325
1326     void Set(const CBlockIndex* pindex)
1327     {
1328         vHave.clear();
1329         int nStep = 1;
1330         while (pindex)
1331         {
1332             vHave.push_back(pindex->GetBlockHash());
1333
1334             // Exponentially larger steps back
1335             for (int i = 0; pindex && i < nStep; i++)
1336                 pindex = pindex->pprev;
1337             if (vHave.size() > 10)
1338                 nStep *= 2;
1339         }
1340         vHave.push_back(hashGenesisBlock);
1341     }
1342
1343     int GetDistanceBack()
1344     {
1345         // Retrace how far back it was in the sender's branch
1346         int nDistance = 0;
1347         int nStep = 1;
1348         BOOST_FOREACH(const uint256& hash, vHave)
1349         {
1350             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1351             if (mi != mapBlockIndex.end())
1352             {
1353                 CBlockIndex* pindex = (*mi).second;
1354                 if (pindex->IsInMainChain())
1355                     return nDistance;
1356             }
1357             nDistance += nStep;
1358             if (nDistance > 10)
1359                 nStep *= 2;
1360         }
1361         return nDistance;
1362     }
1363
1364     CBlockIndex* GetBlockIndex()
1365     {
1366         // Find the first block the caller has in the main chain
1367         BOOST_FOREACH(const uint256& hash, vHave)
1368         {
1369             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1370             if (mi != mapBlockIndex.end())
1371             {
1372                 CBlockIndex* pindex = (*mi).second;
1373                 if (pindex->IsInMainChain())
1374                     return pindex;
1375             }
1376         }
1377         return pindexGenesisBlock;
1378     }
1379
1380     uint256 GetBlockHash()
1381     {
1382         // Find the first block the caller has in the main chain
1383         BOOST_FOREACH(const uint256& hash, vHave)
1384         {
1385             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1386             if (mi != mapBlockIndex.end())
1387             {
1388                 CBlockIndex* pindex = (*mi).second;
1389                 if (pindex->IsInMainChain())
1390                     return hash;
1391             }
1392         }
1393         return hashGenesisBlock;
1394     }
1395
1396     int GetHeight()
1397     {
1398         CBlockIndex* pindex = GetBlockIndex();
1399         if (!pindex)
1400             return 0;
1401         return pindex->nHeight;
1402     }
1403 };
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413 //
1414 // Alerts are for notifying old versions if they become too obsolete and
1415 // need to upgrade.  The message is displayed in the status bar.
1416 // Alert messages are broadcast as a vector of signed data.  Unserializing may
1417 // not read the entire buffer if the alert is for a newer version, but older
1418 // versions can still relay the original data.
1419 //
1420 class CUnsignedAlert
1421 {
1422 public:
1423     int nVersion;
1424     int64 nRelayUntil;      // when newer nodes stop relaying to newer nodes
1425     int64 nExpiration;
1426     int nID;
1427     int nCancel;
1428     std::set<int> setCancel;
1429     int nMinVer;            // lowest version inclusive
1430     int nMaxVer;            // highest version inclusive
1431     std::set<std::string> setSubVer;  // empty matches all
1432     int nPriority;
1433
1434     // Actions
1435     std::string strComment;
1436     std::string strStatusBar;
1437     std::string strReserved;
1438
1439     IMPLEMENT_SERIALIZE
1440     (
1441         READWRITE(this->nVersion);
1442         nVersion = this->nVersion;
1443         READWRITE(nRelayUntil);
1444         READWRITE(nExpiration);
1445         READWRITE(nID);
1446         READWRITE(nCancel);
1447         READWRITE(setCancel);
1448         READWRITE(nMinVer);
1449         READWRITE(nMaxVer);
1450         READWRITE(setSubVer);
1451         READWRITE(nPriority);
1452
1453         READWRITE(strComment);
1454         READWRITE(strStatusBar);
1455         READWRITE(strReserved);
1456     )
1457
1458     void SetNull()
1459     {
1460         nVersion = 1;
1461         nRelayUntil = 0;
1462         nExpiration = 0;
1463         nID = 0;
1464         nCancel = 0;
1465         setCancel.clear();
1466         nMinVer = 0;
1467         nMaxVer = 0;
1468         setSubVer.clear();
1469         nPriority = 0;
1470
1471         strComment.clear();
1472         strStatusBar.clear();
1473         strReserved.clear();
1474     }
1475
1476     std::string ToString() const
1477     {
1478         std::string strSetCancel;
1479         BOOST_FOREACH(int n, setCancel)
1480             strSetCancel += strprintf("%d ", n);
1481         std::string strSetSubVer;
1482         BOOST_FOREACH(std::string str, setSubVer)
1483             strSetSubVer += "\"" + str + "\" ";
1484         return strprintf(
1485                 "CAlert(\n"
1486                 "    nVersion     = %d\n"
1487                 "    nRelayUntil  = %"PRI64d"\n"
1488                 "    nExpiration  = %"PRI64d"\n"
1489                 "    nID          = %d\n"
1490                 "    nCancel      = %d\n"
1491                 "    setCancel    = %s\n"
1492                 "    nMinVer      = %d\n"
1493                 "    nMaxVer      = %d\n"
1494                 "    setSubVer    = %s\n"
1495                 "    nPriority    = %d\n"
1496                 "    strComment   = \"%s\"\n"
1497                 "    strStatusBar = \"%s\"\n"
1498                 ")\n",
1499             nVersion,
1500             nRelayUntil,
1501             nExpiration,
1502             nID,
1503             nCancel,
1504             strSetCancel.c_str(),
1505             nMinVer,
1506             nMaxVer,
1507             strSetSubVer.c_str(),
1508             nPriority,
1509             strComment.c_str(),
1510             strStatusBar.c_str());
1511     }
1512
1513     void print() const
1514     {
1515         printf("%s", ToString().c_str());
1516     }
1517 };
1518
1519 class CAlert : public CUnsignedAlert
1520 {
1521 public:
1522     std::vector<unsigned char> vchMsg;
1523     std::vector<unsigned char> vchSig;
1524
1525     CAlert()
1526     {
1527         SetNull();
1528     }
1529
1530     IMPLEMENT_SERIALIZE
1531     (
1532         READWRITE(vchMsg);
1533         READWRITE(vchSig);
1534     )
1535
1536     void SetNull()
1537     {
1538         CUnsignedAlert::SetNull();
1539         vchMsg.clear();
1540         vchSig.clear();
1541     }
1542
1543     bool IsNull() const
1544     {
1545         return (nExpiration == 0);
1546     }
1547
1548     uint256 GetHash() const
1549     {
1550         return SerializeHash(*this);
1551     }
1552
1553     bool IsInEffect() const
1554     {
1555         return (GetAdjustedTime() < nExpiration);
1556     }
1557
1558     bool Cancels(const CAlert& alert) const
1559     {
1560         if (!IsInEffect())
1561             return false; // this was a no-op before 31403
1562         return (alert.nID <= nCancel || setCancel.count(alert.nID));
1563     }
1564
1565     bool AppliesTo(int nVersion, std::string strSubVerIn) const
1566     {
1567         return (IsInEffect() &&
1568                 nMinVer <= nVersion && nVersion <= nMaxVer &&
1569                 (setSubVer.empty() || setSubVer.count(strSubVerIn)));
1570     }
1571
1572     bool AppliesToMe() const
1573     {
1574         return AppliesTo(VERSION, ::pszSubVer);
1575     }
1576
1577     bool RelayTo(CNode* pnode) const
1578     {
1579         if (!IsInEffect())
1580             return false;
1581         // returns true if wasn't already contained in the set
1582         if (pnode->setKnown.insert(GetHash()).second)
1583         {
1584             if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
1585                 AppliesToMe() ||
1586                 GetAdjustedTime() < nRelayUntil)
1587             {
1588                 pnode->PushMessage("alert", *this);
1589                 return true;
1590             }
1591         }
1592         return false;
1593     }
1594
1595     bool CheckSignature()
1596     {
1597         CKey key;
1598         if (!key.SetPubKey(ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284")))
1599             return error("CAlert::CheckSignature() : SetPubKey failed");
1600         if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
1601             return error("CAlert::CheckSignature() : verify signature failed");
1602
1603         // Now unserialize the data
1604         CDataStream sMsg(vchMsg);
1605         sMsg >> *(CUnsignedAlert*)this;
1606         return true;
1607     }
1608
1609     bool ProcessAlert();
1610 };
1611
1612 #endif