mini_miner.h

Go to the documentation of this file.

// Copyright (c) 2022 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_MINI_MINER_H
#define BITCOIN_NODE_MINI_MINER_H
 
#include <consensus/amount.h>
#include <primitives/transaction.h>
#include <uint256.h>
 
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <stdint.h>
#include <vector>
 
class CFeeRate;
class CTxMemPool;
 
namespace node {
 
// Container for tracking updates to ancestor feerate as we include ancestors in the "block"
class MiniMinerMempoolEntry
{
    const CTransactionRef tx;
    const int64_t vsize_individual;
    int64_t vsize_with_ancestors;
    const CAmount fee_individual;
    CAmount fee_with_ancestors;
 
// This class must be constructed while holding mempool.cs. After construction, the object's
// methods can be called without holding that lock.
 
public:
    explicit MiniMinerMempoolEntry(const CTransactionRef& tx_in,
                                   int64_t vsize_self,
                                   int64_t vsize_ancestor,
                                   CAmount fee_self,
                                   CAmount fee_ancestor):
        tx{tx_in},
        vsize_individual{vsize_self},
        vsize_with_ancestors{vsize_ancestor},
        fee_individual{fee_self},
        fee_with_ancestors{fee_ancestor}
    { }
 
    CAmount GetModifiedFee() const { return fee_individual; }
    CAmount GetModFeesWithAncestors() const { return fee_with_ancestors; }
    int64_t GetTxSize() const { return vsize_individual; }
    int64_t GetSizeWithAncestors() const { return vsize_with_ancestors; }
    const CTransaction& GetTx() const LIFETIMEBOUND { return *tx; }
    void UpdateAncestorState(int64_t vsize_change, CAmount fee_change) {
        vsize_with_ancestors += vsize_change;
        fee_with_ancestors += fee_change;
    }
};
 
// Comparator needed for std::set<MockEntryMap::iterator>
struct IteratorComparator
{
    template<typename I>
    bool operator()(const I& a, const I& b) const
    {
        return a->first < b->first;
    }
};
 
class MiniMiner
{
    // When true, a caller may use CalculateBumpFees(). Becomes false if we failed to retrieve
    // mempool entries (i.e. cluster size too large) or bump fees have already been calculated.
    bool m_ready_to_calculate{true};
 
    // Set once per lifetime, fill in during initialization.
    // txids of to-be-replaced transactions
    std::set<uint256> m_to_be_replaced;
 
    // If multiple argument outpoints correspond to the same transaction, cache them together in
    // a single entry indexed by txid. Then we can just work with txids since all outpoints from
    // the same tx will have the same bumpfee. Excludes non-mempool transactions.
    std::map<uint256, std::vector<COutPoint>> m_requested_outpoints_by_txid;
 
    // Txid to a number representing the order in which this transaction was included (smaller
    // number = included earlier).  Transactions included in an ancestor set together have the same
    // sequence number.
    std::map<Txid, uint32_t> m_inclusion_order;
    // What we're trying to calculate. Outpoint to the fee needed to bring the transaction to the target feerate.
    std::map<COutPoint, CAmount> m_bump_fees;
 
    // The constructed block template
    std::set<uint256> m_in_block;
 
    // Information on the current status of the block
    CAmount m_total_fees{0};
    int32_t m_total_vsize{0};
 
    std::map<uint256, MiniMinerMempoolEntry> m_entries_by_txid;
    using MockEntryMap = decltype(m_entries_by_txid);
 
    std::vector<MockEntryMap::iterator> m_entries;
 
    std::map<uint256, std::vector<MockEntryMap::iterator>> m_descendant_set_by_txid;
 
    void DeleteAncestorPackage(const std::set<MockEntryMap::iterator, IteratorComparator>& ancestors);
 
    void SanityCheck() const;
 
public:
    bool IsReadyToCalculate() const { return m_ready_to_calculate; }
 
    void BuildMockTemplate(std::optional<CFeeRate> target_feerate);
 
    std::set<uint256> GetMockTemplateTxids() const { return m_in_block; }
 
    MiniMiner(const CTxMemPool& mempool, const std::vector<COutPoint>& outpoints);
 
    MiniMiner(const std::vector<MiniMinerMempoolEntry>& manual_entries,
              const std::map<Txid, std::set<Txid>>& descendant_caches);
 
    std::map<COutPoint, CAmount> CalculateBumpFees(const CFeeRate& target_feerate);
 
    std::optional<CAmount> CalculateTotalBumpFees(const CFeeRate& target_feerate);
 
    std::map<Txid, uint32_t> Linearize();
};
} // namespace node
 
#endif // BITCOIN_NODE_MINI_MINER_H