Coverage Report

Created: 2026-09-15 16:03

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/root/bitcoin/src/policy/fees/estimator_man.cpp
Line
Count
Source
1
// Copyright (c) The Bitcoin Core developers
2
// Distributed under the MIT software license. See the accompanying
3
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5
#include <policy/fees/estimator_man.h>
6
7
#include <logging.h>
8
#include <policy/feerate.h>
9
#include <policy/fees/block_policy_estimator.h>
10
#include <policy/fees/mempool_estimator.h>
11
#include <util/fees.h>
12
13
0
FeeRateEstimatorManager::~FeeRateEstimatorManager() = default;
14
15
FeeRateEstimatorManager::FeeRateEstimatorManager(const fs::path& block_policy_path,
16
                                                 bool read_stale_estimates,
17
                                                 const fs::path& mempool_estimator_path,
18
                                                 const CTxMemPool& mempool,
19
                                                 ChainstateManager& chainman)
20
0
    : m_block_policy_estimator(std::make_unique<CBlockPolicyEstimator>(block_policy_path, read_stale_estimates)),
21
0
      m_mempool_estimator(std::make_unique<MemPoolFeeRateEstimator>(mempool_estimator_path, mempool, chainman))
22
0
{
23
0
}
24
25
util::Expected<FeeRateEstimation, FeeRateEstimationError> FeeRateEstimatorManager::GetFeeRateEstimate(int target, bool conservative) const
26
0
{
27
0
    auto block_policy_estimate = m_block_policy_estimator->EstimateFeeRate(target, conservative);
28
0
    if (!block_policy_estimate) {
  Branch (28:9): [True: 0, False: 0]

29
0
        LogDebug(BCLog::ESTIMATEFEE, "%s", block_policy_estimate.error().reason);
30
0
        return block_policy_estimate;
31
0
    }
32
0
    auto mempool_estimate = m_mempool_estimator->EstimateFeeRate(conservative);
33
0
    if (!mempool_estimate) {
  Branch (33:9): [True: 0, False: 0]

34
        // A failed mempool estimate is surfaced as a warning rather than silently returning the
35
        // block policy estimate, which callers can still request explicitly.
36
0
        LogDebug(BCLog::ESTIMATEFEE, "%s", mempool_estimate.error().reason);
37
0
        return mempool_estimate;
38
0
    }
39
0
    auto selected_estimate = std::min(*block_policy_estimate, *mempool_estimate);
40
0
    LogDebug(BCLog::ESTIMATEFEE, "Fee rate estimated using %s: target=%s feerate=%s %s/kvB.",
41
0
             FeeRateEstimatorTypeToString(selected_estimate.feerate_estimator),
42
0
             selected_estimate.returned_target, CFeeRate(selected_estimate.feerate).GetFeePerK(), CURRENCY_ATOM);
43
0
    return selected_estimate;
44
0
}
45
46
util::Expected<FeeRateEstimation, FeeRateEstimationError> FeeRateEstimatorManager::GetFeeRateEstimate(FeeRateEstimatorType type, int target, bool conservative) const
47
0
{
48
0
    switch (type) {
  Branch (48:13): [True: 0, False: 0]

49
0
    case FeeRateEstimatorType::NONE:
  Branch (49:5): [True: 0, False: 0]

50
0
        return GetFeeRateEstimate(target, conservative);
51
0
    case FeeRateEstimatorType::BLOCK_POLICY:
  Branch (51:5): [True: 0, False: 0]

52
0
        return m_block_policy_estimator->EstimateFeeRate(target, conservative);
53
0
    case FeeRateEstimatorType::MEMPOOL_POLICY:
  Branch (53:5): [True: 0, False: 0]

54
0
        return m_mempool_estimator->EstimateFeeRate(conservative);
55
0
    } // no default case, so the compiler can warn about missing cases
56
0
    assert(false);
  Branch (56:5): [Folded - Ignored]

57
0
}
58
59
void FeeRateEstimatorManager::IntervalFlush()
60
0
{
61
0
    m_block_policy_estimator->FlushFeeEstimates();
62
0
    m_mempool_estimator->FlushMinedBlockStats();
63
0
}
64
65
void FeeRateEstimatorManager::ShutdownFlush()
66
0
{
67
0
    m_block_policy_estimator->Flush();
68
0
    m_mempool_estimator->FlushMinedBlockStats();
69
0
}
70
71
std::vector<MinedBlockStats> FeeRateEstimatorManager::MempoolPolicyEstimatorBlocksStats() const
72
0
{
73
0
    return m_mempool_estimator->GetPrevBlockData();
74
0
}
75
76
void FeeRateEstimatorManager::TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t /*unused*/)
77
0
{
78
0
    m_block_policy_estimator->processTransaction(tx);
79
0
}
80
81
void FeeRateEstimatorManager::TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason /*unused*/, uint64_t /*unused*/)
82
0
{
83
0
    m_block_policy_estimator->removeTx(tx->GetHash());
84
0
}
85
86
void FeeRateEstimatorManager::MempoolTransactionsRemovedForBlock(const std::shared_ptr<const CBlock>& block, const std::vector<RemovedMempoolTransactionInfo>& txs_removed_for_block, unsigned int block_height)
87
0
{
88
0
    m_block_policy_estimator->processBlock(txs_removed_for_block, block_height);
89
0
    m_mempool_estimator->MempoolTxsRemovedForBlock(block, txs_removed_for_block, block_height);
90
0
}
91
92
CFeeRate FeeRateEstimatorManager::BlockPolicyEstimateRawFee(unsigned int target, double threshold, FeeEstimateHorizon horizon, EstimationResult* buckets) const
93
0
{
94
0
    return m_block_policy_estimator->estimateRawFee(target, threshold, horizon, buckets);
95
0
}
96
97
unsigned int FeeRateEstimatorManager::BlockPolicyHighestTargetTracked(FeeEstimateHorizon horizon) const
98
0
{
99
0
    return m_block_policy_estimator->HighestTargetTracked(horizon);
100
0
}
101
102
unsigned int FeeRateEstimatorManager::MaximumTarget() const
103
0
{
104
0
    return std::max(m_block_policy_estimator->MaximumTarget(), m_mempool_estimator->MaximumTarget());
105
0
}