mempool_estimator.h

Go to the documentation of this file.

// Copyright (c) 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_POLICY_FEES_MEMPOOL_ESTIMATOR_H
#define BITCOIN_POLICY_FEES_MEMPOOL_ESTIMATOR_H
 
#include <primitives/transaction.h>
#include <sync.h>
#include <threadsafety.h>
#include <uint256.h>
#include <util/expected.h>
#include <util/feefrac.h>
#include <util/fees.h>
#include <util/fs.h>
#include <util/time.h>
 
#include <chrono>
#include <memory>
#include <optional>
#include <span>
#include <vector>
 
class CBlock;
class AutoFile;
class ChainstateManager;
class CTxMemPool;
 
struct RemovedMempoolTransactionInfo;
 
// Fee rate estimate for confirmation target above this is not reliable,
// as mempool conditions are likely to change.
constexpr int MEMPOOL_FEE_ESTIMATOR_MAX_TARGET{2};
constexpr std::chrono::seconds CACHE_LIFE{7};
 
// Constants for mempool sanity checks.
constexpr size_t MEMPOOL_HEALTH_WINDOW_BLOCKS = 6;
constexpr double MEMPOOL_REPRESENTATION_THRESHOLD = 0.75;
 
struct MinedBlockStats {
    uint64_t m_height{0};
    uint64_t m_removed_block_txs_weight{0};
    uint64_t m_block_weight{0};
};
 
class MemPoolFeeRateEstimatorCache
{
public:
    MemPoolFeeRateEstimatorCache() = default;
    MemPoolFeeRateEstimatorCache(const MemPoolFeeRateEstimatorCache&) = delete;
    MemPoolFeeRateEstimatorCache& operator=(const MemPoolFeeRateEstimatorCache&) = delete;
    bool IsStale() const;
    struct FeeRateEstimate {
        FeePerVSize m_conservative;
        FeePerVSize m_economical;
    };
    std::optional<FeeRateEstimate> GetCachedEstimate(const uint256& tip_hash) const;
    void Update(FeePerVSize conservative, FeePerVSize economical, const uint256& tip_hash);
    void Clear();
 
private:
    std::optional<FeeRateEstimate> m_fee_rate_estimation;
    uint256 m_tip_hash;
    NodeClock::time_point m_last_updated{};
};
 
class MemPoolFeeRateEstimator
{
public:
    // Block percentiles fee rate (in sat/vB).
    struct Percentiles {
        FeePerVSize p50;
        FeePerVSize p75;
    };
 
    MemPoolFeeRateEstimator(fs::path mempool_estimator_file_path,
                            const CTxMemPool& mempool,
                            ChainstateManager& chainman);
    ~MemPoolFeeRateEstimator() = default;
    static Percentiles CalculateMaxWeightPercentiles(std::span<const FeePerVSize> chunk_feerates);
    util::Expected<FeeRateEstimation, FeeRateEstimationError> EstimateFeeRate(bool conservative) const
        EXCLUSIVE_LOCKS_REQUIRED(!cs);
    unsigned int MaximumTarget() const
    {
        return MEMPOOL_FEE_ESTIMATOR_MAX_TARGET;
    }
 
    std::vector<MinedBlockStats> GetPrevBlockData() const EXCLUSIVE_LOCKS_REQUIRED(!cs)
    {
        LOCK(cs);
        return m_prev_mined_blocks;
    }
 
    void MempoolTxsRemovedForBlock(const std::shared_ptr<const CBlock>& block,
                                   const std::vector<RemovedMempoolTransactionInfo>& txs_removed_for_block,
                                   unsigned int block_height)
        EXCLUSIVE_LOCKS_REQUIRED(!cs);
    enum class MempoolHealth {
        HEALTHY,
        INSUFFICIENT_DATA,
        LOW_COVERAGE,
    };
    MempoolHealth GetMempoolHealth() const EXCLUSIVE_LOCKS_REQUIRED(!cs);
    bool IsMempoolHealthy() const EXCLUSIVE_LOCKS_REQUIRED(!cs) { return GetMempoolHealth() == MempoolHealth::HEALTHY; }
    void FlushMinedBlockStats() EXCLUSIVE_LOCKS_REQUIRED(!cs);
    bool Read(AutoFile& file) EXCLUSIVE_LOCKS_REQUIRED(!cs);
    bool Write(AutoFile& file) const EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
private:
    void ReadFromDisk() EXCLUSIVE_LOCKS_REQUIRED(!cs);
    std::vector<MinedBlockStats> m_prev_mined_blocks GUARDED_BY(cs);
    uint256 m_mined_blocks_tip_hash GUARDED_BY(cs);
 
    const CTxMemPool& m_mempool;
    ChainstateManager& m_chainman;
    mutable Mutex cs;
    mutable MemPoolFeeRateEstimatorCache m_cache GUARDED_BY(cs);
    const fs::path m_mempool_estimator_file_path;
};
 
#endif // BITCOIN_POLICY_FEES_MEMPOOL_ESTIMATOR_H