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 <txmempool.h>
 
#include <memory>
#include <optional>
#include <stdint.h>
 
namespace node {
 
// Container for tracking updates to ancestor feerate as we include ancestors in the "block"
class MiniMinerMempoolEntry
{
    const CAmount fee_individual;
    const CTransactionRef tx;
    const int64_t vsize_individual;
 
// This class must be constructed while holding mempool.cs. After construction, the object's
// methods can be called without holding that lock.
public:
    CAmount fee_with_ancestors;
    int64_t vsize_with_ancestors;
    explicit MiniMinerMempoolEntry(CTxMemPool::txiter entry) :
        fee_individual{entry->GetModifiedFee()},
        tx{entry->GetSharedTx()},
        vsize_individual(entry->GetTxSize()),
        fee_with_ancestors{entry->GetModFeesWithAncestors()},
        vsize_with_ancestors(entry->GetSizeWithAncestors())
    { }
 
    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; }
};
 
// Comparator needed for std::set<MockEntryMap::iterator>
struct IteratorComparator
{
    template<typename I>
    bool operator()(const I& a, const I& b) const
    {
        return &(*a) < &(*b);
    }
};
 
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;
 
    // What we're trying to calculate.
    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(const CFeeRate& target_feerate);
 
    std::set<uint256> GetMockTemplateTxids() const { return m_in_block; }
 
    MiniMiner(const CTxMemPool& mempool, const std::vector<COutPoint>& outpoints);
 
    std::map<COutPoint, CAmount> CalculateBumpFees(const CFeeRate& target_feerate);
 
    std::optional<CAmount> CalculateTotalBumpFees(const CFeeRate& target_feerate);
};
} // namespace node
 
#endif // BITCOIN_NODE_MINI_MINER_H