From 66d4a29ab073fbfdd4fa34f15cf07b638bcdb967 Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Thu, 9 Jan 2025 14:41:53 -0500
Subject: [PATCH 01/22] fees: add `ForecastResult` class

- This class represents the response returned by
  a fee rate forecaster.
---
 src/policy/fees/forecaster_util.h | 102 ++++++++++++++++++++++++++++++
 1 file changed, 102 insertions(+)
 create mode 100644 src/policy/fees/forecaster_util.h

diff --git a/src/policy/fees/forecaster_util.h b/src/policy/fees/forecaster_util.h
new file mode 100644
index 00000000000..a81057f664b
--- /dev/null
+++ b/src/policy/fees/forecaster_util.h
@@ -0,0 +1,102 @@
+// Copyright (c) 2025 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_POLICY_FEES_FORECASTER_UTIL_H
+#define BITCOIN_POLICY_FEES_FORECASTER_UTIL_H
+
+#include <util/feefrac.h>
+
+#include <optional>
+#include <string>
+
+/**
+ * @class ForecastResult
+ * Represents the response returned by a fee rate forecaster.
+ */
+class ForecastResult
+{
+public:
+    /**
+     * @struct ForecastResponse
+     * Contains fee rate forecast metadata.
+     */
+    struct ForecastResponse {
+        /**
+         * An estimated fee rate as a result of a forecast for economical transactions.
+         * This value is sufficient to confirm a package within the specified target.
+         */
+        FeeFrac low_priority;
+
+        /**
+         * An estimated fee rate as a result of forecast for high-priority transactions.
+         * This value is for users willing to pay more to increase the likelihood of
+         * confirmation within the specified target.
+         */
+        FeeFrac high_priority;
+
+        /**
+         * The chain tip at which the forecast was made.
+         */
+        unsigned int current_block_height{0};
+    };
+
+    /**
+     * Default ForecastResult constructor.
+     */
+    ForecastResult() {}
+
+    /**
+     * Constructs a ForecastResult object.
+     * @param response The forecast response data.
+     * @param error An optional error message (default: nullopt).
+     */
+    ForecastResult(ForecastResponse response, std::optional<std::string> error = std::nullopt)
+        : m_response(std::move(response)), m_error(std::move(error))
+    {
+    }
+
+    /**
+     * Checks if the forecast response is empty.
+     * @return true if both low and high priority forecast estimates are empty, false otherwise.
+     */
+    bool Empty() const
+    {
+        return m_response.low_priority.IsEmpty() && m_response.high_priority.IsEmpty();
+    }
+
+    /**
+     * Overloaded less than operator which compares two ForecastResult objects based on
+     * their high priority estimates.
+     * @param other The other ForecastResult object to compare with.
+     * @return true if the current object's high priority estimate is less than the other, false otherwise.
+     */
+    bool operator<(const ForecastResult& other) const
+    {
+        return m_response.high_priority << other.m_response.high_priority;
+    }
+
+    /**
+     * Retrieves the forecast response.
+     * @return A reference to the forecast response metadata.
+     */
+    const ForecastResponse& GetResponse() const
+    {
+        return m_response;
+    }
+
+    /**
+     * Retrieves the error message, if any.
+     * @return An optional string containing the error message.
+     */
+    const std::optional<std::string>& GetError() const
+    {
+        return m_error;
+    }
+
+private:
+    ForecastResponse m_response;        ///< The forecast response data.
+    std::optional<std::string> m_error; ///< Optional error message.
+};
+
+#endif // BITCOIN_POLICY_FEES_FORECASTER_UTIL_H

From a29c038e1afbf9ca4fcf168b1553785c2ba0e597 Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Thu, 9 Jan 2025 14:43:02 -0500
Subject: [PATCH 02/22] fees: add `ConfirmationTarget` struct

- Defines the types of confirmation targets for fee rate forecasters.

- This enable having a generic input for fee rate forecasters.
---
 src/policy/fees/forecaster_util.h | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/src/policy/fees/forecaster_util.h b/src/policy/fees/forecaster_util.h
index a81057f664b..c641b622001 100644
--- a/src/policy/fees/forecaster_util.h
+++ b/src/policy/fees/forecaster_util.h
@@ -99,4 +99,21 @@ private:
     std::optional<std::string> m_error; ///< Optional error message.
 };
 
+/**
+ * @enum ConfirmationTargetType
+ * Defines the types of confirmation targets for fee rate forecasters.
+ */
+enum class ConfirmationTargetType {
+    BLOCKS, /**< Forecasters providing estimates for a specific number of blocks use this type. */
+};
+
+/**
+ * @struct ConfirmationTarget
+ * Represents the input for a parameter of fee rate forecaster.
+ */
+struct ConfirmationTarget {
+    unsigned int value;
+    ConfirmationTargetType type;
+};
+
 #endif // BITCOIN_POLICY_FEES_FORECASTER_UTIL_H

From 0de1842f1ba56395e522e5be1c58750c973fd14d Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Thu, 9 Jan 2025 14:55:59 -0500
Subject: [PATCH 03/22] fees: add Forecaster abstract class

- This commit implements `Forecaster` abstract class
  as the base class of fee rate forecasters.

- Derived classes must provide concrete implementation
  of the virtual methods.

Co-authored-by: willcl-ark <will@256k1.dev>
---
 src/policy/fees/forecaster.h | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 src/policy/fees/forecaster.h

diff --git a/src/policy/fees/forecaster.h b/src/policy/fees/forecaster.h
new file mode 100644
index 00000000000..3fd7aeb0d81
--- /dev/null
+++ b/src/policy/fees/forecaster.h
@@ -0,0 +1,31 @@
+// Copyright (c) 2025 The Bitcoin Core developers
+// Distributed under the MIT software license. See the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_POLICY_FEES_FORECASTER_H
+#define BITCOIN_POLICY_FEES_FORECASTER_H
+
+#include <policy/fees/forecaster_util.h>
+
+/** \class Forecaster
+ * Abstract base class for fee rate forecasters.
+ */
+class Forecaster
+{
+public:
+    Forecaster() = default;
+
+    /**
+     * Forecast the fee rate required for package to confirm within
+     * a specified target.
+     *
+     * This pure virtual function must be overridden by derived classes.
+     * @param target The confirmation target for which to forecast the feerate for.
+     * @return ForecastResult containing the forecasted fee rate.
+     */
+    virtual ForecastResult EstimateFee(ConfirmationTarget& target) = 0;
+
+    virtual ~Forecaster() = default;
+};
+
+#endif // BITCOIN_POLICY_FEES_FORECASTER_H

From 35a0576ee2b087b8a953ab9fae7ed9faf492f3b0 Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Thu, 9 Jan 2025 15:17:07 -0500
Subject: [PATCH 04/22] fees: add `ForecastType` enum

- ForecastType will be used to identify forecasters.

- Each time a new forecaster is added, a corresponding
  enum value should be added to ForecastType.

- This allows users to identify which forecasting strategy
  was used to make a fee rate estimate.
---
 src/policy/fees/forecaster.h      | 7 ++++++-
 src/policy/fees/forecaster_util.h | 8 ++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/policy/fees/forecaster.h b/src/policy/fees/forecaster.h
index 3fd7aeb0d81..6bcc37a4dd1 100644
--- a/src/policy/fees/forecaster.h
+++ b/src/policy/fees/forecaster.h
@@ -12,8 +12,13 @@
  */
 class Forecaster
 {
+protected:
+    const ForecastType m_forecastType;
+
 public:
-    Forecaster() = default;
+    Forecaster(ForecastType forecastType) : m_forecastType(forecastType) {}
+
+    ForecastType GetForecastType() const { return m_forecastType; }
 
     /**
      * Forecast the fee rate required for package to confirm within
diff --git a/src/policy/fees/forecaster_util.h b/src/policy/fees/forecaster_util.h
index c641b622001..6485fc76b9b 100644
--- a/src/policy/fees/forecaster_util.h
+++ b/src/policy/fees/forecaster_util.h
@@ -10,6 +10,12 @@
 #include <optional>
 #include <string>
 
+/**
+ * @enum ForecastType
+ * Identifier for fee rate forecasters.
+ */
+enum class ForecastType {};
+
 /**
  * @class ForecastResult
  * Represents the response returned by a fee rate forecaster.
@@ -39,6 +45,8 @@ public:
          * The chain tip at which the forecast was made.
          */
         unsigned int current_block_height{0};
+        /* This identifies which forecaster is providing this feerate forecast */
+        ForecastType forecaster;
     };
 
     /**

From 51347355a74f6be729d3749c6dd6a4ec3c253df0 Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Mon, 13 Jan 2025 17:02:27 -0500
Subject: [PATCH 05/22] fees: add `ForecasterMan` class

- Its a module for managing and utilising multiple
  fee rate forecasters to provide fee rate forecast.

- The ForecasterManager class allows for the registration of
  multiple fee rate forecasters.

Co-authored-by: willcl-ark <will@256k1.dev>
---
 src/CMakeLists.txt                 |  1 +
 src/policy/fees/forecaster_man.cpp | 14 +++++++++++
 src/policy/fees/forecaster_man.h   | 37 ++++++++++++++++++++++++++++++
 3 files changed, 52 insertions(+)
 create mode 100644 src/policy/fees/forecaster_man.cpp
 create mode 100644 src/policy/fees/forecaster_man.h

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 89fdd855a45..e06f0dd0693 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -259,6 +259,7 @@ add_library(bitcoin_node STATIC EXCLUDE_FROM_ALL
   policy/ephemeral_policy.cpp
   policy/fees.cpp
   policy/fees_args.cpp
+  policy/fees/forecaster_man.cpp
   policy/packages.cpp
   policy/rbf.cpp
   policy/settings.cpp
diff --git a/src/policy/fees/forecaster_man.cpp b/src/policy/fees/forecaster_man.cpp
new file mode 100644
index 00000000000..462fb2c8026
--- /dev/null
+++ b/src/policy/fees/forecaster_man.cpp
@@ -0,0 +1,14 @@
+// Copyright (c) 2025 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/forecaster.h>
+#include <policy/fees/forecaster_man.h>
+#include <policy/fees/forecaster_util.h>
+
+#include <utility>
+
+void FeeRateForecasterManager::RegisterForecaster(std::shared_ptr<Forecaster> forecaster)
+{
+    forecasters.emplace(forecaster->GetForecastType(), forecaster);
+}
diff --git a/src/policy/fees/forecaster_man.h b/src/policy/fees/forecaster_man.h
new file mode 100644
index 00000000000..13784e0e0a3
--- /dev/null
+++ b/src/policy/fees/forecaster_man.h
@@ -0,0 +1,37 @@
+// Copyright (c) 2025 The Bitcoin Core developers
+// Distributed under the MIT software license. See the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_POLICY_FEES_FORECASTER_MAN_H
+#define BITCOIN_POLICY_FEES_FORECASTER_MAN_H
+
+#include <memory>
+#include <unordered_map>
+
+class Forecaster;
+class ForecastResult;
+
+enum class ForecastType;
+
+/** \class FeeRateForecasterManager
+ * Module for managing and utilising multiple fee rate forecasters to provide a forecast for a target.
+ *
+ * The FeeRateForecasterManager class allows for the registration of multiple fee rate
+ * forecasters.
+ */
+class FeeRateForecasterManager
+{
+private:
+    //! Map of all registered forecasters to their shared pointers.
+    std::unordered_map<ForecastType, std::shared_ptr<Forecaster>> forecasters;
+
+public:
+    /**
+     * Register a forecaster to provide fee rate estimates.
+     *
+     * @param[in] forecaster shared pointer to a Forecaster instance.
+     */
+    void RegisterForecaster(std::shared_ptr<Forecaster> forecaster);
+};
+
+#endif // BITCOIN_POLICY_FEES_FORECASTER_MAN_H

From 435f2424d1b0013a6ef58de7cb50e6e77e8d1659 Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Mon, 13 Jan 2025 09:58:23 -0500
Subject: [PATCH 06/22] fees: refactor: rename policy_fee_tests.cpp to
 feerounder_tests.cpp

- Also remame the test suite name to match the new name.
---
 src/test/CMakeLists.txt                                 | 2 +-
 src/test/{policy_fee_tests.cpp => feerounder_tests.cpp} | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename src/test/{policy_fee_tests.cpp => feerounder_tests.cpp} (96%)

diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index 859b9132067..09669dd3d85 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -62,6 +62,7 @@ add_executable(test_bitcoin
   descriptor_tests.cpp
   disconnected_transactions.cpp
   feefrac_tests.cpp
+  feerounder_tests.cpp
   flatfile_tests.cpp
   fs_tests.cpp
   getarg_tests.cpp
@@ -89,7 +90,6 @@ add_executable(test_bitcoin
   orphanage_tests.cpp
   peerman_tests.cpp
   pmt_tests.cpp
-  policy_fee_tests.cpp
   policyestimator_tests.cpp
   pool_tests.cpp
   pow_tests.cpp
diff --git a/src/test/policy_fee_tests.cpp b/src/test/feerounder_tests.cpp
similarity index 96%
rename from src/test/policy_fee_tests.cpp
rename to src/test/feerounder_tests.cpp
index 29d70cb5f85..400437e65ec 100644
--- a/src/test/policy_fee_tests.cpp
+++ b/src/test/feerounder_tests.cpp
@@ -9,7 +9,7 @@
 
 #include <set>
 
-BOOST_AUTO_TEST_SUITE(policy_fee_tests)
+BOOST_AUTO_TEST_SUITE(fee_rounder_tests)
 
 BOOST_AUTO_TEST_CASE(FeeRounder)
 {

From 86d46e71b5db222c6268f6347e9ed8524597d95f Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Thu, 9 Jan 2025 17:31:05 -0500
Subject: [PATCH 07/22] fees: refactor: rename fees to block_policy_estimator

- Also move it to policy/fees and update the includes
- Note: the block_policy_estimator.h include in block_policy_estimator.cpp was done manually.
---
 src/CMakeLists.txt                                       | 2 +-
 src/common/messages.cpp                                  | 2 +-
 src/init.cpp                                             | 3 ++-
 src/net_processing.cpp                                   | 2 +-
 src/node/context.cpp                                     | 2 +-
 src/node/interfaces.cpp                                  | 3 ++-
 src/policy/{fees.cpp => fees/block_policy_estimator.cpp} | 2 +-
 src/policy/{fees.h => fees/block_policy_estimator.h}     | 6 +++---
 src/qt/sendcoinsdialog.cpp                               | 2 +-
 src/rpc/fees.cpp                                         | 2 +-
 src/rpc/server_util.cpp                                  | 3 ++-
 src/test/feerounder_tests.cpp                            | 2 +-
 src/test/fuzz/fees.cpp                                   | 2 +-
 src/test/fuzz/kitchen_sink.cpp                           | 2 +-
 src/test/fuzz/policy_estimator.cpp                       | 2 +-
 src/test/fuzz/policy_estimator_io.cpp                    | 2 +-
 src/test/policyestimator_tests.cpp                       | 2 +-
 src/test/util/setup_common.cpp                           | 2 +-
 src/wallet/coincontrol.h                                 | 2 +-
 src/wallet/feebumper.cpp                                 | 2 +-
 src/wallet/interfaces.cpp                                | 2 +-
 src/wallet/spend.h                                       | 2 +-
 src/wallet/test/spend_tests.cpp                          | 2 +-
 23 files changed, 28 insertions(+), 25 deletions(-)
 rename src/policy/{fees.cpp => fees/block_policy_estimator.cpp} (99%)
 rename src/policy/{fees.h => fees/block_policy_estimator.h} (98%)

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index e06f0dd0693..18fc303ed62 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -257,7 +257,7 @@ add_library(bitcoin_node STATIC EXCLUDE_FROM_ALL
   node/warnings.cpp
   noui.cpp
   policy/ephemeral_policy.cpp
-  policy/fees.cpp
+  policy/fees/block_policy_estimator.cpp
   policy/fees_args.cpp
   policy/fees/forecaster_man.cpp
   policy/packages.cpp
diff --git a/src/common/messages.cpp b/src/common/messages.cpp
index 5fe3e9e4d86..c08889f125b 100644
--- a/src/common/messages.cpp
+++ b/src/common/messages.cpp
@@ -6,7 +6,7 @@
 #include <common/messages.h>
 
 #include <common/types.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 #include <node/types.h>
 #include <tinyformat.h>
 #include <util/strencodings.h>
diff --git a/src/init.cpp b/src/init.cpp
index 1f597cb7cb2..52c71b56843 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -56,7 +56,8 @@
 #include <node/miner.h>
 #include <node/peerman_args.h>
 #include <policy/feerate.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
+#include <policy/fees/forecaster_man.h>
 #include <policy/fees_args.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index def758b9157..c8454816f01 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -27,7 +27,7 @@
 #include <node/txdownloadman.h>
 #include <node/txreconciliation.h>
 #include <node/warnings.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <primitives/block.h>
diff --git a/src/node/context.cpp b/src/node/context.cpp
index 75dfaee866d..bfec54bc0f5 100644
--- a/src/node/context.cpp
+++ b/src/node/context.cpp
@@ -15,7 +15,7 @@
 #include <netgroup.h>
 #include <node/kernel_notifications.h>
 #include <node/warnings.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 #include <scheduler.h>
 #include <txmempool.h>
 #include <validation.h>
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index fe88a6dad11..0edf01d4c92 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -40,7 +40,8 @@
 #include <node/types.h>
 #include <node/warnings.h>
 #include <policy/feerate.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
+#include <policy/fees/forecaster_man.h>
 #include <policy/policy.h>
 #include <policy/rbf.h>
 #include <policy/settings.h>
diff --git a/src/policy/fees.cpp b/src/policy/fees/block_policy_estimator.cpp
similarity index 99%
rename from src/policy/fees.cpp
rename to src/policy/fees/block_policy_estimator.cpp
index e85b2f2caaa..d23dae672cd 100644
--- a/src/policy/fees.cpp
+++ b/src/policy/fees/block_policy_estimator.cpp
@@ -3,7 +3,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 
 #include <common/system.h>
 #include <consensus/amount.h>
diff --git a/src/policy/fees.h b/src/policy/fees/block_policy_estimator.h
similarity index 98%
rename from src/policy/fees.h
rename to src/policy/fees/block_policy_estimator.h
index a95cc19dd45..394a1d7f885 100644
--- a/src/policy/fees.h
+++ b/src/policy/fees/block_policy_estimator.h
@@ -2,8 +2,8 @@
 // Copyright (c) 2009-2022 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
-#ifndef BITCOIN_POLICY_FEES_H
-#define BITCOIN_POLICY_FEES_H
+#ifndef BITCOIN_POLICY_FEES_BLOCK_POLICY_ESTIMATOR_H
+#define BITCOIN_POLICY_FEES_BLOCK_POLICY_ESTIMATOR_H
 
 #include <consensus/amount.h>
 #include <policy/feerate.h>
@@ -342,4 +342,4 @@ private:
     FastRandomContext& insecure_rand GUARDED_BY(m_insecure_rand_mutex);
 };
 
-#endif // BITCOIN_POLICY_FEES_H
+#endif // BITCOIN_POLICY_FEES_BLOCK_POLICY_ESTIMATOR_H
diff --git a/src/qt/sendcoinsdialog.cpp b/src/qt/sendcoinsdialog.cpp
index 0ee1b359fa9..d079cf76df2 100644
--- a/src/qt/sendcoinsdialog.cpp
+++ b/src/qt/sendcoinsdialog.cpp
@@ -21,7 +21,7 @@
 #include <key_io.h>
 #include <node/interface_ui.h>
 #include <node/types.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 #include <txmempool.h>
 #include <validation.h>
 #include <wallet/coincontrol.h>
diff --git a/src/rpc/fees.cpp b/src/rpc/fees.cpp
index 10caa9ed2ec..f5dae48bd29 100644
--- a/src/rpc/fees.cpp
+++ b/src/rpc/fees.cpp
@@ -7,7 +7,7 @@
 #include <core_io.h>
 #include <node/context.h>
 #include <policy/feerate.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 #include <rpc/protocol.h>
 #include <rpc/request.h>
 #include <rpc/server.h>
diff --git a/src/rpc/server_util.cpp b/src/rpc/server_util.cpp
index 0edd7527a95..4ad99499d46 100644
--- a/src/rpc/server_util.cpp
+++ b/src/rpc/server_util.cpp
@@ -9,7 +9,8 @@
 #include <net_processing.h>
 #include <node/context.h>
 #include <node/miner.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
+#include <policy/fees/forecaster_man.h>
 #include <pow.h>
 #include <rpc/protocol.h>
 #include <rpc/request.h>
diff --git a/src/test/feerounder_tests.cpp b/src/test/feerounder_tests.cpp
index 400437e65ec..3fbbec226d4 100644
--- a/src/test/feerounder_tests.cpp
+++ b/src/test/feerounder_tests.cpp
@@ -3,7 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <consensus/amount.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 
 #include <boost/test/unit_test.hpp>
 
diff --git a/src/test/fuzz/fees.cpp b/src/test/fuzz/fees.cpp
index 5c760be13d8..861168ff6ad 100644
--- a/src/test/fuzz/fees.cpp
+++ b/src/test/fuzz/fees.cpp
@@ -4,7 +4,7 @@
 
 #include <common/messages.h>
 #include <consensus/amount.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
diff --git a/src/test/fuzz/kitchen_sink.cpp b/src/test/fuzz/kitchen_sink.cpp
index 62b49106cdd..2ff0841ac7c 100644
--- a/src/test/fuzz/kitchen_sink.cpp
+++ b/src/test/fuzz/kitchen_sink.cpp
@@ -5,7 +5,7 @@
 #include <common/messages.h>
 #include <merkleblock.h>
 #include <node/types.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 #include <rpc/util.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
diff --git a/src/test/fuzz/policy_estimator.cpp b/src/test/fuzz/policy_estimator.cpp
index 29427403952..699b72beeaf 100644
--- a/src/test/fuzz/policy_estimator.cpp
+++ b/src/test/fuzz/policy_estimator.cpp
@@ -3,7 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <kernel/mempool_entry.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 #include <policy/fees_args.h>
 #include <primitives/transaction.h>
 #include <streams.h>
diff --git a/src/test/fuzz/policy_estimator_io.cpp b/src/test/fuzz/policy_estimator_io.cpp
index 3e7d0933439..2a50b6da8bb 100644
--- a/src/test/fuzz/policy_estimator_io.cpp
+++ b/src/test/fuzz/policy_estimator_io.cpp
@@ -2,7 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 #include <policy/fees_args.h>
 #include <streams.h>
 #include <test/fuzz/FuzzedDataProvider.h>
diff --git a/src/test/policyestimator_tests.cpp b/src/test/policyestimator_tests.cpp
index f767cd42871..945cc7519e2 100644
--- a/src/test/policyestimator_tests.cpp
+++ b/src/test/policyestimator_tests.cpp
@@ -2,7 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 #include <policy/fees_args.h>
 #include <policy/policy.h>
 #include <test/util/txmempool.h>
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 970e1a917cb..a1f7355f43d 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -28,7 +28,7 @@
 #include <node/peerman_args.h>
 #include <node/warnings.h>
 #include <noui.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 #include <pow.h>
 #include <random.h>
 #include <rpc/blockchain.h>
diff --git a/src/wallet/coincontrol.h b/src/wallet/coincontrol.h
index d36314312ad..55eb792f4e4 100644
--- a/src/wallet/coincontrol.h
+++ b/src/wallet/coincontrol.h
@@ -7,7 +7,7 @@
 
 #include <outputtype.h>
 #include <policy/feerate.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 #include <primitives/transaction.h>
 #include <script/keyorigin.h>
 #include <script/signingprovider.h>
diff --git a/src/wallet/feebumper.cpp b/src/wallet/feebumper.cpp
index b875461c9f2..c9f11b3fb57 100644
--- a/src/wallet/feebumper.cpp
+++ b/src/wallet/feebumper.cpp
@@ -6,7 +6,7 @@
 #include <consensus/validation.h>
 #include <interfaces/chain.h>
 #include <node/types.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 #include <policy/policy.h>
 #include <util/moneystr.h>
 #include <util/rbf.h>
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index 21e8a0b3bd2..43954409125 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -9,7 +9,7 @@
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
 #include <node/types.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
 #include <scheduler.h>
diff --git a/src/wallet/spend.h b/src/wallet/spend.h
index 62a7b4e4c89..a862c573862 100644
--- a/src/wallet/spend.h
+++ b/src/wallet/spend.h
@@ -6,7 +6,7 @@
 #define BITCOIN_WALLET_SPEND_H
 
 #include <consensus/amount.h>
-#include <policy/fees.h> // for FeeCalculation
+#include <policy/fees/block_policy_estimator.h> // for FeeCalculation
 #include <util/result.h>
 #include <wallet/coinselection.h>
 #include <wallet/transaction.h>
diff --git a/src/wallet/test/spend_tests.cpp b/src/wallet/test/spend_tests.cpp
index 963c0f838b1..1302fc0bde0 100644
--- a/src/wallet/test/spend_tests.cpp
+++ b/src/wallet/test/spend_tests.cpp
@@ -3,7 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <consensus/amount.h>
-#include <policy/fees.h>
+#include <policy/fees/block_policy_estimator.h>
 #include <script/solver.h>
 #include <validation.h>
 #include <wallet/coincontrol.h>

From 0e6690e1295a0ad43ee5e3c9f4dfb94181525235 Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Wed, 15 Jan 2025 13:10:55 -0500
Subject: [PATCH 08/22] fees: rename fees_args to block_policy_estimator_args

- Also move them to policy/fees/ and update includes
- Note: the block_policy_estimator_args.h include in block_policy_estimator_args.cpp was done manually.
---
 src/CMakeLists.txt                                          | 2 +-
 src/init.cpp                                                | 2 +-
 .../{fees_args.cpp => fees/block_policy_estimator_args.cpp} | 2 +-
 .../{fees_args.h => fees/block_policy_estimator_args.h}     | 6 +++---
 src/test/fuzz/policy_estimator.cpp                          | 2 +-
 src/test/fuzz/policy_estimator_io.cpp                       | 2 +-
 src/test/policyestimator_tests.cpp                          | 2 +-
 7 files changed, 9 insertions(+), 9 deletions(-)
 rename src/policy/{fees_args.cpp => fees/block_policy_estimator_args.cpp} (88%)
 rename src/policy/{fees_args.h => fees/block_policy_estimator_args.h} (65%)

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 18fc303ed62..9b3f28b9bfe 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -258,7 +258,7 @@ add_library(bitcoin_node STATIC EXCLUDE_FROM_ALL
   noui.cpp
   policy/ephemeral_policy.cpp
   policy/fees/block_policy_estimator.cpp
-  policy/fees_args.cpp
+  policy/fees/block_policy_estimator_args.cpp
   policy/fees/forecaster_man.cpp
   policy/packages.cpp
   policy/rbf.cpp
diff --git a/src/init.cpp b/src/init.cpp
index 52c71b56843..1e13f1b2567 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -58,7 +58,7 @@
 #include <policy/feerate.h>
 #include <policy/fees/block_policy_estimator.h>
 #include <policy/fees/forecaster_man.h>
-#include <policy/fees_args.h>
+#include <policy/fees/block_policy_estimator_args.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <protocol.h>
diff --git a/src/policy/fees_args.cpp b/src/policy/fees/block_policy_estimator_args.cpp
similarity index 88%
rename from src/policy/fees_args.cpp
rename to src/policy/fees/block_policy_estimator_args.cpp
index 988b6d443a5..c66b09bf6e3 100644
--- a/src/policy/fees_args.cpp
+++ b/src/policy/fees/block_policy_estimator_args.cpp
@@ -2,7 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <policy/fees_args.h>
+#include <policy/fees/block_policy_estimator_args.h>
 
 #include <common/args.h>
 
diff --git a/src/policy/fees_args.h b/src/policy/fees/block_policy_estimator_args.h
similarity index 65%
rename from src/policy/fees_args.h
rename to src/policy/fees/block_policy_estimator_args.h
index ef5cf144af5..f206c667c23 100644
--- a/src/policy/fees_args.h
+++ b/src/policy/fees/block_policy_estimator_args.h
@@ -2,8 +2,8 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef BITCOIN_POLICY_FEES_ARGS_H
-#define BITCOIN_POLICY_FEES_ARGS_H
+#ifndef BITCOIN_POLICY_FEES_BLOCK_POLICY_ESTIMATOR_ARGS_H
+#define BITCOIN_POLICY_FEES_BLOCK_POLICY_ESTIMATOR_ARGS_H
 
 #include <util/fs.h>
 
@@ -12,4 +12,4 @@ class ArgsManager;
 /** @return The fee estimates data file path. */
 fs::path FeeestPath(const ArgsManager& argsman);
 
-#endif // BITCOIN_POLICY_FEES_ARGS_H
+#endif // BITCOIN_POLICY_FEES_BLOCK_POLICY_ESTIMATOR_ARGS_H
diff --git a/src/test/fuzz/policy_estimator.cpp b/src/test/fuzz/policy_estimator.cpp
index 699b72beeaf..4b5696fb7b6 100644
--- a/src/test/fuzz/policy_estimator.cpp
+++ b/src/test/fuzz/policy_estimator.cpp
@@ -4,7 +4,7 @@
 
 #include <kernel/mempool_entry.h>
 #include <policy/fees/block_policy_estimator.h>
-#include <policy/fees_args.h>
+#include <policy/fees/block_policy_estimator_args.h>
 #include <primitives/transaction.h>
 #include <streams.h>
 #include <test/fuzz/FuzzedDataProvider.h>
diff --git a/src/test/fuzz/policy_estimator_io.cpp b/src/test/fuzz/policy_estimator_io.cpp
index 2a50b6da8bb..825c54dee53 100644
--- a/src/test/fuzz/policy_estimator_io.cpp
+++ b/src/test/fuzz/policy_estimator_io.cpp
@@ -3,7 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <policy/fees/block_policy_estimator.h>
-#include <policy/fees_args.h>
+#include <policy/fees/block_policy_estimator_args.h>
 #include <streams.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
diff --git a/src/test/policyestimator_tests.cpp b/src/test/policyestimator_tests.cpp
index 945cc7519e2..0327ba67b92 100644
--- a/src/test/policyestimator_tests.cpp
+++ b/src/test/policyestimator_tests.cpp
@@ -3,7 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <policy/fees/block_policy_estimator.h>
-#include <policy/fees_args.h>
+#include <policy/fees/block_policy_estimator_args.h>
 #include <policy/policy.h>
 #include <test/util/txmempool.h>
 #include <txmempool.h>

From c67949ddadf6328821d23eed3c2bd3bfbd292d34 Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Mon, 12 Aug 2024 15:40:20 +0100
Subject: [PATCH 09/22] fees: return current block height in `estimateSmartFee`

---
 src/policy/fees/block_policy_estimator.cpp | 1 +
 src/policy/fees/block_policy_estimator.h   | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/policy/fees/block_policy_estimator.cpp b/src/policy/fees/block_policy_estimator.cpp
index d23dae672cd..8d5f3f75d6f 100644
--- a/src/policy/fees/block_policy_estimator.cpp
+++ b/src/policy/fees/block_policy_estimator.cpp
@@ -874,6 +874,7 @@ CFeeRate CBlockPolicyEstimator::estimateSmartFee(int confTarget, FeeCalculation
     if (feeCalc) {
         feeCalc->desiredTarget = confTarget;
         feeCalc->returnedTarget = confTarget;
+        feeCalc->bestheight = nBestSeenHeight;
     }
 
     double median = -1;
diff --git a/src/policy/fees/block_policy_estimator.h b/src/policy/fees/block_policy_estimator.h
index 394a1d7f885..6925269123a 100644
--- a/src/policy/fees/block_policy_estimator.h
+++ b/src/policy/fees/block_policy_estimator.h
@@ -95,6 +95,7 @@ struct FeeCalculation
     FeeReason reason = FeeReason::NONE;
     int desiredTarget = 0;
     int returnedTarget = 0;
+    unsigned int bestheight{0};
 };
 
 /** \class CBlockPolicyEstimator

From 956926cee3beaedc221b2224010722c91cbd12b1 Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Mon, 13 Jan 2025 17:59:06 -0500
Subject: [PATCH 10/22] fees: make block_policy_estimator a forecaster

---
 src/policy/fees/block_policy_estimator.cpp | 26 +++++++++++++++++++++-
 src/policy/fees/block_policy_estimator.h   | 11 ++++++++-
 src/policy/fees/forecaster_util.h          |  4 +++-
 3 files changed, 38 insertions(+), 3 deletions(-)

diff --git a/src/policy/fees/block_policy_estimator.cpp b/src/policy/fees/block_policy_estimator.cpp
index 8d5f3f75d6f..2025a8ec615 100644
--- a/src/policy/fees/block_policy_estimator.cpp
+++ b/src/policy/fees/block_policy_estimator.cpp
@@ -10,6 +10,7 @@
 #include <kernel/mempool_entry.h>
 #include <logging.h>
 #include <policy/feerate.h>
+#include <policy/fees/forecaster_util.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <serialize.h>
@@ -540,7 +541,7 @@ bool CBlockPolicyEstimator::_removeTx(const uint256& hash, bool inBlock)
 }
 
 CBlockPolicyEstimator::CBlockPolicyEstimator(const fs::path& estimation_filepath, const bool read_stale_estimates)
-    : m_estimation_filepath{estimation_filepath}
+    : Forecaster(ForecastType::BLOCK_POLICY), m_estimation_filepath{estimation_filepath}
 {
     static_assert(MIN_BUCKET_FEERATE > 0, "Min feerate must be nonzero");
     size_t bucketIndex = 0;
@@ -723,6 +724,29 @@ CFeeRate CBlockPolicyEstimator::estimateFee(int confTarget) const
     return estimateRawFee(confTarget, DOUBLE_SUCCESS_PCT, FeeEstimateHorizon::MED_HALFLIFE);
 }
 
+ForecastResult CBlockPolicyEstimator::EstimateFee(ConfirmationTarget& target)
+{
+    ForecastResult::ForecastResponse response;
+    response.forecaster = ForecastType::BLOCK_POLICY;
+    if (target.type != ConfirmationTargetType::BLOCKS) {
+        return ForecastResult(response, "Incorrect Confirmation target, expecting blocks");
+    }
+    FeeCalculation feeCalcConservative;
+    CFeeRate feerate_conservative{estimateSmartFee(target.value, &feeCalcConservative, /**conservative**/ true)};
+    FeeCalculation feeCalcEconomical;
+    CFeeRate feerate_economical{estimateSmartFee(target.value, &feeCalcEconomical, /**conservative**/ false)};
+    response.current_block_height = feeCalcEconomical.bestheight;
+    if (feerate_conservative == CFeeRate(0) || feerate_economical == CFeeRate(0)) {
+        return ForecastResult(response, "Insufficient data or no feerate found");
+    }
+    // Note: size can be any positive non-zero integer; the evaluated fee/size will result in the same fee rate,
+    // and we only care that the fee rate remains consistent.
+    int32_t size = 1000;
+    response.low_priority = FeeFrac(feerate_economical.GetFee(size), size);
+    response.high_priority = FeeFrac(feerate_conservative.GetFee(size), size);
+    return ForecastResult(response);
+}
+
 CFeeRate CBlockPolicyEstimator::estimateRawFee(int confTarget, double successThreshold, FeeEstimateHorizon horizon, EstimationResult* result) const
 {
     TxConfirmStats* stats = nullptr;
diff --git a/src/policy/fees/block_policy_estimator.h b/src/policy/fees/block_policy_estimator.h
index 6925269123a..b890bccb66d 100644
--- a/src/policy/fees/block_policy_estimator.h
+++ b/src/policy/fees/block_policy_estimator.h
@@ -7,6 +7,7 @@
 
 #include <consensus/amount.h>
 #include <policy/feerate.h>
+#include <policy/fees/forecaster.h>
 #include <random.h>
 #include <sync.h>
 #include <threadsafety.h>
@@ -36,10 +37,14 @@ static constexpr std::chrono::hours MAX_FILE_AGE{60};
 static constexpr bool DEFAULT_ACCEPT_STALE_FEE_ESTIMATES{false};
 
 class AutoFile;
+class ForecastResult;
 class TxConfirmStats;
+
+struct ConfirmationTarget;
 struct RemovedMempoolTransactionInfo;
 struct NewMempoolTransactionInfo;
 
+
 /* Identifier for each of the 3 different TxConfirmStats which will track
  * history over different time horizons. */
 enum class FeeEstimateHorizon {
@@ -146,7 +151,7 @@ struct FeeCalculation
  * a certain number of blocks.  Every time a block is added to the best chain, this class records
  * stats on the transactions included in that block
  */
-class CBlockPolicyEstimator : public CValidationInterface
+class CBlockPolicyEstimator : public Forecaster, public CValidationInterface
 {
 private:
     /** Track confirm delays up to 12 blocks for short horizon */
@@ -272,6 +277,10 @@ protected:
     void MempoolTransactionsRemovedForBlock(const std::vector<RemovedMempoolTransactionInfo>& txs_removed_for_block, unsigned int nBlockHeight) override
         EXCLUSIVE_LOCKS_REQUIRED(!m_cs_fee_estimator);
 
+    /** Overridden from Forecaster. */
+    ForecastResult EstimateFee(ConfirmationTarget& target) override
+        EXCLUSIVE_LOCKS_REQUIRED(!m_cs_fee_estimator);
+
 private:
     mutable Mutex m_cs_fee_estimator;
 
diff --git a/src/policy/fees/forecaster_util.h b/src/policy/fees/forecaster_util.h
index 6485fc76b9b..b1c72e5fdeb 100644
--- a/src/policy/fees/forecaster_util.h
+++ b/src/policy/fees/forecaster_util.h
@@ -14,7 +14,9 @@
  * @enum ForecastType
  * Identifier for fee rate forecasters.
  */
-enum class ForecastType {};
+enum class ForecastType {
+    BLOCK_POLICY,
+};
 
 /**
  * @class ForecastResult

From ce7199070b72d0c42522716caba29897ae6ceaca Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Wed, 15 Jan 2025 13:44:28 -0500
Subject: [PATCH 11/22] fees: add block policy estimator to forecaster manager

- This changes `CBlockPolicyEstimator` to a shared pointer
  this gives us three advantages.
   - Registering to validation interface using shared pointer
   - Scheduling block policy estimator flushes using shared pointer
   - Registering block policy estimator to forecaster_man
---
 src/init.cpp                       | 26 ++++++++++++--------------
 src/node/context.cpp               |  2 +-
 src/node/context.h                 |  4 ++--
 src/node/interfaces.cpp            |  8 ++++----
 src/policy/fees/forecaster_man.cpp |  8 ++++++++
 src/policy/fees/forecaster_man.h   |  6 ++++++
 src/rpc/fees.cpp                   | 15 ++++++++-------
 src/rpc/server_util.cpp            | 11 ++++++-----
 src/rpc/server_util.h              |  6 +++---
 src/test/util/setup_common.cpp     |  2 +-
 10 files changed, 51 insertions(+), 37 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index 1e13f1b2567..7b82067c8c7 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -328,13 +328,9 @@ void Shutdown(NodeContext& node)
         DumpMempool(*node.mempool, MempoolPath(*node.args));
     }
 
-    // Drop transactions we were still watching, record fee estimations and unregister
-    // fee estimator from validation interface.
-    if (node.fee_estimator) {
-        node.fee_estimator->Flush();
-        if (node.validation_signals) {
-            node.validation_signals->UnregisterValidationInterface(node.fee_estimator.get());
-        }
+    // Drop transactions we were still watching, record fee estimations.
+    if (node.forecasterman) {
+        node.forecasterman->GetBlockPolicyEstimator()->Flush();
     }
 
     // FlushStateToDisk generates a ChainStateFlushed callback, which we should avoid missing
@@ -389,7 +385,7 @@ void Shutdown(NodeContext& node)
         node.validation_signals->UnregisterAllValidationInterfaces();
     }
     node.mempool.reset();
-    node.fee_estimator.reset();
+    node.forecasterman.reset();
     node.chainman.reset();
     node.validation_signals.reset();
     node.scheduler.reset();
@@ -1433,7 +1429,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
                                               rng.rand64(),
                                               *node.addrman, *node.netgroupman, chainparams, args.GetBoolArg("-networkactive", true));
 
-    assert(!node.fee_estimator);
+    assert(!node.forecasterman);
     // Don't initialize fee estimation with old data if we don't relay transactions,
     // as they would never get updated.
     if (!peerman_opts.ignore_incoming_txs) {
@@ -1441,12 +1437,14 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         if (read_stale_estimates && (chainparams.GetChainType() != ChainType::REGTEST)) {
             return InitError(strprintf(_("acceptstalefeeestimates is not supported on %s chain."), chainparams.GetChainTypeString()));
         }
-        node.fee_estimator = std::make_unique<CBlockPolicyEstimator>(FeeestPath(args), read_stale_estimates);
+        node.forecasterman = std::make_unique<FeeRateForecasterManager>();
+        auto block_policy_estimator = std::make_shared<CBlockPolicyEstimator>(FeeestPath(args), read_stale_estimates);
+        validation_signals.RegisterSharedValidationInterface(block_policy_estimator);
+        // Flush block policy estimates to disk periodically
+        scheduler.scheduleEvery([block_policy_estimator] { block_policy_estimator->FlushFeeEstimates(); }, FEE_FLUSH_INTERVAL);
 
-        // Flush estimates to disk periodically
-        CBlockPolicyEstimator* fee_estimator = node.fee_estimator.get();
-        scheduler.scheduleEvery([fee_estimator] { fee_estimator->FlushFeeEstimates(); }, FEE_FLUSH_INTERVAL);
-        validation_signals.RegisterValidationInterface(fee_estimator);
+        // Register block policy estimator to forecaster manager
+        node.forecasterman->RegisterForecaster(block_policy_estimator);
     }
 
     for (const std::string& socket_addr : args.GetArgs("-bind")) {
diff --git a/src/node/context.cpp b/src/node/context.cpp
index bfec54bc0f5..762c663de49 100644
--- a/src/node/context.cpp
+++ b/src/node/context.cpp
@@ -15,7 +15,7 @@
 #include <netgroup.h>
 #include <node/kernel_notifications.h>
 #include <node/warnings.h>
-#include <policy/fees/block_policy_estimator.h>
+#include <policy/fees/forecaster_man.h>
 #include <scheduler.h>
 #include <txmempool.h>
 #include <validation.h>
diff --git a/src/node/context.h b/src/node/context.h
index debc1221206..26d33b051b7 100644
--- a/src/node/context.h
+++ b/src/node/context.h
@@ -16,7 +16,7 @@ class ArgsManager;
 class AddrMan;
 class BanMan;
 class BaseIndex;
-class CBlockPolicyEstimator;
+class FeeRateForecasterManager;
 class CConnman;
 class ValidationSignals;
 class CScheduler;
@@ -67,7 +67,7 @@ struct NodeContext {
     std::unique_ptr<CConnman> connman;
     std::unique_ptr<CTxMemPool> mempool;
     std::unique_ptr<const NetGroupManager> netgroupman;
-    std::unique_ptr<CBlockPolicyEstimator> fee_estimator;
+    std::unique_ptr<FeeRateForecasterManager> forecasterman;
     std::unique_ptr<PeerManager> peerman;
     std::unique_ptr<ChainstateManager> chainman;
     std::unique_ptr<BanMan> banman;
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 0edf01d4c92..2ac721dbd00 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -738,13 +738,13 @@ public:
     }
     CFeeRate estimateSmartFee(int num_blocks, bool conservative, FeeCalculation* calc) override
     {
-        if (!m_node.fee_estimator) return {};
-        return m_node.fee_estimator->estimateSmartFee(num_blocks, calc, conservative);
+        if (!m_node.forecasterman) return {};
+        return m_node.forecasterman->GetBlockPolicyEstimator()->estimateSmartFee(num_blocks, calc, conservative);
     }
     unsigned int estimateMaxBlocks() override
     {
-        if (!m_node.fee_estimator) return 0;
-        return m_node.fee_estimator->HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
+        if (!m_node.forecasterman) return 0;
+        return m_node.forecasterman->GetBlockPolicyEstimator()->HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
     }
     CFeeRate mempoolMinFee() override
     {
diff --git a/src/policy/fees/forecaster_man.cpp b/src/policy/fees/forecaster_man.cpp
index 462fb2c8026..38f2f65bbbc 100644
--- a/src/policy/fees/forecaster_man.cpp
+++ b/src/policy/fees/forecaster_man.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license. See the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <policy/fees/block_policy_estimator.h>
 #include <policy/fees/forecaster.h>
 #include <policy/fees/forecaster_man.h>
 #include <policy/fees/forecaster_util.h>
@@ -12,3 +13,10 @@ void FeeRateForecasterManager::RegisterForecaster(std::shared_ptr<Forecaster> fo
 {
     forecasters.emplace(forecaster->GetForecastType(), forecaster);
 }
+
+CBlockPolicyEstimator* FeeRateForecasterManager::GetBlockPolicyEstimator()
+{
+    Assume(forecasters.contains(ForecastType::BLOCK_POLICY));
+    Forecaster* block_policy_estimator = forecasters.find(ForecastType::BLOCK_POLICY)->second.get();
+    return dynamic_cast<CBlockPolicyEstimator*>(block_policy_estimator);
+}
diff --git a/src/policy/fees/forecaster_man.h b/src/policy/fees/forecaster_man.h
index 13784e0e0a3..3e352fc4817 100644
--- a/src/policy/fees/forecaster_man.h
+++ b/src/policy/fees/forecaster_man.h
@@ -8,6 +8,7 @@
 #include <memory>
 #include <unordered_map>
 
+class CBlockPolicyEstimator;
 class Forecaster;
 class ForecastResult;
 
@@ -32,6 +33,11 @@ public:
      * @param[in] forecaster shared pointer to a Forecaster instance.
      */
     void RegisterForecaster(std::shared_ptr<Forecaster> forecaster);
+
+    /*
+     * Return the pointer to block policy estimator.
+     */
+    CBlockPolicyEstimator* GetBlockPolicyEstimator();
 };
 
 #endif // BITCOIN_POLICY_FEES_FORECASTER_MAN_H
diff --git a/src/rpc/fees.cpp b/src/rpc/fees.cpp
index f5dae48bd29..0437bd626ad 100644
--- a/src/rpc/fees.cpp
+++ b/src/rpc/fees.cpp
@@ -8,6 +8,7 @@
 #include <node/context.h>
 #include <policy/feerate.h>
 #include <policy/fees/block_policy_estimator.h>
+#include <policy/fees/forecaster_man.h>
 #include <rpc/protocol.h>
 #include <rpc/request.h>
 #include <rpc/server.h>
@@ -59,12 +60,12 @@ static RPCHelpMan estimatesmartfee()
         },
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
         {
-            CBlockPolicyEstimator& fee_estimator = EnsureAnyFeeEstimator(request.context);
+            CBlockPolicyEstimator& block_policy_fee_estimator = *(EnsureAnyForecasterMan(request.context).GetBlockPolicyEstimator());
             const NodeContext& node = EnsureAnyNodeContext(request.context);
             const CTxMemPool& mempool = EnsureMemPool(node);
 
             CHECK_NONFATAL(mempool.m_opts.signals)->SyncWithValidationInterfaceQueue();
-            unsigned int max_target = fee_estimator.HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
+            unsigned int max_target = block_policy_fee_estimator.HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
             unsigned int conf_target = ParseConfirmTarget(request.params[0], max_target);
             bool conservative = false;
             if (!request.params[1].isNull()) {
@@ -78,7 +79,7 @@ static RPCHelpMan estimatesmartfee()
             UniValue result(UniValue::VOBJ);
             UniValue errors(UniValue::VARR);
             FeeCalculation feeCalc;
-            CFeeRate feeRate{fee_estimator.estimateSmartFee(conf_target, &feeCalc, conservative)};
+            CFeeRate feeRate{block_policy_fee_estimator.estimateSmartFee(conf_target, &feeCalc, conservative)};
             if (feeRate != CFeeRate(0)) {
                 CFeeRate min_mempool_feerate{mempool.GetMinFee()};
                 CFeeRate min_relay_feerate{mempool.m_opts.min_relay_feerate};
@@ -150,11 +151,11 @@ static RPCHelpMan estimaterawfee()
         },
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
         {
-            CBlockPolicyEstimator& fee_estimator = EnsureAnyFeeEstimator(request.context);
+            CBlockPolicyEstimator& block_policy_fee_estimator = *(EnsureAnyForecasterMan(request.context).GetBlockPolicyEstimator());
             const NodeContext& node = EnsureAnyNodeContext(request.context);
 
             CHECK_NONFATAL(node.validation_signals)->SyncWithValidationInterfaceQueue();
-            unsigned int max_target = fee_estimator.HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
+            unsigned int max_target = block_policy_fee_estimator.HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
             unsigned int conf_target = ParseConfirmTarget(request.params[0], max_target);
             double threshold = 0.95;
             if (!request.params[1].isNull()) {
@@ -171,9 +172,9 @@ static RPCHelpMan estimaterawfee()
                 EstimationResult buckets;
 
                 // Only output results for horizons which track the target
-                if (conf_target > fee_estimator.HighestTargetTracked(horizon)) continue;
+                if (conf_target > block_policy_fee_estimator.HighestTargetTracked(horizon)) continue;
 
-                feeRate = fee_estimator.estimateRawFee(conf_target, threshold, horizon, &buckets);
+                feeRate = block_policy_fee_estimator.estimateRawFee(conf_target, threshold, horizon, &buckets);
                 UniValue horizon_result(UniValue::VOBJ);
                 UniValue errors(UniValue::VARR);
                 UniValue passbucket(UniValue::VOBJ);
diff --git a/src/rpc/server_util.cpp b/src/rpc/server_util.cpp
index 4ad99499d46..52aadd25989 100644
--- a/src/rpc/server_util.cpp
+++ b/src/rpc/server_util.cpp
@@ -85,19 +85,20 @@ ChainstateManager& EnsureAnyChainman(const std::any& context)
     return EnsureChainman(EnsureAnyNodeContext(context));
 }
 
-CBlockPolicyEstimator& EnsureFeeEstimator(const NodeContext& node)
+FeeRateForecasterManager& EnsureForecasterMan(const NodeContext& node)
 {
-    if (!node.fee_estimator) {
+    if (!node.forecasterman) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Fee estimation disabled");
     }
-    return *node.fee_estimator;
+    return *node.forecasterman.get();
 }
 
-CBlockPolicyEstimator& EnsureAnyFeeEstimator(const std::any& context)
+FeeRateForecasterManager& EnsureAnyForecasterMan(const std::any& context)
 {
-    return EnsureFeeEstimator(EnsureAnyNodeContext(context));
+    return EnsureForecasterMan(EnsureAnyNodeContext(context));
 }
 
+
 CConnman& EnsureConnman(const NodeContext& node)
 {
     if (!node.connman) {
diff --git a/src/rpc/server_util.h b/src/rpc/server_util.h
index 6fb5e1c9b35..fd79a042fd1 100644
--- a/src/rpc/server_util.h
+++ b/src/rpc/server_util.h
@@ -12,10 +12,10 @@
 class AddrMan;
 class ArgsManager;
 class CBlockIndex;
-class CBlockPolicyEstimator;
 class CConnman;
 class CTxMemPool;
 class ChainstateManager;
+class FeeRateForecasterManager;
 class PeerManager;
 class BanMan;
 namespace node {
@@ -34,8 +34,8 @@ ArgsManager& EnsureArgsman(const node::NodeContext& node);
 ArgsManager& EnsureAnyArgsman(const std::any& context);
 ChainstateManager& EnsureChainman(const node::NodeContext& node);
 ChainstateManager& EnsureAnyChainman(const std::any& context);
-CBlockPolicyEstimator& EnsureFeeEstimator(const node::NodeContext& node);
-CBlockPolicyEstimator& EnsureAnyFeeEstimator(const std::any& context);
+FeeRateForecasterManager& EnsureForecasterMan(const node::NodeContext& node);
+FeeRateForecasterManager& EnsureAnyForecasterMan(const std::any& context);
 CConnman& EnsureConnman(const node::NodeContext& node);
 interfaces::Mining& EnsureMining(const node::NodeContext& node);
 PeerManager& EnsurePeerman(const node::NodeContext& node);
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index a1f7355f43d..79543928147 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -274,7 +274,7 @@ ChainTestingSetup::~ChainTestingSetup()
     m_node.netgroupman.reset();
     m_node.args = nullptr;
     m_node.mempool.reset();
-    Assert(!m_node.fee_estimator); // Each test must create a local object, if they wish to use the fee_estimator
+    Assert(!m_node.forecasterman); // Each test must create a local object, if they wish to use the forecasterman
     m_node.chainman.reset();
     m_node.validation_signals.reset();
     m_node.scheduler.reset();

From 17e844276f67f3fd28179c684b2106da89d8423b Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Thu, 2 Jan 2025 13:46:32 -0500
Subject: [PATCH 12/22] fees: add `forecastTypeToString` method

- This method converts a ForecastType enum to its
  string representation.
---
 src/CMakeLists.txt                  |  1 +
 src/policy/fees/forecaster_util.cpp | 15 +++++++++++++++
 src/policy/fees/forecaster_util.h   |  2 ++
 3 files changed, 18 insertions(+)
 create mode 100644 src/policy/fees/forecaster_util.cpp

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 9b3f28b9bfe..00af5e553d0 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -142,6 +142,7 @@ add_library(bitcoin_common STATIC EXCLUDE_FROM_ALL
   netbase.cpp
   outputtype.cpp
   policy/feerate.cpp
+  policy/fees/forecaster_util.cpp
   policy/policy.cpp
   pow.cpp
   protocol.cpp
diff --git a/src/policy/fees/forecaster_util.cpp b/src/policy/fees/forecaster_util.cpp
new file mode 100644
index 00000000000..79ff1f8adbd
--- /dev/null
+++ b/src/policy/fees/forecaster_util.cpp
@@ -0,0 +1,15 @@
+// Copyright (c) 2025 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/forecaster_util.h>
+
+std::string forecastTypeToString(ForecastType forecastType)
+{
+    switch (forecastType) {
+    case ForecastType::BLOCK_POLICY:
+        return std::string("Block Policy Estimator");
+    }
+    // no default case, so the compiler can warn about missing cases
+    assert(false);
+}
diff --git a/src/policy/fees/forecaster_util.h b/src/policy/fees/forecaster_util.h
index b1c72e5fdeb..a024b8d4e8a 100644
--- a/src/policy/fees/forecaster_util.h
+++ b/src/policy/fees/forecaster_util.h
@@ -126,4 +126,6 @@ struct ConfirmationTarget {
     ConfirmationTargetType type;
 };
 
+std::string forecastTypeToString(ForecastType forecastType);
+
 #endif // BITCOIN_POLICY_FEES_FORECASTER_UTIL_H

From 4892df53de8200a258fdb77151f8977ba6bc1c77 Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Wed, 15 Jan 2025 11:26:09 -0500
Subject: [PATCH 13/22] fees: add `CalculatePercentiles` function

- The CalculatePercentiles function, given
  a vector of feerates in the order they were added
  to the block, will return the 25th, 50th, 75th,
  and 95th percentile feerates.

- Also add a unit test for this function.
---
 src/policy/fees/forecaster_util.cpp | 40 ++++++++++++++++++
 src/policy/fees/forecaster_util.h   | 29 +++++++++++++
 src/test/CMakeLists.txt             |  1 +
 src/test/forecaster_util_tests.cpp  | 65 +++++++++++++++++++++++++++++
 4 files changed, 135 insertions(+)
 create mode 100644 src/test/forecaster_util_tests.cpp

diff --git a/src/policy/fees/forecaster_util.cpp b/src/policy/fees/forecaster_util.cpp
index 79ff1f8adbd..21eb8a74934 100644
--- a/src/policy/fees/forecaster_util.cpp
+++ b/src/policy/fees/forecaster_util.cpp
@@ -3,6 +3,46 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <policy/fees/forecaster_util.h>
+#include <policy/policy.h>
+
+#include <algorithm>
+
+Percentiles CalculatePercentiles(const std::vector<FeeFrac>& package_feerates, const int32_t total_weight)
+{
+    if (package_feerates.empty()) return Percentiles{};
+    int32_t accumulated_weight{0};
+    const int32_t p25_weight = 0.25 * total_weight;
+    const int32_t p50_weight = 0.50 * total_weight;
+    const int32_t p75_weight = 0.75 * total_weight;
+    const int32_t p95_weight = 0.95 * total_weight;
+    auto last_tracked_feerate = package_feerates.front();
+    auto percentiles = Percentiles{};
+
+    // Process histogram entries while maintaining monotonicity
+    for (const auto& curr_feerate : package_feerates) {
+        accumulated_weight += curr_feerate.size * WITNESS_SCALE_FACTOR;
+        // Maintain monotonicity by taking the minimum between the current and last tracked fee rate
+        last_tracked_feerate = std::min(last_tracked_feerate, curr_feerate, [](const FeeFrac& a, const FeeFrac& b) {
+            return std::is_lt(FeeRateCompare(a, b));
+        });
+        if (accumulated_weight >= p25_weight && percentiles.p25.IsEmpty()) {
+            percentiles.p25 = last_tracked_feerate;
+        }
+        if (accumulated_weight >= p50_weight && percentiles.p50.IsEmpty()) {
+            percentiles.p50 = last_tracked_feerate;
+        }
+        if (accumulated_weight >= p75_weight && percentiles.p75.IsEmpty()) {
+            percentiles.p75 = last_tracked_feerate;
+        }
+        if (accumulated_weight >= p95_weight && percentiles.p95.IsEmpty()) {
+            percentiles.p95 = last_tracked_feerate;
+            break; // Early exit once all percentiles are calculated
+        }
+    }
+
+    // Return empty percentiles if we couldn't calculate the 95th percentile.
+    return percentiles.p95.IsEmpty() ? Percentiles{} : percentiles;
+}
 
 std::string forecastTypeToString(ForecastType forecastType)
 {
diff --git a/src/policy/fees/forecaster_util.h b/src/policy/fees/forecaster_util.h
index a024b8d4e8a..6fd5ac7c3b2 100644
--- a/src/policy/fees/forecaster_util.h
+++ b/src/policy/fees/forecaster_util.h
@@ -126,6 +126,35 @@ struct ConfirmationTarget {
     ConfirmationTargetType type;
 };
 
+// Block percentiles fee rate (in sat/kvB).
+struct Percentiles {
+    FeeFrac p25; // 25th percentile
+    FeeFrac p50; // 50th percentile
+    FeeFrac p75; // 75th percentile
+    FeeFrac p95; // 5th percentile
+
+    Percentiles() = default;
+
+    bool empty() const
+    {
+        return p25.IsEmpty() && p50.IsEmpty() && p75.IsEmpty() && p95.IsEmpty();
+    }
+};
+
+/**
+ * Calculates the percentile fee rates from a given vector of fee rates.
+ *
+ * This function assumes that the fee rates in the input vector are sorted in descending order
+ * based on mining score priority. It ensures that the calculated percentile fee rates
+ * are monotonically decreasing by filtering out outliers. Outliers can occur when
+ * the mining score of a transaction increases due to the inclusion of its ancestors
+ * in different transaction packages.
+ *
+ * @param[in] package_feerates A vector containing fee rates and their corresponding virtual sizes.
+ * @return Percentiles object containing the calculated percentile fee rates.
+ */
+Percentiles CalculatePercentiles(const std::vector<FeeFrac>& package_feerates, const int32_t total_weight);
+
 std::string forecastTypeToString(ForecastType forecastType);
 
 #endif // BITCOIN_POLICY_FEES_FORECASTER_UTIL_H
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index 09669dd3d85..27af30af6cd 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -63,6 +63,7 @@ add_executable(test_bitcoin
   disconnected_transactions.cpp
   feefrac_tests.cpp
   feerounder_tests.cpp
+  forecaster_util_tests.cpp
   flatfile_tests.cpp
   fs_tests.cpp
   getarg_tests.cpp
diff --git a/src/test/forecaster_util_tests.cpp b/src/test/forecaster_util_tests.cpp
new file mode 100644
index 00000000000..114dfabb383
--- /dev/null
+++ b/src/test/forecaster_util_tests.cpp
@@ -0,0 +1,65 @@
+// Copyright (c) 2024 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/forecaster_util.h>
+#include <policy/policy.h>
+
+#include <boost/test/unit_test.hpp>
+#include <vector>
+
+BOOST_AUTO_TEST_SUITE(forecaster_util_tests)
+
+BOOST_AUTO_TEST_CASE(calculate_percentile_test)
+{
+    // Test that CalculatePercentiles returns empty when vector is empty
+    BOOST_CHECK(CalculatePercentiles({}, DEFAULT_BLOCK_MAX_WEIGHT).empty());
+
+    const int32_t package_size{10};
+    const int32_t individual_tx_vsize = static_cast<int32_t>(DEFAULT_BLOCK_MAX_WEIGHT / WITNESS_SCALE_FACTOR) / package_size;
+
+    // Define fee rate categories with corresponding fee rates in satoshis per kvB
+    const FeeFrac superHighFeerate{500 * individual_tx_vsize, individual_tx_vsize}; // Super High fee: 500 sat/kvB
+    const FeeFrac highFeerate{100 * individual_tx_vsize, individual_tx_vsize};      // High fee: 100 sat/kvB
+    const FeeFrac mediumFeerate{50 * individual_tx_vsize, individual_tx_vsize};     // Medium fee: 50 sat/kvB
+    const FeeFrac lowFeerate{10 * individual_tx_vsize, individual_tx_vsize};        // Low fee: 10 sat/kvB
+
+    std::vector<FeeFrac> package_feerates;
+    package_feerates.reserve(package_size);
+
+    // Populate the feerate histogram based on specified index ranges.
+    for (int i = 0; i < package_size; ++i) {
+        if (i < 3) {
+            package_feerates.emplace_back(superHighFeerate); // Super High fee rate for top 3
+        } else if (i < 5) {
+            package_feerates.emplace_back(highFeerate); // High fee rate for next 2
+        } else if (i < 8) {
+            package_feerates.emplace_back(mediumFeerate);                                          // Medium fee rate for next 3
+            BOOST_CHECK(CalculatePercentiles(package_feerates, DEFAULT_BLOCK_MAX_WEIGHT).empty()); // CalculatePercentiles should return empty until reaching the 95th percentile
+        } else {
+            package_feerates.emplace_back(lowFeerate); // Low fee rate for remaining 2
+        }
+    }
+
+    // Test percentile calculation on a complete histogram
+    {
+        const auto percentiles = CalculatePercentiles(package_feerates, DEFAULT_BLOCK_MAX_WEIGHT);
+        BOOST_CHECK(percentiles.p25 == superHighFeerate);
+        BOOST_CHECK(percentiles.p50 == highFeerate);
+        BOOST_CHECK(percentiles.p75 == mediumFeerate);
+        BOOST_CHECK(percentiles.p95 == lowFeerate);
+    }
+
+    // Test that CalculatePercentiles maintains monotonicity across all percentiles
+    {
+        package_feerates[7] = superHighFeerate; // Increase 8th index to a high fee rate
+        const auto percentiles = CalculatePercentiles(package_feerates, DEFAULT_BLOCK_MAX_WEIGHT);
+        BOOST_CHECK(percentiles.p25 == superHighFeerate);
+        BOOST_CHECK(percentiles.p50 == highFeerate);
+        BOOST_CHECK(percentiles.p75 == mediumFeerate); // Should still reflect the previous medium rate
+        BOOST_CHECK(percentiles.p95 == lowFeerate);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()

From 8befea5451e21ed482eeed7216c5cb07c280ec69 Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Wed, 13 Nov 2024 13:34:33 -0500
Subject: [PATCH 14/22] fees: add `MemPoolForecaster` class

- The mempool based fee rate forecaster generate a predicted fee rate estimate
  for a given confirmation target using the mempool unconfirmed transactions.

Co-authored-by: willcl-ark <will@256k1.dev>
---
 src/CMakeLists.txt                     |  1 +
 src/policy/fees/forecaster_util.cpp    |  2 +
 src/policy/fees/forecaster_util.h      |  1 +
 src/policy/fees/mempool_forecaster.cpp | 63 ++++++++++++++++++++++++++
 src/policy/fees/mempool_forecaster.h   | 45 ++++++++++++++++++
 5 files changed, 112 insertions(+)
 create mode 100644 src/policy/fees/mempool_forecaster.cpp
 create mode 100644 src/policy/fees/mempool_forecaster.h

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 00af5e553d0..f958af3d2e7 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -261,6 +261,7 @@ add_library(bitcoin_node STATIC EXCLUDE_FROM_ALL
   policy/fees/block_policy_estimator.cpp
   policy/fees/block_policy_estimator_args.cpp
   policy/fees/forecaster_man.cpp
+  policy/fees/mempool_forecaster.cpp
   policy/packages.cpp
   policy/rbf.cpp
   policy/settings.cpp
diff --git a/src/policy/fees/forecaster_util.cpp b/src/policy/fees/forecaster_util.cpp
index 21eb8a74934..966ed2c9bfe 100644
--- a/src/policy/fees/forecaster_util.cpp
+++ b/src/policy/fees/forecaster_util.cpp
@@ -47,6 +47,8 @@ Percentiles CalculatePercentiles(const std::vector<FeeFrac>& package_feerates, c
 std::string forecastTypeToString(ForecastType forecastType)
 {
     switch (forecastType) {
+    case ForecastType::MEMPOOL_FORECAST:
+        return std::string("Mempool Forecast");
     case ForecastType::BLOCK_POLICY:
         return std::string("Block Policy Estimator");
     }
diff --git a/src/policy/fees/forecaster_util.h b/src/policy/fees/forecaster_util.h
index 6fd5ac7c3b2..6be12a03661 100644
--- a/src/policy/fees/forecaster_util.h
+++ b/src/policy/fees/forecaster_util.h
@@ -16,6 +16,7 @@
  */
 enum class ForecastType {
     BLOCK_POLICY,
+    MEMPOOL_FORECAST,
 };
 
 /**
diff --git a/src/policy/fees/mempool_forecaster.cpp b/src/policy/fees/mempool_forecaster.cpp
new file mode 100644
index 00000000000..be36f1c567d
--- /dev/null
+++ b/src/policy/fees/mempool_forecaster.cpp
@@ -0,0 +1,63 @@
+// Copyright (c) 2024 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 <logging.h>
+#include <node/miner.h>
+#include <policy/fees/forecaster.h>
+#include <policy/fees/forecaster_util.h>
+#include <policy/fees/mempool_forecaster.h>
+#include <policy/policy.h>
+#include <validation.h>
+
+ForecastResult MemPoolForecaster::EstimateFee(ConfirmationTarget& target)
+{
+    ForecastResult::ForecastResponse response;
+    response.forecaster = m_forecastType;
+    LOCK2(cs_main, m_mempool->cs);
+    auto activeTip = m_chainstate->m_chainman.ActiveTip();
+    if (!activeTip) {
+        return ForecastResult(response, "No active chainstate available");
+    }
+    response.current_block_height = static_cast<unsigned int>(activeTip->nHeight);
+
+    if (target.type != ConfirmationTargetType::BLOCKS) {
+        return ForecastResult(response, "Forecaster can only provide an estimate for block targets");
+    }
+    if (target.value > MEMPOOL_FORECAST_MAX_TARGET) {
+        return ForecastResult(response, strprintf(
+                                            "Confirmation target %s exceeds the maximum limit of %s. mempool conditions might change, "
+                                            "making forecasts above %s block may be unreliable",
+                                            target.value, MEMPOOL_FORECAST_MAX_TARGET, MEMPOOL_FORECAST_MAX_TARGET));
+    }
+
+    node::BlockAssembler::Options options;
+    options.test_block_validity = false;
+    node::BlockAssembler assembler(*m_chainstate, m_mempool, options);
+
+    const auto pblocktemplate = assembler.CreateNewBlock();
+    const auto& m_package_feerates = pblocktemplate->m_package_feerates;
+    if (m_package_feerates.empty()) {
+        return ForecastResult(response, "No enough transactions in the mempool to provide a fee rate forecast");
+    }
+
+    const auto percentiles = CalculatePercentiles(m_package_feerates, DEFAULT_BLOCK_MAX_WEIGHT);
+    if (percentiles.empty()) {
+        return ForecastResult(response, "Forecaster unable to provide an estimate due to insufficient data");
+    }
+
+    LogDebug(BCLog::ESTIMATEFEE,
+             "FeeEstimation: %s: Block height %s, 25th percentile fee rate: %s %s/kvB, "
+             "50th percentile fee rate: %s %s/kvB, 75th percentile fee rate: %s %s/kvB, "
+             "95th percentile fee rate: %s %s/kvB\n",
+             forecastTypeToString(m_forecastType), response.current_block_height,
+             CFeeRate(percentiles.p25.fee, percentiles.p25.size).GetFeePerK(), CURRENCY_ATOM,
+             CFeeRate(percentiles.p50.fee, percentiles.p50.size).GetFeePerK(), CURRENCY_ATOM,
+             CFeeRate(percentiles.p75.fee, percentiles.p75.size).GetFeePerK(), CURRENCY_ATOM,
+             CFeeRate(percentiles.p95.fee, percentiles.p95.size).GetFeePerK(), CURRENCY_ATOM);
+
+    response.low_priority = percentiles.p75;
+    response.high_priority = percentiles.p50;
+
+    return ForecastResult(response);
+}
diff --git a/src/policy/fees/mempool_forecaster.h b/src/policy/fees/mempool_forecaster.h
new file mode 100644
index 00000000000..d7e2d65d6e9
--- /dev/null
+++ b/src/policy/fees/mempool_forecaster.h
@@ -0,0 +1,45 @@
+// Copyright (c) 2024 The Bitcoin Core developers
+// Distributed under the MIT software license. See the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_POLICY_FEES_MEMPOOL_FORECASTER_H
+#define BITCOIN_POLICY_FEES_MEMPOOL_FORECASTER_H
+
+
+#include <policy/fees/forecaster.h>
+
+class Chainstate;
+class CTxMemPool;
+
+struct ConfirmationTarget;
+
+// Fee rate estimates above this confirmation target are not reliable,
+// mempool condition might likely change.
+constexpr int MEMPOOL_FORECAST_MAX_TARGET{2};
+
+/** \class MemPoolForecaster
+ * This fee estimate forecaster estimates the fee rate that a transaction will pay
+ * to be included in a block as soon as possible.
+ * It uses the unconfirmed transactions in the mempool to generate the next block template
+ * that will likely be mined.
+ * The percentile fee rate's are computed, and the bottom 25th percentile and 50th percentile fee rate's are returned.
+ */
+class MemPoolForecaster : public Forecaster
+{
+public:
+    MemPoolForecaster(const CTxMemPool* mempool, Chainstate* chainstate)
+        : Forecaster(ForecastType::MEMPOOL_FORECAST), m_mempool(mempool), m_chainstate(chainstate) {};
+    ~MemPoolForecaster() = default;
+
+    /**
+     * Estimate the fee rate from mempool transactions given a confirmation target.
+     * @param[in] target The confirmation target to provide estimate for.
+     * @return The forecasted fee rates.
+     */
+    ForecastResult EstimateFee(ConfirmationTarget& target) override;
+
+private:
+    const CTxMemPool* m_mempool;
+    Chainstate* m_chainstate;
+};
+#endif // BITCOIN_POLICY_FEES_MEMPOOL_FORECASTER_H

From 115928a33c9baa9a68bd7e44653a313e58435bf1 Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Wed, 13 Nov 2024 13:36:45 -0500
Subject: [PATCH 15/22] test: add mempool forecaster unit test

---
 src/test/CMakeLists.txt              |  1 +
 src/test/mempoolforecaster_tests.cpp | 99 ++++++++++++++++++++++++++++
 2 files changed, 100 insertions(+)
 create mode 100644 src/test/mempoolforecaster_tests.cpp

diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index 27af30af6cd..29bee7f2862 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -76,6 +76,7 @@ add_executable(test_bitcoin
   key_tests.cpp
   logging_tests.cpp
   mempool_tests.cpp
+  mempoolforecaster_tests.cpp
   merkle_tests.cpp
   merkleblock_tests.cpp
   miner_tests.cpp
diff --git a/src/test/mempoolforecaster_tests.cpp b/src/test/mempoolforecaster_tests.cpp
new file mode 100644
index 00000000000..5dc2c33bec2
--- /dev/null
+++ b/src/test/mempoolforecaster_tests.cpp
@@ -0,0 +1,99 @@
+// Copyright (c) 2024 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/forecaster.h>
+#include <policy/fees/forecaster_util.h>
+#include <policy/fees/mempool_forecaster.h>
+#include <random.h>
+#include <test/util/txmempool.h>
+#include <txmempool.h>
+#include <uint256.h>
+#include <util/feefrac.h>
+#include <util/strencodings.h>
+#include <validation.h>
+
+
+#include <test/util/setup_common.h>
+
+#include <memory>
+#include <string>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(mempoolforecaster_tests, TestChain100Setup)
+
+static inline CTransactionRef make_random_tx()
+{
+    auto rng = FastRandomContext();
+    auto tx = CMutableTransaction();
+    tx.vin.resize(1);
+    tx.vout.resize(1);
+    tx.vin[0].prevout.hash = Txid::FromUint256(rng.rand256());
+    tx.vin[0].prevout.n = 0;
+    tx.vin[0].scriptSig << OP_TRUE;
+    tx.vout[0].scriptPubKey = CScript() << OP_TRUE;
+    tx.vout[0].nValue = COIN;
+    return MakeTransactionRef(tx);
+}
+
+BOOST_AUTO_TEST_CASE(MempoolEstimator)
+{
+    auto mempool_fee_estimator = std::make_unique<MemPoolForecaster>(m_node.mempool.get(), &(m_node.chainman->ActiveChainstate()));
+    ConfirmationTarget conf_target = {MEMPOOL_FORECAST_MAX_TARGET + 1, ConfirmationTargetType::BLOCKS};
+    LOCK2(cs_main, m_node.mempool->cs);
+    {
+        // Test when targetBlocks > MEMPOOL_FORECAST_MAX_TARGET
+        const auto fee_estimate = mempool_fee_estimator->EstimateFee(conf_target);
+        BOOST_CHECK(fee_estimate.Empty());
+        BOOST_CHECK(*fee_estimate.GetError() == strprintf("Confirmation target %s exceeds the maximum limit of %s. mempool conditions might change, "
+                                                          "making forecasts above %s block may be unreliable",
+                                                          MEMPOOL_FORECAST_MAX_TARGET + 1, MEMPOOL_FORECAST_MAX_TARGET, MEMPOOL_FORECAST_MAX_TARGET));
+    }
+
+    BOOST_CHECK(m_node.mempool->GetTotalTxSize() == 0);
+    TestMemPoolEntryHelper entry;
+
+    const CAmount low_fee{CENT / 3000};
+    const CAmount med_fee{CENT / 100};
+    const CAmount high_fee{CENT / 10};
+
+    conf_target.value = MEMPOOL_FORECAST_MAX_TARGET;
+    // Test when there are not enough mempool transactions to get an accurate estimate
+    {
+        // Add transactions with high_fee fee until mempool transactions weight is more than 25th percent of DEFAULT_BLOCK_MAX_WEIGHT
+        while (static_cast<int>(m_node.mempool->GetTotalTxSize() * WITNESS_SCALE_FACTOR) <= static_cast<int>(0.25 * DEFAULT_BLOCK_MAX_WEIGHT)) {
+            AddToMempool(*m_node.mempool, entry.Fee(high_fee).FromTx(make_random_tx()));
+        }
+        const auto fee_estimate = mempool_fee_estimator->EstimateFee(conf_target);
+        BOOST_CHECK(fee_estimate.Empty());
+        BOOST_CHECK(*fee_estimate.GetError() == "Forecaster unable to provide an estimate due to insufficient data");
+    }
+
+    {
+        // Add transactions with med_fee fee until mempool transactions weight is more than 50th percent of DEFAULT_BLOCK_MAX_WEIGHT
+        while (static_cast<int>(m_node.mempool->GetTotalTxSize() * WITNESS_SCALE_FACTOR) <= static_cast<int>(0.5 * DEFAULT_BLOCK_MAX_WEIGHT)) {
+            AddToMempool(*m_node.mempool, entry.Fee(med_fee).FromTx(make_random_tx()));
+        }
+        const auto fee_estimate = mempool_fee_estimator->EstimateFee(conf_target);
+        BOOST_CHECK(fee_estimate.Empty());
+        BOOST_CHECK(*fee_estimate.GetError() == "Forecaster unable to provide an estimate due to insufficient data");
+    }
+
+    // Mempool transactions are enough to provide feerate estimate
+    {
+        // Add low_fee transactions until mempool transactions weight is more than 95th percent of DEFAULT_BLOCK_MAX_WEIGHT
+        while (static_cast<int>(m_node.mempool->GetTotalTxSize() * WITNESS_SCALE_FACTOR) <= static_cast<int>(0.95 * DEFAULT_BLOCK_MAX_WEIGHT)) {
+            const auto txref = make_random_tx();
+            AddToMempool(*m_node.mempool, entry.Fee(low_fee).FromTx(make_random_tx()));
+        }
+
+        const auto fee_estimate = mempool_fee_estimator->EstimateFee(conf_target);
+        BOOST_CHECK(!fee_estimate.Empty());
+        const auto tx_vsize = entry.FromTx(make_random_tx()).GetTxSize();
+        BOOST_CHECK(fee_estimate.GetResponse().low_priority == FeeFrac(low_fee, tx_vsize));
+        BOOST_CHECK(fee_estimate.GetResponse().high_priority == FeeFrac(med_fee, tx_vsize));
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()

From aecb08b81cbdec0c2027321c6074c430ce826ced Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Wed, 13 Nov 2024 13:38:17 -0500
Subject: [PATCH 16/22] fees: cache `MemPoolPolicyEstimator` forecasts

- Provide new estimates only when the time delta from previous
  forecast is older than 30 seconds.

- This caching helps avoid the high cost of frequently generating block templates,
  preventing users from inadvertently calling `estimateFee` repeatedly.

Co-authored-by: willcl-ark <will@256k1.dev>
---
 src/policy/fees/mempool_forecaster.cpp |  8 +++++
 src/policy/fees/mempool_forecaster.h   | 47 ++++++++++++++++++++++++++
 2 files changed, 55 insertions(+)

diff --git a/src/policy/fees/mempool_forecaster.cpp b/src/policy/fees/mempool_forecaster.cpp
index be36f1c567d..0b89b007d9f 100644
--- a/src/policy/fees/mempool_forecaster.cpp
+++ b/src/policy/fees/mempool_forecaster.cpp
@@ -31,6 +31,13 @@ ForecastResult MemPoolForecaster::EstimateFee(ConfirmationTarget& target)
                                             target.value, MEMPOOL_FORECAST_MAX_TARGET, MEMPOOL_FORECAST_MAX_TARGET));
     }
 
+    const auto cached_estimate = cache.get();
+    if (cached_estimate) {
+        response.low_priority = cached_estimate->p75;
+        response.high_priority = cached_estimate->p50;
+        return ForecastResult(response);
+    }
+
     node::BlockAssembler::Options options;
     options.test_block_validity = false;
     node::BlockAssembler assembler(*m_chainstate, m_mempool, options);
@@ -56,6 +63,7 @@ ForecastResult MemPoolForecaster::EstimateFee(ConfirmationTarget& target)
              CFeeRate(percentiles.p75.fee, percentiles.p75.size).GetFeePerK(), CURRENCY_ATOM,
              CFeeRate(percentiles.p95.fee, percentiles.p95.size).GetFeePerK(), CURRENCY_ATOM);
 
+    cache.update(percentiles);
     response.low_priority = percentiles.p75;
     response.high_priority = percentiles.p50;
 
diff --git a/src/policy/fees/mempool_forecaster.h b/src/policy/fees/mempool_forecaster.h
index d7e2d65d6e9..4901093b39d 100644
--- a/src/policy/fees/mempool_forecaster.h
+++ b/src/policy/fees/mempool_forecaster.h
@@ -6,7 +6,13 @@
 #define BITCOIN_POLICY_FEES_MEMPOOL_FORECASTER_H
 
 
+#include <logging.h>
 #include <policy/fees/forecaster.h>
+#include <policy/fees/forecaster_util.h>
+#include <sync.h>
+#include <util/time.h>
+
+#include <chrono>
 
 class Chainstate;
 class CTxMemPool;
@@ -16,6 +22,46 @@ struct ConfirmationTarget;
 // Fee rate estimates above this confirmation target are not reliable,
 // mempool condition might likely change.
 constexpr int MEMPOOL_FORECAST_MAX_TARGET{2};
+constexpr std::chrono::seconds CACHE_LIFE{30};
+
+/**
+ * CachedMempoolEstimates holds a cache of recent forecast.
+ * We only provide fresh estimates if the last cached fee rate
+ * forecast ages more than CACHE_LIFE.
+ */
+struct CachedMempoolEstimates {
+private:
+    mutable Mutex cache_mutex;
+    Percentiles fee_estimate GUARDED_BY(cache_mutex);
+    NodeClock::time_point last_updated GUARDED_BY(cache_mutex){NodeClock::now() - CACHE_LIFE - std::chrono::seconds(1)};
+
+    bool isStale() const EXCLUSIVE_LOCKS_REQUIRED(cache_mutex)
+    {
+        AssertLockHeld(cache_mutex);
+        return (last_updated + CACHE_LIFE) < NodeClock::now();
+    }
+
+public:
+    CachedMempoolEstimates() = default;
+    CachedMempoolEstimates(const CachedMempoolEstimates&) = delete;
+    CachedMempoolEstimates& operator=(const CachedMempoolEstimates&) = delete;
+
+    std::optional<Percentiles> get() const EXCLUSIVE_LOCKS_REQUIRED(!cache_mutex)
+    {
+        LOCK(cache_mutex);
+        if (isStale()) return std::nullopt;
+        LogDebug(BCLog::ESTIMATEFEE, "%s: cache is not stale, using cached value\n", forecastTypeToString(ForecastType::MEMPOOL_FORECAST));
+        return fee_estimate;
+    }
+
+    void update(const Percentiles& new_fee_estimate) EXCLUSIVE_LOCKS_REQUIRED(!cache_mutex)
+    {
+        LOCK(cache_mutex);
+        fee_estimate = new_fee_estimate;
+        last_updated = NodeClock::now();
+        LogDebug(BCLog::ESTIMATEFEE, "%s: updated cache\n", forecastTypeToString(ForecastType::MEMPOOL_FORECAST));
+    }
+};
 
 /** \class MemPoolForecaster
  * This fee estimate forecaster estimates the fee rate that a transaction will pay
@@ -41,5 +87,6 @@ public:
 private:
     const CTxMemPool* m_mempool;
     Chainstate* m_chainstate;
+    mutable CachedMempoolEstimates cache;
 };
 #endif // BITCOIN_POLICY_FEES_MEMPOOL_FORECASTER_H

From 3bf2c46428039fd94073fa225e2515e23e2647c8 Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Wed, 15 Jan 2025 12:57:02 -0500
Subject: [PATCH 17/22] fees: add `GetFeeEstimateFromForecasters` method

- Fallback to Block policy estimator estimates whenever mempool forecaster
  estimates are higher than block policy estimator.
---
 src/init.cpp                       | 41 ++++++++++++++-------------
 src/policy/fees/forecaster_man.cpp | 45 ++++++++++++++++++++++++++++++
 src/policy/fees/forecaster_man.h   | 14 ++++++++++
 3 files changed, 81 insertions(+), 19 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index 7b82067c8c7..3b5d4b930b6 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -57,8 +57,9 @@
 #include <node/peerman_args.h>
 #include <policy/feerate.h>
 #include <policy/fees/block_policy_estimator.h>
-#include <policy/fees/forecaster_man.h>
 #include <policy/fees/block_policy_estimator_args.h>
+#include <policy/fees/forecaster_man.h>
+#include <policy/fees/mempool_forecaster.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <protocol.h>
@@ -1429,24 +1430,6 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
                                               rng.rand64(),
                                               *node.addrman, *node.netgroupman, chainparams, args.GetBoolArg("-networkactive", true));
 
-    assert(!node.forecasterman);
-    // Don't initialize fee estimation with old data if we don't relay transactions,
-    // as they would never get updated.
-    if (!peerman_opts.ignore_incoming_txs) {
-        bool read_stale_estimates = args.GetBoolArg("-acceptstalefeeestimates", DEFAULT_ACCEPT_STALE_FEE_ESTIMATES);
-        if (read_stale_estimates && (chainparams.GetChainType() != ChainType::REGTEST)) {
-            return InitError(strprintf(_("acceptstalefeeestimates is not supported on %s chain."), chainparams.GetChainTypeString()));
-        }
-        node.forecasterman = std::make_unique<FeeRateForecasterManager>();
-        auto block_policy_estimator = std::make_shared<CBlockPolicyEstimator>(FeeestPath(args), read_stale_estimates);
-        validation_signals.RegisterSharedValidationInterface(block_policy_estimator);
-        // Flush block policy estimates to disk periodically
-        scheduler.scheduleEvery([block_policy_estimator] { block_policy_estimator->FlushFeeEstimates(); }, FEE_FLUSH_INTERVAL);
-
-        // Register block policy estimator to forecaster manager
-        node.forecasterman->RegisterForecaster(block_policy_estimator);
-    }
-
     for (const std::string& socket_addr : args.GetArgs("-bind")) {
         std::string host_out;
         uint16_t port_out{0};
@@ -1660,6 +1643,26 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
 
     ChainstateManager& chainman = *Assert(node.chainman);
 
+    assert(!node.forecasterman);
+    // Don't initialize fee estimation with old data if we don't relay transactions,
+    // as they would never get updated.
+    if (!peerman_opts.ignore_incoming_txs) {
+        bool read_stale_estimates = args.GetBoolArg("-acceptstalefeeestimates", DEFAULT_ACCEPT_STALE_FEE_ESTIMATES);
+        if (read_stale_estimates && (chainparams.GetChainType() != ChainType::REGTEST)) {
+            return InitError(strprintf(_("acceptstalefeeestimates is not supported on %s chain."), chainparams.GetChainTypeString()));
+        }
+        node.forecasterman = std::make_unique<FeeRateForecasterManager>();
+        auto mempool_forecaster = std::make_shared<MemPoolForecaster>(node.mempool.get(), &(chainman.ActiveChainstate()));
+        node.forecasterman->RegisterForecaster(mempool_forecaster);
+        auto block_policy_estimator = std::make_shared<CBlockPolicyEstimator>(FeeestPath(args), read_stale_estimates);
+        validation_signals.RegisterSharedValidationInterface(block_policy_estimator);
+        // Flush block policy estimates to disk periodically
+        scheduler.scheduleEvery([block_policy_estimator] { block_policy_estimator->FlushFeeEstimates(); }, FEE_FLUSH_INTERVAL);
+
+        // Register block policy estimator to forecaster manager
+        node.forecasterman->RegisterForecaster(block_policy_estimator);
+    }
+
     assert(!node.peerman);
     node.peerman = PeerManager::make(*node.connman, *node.addrman,
                                      node.banman.get(), chainman,
diff --git a/src/policy/fees/forecaster_man.cpp b/src/policy/fees/forecaster_man.cpp
index 38f2f65bbbc..38082fa34e9 100644
--- a/src/policy/fees/forecaster_man.cpp
+++ b/src/policy/fees/forecaster_man.cpp
@@ -2,11 +2,13 @@
 // Distributed under the MIT software license. See the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <logging.h>
 #include <policy/fees/block_policy_estimator.h>
 #include <policy/fees/forecaster.h>
 #include <policy/fees/forecaster_man.h>
 #include <policy/fees/forecaster_util.h>
 
+#include <algorithm>
 #include <utility>
 
 void FeeRateForecasterManager::RegisterForecaster(std::shared_ptr<Forecaster> forecaster)
@@ -20,3 +22,46 @@ CBlockPolicyEstimator* FeeRateForecasterManager::GetBlockPolicyEstimator()
     Forecaster* block_policy_estimator = forecasters.find(ForecastType::BLOCK_POLICY)->second.get();
     return dynamic_cast<CBlockPolicyEstimator*>(block_policy_estimator);
 }
+
+std::pair<std::optional<ForecastResult>, std::vector<std::string>> FeeRateForecasterManager::GetFeeEstimateFromForecasters(ConfirmationTarget& target)
+{
+    std::vector<std::string> err_messages;
+    ForecastResult selected_forecast;
+
+    for (const auto& forecaster : forecasters) {
+        auto curr_forecast = forecaster.second->EstimateFee(target);
+
+        if (curr_forecast.GetError().has_value()) {
+            err_messages.emplace_back(
+                strprintf("%s: %s", forecastTypeToString(forecaster.first), curr_forecast.GetError().value_or("")));
+        }
+
+        // Handle case where the block policy estimator does not have enough data for fee estimates.
+        if (curr_forecast.Empty() && forecaster.first == ForecastType::BLOCK_POLICY) {
+            return {std::nullopt, err_messages};
+        }
+
+        if (!curr_forecast.Empty()) {
+            if (selected_forecast.Empty()) {
+                // If there's no selected forecast, choose curr_forecast as selected_forecast.
+                selected_forecast = curr_forecast;
+            } else {
+                // Otherwise, choose the smaller as selected_forecast.
+                selected_forecast = std::min(selected_forecast, curr_forecast);
+            }
+        }
+    }
+
+    if (!selected_forecast.Empty()) {
+        LogDebug(BCLog::ESTIMATEFEE,
+                 "FeeEst %s: Block height %s, low priority fee rate %s %s/kvB, high priority fee rate %s %s/kvB.\n",
+                 forecastTypeToString(selected_forecast.GetResponse().forecaster),
+                 selected_forecast.GetResponse().current_block_height,
+                 CFeeRate(selected_forecast.GetResponse().low_priority.fee, selected_forecast.GetResponse().low_priority.size).GetFeePerK(),
+                 CURRENCY_ATOM,
+                 CFeeRate(selected_forecast.GetResponse().high_priority.fee, selected_forecast.GetResponse().high_priority.size).GetFeePerK(),
+                 CURRENCY_ATOM);
+    }
+
+    return {selected_forecast, err_messages};
+}
diff --git a/src/policy/fees/forecaster_man.h b/src/policy/fees/forecaster_man.h
index 3e352fc4817..3a2b0f0c4a5 100644
--- a/src/policy/fees/forecaster_man.h
+++ b/src/policy/fees/forecaster_man.h
@@ -6,12 +6,15 @@
 #define BITCOIN_POLICY_FEES_FORECASTER_MAN_H
 
 #include <memory>
+#include <optional>
 #include <unordered_map>
 
 class CBlockPolicyEstimator;
 class Forecaster;
 class ForecastResult;
 
+struct ConfirmationTarget;
+
 enum class ForecastType;
 
 /** \class FeeRateForecasterManager
@@ -38,6 +41,17 @@ public:
      * Return the pointer to block policy estimator.
      */
     CBlockPolicyEstimator* GetBlockPolicyEstimator();
+
+    /**
+     * Get a fee rate estimate from all registered forecasters for a given confirmation target.
+     *
+     * Polls all registered forecasters and selects the lowest fee rate
+     * estimate with acceptable confidence.
+     *
+     * @param[in] target The target within which the transaction should be confirmed.
+     * @return A pair consisting of the forecast result and a vector of forecaster names.
+     */
+    std::pair<std::optional<ForecastResult>, std::vector<std::string>> GetFeeEstimateFromForecasters(ConfirmationTarget& target);
 };
 
 #endif // BITCOIN_POLICY_FEES_FORECASTER_MAN_H

From c667bb1c6dbdcb67faa3e9e59a0cc2e13984450f Mon Sep 17 00:00:00 2001
From: willcl-ark <will@256k1.dev>
Date: Mon, 1 Jul 2024 19:27:43 +0100
Subject: [PATCH 18/22] ===== End of FeeRateForecasterMan commits =====


From d1b786e5e20bcc66fa64873671487d7dd3d50ed7 Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Fri, 18 Aug 2023 09:00:37 +0100
Subject: [PATCH 19/22] rpc: create an rpc `estimatefee`

- Given a confirmation target, we use fee estimator module that call all
available fee estimator forcasters and return the lowest fee rate that if
a transaction use will likely confirm in a given confirmation target.

Co-authored-by: willcl-ark <will@256k1.dev>
---
 src/rpc/client.cpp    |  1 +
 src/rpc/fees.cpp      | 56 +++++++++++++++++++++++++++++++++++++++++++
 src/test/fuzz/rpc.cpp |  1 +
 3 files changed, 58 insertions(+)

diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 1b711e3c5b1..3323c4293b9 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -261,6 +261,7 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "estimatesmartfee", 0, "conf_target" },
     { "estimaterawfee", 0, "conf_target" },
     { "estimaterawfee", 1, "threshold" },
+    { "estimatefee", 0, "conf_target" },
     { "prioritisetransaction", 1, "dummy" },
     { "prioritisetransaction", 2, "fee_delta" },
     { "setban", 2, "bantime" },
diff --git a/src/rpc/fees.cpp b/src/rpc/fees.cpp
index 0437bd626ad..fe8377a44ef 100644
--- a/src/rpc/fees.cpp
+++ b/src/rpc/fees.cpp
@@ -9,6 +9,7 @@
 #include <policy/feerate.h>
 #include <policy/fees/block_policy_estimator.h>
 #include <policy/fees/forecaster_man.h>
+#include <policy/fees/forecaster_util.h>
 #include <rpc/protocol.h>
 #include <rpc/request.h>
 #include <rpc/server.h>
@@ -95,6 +96,60 @@ static RPCHelpMan estimatesmartfee()
     };
 }
 
+static RPCHelpMan estimatefee()
+{
+    return RPCHelpMan{
+        "estimatefee",
+        "\nEstimates the approximate fee per kilobyte needed for a transaction to begin\n"
+        "confirmation within conf_target blocks if possible Uses virtual transaction size as defined\n"
+        "in BIP 141 (witness data is discounted).\n",
+        {
+            {"conf_target", RPCArg::Type::NUM, RPCArg::Optional::NO, "Confirmation target in blocks"},
+        },
+        RPCResult{
+            RPCResult::Type::OBJ, "", "", {
+                                              {RPCResult::Type::NUM, "minrelayfee", /*optional=*/true, "Minimum fee rate in " + CURRENCY_UNIT + "/kvB that a transaction has to pay to be relayed in the network"},
+                                              {RPCResult::Type::NUM, "low", /*optional=*/true, "fee rate estimate in " + CURRENCY_UNIT + "/kvB for economical users"},
+                                              {RPCResult::Type::NUM, "high", /*optional=*/true, "fee rate estimate in " + CURRENCY_UNIT + "/kvB for conservative users"},
+                                              {RPCResult::Type::STR, "forecaster", /*optional=*/true, "the forecaster that provide the fee rate estimate"},
+                                              {RPCResult::Type::ARR, "errors", /*optional=*/true, "Errors encountered during processing (if there are any)", {
+                                                                                                                                                                 {RPCResult::Type::STR, "", "error"},
+                                                                                                                                                             }},
+                                          }},
+        RPCExamples{HelpExampleCli("estimatefee", "2") + HelpExampleRpc("estimatefee", "2")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            const auto targetBlocks = request.params[0].getInt<int>();
+            UniValue result(UniValue::VOBJ);
+            UniValue errors(UniValue::VARR);
+            if (targetBlocks <= 0) {
+                errors.push_back("confirmation target must be greater than 0");
+                result.pushKV("errors", errors);
+                return result;
+            }
+            const NodeContext& node = EnsureAnyNodeContext(request.context);
+            const CTxMemPool& mempool = EnsureMemPool(node);
+            FeeRateForecasterManager& forecasterman = EnsureAnyForecasterMan(request.context);
+            ConfirmationTarget target = {/*value=*/static_cast<unsigned int>(targetBlocks), /*type*/ ConfirmationTargetType::BLOCKS};
+            auto forecast_result = forecasterman.GetFeeEstimateFromForecasters(target);
+            CFeeRate min_relay_feerate{mempool.m_opts.min_relay_feerate};
+            result.pushKV("minrelayfee", ValueFromAmount(min_relay_feerate.GetFeePerK()));
+            if (forecast_result.first && !forecast_result.first->Empty()) {
+                result.pushKV("low", ValueFromAmount(CFeeRate(forecast_result.first->GetResponse().low_priority.fee, forecast_result.first->GetResponse().low_priority.size).GetFeePerK()));
+                result.pushKV("high", ValueFromAmount(CFeeRate(forecast_result.first->GetResponse().high_priority.fee, forecast_result.first->GetResponse().high_priority.size).GetFeePerK()));
+                result.pushKV("forecaster", forecastTypeToString(forecast_result.first->GetResponse().forecaster));
+            } else {
+                errors.push_back("Failed to get estimate from forecasters");
+            }
+
+            for (auto& err : forecast_result.second) {
+                errors.push_back(err);
+            }
+            result.pushKV("errors", errors);
+            return result;
+        },
+    };
+}
+
 static RPCHelpMan estimaterawfee()
 {
     return RPCHelpMan{"estimaterawfee",
@@ -219,6 +274,7 @@ void RegisterFeeRPCCommands(CRPCTable& t)
 {
     static const CRPCCommand commands[]{
         {"util", &estimatesmartfee},
+        {"util", &estimatefee},
         {"hidden", &estimaterawfee},
     };
     for (const auto& c : commands) {
diff --git a/src/test/fuzz/rpc.cpp b/src/test/fuzz/rpc.cpp
index 7bf90b9b775..21dde750683 100644
--- a/src/test/fuzz/rpc.cpp
+++ b/src/test/fuzz/rpc.cpp
@@ -108,6 +108,7 @@ const std::vector<std::string> RPC_COMMANDS_SAFE_FOR_FUZZING{
     "disconnectnode",
     "echo",
     "echojson",
+    "estimatefee",
     "estimaterawfee",
     "estimatesmartfee",
     "finalizepsbt",

From a405eefac94aa05146f1b4c13226fd3cdf8ffe38 Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Mon, 24 Jun 2024 19:01:46 +0100
Subject: [PATCH 20/22] test: test `estimatefee` rpc

---
 test/functional/rpc_estimatefee.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/functional/rpc_estimatefee.py b/test/functional/rpc_estimatefee.py
index 05ceafbe4e0..fec29935863 100755
--- a/test/functional/rpc_estimatefee.py
+++ b/test/functional/rpc_estimatefee.py
@@ -20,10 +20,12 @@ class EstimateFeeTest(BitcoinTestFramework):
         # missing required params
         assert_raises_rpc_error(-1, "estimatesmartfee", self.nodes[0].estimatesmartfee)
         assert_raises_rpc_error(-1, "estimaterawfee", self.nodes[0].estimaterawfee)
+        assert_raises_rpc_error(-1, "estimatefee", self.nodes[0].estimatefee)
 
         # wrong type for conf_target
         assert_raises_rpc_error(-3, "JSON value of type string is not of expected type number", self.nodes[0].estimatesmartfee, 'foo')
         assert_raises_rpc_error(-3, "JSON value of type string is not of expected type number", self.nodes[0].estimaterawfee, 'foo')
+        assert_raises_rpc_error(-3, "JSON value of type string is not of expected type number", self.nodes[0].estimatefee, 'foo')
 
         # wrong type for estimatesmartfee(estimate_mode)
         assert_raises_rpc_error(-3, "JSON value of type number is not of expected type string", self.nodes[0].estimatesmartfee, 1, 1)
@@ -35,6 +37,7 @@ class EstimateFeeTest(BitcoinTestFramework):
         # extra params
         assert_raises_rpc_error(-1, "estimatesmartfee", self.nodes[0].estimatesmartfee, 1, 'ECONOMICAL', 1)
         assert_raises_rpc_error(-1, "estimaterawfee", self.nodes[0].estimaterawfee, 1, 1, 1)
+        assert_raises_rpc_error(-1, "estimatefee", self.nodes[0].estimatefee, 1, 1)
 
         # max value of 1008 per src/policy/fees.h
         assert_raises_rpc_error(-8, "Invalid conf_target, must be between 1 and 1008", self.nodes[0].estimaterawfee, 1009)
@@ -50,6 +53,8 @@ class EstimateFeeTest(BitcoinTestFramework):
         self.nodes[0].estimaterawfee(1, None)
         self.nodes[0].estimaterawfee(1, 1)
 
+        self.nodes[0].estimatefee(1)
+
 
 if __name__ == '__main__':
     EstimateFeeTest(__file__).main()

From 8982cfea52d6e1140118f24716526b11509aadac Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Wed, 22 Jan 2025 17:26:22 -0500
Subject: [PATCH 21/22] test: add `estimatefee` functionality test

---
 test/functional/feature_fee_estimation.py  | 94 ++++++++++++++++++++--
 test/functional/test_framework/messages.py |  1 +
 2 files changed, 90 insertions(+), 5 deletions(-)

diff --git a/test/functional/feature_fee_estimation.py b/test/functional/feature_fee_estimation.py
index 974d8268a2a..fe65ddabdda 100755
--- a/test/functional/feature_fee_estimation.py
+++ b/test/functional/feature_fee_estimation.py
@@ -11,6 +11,8 @@ import time
 
 from test_framework.messages import (
     COIN,
+    DEFAULT_BLOCK_MAX_WEIGHT,
+    WITNESS_SCALE_FACTOR,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
@@ -24,6 +26,7 @@ from test_framework.wallet import MiniWallet
 
 MAX_FILE_AGE = 60
 SECONDS_PER_HOUR = 60 * 60
+MEMPOOL_FORECASTER_CACHE_LIFE = 30 # Seconds
 
 def small_txpuzzle_randfee(
     wallet, from_node, conflist, unconflist, amount, min_fee, fee_increment, batch_reqs
@@ -136,6 +139,14 @@ def check_fee_estimates_btw_modes(node, expected_conservative, expected_economic
     assert_equal(fee_est_economical, expected_economical)
     assert_equal(fee_est_default, expected_economical)
 
+def verify_estimate_response(estimate, min_relay_fee, low_fee, high_fee, forecaster, errors):
+    assert_equal(estimate["minrelayfee"], min_relay_fee)
+    if low_fee and high_fee:
+        assert_equal(estimate["low"], low_fee)
+        assert_equal(estimate["high"], high_fee)
+        assert_equal(estimate["forecaster"], forecaster)
+    assert all(err in estimate["errors"] for err in errors)
+
 
 class EstimateFeeTest(BitcoinTestFramework):
     def set_test_params(self):
@@ -408,24 +419,93 @@ class EstimateFeeTest(BitcoinTestFramework):
         self.sync_mempools()
         self.generate(miner, 1)
 
+
+    def setup_and_broadcast(self, fee_rate, blocks, txs):
+        """Helper for broadcasting transactions from node 1 and mining them using node 2 consecutively."""
+        for _ in range(blocks):
+            self.broadcast_and_mine(self.nodes[1], self.nodes[2], fee_rate, txs)
+
+    def send_transactions(self, utxos, fee_rate, target_vsize):
+        for utxo in utxos:
+            self.wallet.send_self_transfer(
+                from_node=self.nodes[0],
+                utxo_to_spend=utxo,
+                fee_rate=fee_rate,
+                target_vsize=target_vsize,
+            )
+
+
     def test_estimation_modes(self):
         low_feerate = Decimal("0.001")
         high_feerate = Decimal("0.005")
         tx_count = 24
         # Broadcast and mine high fee transactions for the first 12 blocks.
-        for _ in range(12):
-            self.broadcast_and_mine(self.nodes[1], self.nodes[2], high_feerate, tx_count)
-        check_fee_estimates_btw_modes(self.nodes[0], high_feerate, high_feerate)
+        self.setup_and_broadcast(high_feerate, blocks=12, txs=tx_count)
 
         # We now track 12 blocks; short horizon stats will start decaying.
         # Broadcast and mine low fee transactions for the next 4 blocks.
-        for _ in range(4):
-            self.broadcast_and_mine(self.nodes[1], self.nodes[2], low_feerate, tx_count)
+        self.setup_and_broadcast(low_feerate, blocks=4, txs=tx_count)
         # conservative mode will consider longer time horizons while economical mode does not
         # Check the fee estimates for both modes after mining low fee transactions.
         check_fee_estimates_btw_modes(self.nodes[0], high_feerate, low_feerate)
 
 
+    def test_estimatefee(self):
+        node0 = self.nodes[0]
+        self.log.info("Ensure node0's mempool is empty at the start")
+        assert_equal(node0.getmempoolinfo()['size'], 0)
+
+        self.log.info("Test estimatefee after restart with empty mempool and no block policy estimator data")
+        mempool_forecast_error = "Mempool Forecast: No enough transactions in the mempool to provide a fee rate forecast"
+        block_policy_error = "Block Policy Estimator: Insufficient data or no feerate found"
+        generic_error = "Failed to get estimate from forecasters"
+        estimate_after_restart = node0.estimatefee(1)
+        min_relay_fee = Decimal("0.0000100")
+        verify_estimate_response(estimate_after_restart, min_relay_fee, None, None, None, [generic_error, block_policy_error])
+
+        self.log.info("Test estimatefee after gathering sufficient block policy estimator data")
+        # Generate high-feerate transactions and mine them over 6 blocks
+        high_feerate, tx_count = Decimal("0.004"), 24
+        self.setup_and_broadcast(high_feerate, blocks=6, txs=tx_count)
+        estimate_from_block_policy = node0.estimatefee(1)
+        verify_estimate_response(estimate_from_block_policy, min_relay_fee, high_feerate, high_feerate, "Block Policy Estimator", [mempool_forecast_error])
+
+        self.log.info("Verify we return block policy estimator estimate when mempool provides higher estimate")
+        # Add 10 large high-feerate transactions enough to generate a block template
+        num_txs = 10
+        target_vsize = int((DEFAULT_BLOCK_MAX_WEIGHT / WITNESS_SCALE_FACTOR - 4000) / num_txs) # Account for coinbase space
+        self.restart_node(0, extra_args=[f"-datacarriersize={target_vsize}"])
+        utxos = [self.wallet.get_utxo(confirmed_only=True) for _ in range(num_txs)]
+        insane_feerate = Decimal("0.01")
+        self.send_transactions(utxos, insane_feerate, target_vsize)
+        estimate_after_spike = node0.estimatefee(1)
+        verify_estimate_response(estimate_after_spike, min_relay_fee, high_feerate, high_feerate, "Block Policy Estimator", [])
+
+        self.log.info("Test caching of recent estimates")
+        # Restart node with empty mempool, then broadcast low-feerate transactions
+        # Check that estimate reflects the lower feerate even after higher-feerate transactions were recently broadcasted
+        self.stop_node(0)
+        os.remove(node0.chain_path / "mempool.dat")
+        self.restart_node(0, extra_args=[f"-datacarriersize={target_vsize}"])
+
+        low_feerate = Decimal("0.00004")
+        self.send_transactions(utxos, low_feerate, target_vsize)
+        lower_estimate = node0.estimatefee(1)
+        verify_estimate_response(lower_estimate, min_relay_fee, low_feerate, low_feerate, "Mempool Forecast", [])
+
+        # Verify cache persists low-feerate estimate after broadcasting higher-feerate transactions
+        med_feerate = Decimal("0.002")
+        self.send_transactions(utxos, med_feerate, target_vsize)  # Double-spend UTXOs with medium feerate
+        cached_estimate = node0.estimatefee(1)
+        verify_estimate_response(cached_estimate, min_relay_fee, low_feerate, low_feerate, "Mempool Forecast", [])
+
+        self.log.info("Test estimate refresh after cache expiration")
+        current_timestamp = int(time.time())
+        node0.setmocktime(current_timestamp + (MEMPOOL_FORECASTER_CACHE_LIFE + 1))
+        new_estimate = node0.estimatefee(1)
+        verify_estimate_response(new_estimate, min_relay_fee, med_feerate, med_feerate, "Mempool Forecast", [])
+
+
     def run_test(self):
         self.log.info("This test is time consuming, please be patient")
         self.log.info("Splitting inputs so we can generate tx's")
@@ -472,6 +552,10 @@ class EstimateFeeTest(BitcoinTestFramework):
         self.log.info("Test estimatesmartfee modes")
         self.test_estimation_modes()
 
+        self.clear_estimates()
+        self.log.info("Test estimatefee RPC")
+        self.test_estimatefee()
+
         self.log.info("Testing that fee estimation is disabled in blocksonly.")
         self.restart_node(0, ["-blocksonly"])
         assert_raises_rpc_error(
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index b4a5d9d5efa..c4a3b0a2884 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -35,6 +35,7 @@ MAX_LOCATOR_SZ = 101
 MAX_BLOCK_WEIGHT = 4000000
 MAX_BLOOM_FILTER_SIZE = 36000
 MAX_BLOOM_HASH_FUNCS = 50
+DEFAULT_BLOCK_MAX_WEIGHT = MAX_BLOCK_WEIGHT - 4000
 
 COIN = 100000000  # 1 btc in satoshis
 MAX_MONEY = 21000000 * COIN

From 6d0c2c7a7ad31fdca00fddb0260f404566fa8304 Mon Sep 17 00:00:00 2001
From: willcl-ark <will@256k1.dev>
Date: Mon, 1 Jul 2024 19:28:02 +0100
Subject: [PATCH 22/22] ===== End of RPC commits  =====