Inside Bitcoin

751    LOCK(m_cs_fee_estimator);
752    // Return failure if trying to analyze a target we're not tracking
753    if (confTarget <= 0 || (unsigned int)confTarget > stats->GetMaxConfirms())
754        return CFeeRate(0);
755    if (successThreshold > 1)
756        return CFeeRate(0);
757
758    double median = stats->EstimateMedianVal(confTarget, sufficientTxs, successThreshold, nBestSeenHeight, result);
759
760    if (median < 0)
761        return CFeeRate(0);
762
763    return CFeeRate(llround(median));
764}
765
766unsigned int CBlockPolicyEstimator::HighestTargetTracked(FeeEstimateHorizon horizon) const
767{
768    LOCK(m_cs_fee_estimator);
769    switch (horizon) {
770    case FeeEstimateHorizon::SHORT_HALFLIFE: {
771        return shortStats->GetMaxConfirms();
772    }
773    case FeeEstimateHorizon::MED_HALFLIFE: {
774        return feeStats->GetMaxConfirms();
775    }
776    case FeeEstimateHorizon::LONG_HALFLIFE: {
777        return longStats->GetMaxConfirms();
778    }
779    } // no default case, so the compiler can warn about missing cases
780    assert(false);
781}
782
783unsigned int CBlockPolicyEstimator::BlockSpan() const
784{
785    if (firstRecordedHeight == 0) return 0;
786    assert(nBestSeenHeight >= firstRecordedHeight);
787
788    return nBestSeenHeight - firstRecordedHeight;
789}
790
791unsigned int CBlockPolicyEstimator::HistoricalBlockSpan() const
792{
793    if (historicalFirst == 0) return 0;
794    assert(historicalBest >= historicalFirst);
795
796    if (nBestSeenHeight - historicalBest > OLDEST_ESTIMATE_HISTORY) return 0;
797
798    return historicalBest - historicalFirst;
799}
800
801unsigned int CBlockPolicyEstimator::MaxUsableEstimate() const
802{
803    // Block spans are divided by 2 to make sure there are enough potential failing data points for the estimate
804    return std::min(longStats->GetMaxConfirms(), std::max(BlockSpan(), HistoricalBlockSpan()) / 2);
805}
806
807/** Return a fee estimate at the required successThreshold from the shortest
808 * time horizon which tracks confirmations up to the desired target.  If
809 * checkShorterHorizon is requested, also allow short time horizon estimates
810 * for a lower target to reduce the given answer */
811double CBlockPolicyEstimator::estimateCombinedFee(unsigned int confTarget, double successThreshold, bool checkShorterHorizon, EstimationResult *result) const
812{
813    double estimate = -1;
814    if (confTarget >= 1 && confTarget <= longStats->GetMaxConfirms()) {
815        // Find estimate from shortest time horizon possible
816        if (confTarget <= shortStats->GetMaxConfirms()) { // short horizon
817            estimate = shortStats->EstimateMedianVal(confTarget, SUFFICIENT_TXS_SHORT, successThreshold, nBestSeenHeight, result);
818        }
819        else if (confTarget <= feeStats->GetMaxConfirms()) { // medium horizon
820            estimate = feeStats->EstimateMedianVal(confTarget, SUFFICIENT_FEETXS, successThreshold, nBestSeenHeight, result);
821        }
822        else { // long horizon
823            estimate = longStats->EstimateMedianVal(confTarget, SUFFICIENT_FEETXS, successThreshold, nBestSeenHeight, result);
824        }
825        if (checkShorterHorizon) {
826            EstimationResult tempResult;
827            // If a lower confTarget from a more recent horizon returns a lower answer use it.
828            if (confTarget > feeStats->GetMaxConfirms()) {
829                double medMax = feeStats->EstimateMedianVal(feeStats->GetMaxConfirms(), SUFFICIENT_FEETXS, successThreshold, nBestSeenHeight, &tempResult);
830                if (medMax > 0 && (estimate == -1 || medMax < estimate)) {
831                    estimate = medMax;
832                    if (result) *result = tempResult;
833                }
834            }
835            if (confTarget > shortStats->GetMaxConfirms()) {
836                double shortMax = shortStats->EstimateMedianVal(shortStats->GetMaxConfirms(), SUFFICIENT_TXS_SHORT, successThreshold, nBestSeenHeight, &tempResult);
837                if (shortMax > 0 && (estimate == -1 || shortMax < estimate)) {
838                    estimate = shortMax;
839                    if (result) *result = tempResult;
840                }
841            }
842        }
843    }
844    return estimate;
845}
846
847/** Ensure that for a conservative estimate, the DOUBLE_SUCCESS_PCT is also met
848 * at 2 * target for any longer time horizons.
849 */
850double CBlockPolicyEstimator::estimateConservativeFee(unsigned int doubleTarget, EstimationResult *result) const
851{
852    double estimate = -1;
853    EstimationResult tempResult;
854    if (doubleTarget <= shortStats->GetMaxConfirms()) {
855        estimate = feeStats->EstimateMedianVal(doubleTarget, SUFFICIENT_FEETXS, DOUBLE_SUCCESS_PCT, nBestSeenHeight, result);
856    }
857    if (doubleTarget <= feeStats->GetMaxConfirms()) {
858        double longEstimate = longStats->EstimateMedianVal(doubleTarget, SUFFICIENT_FEETXS, DOUBLE_SUCCESS_PCT, nBestSeenHeight, &tempResult);
859        if (longEstimate > estimate) {
860            estimate = longEstimate;
861            if (result) *result = tempResult;
862        }
863    }
864    return estimate;
865}
866
867/** estimateSmartFee returns the max of the feerates calculated with a 60%
868 * threshold required at target / 2, an 85% threshold required at target and a
869 * 95% threshold required at 2 * target.  Each calculation is performed at the
870 * shortest time horizon which tracks the required target.  Conservative
871 * estimates, however, required the 95% threshold at 2 * target be met for any
872 * longer time horizons also.
873 */
874CFeeRate CBlockPolicyEstimator::estimateSmartFee(int confTarget, FeeCalculation *feeCalc, bool conservative) const
875{
876    LOCK(m_cs_fee_estimator);
877
878    FeeCalculation temp_fee_calc;
879    if (!feeCalc) feeCalc = &temp_fee_calc;
880
881    feeCalc->desiredTarget = confTarget;
882    feeCalc->returnedTarget = confTarget;
883    feeCalc->best_height = nBestSeenHeight;
884
885    double median = -1;
886    EstimationResult tempResult;
887
888    // Return failure if trying to analyze a target we're not tracking
889    if (confTarget <= 0 || (unsigned int)confTarget > longStats->GetMaxConfirms()) {
890        return CFeeRate(0);  // error condition
891    }
892
893    // It's not possible to get reasonable estimates for confTarget of 1
894    if (confTarget == 1) confTarget = 2;
895
896    unsigned int maxUsableEstimate = MaxUsableEstimate();
897    if ((unsigned int)confTarget > maxUsableEstimate) {
898        confTarget = maxUsableEstimate;
899    }
900    feeCalc->returnedTarget = confTarget;
901
902    if (confTarget <= 1) return CFeeRate(0); // error condition
903
904    assert(confTarget > 0); //estimateCombinedFee and estimateConservativeFee take unsigned ints
905    /** true is passed to estimateCombined fee for target/2 and target so
906     * that we check the max confirms for shorter time horizons as well.
907     * This is necessary to preserve monotonically increasing estimates.
908     * For non-conservative estimates we do the same thing for 2*target, but
909     * for conservative estimates we want to skip these shorter horizons
910     * checks for 2*target because we are taking the max over all time
911     * horizons so we already have monotonically increasing estimates and
912     * the purpose of conservative estimates is not to let short term
913     * fluctuations lower our estimates by too much.
914     *
915     * Note: In certain rare edge cases, monotonically increasing estimates may
916     * not be guaranteed. Specifically, given two targets N and M, where M > N,
917     * if a sub-estimate for target N fails to return a valid fee rate, while
918     * target M has valid fee rate for that sub-estimate, target M may result
919     * in a higher fee rate estimate than target N.
920     *
921     * See: https://github.com/bitcoin/bitcoin/issues/11800#issuecomment-349697807
922     */
923    double halfEst = estimateCombinedFee(confTarget/2, HALF_SUCCESS_PCT, true, &tempResult);
924    feeCalc->est = tempResult;
925    feeCalc->reason = BlockPolicyEstimateReason::HALF_ESTIMATE;
926    median = halfEst;
927    double actualEst = estimateCombinedFee(confTarget, SUCCESS_PCT, true, &tempResult);
928    if (actualEst > median) {
929        median = actualEst;
930        feeCalc->est = tempResult;
931        feeCalc->reason = BlockPolicyEstimateReason::FULL_ESTIMATE;
932    }
933    double doubleEst = estimateCombinedFee(2 * confTarget, DOUBLE_SUCCESS_PCT, !conservative, &tempResult);
934    if (doubleEst > median) {
935        median = doubleEst;
936        feeCalc->est = tempResult;
937        feeCalc->reason = BlockPolicyEstimateReason::DOUBLE_ESTIMATE;
938    }
939
940    if (conservative || median == -1) {
941        double consEst =  estimateConservativeFee(2 * confTarget, &tempResult);
942        if (consEst > median) {
943            median = consEst;
944            feeCalc->est = tempResult;
945            feeCalc->reason = BlockPolicyEstimateReason::CONSERVATIVE;
946        }
947    }
948
949    if (median < 0) return CFeeRate(0); // error condition
950
951    LogDebug(BCLog::ESTIMATEFEE, "estimateSmartFee Selected feerate: %g Tgt: %d (requested %d) Reason: \"%s\" Decay %.5f: Estimation: (%g - %g) %.2f%% %.1f/(%.1f %d mem %.1f out) Fail: (%g - %g) %.2f%% %.1f/(%.1f %d mem %.1f out)",
952             median, feeCalc->returnedTarget, feeCalc->desiredTarget, StringForBlockPolicyEstimateReason(feeCalc->reason), feeCalc->est.decay,
953             feeCalc->est.pass.start, feeCalc->est.pass.end,
954             (feeCalc->est.pass.totalConfirmed + feeCalc->est.pass.inMempool + feeCalc->est.pass.leftMempool) > 0.0 ? 100 * feeCalc->est.pass.withinTarget / (feeCalc->est.pass.totalConfirmed + feeCalc->est.pass.inMempool + feeCalc->est.pass.leftMempool) : 0.0,
955             feeCalc->est.pass.withinTarget, feeCalc->est.pass.totalConfirmed, feeCalc->est.pass.inMempool, feeCalc->est.pass.leftMempool,
956             feeCalc->est.fail.start, feeCalc->est.fail.end,
957             (feeCalc->est.fail.totalConfirmed + feeCalc->est.fail.inMempool + feeCalc->est.fail.leftMempool) > 0.0 ? 100 * feeCalc->est.fail.withinTarget / (feeCalc->est.fail.totalConfirmed + feeCalc->est.fail.inMempool + feeCalc->est.fail.leftMempool) : 0.0,
958             feeCalc->est.fail.withinTarget, feeCalc->est.fail.totalConfirmed, feeCalc->est.fail.inMempool, feeCalc->est.fail.leftMempool);
959
960    return CFeeRate(llround(median));
961}
962
963util::Expected<FeeRateEstimation, FeeRateEstimationError> CBlockPolicyEstimator::EstimateFeeRate(int target, bool conservative) const
964{
965    FeeCalculation fee_calc;
966    CFeeRate feerate{estimateSmartFee(target, &fee_calc, conservative)};
967    if (feerate == CFeeRate(0)) {
968        return EstimationError(FeeRateEstimatorType::BLOCK_POLICY, fee_calc.returnedTarget, "Insufficient data or no feerate found");
969    }
970    return FeeRateEstimation{FeeRateEstimatorType::BLOCK_POLICY, feerate.GetFeePerVSize(), fee_calc.returnedTarget};
971}
972
973unsigned int CBlockPolicyEstimator::MaximumTarget() const
974{
975    return HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
976}
977
978void CBlockPolicyEstimator::Flush() {
979    FlushUnconfirmed();
980    FlushFeeEstimates();
981}
982
983void CBlockPolicyEstimator::FlushFeeEstimates()
984{
985    if (!m_estimation_filepath.parent_path().empty()) {
986        std::error_code error;
987        fs::create_directories(m_estimation_filepath.parent_path(), error);
988        if (error) {
989            LogWarning("Failed to create fee estimates directory %s: %s. Continue anyway.", fs::PathToString(m_estimation_filepath.parent_path()), error.message());
990            return;
991        }
992    }
993
994    AutoFile est_file{fsbridge::fopen(m_estimation_filepath, "wb")};
995    if (est_file.IsNull() || !Write(est_file)) {
996        LogWarning("Failed to write fee estimates to %s. Continue anyway.", fs::PathToString(m_estimation_filepath));
997        (void)est_file.fclose();
998        return;
999    }
1000    if (est_file.fclose() != 0) {