src/miner.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2016 The Bitcoin Core developers
   3 // Distributed under the MIT software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #ifndef BITCOIN_MINER_H
   7 #define BITCOIN_MINER_H
   8
   9 #include "primitives/block.h"
  10 #include "txmempool.h"
  11
  12 #include <stdint.h>
  13 #include <memory>
  14 #include "boost/multi_index_container.hpp"
  15 #include "boost/multi_index/ordered_index.hpp"
  16
  17 class CBlockIndex;
  18 class CChainParams;
  19 class CScript;
  20
  21 namespace Consensus { struct Params; };
  22
  23 static const bool DEFAULT_PRINTPRIORITY = false;
  24
  25 struct CBlockTemplate
  26 {
  27     CBlock block;
  28     std::vector<CAmount> vTxFees;
  29     std::vector<int64_t> vTxSigOpsCost;
  30     std::vector<unsigned char> vchCoinbaseCommitment;
  31 };
  32
  33 // Container for tracking updates to ancestor feerate as we include (parent)
  34 // transactions in a block
  35 struct CTxMemPoolModifiedEntry {
  36     CTxMemPoolModifiedEntry(CTxMemPool::txiter entry)
  37     {
  38         iter = entry;
  39         nSizeWithAncestors = entry->GetSizeWithAncestors();
  40         nModFeesWithAncestors = entry->GetModFeesWithAncestors();
  41         nSigOpCostWithAncestors = entry->GetSigOpCostWithAncestors();
  42     }
  43
  44     CTxMemPool::txiter iter;
  45     uint64_t nSizeWithAncestors;
  46     CAmount nModFeesWithAncestors;
  47     int64_t nSigOpCostWithAncestors;
  48 };
  49
  50 /** Comparator for CTxMemPool::txiter objects.
  51  *  It simply compares the internal memory address of the CTxMemPoolEntry object
  52  *  pointed to. This means it has no meaning, and is only useful for using them
  53  *  as key in other indexes.
  54  */
  55 struct CompareCTxMemPoolIter {
  56     bool operator()(const CTxMemPool::txiter& a, const CTxMemPool::txiter& b) const
  57     {
  58         return &(*a) < &(*b);
  59     }
  60 };
  61
  62 struct modifiedentry_iter {
  63     typedef CTxMemPool::txiter result_type;
  64     result_type operator() (const CTxMemPoolModifiedEntry &entry) const
  65     {
  66         return entry.iter;
  67     }
  68 };
  69
  70 // This matches the calculation in CompareTxMemPoolEntryByAncestorFee,
  71 // except operating on CTxMemPoolModifiedEntry.
  72 // TODO: refactor to avoid duplication of this logic.
  73 struct CompareModifiedEntry {
  74     bool operator()(const CTxMemPoolModifiedEntry &a, const CTxMemPoolModifiedEntry &b)
  75     {
  76         double f1 = (double)a.nModFeesWithAncestors * b.nSizeWithAncestors;
  77         double f2 = (double)b.nModFeesWithAncestors * a.nSizeWithAncestors;
  78         if (f1 == f2) {
  79             return CTxMemPool::CompareIteratorByHash()(a.iter, b.iter);
  80         }
  81         return f1 > f2;
  82     }
  83 };
  84
  85 // A comparator that sorts transactions based on number of ancestors.
  86 // This is sufficient to sort an ancestor package in an order that is valid
  87 // to appear in a block.
  88 struct CompareTxIterByAncestorCount {
  89     bool operator()(const CTxMemPool::txiter &a, const CTxMemPool::txiter &b)
  90     {
  91         if (a->GetCountWithAncestors() != b->GetCountWithAncestors())
  92             return a->GetCountWithAncestors() < b->GetCountWithAncestors();
  93         return CTxMemPool::CompareIteratorByHash()(a, b);
  94     }
  95 };
  96
  97 typedef boost::multi_index_container<
  98     CTxMemPoolModifiedEntry,
  99     boost::multi_index::indexed_by<
 100         boost::multi_index::ordered_unique<
 101             modifiedentry_iter,
 102             CompareCTxMemPoolIter
 103         >,
 104         // sorted by modified ancestor fee rate
 105         boost::multi_index::ordered_non_unique<
 106             // Reuse same tag from CTxMemPool's similar index
 107             boost::multi_index::tag<ancestor_score>,
 108             boost::multi_index::identity<CTxMemPoolModifiedEntry>,
 109             CompareModifiedEntry
 110         >
 111     >
 112 > indexed_modified_transaction_set;
 113
 114 typedef indexed_modified_transaction_set::nth_index<0>::type::iterator modtxiter;
 115 typedef indexed_modified_transaction_set::index<ancestor_score>::type::iterator modtxscoreiter;
 116
 117 struct update_for_parent_inclusion
 118 {
 119     update_for_parent_inclusion(CTxMemPool::txiter it) : iter(it) {}
 120
 121     void operator() (CTxMemPoolModifiedEntry &e)
 122     {
 123         e.nModFeesWithAncestors -= iter->GetFee();
 124         e.nSizeWithAncestors -= iter->GetTxSize();
 125         e.nSigOpCostWithAncestors -= iter->GetSigOpCost();
 126     }
 127
 128     CTxMemPool::txiter iter;
 129 };
 130
 131 /** Generate a new block, without valid proof-of-work */
 132 class BlockAssembler
 133 {
 134 private:
 135     // The constructed block template
 136     std::unique_ptr<CBlockTemplate> pblocktemplate;
 137     // A convenience pointer that always refers to the CBlock in pblocktemplate
 138     CBlock* pblock;
 139
 140     // Configuration parameters for the block size
 141     bool fIncludeWitness;
 142     unsigned int nBlockMaxWeight, nBlockMaxSize;
 143     bool fNeedSizeAccounting;
 144     CFeeRate blockMinFeeRate;
 145
 146     // Information on the current status of the block
 147     uint64_t nBlockWeight;
 148     uint64_t nBlockSize;
 149     uint64_t nBlockTx;
 150     uint64_t nBlockSigOpsCost;
 151     CAmount nFees;
 152     CTxMemPool::setEntries inBlock;
 153
 154     // Chain context for the block
 155     int nHeight;
 156     int64_t nLockTimeCutoff;
 157     const CChainParams& chainparams;
 158
 159 public:
 160     struct Options {
 161         Options();
 162         size_t nBlockMaxWeight;
 163         size_t nBlockMaxSize;
 164         CFeeRate blockMinFeeRate;
 165     };
 166
 167     BlockAssembler(const CChainParams& params);
 168     BlockAssembler(const CChainParams& params, const Options& options);
 169
 170     /** Construct a new block template with coinbase to scriptPubKeyIn */
 171     std::unique_ptr<CBlockTemplate> CreateNewBlock(const CScript& scriptPubKeyIn, bool fMineWitnessTx=true);
 172
 173 private:
 174     // utility functions
 175     /** Clear the block's state and prepare for assembling a new block */
 176     void resetBlock();
 177     /** Add a tx to the block */
 178     void AddToBlock(CTxMemPool::txiter iter);
 179
 180     // Methods for how to add transactions to a block.
 181     /** Add transactions based on feerate including unconfirmed ancestors
 182       * Increments nPackagesSelected / nDescendantsUpdated with corresponding
 183       * statistics from the package selection (for logging statistics). */
 184     void addPackageTxs(int &nPackagesSelected, int &nDescendantsUpdated);
 185
 186     // helper functions for addPackageTxs()
 187     /** Remove confirmed (inBlock) entries from given set */
 188     void onlyUnconfirmed(CTxMemPool::setEntries& testSet);
 189     /** Test if a new package would "fit" in the block */
 190     bool TestPackage(uint64_t packageSize, int64_t packageSigOpsCost);
 191     /** Perform checks on each transaction in a package:
 192       * locktime, premature-witness, serialized size (if necessary)
 193       * These checks should always succeed, and they're here
 194       * only as an extra check in case of suboptimal node configuration */
 195     bool TestPackageTransactions(const CTxMemPool::setEntries& package);
 196     /** Return true if given transaction from mapTx has already been evaluated,
 197       * or if the transaction's cached data in mapTx is incorrect. */
 198     bool SkipMapTxEntry(CTxMemPool::txiter it, indexed_modified_transaction_set &mapModifiedTx, CTxMemPool::setEntries &failedTx);
 199     /** Sort the package in an order that is valid to appear in a block */
 200     void SortForBlock(const CTxMemPool::setEntries& package, CTxMemPool::txiter entry, std::vector<CTxMemPool::txiter>& sortedEntries);
 201     /** Add descendants of given transactions to mapModifiedTx with ancestor
 202       * state updated assuming given transactions are inBlock. Returns number
 203       * of updated descendants. */
 204     int UpdatePackagesForAdded(const CTxMemPool::setEntries& alreadyAdded, indexed_modified_transaction_set &mapModifiedTx);
 205 };
 206
 207 /** Modify the extranonce in a block */
 208 void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
 209 int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev);
 210
 211 #endif // BITCOIN_MINER_H