miner.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2019 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_NODE_MINER_H
#define BITCOIN_NODE_MINER_H
 
#include <consensus/amount.h>
#include <kernel/mempool_entry.h>
#include <primitives/block.h>
#include <txmempool.h>
 
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index_container.hpp>
 
#include <cstdint>
#include <memory>
#include <optional>
 
class CBlockIndex;
class CChainParams;
class Config;
class CScript;
 
namespace Consensus {
struct Params;
}
 
namespace avalanche {
class Processor;
}
 
namespace node {
static const bool DEFAULT_PRINTPRIORITY = false;
 
struct CBlockTemplateEntry {
    CTransactionRef tx;
    Amount fees;
    int64_t sigChecks;
 
    CBlockTemplateEntry(CTransactionRef _tx, Amount _fees, int64_t _sigChecks)
        : tx(_tx), fees(_fees), sigChecks(_sigChecks){};
};
 
struct CBlockTemplate {
    CBlock block;
 
    std::vector<CBlockTemplateEntry> entries;
};
 
class BlockAssembler {
private:
    // The constructed block template
    std::unique_ptr<CBlockTemplate> pblocktemplate;
 
    // Configuration parameters for the block size
    uint64_t nMaxGeneratedBlockSize;
    uint64_t nMaxGeneratedBlockSigChecks;
    CFeeRate blockMinFeeRate;
 
    // Information on the current status of the block
    uint64_t nBlockSize;
    uint64_t nBlockTx;
    uint64_t nBlockSigChecks;
    Amount nFees;
 
    // Chain context for the block
    int nHeight;
    int64_t m_lock_time_cutoff;
    const CChainParams &chainParams;
 
    const CTxMemPool *const m_mempool;
    Chainstate &m_chainstate;
    const avalanche::Processor *const m_avalanche;
 
    const bool fPrintPriority;
 
public:
    struct Options {
        Options();
        uint64_t nExcessiveBlockSize;
        uint64_t nMaxGeneratedBlockSize;
        CFeeRate blockMinFeeRate;
    };
 
    BlockAssembler(const Config &config, Chainstate &chainstate,
                   const CTxMemPool *mempool,
                   const avalanche::Processor *avalanche = nullptr);
    BlockAssembler(Chainstate &chainstate, const CTxMemPool *mempool,
                   const Options &options,
                   const avalanche::Processor *avalanche = nullptr);
 
    std::unique_ptr<CBlockTemplate>
    CreateNewBlock(const CScript &scriptPubKeyIn);
 
    uint64_t GetMaxGeneratedBlockSize() const { return nMaxGeneratedBlockSize; }
 
    static std::optional<int64_t> m_last_block_num_txs;
    static std::optional<int64_t> m_last_block_size;
 
private:
    // utility functions
    void resetBlock();
    void AddToBlock(const CTxMemPoolEntryRef &entry);
 
    // Methods for how to add transactions to a block.
    void addTxs(const CTxMemPool &mempool) EXCLUSIVE_LOCKS_REQUIRED(mempool.cs);
 
    // helper functions for addTxs()
    bool TestTxFits(uint64_t txSize, int64_t txSigChecks) const;
 
    bool CheckTx(const CTransaction &tx) const;
};
 
int64_t UpdateTime(CBlockHeader *pblock, const CChainParams &chainParams,
                   const CBlockIndex *pindexPrev, int64_t adjustedTime);
} // namespace node
 
#endif // BITCOIN_NODE_MINER_H