dustdynamic: Support specifying a multiplier (default to 3)

Historically, dustrelayfee was based on 3x the cost to spend an output, so use that for the default multiplier

Author: luke-jr

src/init.cpp

@@ -640,8 +640,9 @@ void SetupServerArgs(ArgsManager& argsman)
     argsman.AddArg("-acceptnonstdtxn", strprintf("Relay and mine \"non-standard\" transactions (test networks only; default: %u)", DEFAULT_ACCEPT_NON_STD_TXN), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::NODE_RELAY);
     argsman.AddArg("-incrementalrelayfee=<amt>", strprintf("Fee rate (in %s/kvB) used to define cost of relay, used for mempool limiting and replacement policy. (default: %s)", CURRENCY_UNIT, FormatMoney(DEFAULT_INCREMENTAL_RELAY_FEE)), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::NODE_RELAY);
     argsman.AddArg("-dustrelayfee=<amt>", strprintf("Fee rate (in %s/kvB) used to define dust, the value of an output such that it will cost more than its value in fees at this fee rate to spend it. (default: %s)", CURRENCY_UNIT, FormatMoney(DUST_RELAY_TX_FEE)), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
-    argsman.AddArg("-dustdynamic=off|target:<blocks>|mempool:<kvB>",
-                   strprintf("Automatically raise dustrelayfee based on either the expected fee to be mined within <blocks> blocks, or to be within the best <kvB> kvB of this node's mempool. (default: %s)",
+    argsman.AddArg("-dustdynamic=off|[<multiplier>*]target:<blocks>|[<multiplier>*]mempool:<kvB>",
+                   strprintf("Automatically raise dustrelayfee based on either the expected fee to be mined within <blocks> blocks, or to be within the best <kvB> kvB of this node's mempool. If unspecified, multiplier is %s. (default: %s)",
+                             DEFAULT_DUST_RELAY_MULTIPLIER,
                              DEFAULT_DUST_DYNAMIC), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     argsman.AddArg("-acceptstalefeeestimates", strprintf("Read fee estimates even if they are stale (%sdefault: %u) fee estimates are considered stale if they are %s hours old", "regtest only; ", DEFAULT_ACCEPT_STALE_FEE_ESTIMATES, Ticks<std::chrono::hours>(MAX_FILE_AGE)), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-bytespersigop", strprintf("Equivalent bytes per sigop in transactions for relay and mining (default: %u)", DEFAULT_BYTES_PER_SIGOP), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);

src/kernel/mempool_options.h

@@ -58,6 +58,8 @@ struct MemPoolOptions {
     CFeeRate dust_relay_feerate_floor{DUST_RELAY_TX_FEE};
     /** Negative for a target number of blocks, positive for target kB into current mempool. */
     int32_t dust_relay_target{0};
+    /** Multiplier for dustdynamic assignments, in thousandths. */
+    int dust_relay_multiplier{DEFAULT_DUST_RELAY_MULTIPLIER};
     /**
      * A data carrying output is an unspendable output containing data. The script
      * type is designated as TxoutType::NULL_DATA.

src/node/mempool_args.cpp

@@ -26,6 +26,8 @@
 #include <chrono>
 #include <cstdint>
 #include <memory>
+#include <string_view>
+#include <utility>
 
 using common::AmountErrMsg;
 using kernel::MemPoolLimits;
@@ -44,11 +46,23 @@ void ApplyArgsManOptions(const ArgsManager& argsman, MemPoolLimits& mempool_limi
 }
 }
 
-util::Result<int32_t> ParseDustDynamicOpt(const std::string& optstr, const unsigned int max_fee_estimate_blocks)
+util::Result<std::pair<int32_t, int>> ParseDustDynamicOpt(std::string_view optstr, const unsigned int max_fee_estimate_blocks)
 {
     if (optstr == "0" || optstr == "off") {
-        return 0;
-    } else if (optstr.rfind("target:", 0) == 0) {
+        return std::pair<int32_t, int>(0, DEFAULT_DUST_RELAY_MULTIPLIER);
+    }
+
+    int multiplier{DEFAULT_DUST_RELAY_MULTIPLIER};
+    if (auto pos = optstr.find('*'); pos != optstr.npos) {
+        int64_t parsed;
+        if ((!ParseFixedPoint(optstr.substr(0, pos), 3, &parsed)) || parsed > std::numeric_limits<int>::max() || parsed < 1) {
+            return util::Error{_("failed to parse multiplier")};
+        }
+        multiplier = parsed;
+        optstr.remove_prefix(pos + 1);
+    }
+
+    if (optstr.rfind("target:", 0) == 0) {
         if (!max_fee_estimate_blocks) {
             return util::Error{_("\"target\" mode requires fee estimator (disabled)")};
         }
@@ -62,7 +76,7 @@ util::Result<int32_t> ParseDustDynamicOpt(const std::string& optstr, const unsig
         if (*val > max_fee_estimate_blocks) {
             return util::Error{strprintf(_("target can only be at most %s blocks"), max_fee_estimate_blocks)};
         }
-        return -*val;
+        return std::pair<int32_t, int>(-*val, multiplier);
     } else if (optstr.rfind("mempool:", 0) == 0) {
         const auto val = ToIntegral<int32_t>(optstr.substr(8));
         if (!val) {
@@ -71,7 +85,7 @@ util::Result<int32_t> ParseDustDynamicOpt(const std::string& optstr, const unsig
         if (*val < 1) {
             return util::Error{_("mempool position must be at least 1 kB")};
         }
-        return *val;
+        return std::pair<int32_t, int>(*val, multiplier);
     } else {
         return util::Error{strprintf(_("\"%s\""), optstr)};
     }
@@ -124,7 +138,8 @@ util::Result<void> ApplyArgsManOptions(const ArgsManager& argsman, const CChainP
         if (!parsed) {
             return util::Error{strprintf(_("Invalid mode for dustdynamic: %s"), util::ErrorString(parsed))};
         }
-        mempool_opts.dust_relay_target = *parsed;
+        mempool_opts.dust_relay_target = parsed->first;
+        mempool_opts.dust_relay_multiplier = parsed->second;
     }
 
     mempool_opts.permit_bare_pubkey = argsman.GetBoolArg("-permitbarepubkey", DEFAULT_PERMIT_BAREPUBKEY);

src/node/mempool_args.h

@@ -8,7 +8,8 @@
 #include <util/result.h>
 
 #include <cstdint>
-#include <string>
+#include <string_view>
+#include <utility>
 
 class ArgsManager;
 class CChainParams;
@@ -17,7 +18,7 @@ namespace kernel {
 struct MemPoolOptions;
 };
 
-[[nodiscard]] util::Result<int32_t> ParseDustDynamicOpt(const std::string& optstr, unsigned int max_fee_estimate_blocks);
+[[nodiscard]] util::Result<std::pair<int32_t, int>> ParseDustDynamicOpt(std::string_view optstr, unsigned int max_fee_estimate_blocks);
 
 /**
  * Overlay the options set in \p argsman on top of corresponding members in \p mempool_opts.

src/policy/feerate.h

@@ -71,6 +71,7 @@ class CFeeRate
     std::string ToString(const FeeEstimateMode& fee_estimate_mode = FeeEstimateMode::BTC_KVB) const;
     friend CFeeRate operator*(const CFeeRate& f, int a) { return CFeeRate(a * f.nSatoshisPerK); }
     friend CFeeRate operator*(int a, const CFeeRate& f) { return CFeeRate(a * f.nSatoshisPerK); }
+    friend CFeeRate operator/(const CFeeRate& f, int a) { return CFeeRate(f.nSatoshisPerK / a); }
 
     SERIALIZE_METHODS(CFeeRate, obj) { READWRITE(obj.nSatoshisPerK); }
 };

src/policy/policy.h

@@ -60,6 +60,7 @@ static constexpr unsigned int MAX_STANDARD_SCRIPTSIG_SIZE{1650};
  * outputs below the new threshold */
 static constexpr unsigned int DUST_RELAY_TX_FEE{3000};
 static const std::string DEFAULT_DUST_DYNAMIC{"off"};
+static const int DEFAULT_DUST_RELAY_MULTIPLIER{3'000};
 static const std::string DEFAULT_SPKREUSE{"allow"};
 /** Default for -minrelaytxfee, minimum relay fee for transactions */
 static constexpr unsigned int DEFAULT_MIN_RELAY_TX_FEE{1000};

src/rpc/mempool.cpp

@@ -727,12 +727,19 @@ UniValue MempoolInfoToJSON(const CTxMemPool& pool, const std::optional<MempoolHi
     ret.pushKV("incrementalrelayfee", ValueFromAmount(pool.m_opts.incremental_relay_feerate.GetFeePerK()));
     ret.pushKV("dustrelayfee", ValueFromAmount(pool.m_opts.dust_relay_feerate.GetFeePerK()));
     ret.pushKV("dustrelayfeefloor", ValueFromAmount(pool.m_opts.dust_relay_feerate_floor.GetFeePerK()));
-    if (pool.m_opts.dust_relay_target < 0) {
-        ret.pushKV("dustdynamic", strprintf("target:%u", -pool.m_opts.dust_relay_target));
-    } else if (pool.m_opts.dust_relay_target > 0) {
-        ret.pushKV("dustdynamic", strprintf("mempool:%u", pool.m_opts.dust_relay_target));
-    } else {
+    if (pool.m_opts.dust_relay_target == 0) {
         ret.pushKV("dustdynamic", "off");
+    } else {
+        std::string multiplier_str = strprintf("%u", pool.m_opts.dust_relay_multiplier / 1000);
+        if (pool.m_opts.dust_relay_multiplier % 1000) {
+            multiplier_str += strprintf(".%03u", pool.m_opts.dust_relay_multiplier % 1000);
+            while (multiplier_str.back() == '0') multiplier_str.pop_back();
+        }
+        if (pool.m_opts.dust_relay_target < 0) {
+            ret.pushKV("dustdynamic", strprintf("%s*target:%u", multiplier_str, -pool.m_opts.dust_relay_target));
+        } else { // pool.m_opts.dust_relay_target > 0
+            ret.pushKV("dustdynamic", strprintf("%s*mempool:%u", multiplier_str, pool.m_opts.dust_relay_target));
+        }
     }
     ret.pushKV("unbroadcastcount", uint64_t{pool.GetUnbroadcastTxs().size()});
     ret.pushKV("fullrbf", (pool.m_opts.rbf_policy == RBFPolicy::Always));

src/txmempool.cpp

@@ -714,6 +714,8 @@ void CTxMemPool::UpdateDynamicDustFeerate()
         }
     }
 
+    est_feerate = (est_feerate * m_opts.dust_relay_multiplier) / 1'000;
+
     if (est_feerate < m_opts.dust_relay_feerate_floor) {
         est_feerate = m_opts.dust_relay_feerate_floor;
     }

test/functional/feature_fee_estimation.py

@@ -251,22 +251,32 @@ def sanity_check_estimates_range(self):
         self.log.info("Final estimates after emptying mempools")
         check_estimates(self.nodes[1], self.fees_per_kb)
 
+    def test_feerate_dustrelayfee_common(self, node, multiplier, dust_mode, desc, expected_base):
+        dust_parameter = f"-dustdynamic={dust_mode}".replace('=3*', '=')
+        self.log.info(f"Test dust limit setting {dust_parameter} (fee estimation for {desc})")
+        self.restart_node(0, extra_args=[dust_parameter])
+        assert_equal(node.getmempoolinfo()['dustdynamic'], dust_mode)
+        with node.busy_wait_for_debug_log([b'Updating dust feerate']):
+            node.mockscheduler(SECONDS_PER_HOUR)
+        mempool_info = node.getmempoolinfo()
+        assert_equal(mempool_info['dustrelayfee'], satoshi_round(expected_base() * multiplier))
+        assert mempool_info['dustrelayfee'] > mempool_info['dustrelayfeefloor']
+
+    def test_feerate_dustrelayfee_target(self, node, multiplier, dustfee_target):
+        dust_mode = f"{multiplier}*target:{dustfee_target}"
+        self.test_feerate_dustrelayfee_common(node, multiplier, dust_mode, f'{dustfee_target} blocks', lambda: node.estimaterawfee(dustfee_target, target_success_threshold)['long']['feerate'])
+
+    def test_feerate_dustrelayfee_mempool(self, node, multiplier, dustfee_kB):
+        dust_mode = f"{multiplier}*mempool:{dustfee_kB}"
+        self.test_feerate_dustrelayfee_common(node, multiplier, dust_mode, f'{dustfee_kB} kB into mempool', lambda: get_feerate_into_mempool(node, dustfee_kB))
+
     def test_feerate_dustrelayfee(self):
         node = self.nodes[0]
 
         # test dustdynamic=target:<blocks>
         for dustfee_target in (2, 8, 1008):
-            dust_mode = f"target:{dustfee_target}"
-            dust_parameter = f"-dustdynamic={dust_mode}"
-            self.log.info(f"Test dust limit setting {dust_parameter} (fee estimation for {dustfee_target} blocks)")
-            self.restart_node(0, extra_args=[dust_parameter])
-            assert_equal(node.getmempoolinfo()['dustdynamic'], dust_mode)
-            with node.busy_wait_for_debug_log([b'Updating dust feerate']):
-                node.mockscheduler(SECONDS_PER_HOUR)
-            fee_est = node.estimaterawfee(dustfee_target, target_success_threshold)['long']['feerate']
-            mempool_info = node.getmempoolinfo()
-            assert_equal(mempool_info['dustrelayfee'], fee_est)
-            assert mempool_info['dustrelayfee'] > mempool_info['dustrelayfeefloor']
+            for multiplier in (Decimal('0.5'), 1, 3, Decimal('3.3'), 10, Decimal('10.001')):
+                self.test_feerate_dustrelayfee_target(node, multiplier, dustfee_target)
 
         # Fill mempool up
         mempool_size = 0
@@ -288,17 +298,8 @@ def test_feerate_dustrelayfee(self):
 
         # test dustdynamic=mempool:<kB>
         for dustfee_kB in (1, 10, 50):
-            dust_mode = f"mempool:{dustfee_kB}"
-            dust_parameter = f"-dustdynamic={dust_mode}"
-            self.log.info(f"Test dust limit setting {dust_parameter} (fee estimation for {dustfee_kB} kB into mempool)")
-            self.restart_node(0, extra_args=[dust_parameter])
-            assert_equal(node.getmempoolinfo()['dustdynamic'], dust_mode)
-            with node.busy_wait_for_debug_log([b'Updating dust feerate']):
-                node.mockscheduler(SECONDS_PER_HOUR)
-            feerate_into_mempool = get_feerate_into_mempool(node, dustfee_kB)
-            mempool_info = node.getmempoolinfo()
-            assert_equal(mempool_info['dustrelayfee'], feerate_into_mempool)
-            assert mempool_info['dustrelayfee'] > mempool_info['dustrelayfeefloor']
+            for multiplier in (Decimal('0.5'), 1, 3, Decimal('3.3'), 10, Decimal('10.001')):
+                self.test_feerate_dustrelayfee_mempool(node, multiplier, dustfee_kB)
 
         # Restore nodes to a normal state, wiping the mempool
         self.stop_node(0)