estimator_man.cpp

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.
 
#include <policy/fees/estimator_man.h>
 
#include <logging.h>
#include <policy/feerate.h>
#include <policy/fees/block_policy_estimator.h>
#include <policy/fees/mempool_estimator.h>
#include <util/fees.h>
 
FeeRateEstimatorManager::~FeeRateEstimatorManager() = default;
 
FeeRateEstimatorManager::FeeRateEstimatorManager(const fs::path& block_policy_path,
                                                 bool read_stale_estimates,
                                                 const fs::path& mempool_estimator_path,
                                                 const CTxMemPool& mempool,
                                                 ChainstateManager& chainman)
    : m_block_policy_estimator(std::make_unique<CBlockPolicyEstimator>(block_policy_path, read_stale_estimates)),
      m_mempool_estimator(std::make_unique<MemPoolFeeRateEstimator>(mempool_estimator_path, mempool, chainman))
{
}
 
util::Expected<FeeRateEstimation, FeeRateEstimationError> FeeRateEstimatorManager::GetFeeRateEstimate(int target, bool conservative) const
{
    auto block_policy_estimate = m_block_policy_estimator->EstimateFeeRate(target, conservative);
    if (!block_policy_estimate) {
        LogDebug(BCLog::ESTIMATEFEE, "%s", block_policy_estimate.error().reason);
        return block_policy_estimate;
    }
    auto mempool_estimate = m_mempool_estimator->EstimateFeeRate(conservative);
    if (!mempool_estimate) {
        // A failed mempool estimate is surfaced as a warning rather than silently returning the
        // block policy estimate, which callers can still request explicitly.
        LogDebug(BCLog::ESTIMATEFEE, "%s", mempool_estimate.error().reason);
        return mempool_estimate;
    }
    auto selected_estimate = std::min(*block_policy_estimate, *mempool_estimate);
    LogDebug(BCLog::ESTIMATEFEE, "Fee rate estimated using %s: target=%s feerate=%s %s/kvB.",
             FeeRateEstimatorTypeToString(selected_estimate.feerate_estimator),
             selected_estimate.returned_target, CFeeRate(selected_estimate.feerate).GetFeePerK(), CURRENCY_ATOM);
    return selected_estimate;
}
 
util::Expected<FeeRateEstimation, FeeRateEstimationError> FeeRateEstimatorManager::GetFeeRateEstimate(FeeRateEstimatorType type, int target, bool conservative) const
{
    switch (type) {
    case FeeRateEstimatorType::NONE:
        return GetFeeRateEstimate(target, conservative);
    case FeeRateEstimatorType::BLOCK_POLICY:
        return m_block_policy_estimator->EstimateFeeRate(target, conservative);
    case FeeRateEstimatorType::MEMPOOL_POLICY:
        return m_mempool_estimator->EstimateFeeRate(conservative);
    } // no default case, so the compiler can warn about missing cases
    assert(false);
}
 
void FeeRateEstimatorManager::IntervalFlush()
{
    m_block_policy_estimator->FlushFeeEstimates();
    m_mempool_estimator->FlushMinedBlockStats();
}
 
void FeeRateEstimatorManager::ShutdownFlush()
{
    m_block_policy_estimator->Flush();
    m_mempool_estimator->FlushMinedBlockStats();
}
 
std::vector<MinedBlockStats> FeeRateEstimatorManager::MempoolPolicyEstimatorBlocksStats() const
{
    return m_mempool_estimator->GetPrevBlockData();
}
 
void FeeRateEstimatorManager::TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t /*unused*/)
{
    m_block_policy_estimator->processTransaction(tx);
}
 
void FeeRateEstimatorManager::TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason /*unused*/, uint64_t /*unused*/)
{
    m_block_policy_estimator->removeTx(tx->GetHash());
}
 
void FeeRateEstimatorManager::MempoolTransactionsRemovedForBlock(const std::shared_ptr<const CBlock>& block, const std::vector<RemovedMempoolTransactionInfo>& txs_removed_for_block, unsigned int block_height)
{
    m_block_policy_estimator->processBlock(txs_removed_for_block, block_height);
    m_mempool_estimator->MempoolTxsRemovedForBlock(block, txs_removed_for_block, block_height);
}
 
CFeeRate FeeRateEstimatorManager::BlockPolicyEstimateRawFee(unsigned int target, double threshold, FeeEstimateHorizon horizon, EstimationResult* buckets) const
{
    return m_block_policy_estimator->estimateRawFee(target, threshold, horizon, buckets);
}
 
unsigned int FeeRateEstimatorManager::BlockPolicyHighestTargetTracked(FeeEstimateHorizon horizon) const
{
    return m_block_policy_estimator->HighestTargetTracked(horizon);
}
 
unsigned int FeeRateEstimatorManager::MaximumTarget() const
{
    return std::max(m_block_policy_estimator->MaximumTarget(), m_mempool_estimator->MaximumTarget());
}