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