Bitcoin Core Fuzz Coverage Report

Coverage Report

Created: 2026-03-24 13:57

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/root/bitcoin/src/rpc/fees.cpp
Line
Count
Source
1
// Copyright (c) 2010 Satoshi Nakamoto
2
// Copyright (c) 2009-present The Bitcoin Core developers
3
// Distributed under the MIT software license, see the accompanying
4
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6
#include <common/messages.h>
7
#include <core_io.h>
8
#include <node/context.h>
9
#include <policy/feerate.h>
10
#include <policy/fees/block_policy_estimator.h>
11
#include <rpc/protocol.h>
12
#include <rpc/request.h>
13
#include <rpc/server.h>
14
#include <rpc/server_util.h>
15
#include <rpc/util.h>
16
#include <txmempool.h>
17
#include <univalue.h>
18
#include <util/fees.h>
19
#include <validationinterface.h>
20
21
#include <algorithm>
22
#include <array>
23
#include <cmath>
24
#include <string>
25
#include <string_view>
26
27
using common::FeeModeFromString;
28
using common::FeeModesDetail;
29
using common::InvalidEstimateModeErrorMessage;
30
using node::NodeContext;
31
32
static RPCHelpMan estimatesmartfee()
33
0
{
34
0
    return RPCHelpMan{
35
0
        "estimatesmartfee",
36
0
        "Estimates the approximate fee per kilobyte needed for a transaction to begin\n"
37
0
        "confirmation within conf_target blocks if possible and return the number of blocks\n"
38
0
        "for which the estimate is valid. Uses virtual transaction size as defined\n"
39
0
        "in BIP 141 (witness data is discounted).\n",
40
0
        {
41
0
            {"conf_target", RPCArg::Type::NUM, RPCArg::Optional::NO, "Confirmation target in blocks (1 - 1008)"},
42
0
            {"estimate_mode", RPCArg::Type::STR, RPCArg::Default{"economical"}, "The fee estimate mode.\n"
43
0
              + FeeModesDetail(std::string("default mode will be used"))},
44
0
        },
45
0
        RPCResult{
46
0
            RPCResult::Type::OBJ, "", "",
47
0
            {
48
0
                {RPCResult::Type::NUM, "feerate", /*optional=*/true, "estimate fee rate in " + CURRENCY_UNIT + "/kvB (only present if no errors were encountered)"},
49
0
                {RPCResult::Type::ARR, "errors", /*optional=*/true, "Errors encountered during processing (if there are any)",
50
0
                    {
51
0
                        {RPCResult::Type::STR, "", "error"},
52
0
                    }},
53
0
                {RPCResult::Type::NUM, "blocks", "block number where estimate was found\n"
54
0
                "The request target will be clamped between 2 and the highest target\n"
55
0
                "fee estimation is able to return based on how long it has been running.\n"
56
0
                "An error is returned if not enough transactions and blocks\n"
57
0
                "have been observed to make an estimate for any number of blocks."},
58
0
        }},
59
0
        RPCExamples{
60
0
            HelpExampleCli("estimatesmartfee", "6") +
61
0
            HelpExampleRpc("estimatesmartfee", "6")
62
0
        },
63
0
        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
64
0
        {
65
0
            CBlockPolicyEstimator& fee_estimator = EnsureAnyFeeEstimator(request.context);
66
0
            const NodeContext& node = EnsureAnyNodeContext(request.context);
67
0
            const CTxMemPool& mempool = EnsureMemPool(node);
68
69
0
            CHECK_NONFATAL(mempool.m_opts.signals)->SyncWithValidationInterfaceQueue();
Line
Count
Source
110
0
    inline_check_non_fatal(condition, std::source_location::current(), #condition)
70
0
            unsigned int max_target = fee_estimator.HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
71
0
            unsigned int conf_target = ParseConfirmTarget(request.params[0], max_target);
72
0
            FeeEstimateMode fee_mode;
73
0
            if (!FeeModeFromString(self.Arg<std::string_view>("estimate_mode"), fee_mode)) {
74
0
                throw JSONRPCError(RPC_INVALID_PARAMETER, InvalidEstimateModeErrorMessage());
75
0
            }
76
77
0
            UniValue result(UniValue::VOBJ);
78
0
            UniValue errors(UniValue::VARR);
79
0
            FeeCalculation feeCalc;
80
0
            bool conservative{fee_mode == FeeEstimateMode::CONSERVATIVE};
81
0
            CFeeRate feeRate{fee_estimator.estimateSmartFee(conf_target, &feeCalc, conservative)};
82
0
            if (feeRate != CFeeRate(0)) {
83
0
                CFeeRate min_mempool_feerate{mempool.GetMinFee()};
84
0
                CFeeRate min_relay_feerate{mempool.m_opts.min_relay_feerate};
85
0
                feeRate = std::max({feeRate, min_mempool_feerate, min_relay_feerate});
86
0
                result.pushKV("feerate", ValueFromAmount(feeRate.GetFeePerK()));
87
0
            } else {
88
0
                errors.push_back("Insufficient data or no feerate found");
89
0
                result.pushKV("errors", std::move(errors));
90
0
            }
91
0
            result.pushKV("blocks", feeCalc.returnedTarget);
92
0
            return result;
93
0
        },
94
0
    };
95
0
}
96
97
static RPCHelpMan estimaterawfee()
98
0
{
99
0
    return RPCHelpMan{
100
0
        "estimaterawfee",
101
0
        "WARNING: This interface is unstable and may disappear or change!\n"
102
0
        "\nWARNING: This is an advanced API call that is tightly coupled to the specific\n"
103
0
        "implementation of fee estimation. The parameters it can be called with\n"
104
0
        "and the results it returns will change if the internal implementation changes.\n"
105
0
        "\nEstimates the approximate fee per kilobyte needed for a transaction to begin\n"
106
0
        "confirmation within conf_target blocks if possible. Uses virtual transaction size as\n"
107
0
        "defined in BIP 141 (witness data is discounted).\n",
108
0
        {
109
0
            {"conf_target", RPCArg::Type::NUM, RPCArg::Optional::NO, "Confirmation target in blocks (1 - 1008)"},
110
0
            {"threshold", RPCArg::Type::NUM, RPCArg::Default{0.95}, "The proportion of transactions in a given feerate range that must have been\n"
111
0
            "confirmed within conf_target in order to consider those feerates as high enough and proceed to check\n"
112
0
            "lower buckets."},
113
0
        },
114
0
        RPCResult{
115
0
            RPCResult::Type::OBJ, "", "Results are returned for any horizon which tracks blocks up to the confirmation target",
116
0
            {
117
0
                {RPCResult::Type::OBJ, "short", /*optional=*/true, "estimate for short time horizon",
118
0
                    {
119
0
                        {RPCResult::Type::NUM, "feerate", /*optional=*/true, "estimate fee rate in " + CURRENCY_UNIT + "/kvB"},
120
0
                        {RPCResult::Type::NUM, "decay", "exponential decay (per block) for historical moving average of confirmation data"},
121
0
                        {RPCResult::Type::NUM, "scale", "The resolution of confirmation targets at this time horizon"},
122
0
                        {RPCResult::Type::OBJ, "pass", /*optional=*/true, "information about the lowest range of feerates to succeed in meeting the threshold",
123
0
                        {
124
0
                                {RPCResult::Type::NUM, "startrange", "start of feerate range"},
125
0
                                {RPCResult::Type::NUM, "endrange", "end of feerate range"},
126
0
                                {RPCResult::Type::NUM, "withintarget", "number of txs over history horizon in the feerate range that were confirmed within target"},
127
0
                                {RPCResult::Type::NUM, "totalconfirmed", "number of txs over history horizon in the feerate range that were confirmed at any point"},
128
0
                                {RPCResult::Type::NUM, "inmempool", "current number of txs in mempool in the feerate range unconfirmed for at least target blocks"},
129
0
                                {RPCResult::Type::NUM, "leftmempool", "number of txs over history horizon in the feerate range that left mempool unconfirmed after target"},
130
0
                        }},
131
0
                        {RPCResult::Type::OBJ, "fail", /*optional=*/true, "information about the highest range of feerates to fail to meet the threshold",
132
0
                        {
133
0
                            {RPCResult::Type::ELISION, "", ""},
134
0
                        }},
135
0
                        {RPCResult::Type::ARR, "errors", /*optional=*/true, "Errors encountered during processing (if there are any)",
136
0
                        {
137
0
                            {RPCResult::Type::STR, "error", ""},
138
0
                        }},
139
0
                }},
140
0
                {RPCResult::Type::OBJ, "medium", /*optional=*/true, "estimate for medium time horizon",
141
0
                {
142
0
                    {RPCResult::Type::ELISION, "", ""},
143
0
                }},
144
0
                {RPCResult::Type::OBJ, "long", /*optional=*/true, "estimate for long time horizon",
145
0
                {
146
0
                    {RPCResult::Type::ELISION, "", ""},
147
0
                }},
148
0
            }},
149
0
        RPCExamples{
150
0
            HelpExampleCli("estimaterawfee", "6 0.9")
151
0
        },
152
0
        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
153
0
        {
154
0
            CBlockPolicyEstimator& fee_estimator = EnsureAnyFeeEstimator(request.context);
155
0
            const NodeContext& node = EnsureAnyNodeContext(request.context);
156
157
0
            CHECK_NONFATAL(node.validation_signals)->SyncWithValidationInterfaceQueue();
Line
Count
Source
110
0
    inline_check_non_fatal(condition, std::source_location::current(), #condition)
158
0
            unsigned int max_target = fee_estimator.HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
159
0
            unsigned int conf_target = ParseConfirmTarget(request.params[0], max_target);
160
0
            double threshold = 0.95;
161
0
            if (!request.params[1].isNull()) {
162
0
                threshold = request.params[1].get_real();
163
0
            }
164
0
            if (threshold < 0 || threshold > 1) {
165
0
                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid threshold");
166
0
            }
167
168
0
            UniValue result(UniValue::VOBJ);
169
170
0
            for (const FeeEstimateHorizon horizon : ALL_FEE_ESTIMATE_HORIZONS) {
171
0
                CFeeRate feeRate;
172
0
                EstimationResult buckets;
173
174
                // Only output results for horizons which track the target
175
0
                if (conf_target > fee_estimator.HighestTargetTracked(horizon)) continue;
176
177
0
                feeRate = fee_estimator.estimateRawFee(conf_target, threshold, horizon, &buckets);
178
0
                UniValue horizon_result(UniValue::VOBJ);
179
0
                UniValue errors(UniValue::VARR);
180
0
                UniValue passbucket(UniValue::VOBJ);
181
0
                passbucket.pushKV("startrange", round(buckets.pass.start));
182
0
                passbucket.pushKV("endrange", round(buckets.pass.end));
183
0
                passbucket.pushKV("withintarget", round(buckets.pass.withinTarget * 100.0) / 100.0);
184
0
                passbucket.pushKV("totalconfirmed", round(buckets.pass.totalConfirmed * 100.0) / 100.0);
185
0
                passbucket.pushKV("inmempool", round(buckets.pass.inMempool * 100.0) / 100.0);
186
0
                passbucket.pushKV("leftmempool", round(buckets.pass.leftMempool * 100.0) / 100.0);
187
0
                UniValue failbucket(UniValue::VOBJ);
188
0
                failbucket.pushKV("startrange", round(buckets.fail.start));
189
0
                failbucket.pushKV("endrange", round(buckets.fail.end));
190
0
                failbucket.pushKV("withintarget", round(buckets.fail.withinTarget * 100.0) / 100.0);
191
0
                failbucket.pushKV("totalconfirmed", round(buckets.fail.totalConfirmed * 100.0) / 100.0);
192
0
                failbucket.pushKV("inmempool", round(buckets.fail.inMempool * 100.0) / 100.0);
193
0
                failbucket.pushKV("leftmempool", round(buckets.fail.leftMempool * 100.0) / 100.0);
194
195
                // CFeeRate(0) is used to indicate error as a return value from estimateRawFee
196
0
                if (feeRate != CFeeRate(0)) {
197
0
                    horizon_result.pushKV("feerate", ValueFromAmount(feeRate.GetFeePerK()));
198
0
                    horizon_result.pushKV("decay", buckets.decay);
199
0
                    horizon_result.pushKV("scale", buckets.scale);
200
0
                    horizon_result.pushKV("pass", std::move(passbucket));
201
                    // buckets.fail.start == -1 indicates that all buckets passed, there is no fail bucket to output
202
0
                    if (buckets.fail.start != -1) horizon_result.pushKV("fail", std::move(failbucket));
203
0
                } else {
204
                    // Output only information that is still meaningful in the event of error
205
0
                    horizon_result.pushKV("decay", buckets.decay);
206
0
                    horizon_result.pushKV("scale", buckets.scale);
207
0
                    horizon_result.pushKV("fail", std::move(failbucket));
208
0
                    errors.push_back("Insufficient data or no feerate found which meets threshold");
209
0
                    horizon_result.pushKV("errors", std::move(errors));
210
0
                }
211
0
                result.pushKV(StringForFeeEstimateHorizon(horizon), std::move(horizon_result));
212
0
            }
213
0
            return result;
214
0
        },
215
0
    };
216
0
}
217
218
void RegisterFeeRPCCommands(CRPCTable& t)
219
0
{
220
0
    static const CRPCCommand commands[]{
221
0
        {"util", &estimatesmartfee},
222
0
        {"hidden", &estimaterawfee},
223
0
    };
224
0
    for (const auto& c : commands) {
225
0
        t.appendCommand(c.name, &c);
226
0
    }
227
0
}