From 13525e0c248eab9b199583cde76430c6da2426e2 Mon Sep 17 00:00:00 2001
From: stickies-v <stickies-v@protonmail.com>
Date: Fri, 1 Sep 2023 17:46:23 +0100
Subject: [PATCH 01/63] rpc: add arg helper unit test

Compare the results of self.Arg with the request.params accessors
to ensure they behave the same way.
---
 src/test/rpc_tests.cpp | 54 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/src/test/rpc_tests.cpp b/src/test/rpc_tests.cpp
index 0d2460c606..934a099661 100644
--- a/src/test/rpc_tests.cpp
+++ b/src/test/rpc_tests.cpp
@@ -581,4 +581,58 @@ BOOST_AUTO_TEST_CASE(help_example)
     BOOST_CHECK_NE(HelpExampleRpcNamed("foo", {{"arg", true}}), HelpExampleRpcNamed("foo", {{"arg", "true"}}));
 }
 
+static void CheckRpc(const std::vector<RPCArg>& params, const UniValue& args, RPCHelpMan::RPCMethodImpl test_impl)
+{
+    auto null_result{RPCResult{RPCResult::Type::NONE, "", "None"}};
+    const RPCHelpMan rpc{"dummy", "dummy description", params, null_result, RPCExamples{""}, test_impl};
+    JSONRPCRequest req;
+    req.params = args;
+
+    rpc.HandleRequest(req);
+}
+
+BOOST_AUTO_TEST_CASE(rpc_arg_helper)
+{
+    constexpr bool DEFAULT_BOOL = true;
+    constexpr auto DEFAULT_STRING = "default";
+    constexpr uint64_t DEFAULT_UINT64_T = 3;
+
+    //! Parameters with which the RPCHelpMan is instantiated
+    const std::vector<RPCArg> params{
+        // Required arg
+        {"req_int", RPCArg::Type::NUM, RPCArg::Optional::NO, ""},
+        {"req_str", RPCArg::Type::STR, RPCArg::Optional::NO, ""},
+        // Default arg
+        {"def_uint64_t", RPCArg::Type::NUM, RPCArg::Default{DEFAULT_UINT64_T}, ""},
+        {"def_string", RPCArg::Type::STR, RPCArg::Default{DEFAULT_STRING}, ""},
+        {"def_bool", RPCArg::Type::BOOL, RPCArg::Default{DEFAULT_BOOL}, ""},
+        // Optional arg without default
+        {"opt_double", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, ""},
+        {"opt_string", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""}
+    };
+
+    //! Check that `self.Arg` returns the same value as the `request.params` accessors
+    RPCHelpMan::RPCMethodImpl check_positional = [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            BOOST_CHECK_EQUAL(self.Arg<int>(0), request.params[0].getInt<int>());
+            BOOST_CHECK_EQUAL(self.Arg<std::string>(1), request.params[1].get_str());
+            BOOST_CHECK_EQUAL(self.Arg<uint64_t>(2), request.params[2].isNull() ? DEFAULT_UINT64_T : request.params[2].getInt<uint64_t>());
+            BOOST_CHECK_EQUAL(self.Arg<std::string>(3), request.params[3].isNull() ? DEFAULT_STRING : request.params[3].get_str());
+            BOOST_CHECK_EQUAL(self.Arg<bool>(4), request.params[4].isNull() ? DEFAULT_BOOL : request.params[4].get_bool());
+            if (!request.params[5].isNull()) {
+                BOOST_CHECK_EQUAL(self.MaybeArg<double>(5).value(), request.params[5].get_real());
+            } else {
+                BOOST_CHECK(!self.MaybeArg<double>(5));
+            }
+            if (!request.params[6].isNull()) {
+                BOOST_CHECK(self.MaybeArg<std::string>(6));
+                BOOST_CHECK_EQUAL(*self.MaybeArg<std::string>(6), request.params[6].get_str());
+            } else {
+                BOOST_CHECK(!self.MaybeArg<std::string>(6));
+            }
+            return UniValue{};
+        };
+    CheckRpc(params, UniValue{JSON(R"([5, "hello", null, null, null, null, null])")}, check_positional);
+    CheckRpc(params, UniValue{JSON(R"([5, "hello", 4, "test", true, 1.23, "world"])")}, check_positional);
+}
+
 BOOST_AUTO_TEST_SUITE_END()

From bbb31269bfa449e82d3b6a20c2c3481fb3dcc316 Mon Sep 17 00:00:00 2001
From: stickies-v <stickies-v@protonmail.com>
Date: Thu, 18 Jan 2024 17:27:36 +0000
Subject: [PATCH 02/63] rpc: add named arg helper

Overload the Arg and MaybeArg helpers to allow accessing arguments
by name as well.

Also update the docs to document Arg and MaybeArg separately
---
 src/rpc/util.cpp       | 12 ++++++++
 src/rpc/util.h         | 62 +++++++++++++++++++++++++++++++++++-------
 src/test/rpc_tests.cpp | 14 ++++++++++
 3 files changed, 78 insertions(+), 10 deletions(-)

diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 51c88cc1ba..c90456fe57 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -24,6 +24,8 @@
 #include <util/string.h>
 #include <util/translation.h>
 
+#include <algorithm>
+#include <iterator>
 #include <string_view>
 #include <tuple>
 
@@ -728,6 +730,16 @@ std::vector<std::pair<std::string, bool>> RPCHelpMan::GetArgNames() const
     return ret;
 }
 
+size_t RPCHelpMan::GetParamIndex(std::string_view key) const
+{
+    auto it{std::find_if(
+        m_args.begin(), m_args.end(), [&key](const auto& arg) { return arg.GetName() == key;}
+    )};
+
+    CHECK_NONFATAL(it != m_args.end());  // TODO: ideally this is checked at compile time
+    return std::distance(m_args.begin(), it);
+}
+
 std::string RPCHelpMan::ToString() const
 {
     std::string ret;
diff --git a/src/rpc/util.h b/src/rpc/util.h
index ad3ed97b2e..6b35922d07 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -402,18 +402,25 @@ class RPCHelpMan
 
     UniValue HandleRequest(const JSONRPCRequest& request) const;
     /**
-     * Helper to get a request argument.
-     * This function only works during m_fun(), i.e. it should only be used in
-     * RPC method implementations. The helper internally checks whether the
-     * user-passed argument isNull() and parses (from JSON) and returns the
-     * user-passed argument, or the default value derived from the RPCArg
-     * documentation, or a falsy value if no default was given.
+     * @brief Helper to get a required or default-valued request argument.
      *
-     * Use Arg<Type>(i) to get the argument or its default value. Otherwise,
-     * use MaybeArg<Type>(i) to get the optional argument or a falsy value.
+     * Use this function when the argument is required or when it has a default value. If the
+     * argument is optional and may not be provided, use MaybeArg instead.
      *
-     * The Type passed to this helper must match the corresponding
-     * RPCArg::Type.
+     * This function only works during m_fun(), i.e., it should only be used in
+     * RPC method implementations. It internally checks whether the user-passed
+     * argument isNull() and parses (from JSON) and returns the user-passed argument,
+     * or the default value derived from the RPCArg documentation.
+     *
+     * There are two overloads of this function:
+     * - Use Arg<Type>(size_t i) to get the argument (or the default value) by index.
+     * - Use Arg<Type>(const std::string& key) to get the argument (or the default value) by key.
+     *
+     * The Type passed to this helper must match the corresponding RPCArg::Type.
+     *
+     * @return The value of the RPC argument (or the default value) cast to type Type.
+     *
+     * @see MaybeArg for handling optional arguments without default values.
      */
     template <typename R>
     auto Arg(size_t i) const
@@ -427,6 +434,34 @@ class RPCHelpMan
             return ArgValue<const R&>(i);
         }
     }
+    template<typename R>
+    auto Arg(std::string_view key) const
+    {
+        return Arg<R>(GetParamIndex(key));
+    }
+    /**
+     * @brief Helper to get an optional request argument.
+     *
+     * Use this function when the argument is optional and does not have a default value. If the
+     * argument is required or has a default value, use Arg instead.
+     *
+     * This function only works during m_fun(), i.e., it should only be used in
+     * RPC method implementations. It internally checks whether the user-passed
+     * argument isNull() and parses (from JSON) and returns the user-passed argument,
+     * or a falsy value if no argument was passed.
+     *
+     * There are two overloads of this function:
+     * - Use MaybeArg<Type>(size_t i) to get the optional argument by index.
+     * - Use MaybeArg<Type>(const std::string& key) to get the optional argument by key.
+     *
+     * The Type passed to this helper must match the corresponding RPCArg::Type.
+     *
+     * @return For integral and floating-point types, a std::optional<Type> is returned.
+    *          For other types, a Type* pointer to the argument is returned. If the
+    *          argument is not provided, std::nullopt or a null pointer is returned.
+    *
+     * @see Arg for handling arguments that are required or have a default value.
+     */
     template <typename R>
     auto MaybeArg(size_t i) const
     {
@@ -439,6 +474,11 @@ class RPCHelpMan
             return ArgValue<const R*>(i);
         }
     }
+    template<typename R>
+    auto MaybeArg(std::string_view key) const
+    {
+        return MaybeArg<R>(GetParamIndex(key));
+    }
     std::string ToString() const;
     /** Return the named args that need to be converted from string to another JSON type */
     UniValue GetArgMap() const;
@@ -458,6 +498,8 @@ class RPCHelpMan
     mutable const JSONRPCRequest* m_req{nullptr}; // A pointer to the request for the duration of m_fun()
     template <typename R>
     R ArgValue(size_t i) const;
+    //! Return positional index of a parameter using its name as key.
+    size_t GetParamIndex(std::string_view key) const;
 };
 
 /**
diff --git a/src/test/rpc_tests.cpp b/src/test/rpc_tests.cpp
index 934a099661..9926fdfdcb 100644
--- a/src/test/rpc_tests.cpp
+++ b/src/test/rpc_tests.cpp
@@ -633,6 +633,20 @@ BOOST_AUTO_TEST_CASE(rpc_arg_helper)
         };
     CheckRpc(params, UniValue{JSON(R"([5, "hello", null, null, null, null, null])")}, check_positional);
     CheckRpc(params, UniValue{JSON(R"([5, "hello", 4, "test", true, 1.23, "world"])")}, check_positional);
+
+    //! Check that `self.Arg` returns the same value when using index and key
+    RPCHelpMan::RPCMethodImpl check_named = [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            BOOST_CHECK_EQUAL(self.Arg<int>(0), self.Arg<int>("req_int"));
+            BOOST_CHECK_EQUAL(self.Arg<std::string>(1), self.Arg<std::string>("req_str"));
+            BOOST_CHECK_EQUAL(self.Arg<uint64_t>(2), self.Arg<uint64_t>("def_uint64_t"));
+            BOOST_CHECK_EQUAL(self.Arg<std::string>(3), self.Arg<std::string>("def_string"));
+            BOOST_CHECK_EQUAL(self.Arg<bool>(4), self.Arg<bool>("def_bool"));
+            BOOST_CHECK(self.MaybeArg<double>(5) == self.MaybeArg<double>("opt_double"));
+            BOOST_CHECK(self.MaybeArg<std::string>(6) == self.MaybeArg<std::string>("opt_string"));
+            return UniValue{};
+        };
+    CheckRpc(params, UniValue{JSON(R"([5, "hello", null, null, null, null, null])")}, check_named);
+    CheckRpc(params, UniValue{JSON(R"([5, "hello", 4, "test", true, 1.23, "world"])")}, check_named);
 }
 
 BOOST_AUTO_TEST_SUITE_END()

From 30a6c999351041d6a1e8712a9659be1296a1b46a Mon Sep 17 00:00:00 2001
From: stickies-v <stickies-v@protonmail.com>
Date: Thu, 18 Jan 2024 17:27:50 +0000
Subject: [PATCH 03/63] rpc: access some args by name

Use the new key-based Arg helper in a few locations to show how
it is used.
---
 src/rpc/blockchain.cpp   | 9 +++++----
 src/rpc/mining.cpp       | 8 ++++----
 src/rpc/net.cpp          | 6 +++---
 src/rpc/signmessage.cpp  | 6 +++---
 src/wallet/rpc/coins.cpp | 7 ++-----
 5 files changed, 17 insertions(+), 19 deletions(-)

diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 50908e9f96..2f6e5c4217 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -2149,7 +2149,8 @@ static RPCHelpMan scantxoutset()
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
 {
     UniValue result(UniValue::VOBJ);
-    if (request.params[0].get_str() == "status") {
+    const auto action{self.Arg<std::string>("action")};
+    if (action == "status") {
         CoinsViewScanReserver reserver;
         if (reserver.reserve()) {
             // no scan in progress
@@ -2157,7 +2158,7 @@ static RPCHelpMan scantxoutset()
         }
         result.pushKV("progress", g_scan_progress.load());
         return result;
-    } else if (request.params[0].get_str() == "abort") {
+    } else if (action == "abort") {
         CoinsViewScanReserver reserver;
         if (reserver.reserve()) {
             // reserve was possible which means no scan was running
@@ -2166,7 +2167,7 @@ static RPCHelpMan scantxoutset()
         // set the abort flag
         g_should_abort_scan = true;
         return true;
-    } else if (request.params[0].get_str() == "start") {
+    } else if (action == "start") {
         CoinsViewScanReserver reserver;
         if (!reserver.reserve()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Scan already in progress, use action \"abort\" or \"status\"");
@@ -2235,7 +2236,7 @@ static RPCHelpMan scantxoutset()
         result.pushKV("unspents", unspents);
         result.pushKV("total_amount", ValueFromAmount(total_in));
     } else {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid action '%s'", request.params[0].get_str()));
+        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid action '%s'", action));
     }
     return result;
 },
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index ff39a31a43..bb50de3489 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -122,7 +122,7 @@ static RPCHelpMan getnetworkhashps()
 {
     ChainstateManager& chainman = EnsureAnyChainman(request.context);
     LOCK(cs_main);
-    return GetNetworkHashPS(self.Arg<int>(0), self.Arg<int>(1), chainman.ActiveChain());
+    return GetNetworkHashPS(self.Arg<int>("nblocks"), self.Arg<int>("height"), chainman.ActiveChain());
 },
     };
 }
@@ -229,12 +229,12 @@ static RPCHelpMan generatetodescriptor()
             "\nGenerate 11 blocks to mydesc\n" + HelpExampleCli("generatetodescriptor", "11 \"mydesc\"")},
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
 {
-    const auto num_blocks{self.Arg<int>(0)};
-    const auto max_tries{self.Arg<uint64_t>(2)};
+    const auto num_blocks{self.Arg<int>("num_blocks")};
+    const auto max_tries{self.Arg<uint64_t>("maxtries")};
 
     CScript coinbase_script;
     std::string error;
-    if (!getScriptFromDescriptor(self.Arg<std::string>(1), coinbase_script, error)) {
+    if (!getScriptFromDescriptor(self.Arg<std::string>("descriptor"), coinbase_script, error)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
     }
 
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index 5e6f42b596..666d1586b8 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -322,7 +322,7 @@ static RPCHelpMan addnode()
                 },
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
 {
-    const std::string command{request.params[1].get_str()};
+    const auto command{self.Arg<std::string>("command")};
     if (command != "onetry" && command != "add" && command != "remove") {
         throw std::runtime_error(
             self.ToString());
@@ -331,9 +331,9 @@ static RPCHelpMan addnode()
     NodeContext& node = EnsureAnyNodeContext(request.context);
     CConnman& connman = EnsureConnman(node);
 
-    const std::string node_arg{request.params[0].get_str()};
+    const auto node_arg{self.Arg<std::string>("node")};
     bool node_v2transport = connman.GetLocalServices() & NODE_P2P_V2;
-    bool use_v2transport = self.MaybeArg<bool>(2).value_or(node_v2transport);
+    bool use_v2transport = self.MaybeArg<bool>("v2transport").value_or(node_v2transport);
 
     if (use_v2transport && !node_v2transport) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Error: v2transport requested but not enabled (see -v2transport)");
diff --git a/src/rpc/signmessage.cpp b/src/rpc/signmessage.cpp
index 8c752ba1fd..9f3c24efcf 100644
--- a/src/rpc/signmessage.cpp
+++ b/src/rpc/signmessage.cpp
@@ -38,9 +38,9 @@ static RPCHelpMan verifymessage()
         },
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
         {
-            std::string strAddress = request.params[0].get_str();
-            std::string strSign = request.params[1].get_str();
-            std::string strMessage = request.params[2].get_str();
+            std::string strAddress = self.Arg<std::string>("address");
+            std::string strSign = self.Arg<std::string>("signature");
+            std::string strMessage = self.Arg<std::string>("message");
 
             switch (MessageVerify(strAddress, strSign, strMessage)) {
             case MessageVerificationResult::ERR_INVALID_ADDRESS:
diff --git a/src/wallet/rpc/coins.cpp b/src/wallet/rpc/coins.cpp
index 0cb0891141..b6c7396f4b 100644
--- a/src/wallet/rpc/coins.cpp
+++ b/src/wallet/rpc/coins.cpp
@@ -194,15 +194,12 @@ RPCHelpMan getbalance()
 
     LOCK(pwallet->cs_wallet);
 
-    const auto dummy_value{self.MaybeArg<std::string>(0)};
+    const auto dummy_value{self.MaybeArg<std::string>("dummy")};
     if (dummy_value && *dummy_value != "*") {
         throw JSONRPCError(RPC_METHOD_DEPRECATED, "dummy first argument must be excluded or set to \"*\".");
     }
 
-    int min_depth = 0;
-    if (!request.params[1].isNull()) {
-        min_depth = request.params[1].getInt<int>();
-    }
+    const auto min_depth{self.Arg<int>("minconf")};
 
     bool include_watchonly = ParseIncludeWatchonly(request.params[2], *pwallet);
 

From 2179e2c3209a41c1419f1f5ed6270a0dad68b50d Mon Sep 17 00:00:00 2001
From: brunoerg <brunoely.gc@gmail.com>
Date: Tue, 2 Apr 2024 09:01:15 -0300
Subject: [PATCH 04/63] doc: i2p: improve `-i2pacceptincoming` mention

---
 doc/i2p.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/i2p.md b/doc/i2p.md
index b6c07388b7..b769a74df4 100644
--- a/doc/i2p.md
+++ b/doc/i2p.md
@@ -79,8 +79,8 @@ one of the networks has issues.
 ## Persistent vs transient I2P addresses
 
 The first time Bitcoin Core connects to the I2P router, it automatically
-generates a persistent I2P address and its corresponding private key by default
-or if `-i2pacceptincoming=1` is set.  The private key is saved in a file named
+generates a persistent I2P address and its corresponding private key by default,
+unless `-i2pacceptincoming=0` is set.  The private key is saved in a file named
 `i2p_private_key` in the Bitcoin Core data directory.  The persistent I2P
 address is used for making outbound connections and accepting inbound
 connections.

From 038fd979effb54ee76ce1b7cf078e920c652326a Mon Sep 17 00:00:00 2001
From: dergoegge <n.goeggi@gmail.com>
Date: Fri, 25 Nov 2022 15:31:04 +0000
Subject: [PATCH 05/63] [net processing] Move nTimeOffset to net_processing

---
 src/net.cpp            |  1 -
 src/net.h              |  2 --
 src/net_processing.cpp | 10 +++++++---
 src/net_processing.h   |  1 +
 src/qt/guiutil.cpp     |  4 ++--
 src/qt/guiutil.h       |  4 ++--
 src/qt/rpcconsole.cpp  |  2 +-
 src/rpc/net.cpp        |  2 +-
 8 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/src/net.cpp b/src/net.cpp
index e388f05b03..a1154b60eb 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -599,7 +599,6 @@ void CNode::CopyStats(CNodeStats& stats)
     X(m_last_tx_time);
     X(m_last_block_time);
     X(m_connected);
-    X(nTimeOffset);
     X(m_addr_name);
     X(nVersion);
     {
diff --git a/src/net.h b/src/net.h
index 46d9422695..f1911fa2ce 100644
--- a/src/net.h
+++ b/src/net.h
@@ -191,7 +191,6 @@ class CNodeStats
     std::chrono::seconds m_last_tx_time;
     std::chrono::seconds m_last_block_time;
     std::chrono::seconds m_connected;
-    int64_t nTimeOffset;
     std::string m_addr_name;
     int nVersion;
     std::string cleanSubVer;
@@ -703,7 +702,6 @@ class CNode
     std::atomic<std::chrono::seconds> m_last_recv{0s};
     //! Unix epoch time at peer connection
     const std::chrono::seconds m_connected;
-    std::atomic<int64_t> nTimeOffset{0};
     // Address of this peer
     const CAddress addr;
     // Bind address of our side of the connection
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 6996af38cb..fe48aa25a9 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -390,6 +390,10 @@ struct Peer {
     /** Whether this peer wants invs or headers (when possible) for block announcements */
     bool m_prefers_headers GUARDED_BY(NetEventsInterface::g_msgproc_mutex){false};
 
+    /** Time offset computed during the version handshake based on the
+     * timestamp the peer sent in the version message. */
+    std::atomic<int64_t> m_time_offset{0};
+
     explicit Peer(NodeId id, ServiceFlags our_services)
         : m_id{id}
         , m_our_services{our_services}
@@ -1792,6 +1796,7 @@ bool PeerManagerImpl::GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats) c
             stats.presync_height = peer->m_headers_sync->GetPresyncHeight();
         }
     }
+    stats.time_offset = peer->m_time_offset;
 
     return true;
 }
@@ -3666,12 +3671,11 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
                   peer->m_starting_height, addrMe.ToStringAddrPort(), fRelay, pfrom.GetId(),
                   remoteAddr, (mapped_as ? strprintf(", mapped_as=%d", mapped_as) : ""));
 
-        int64_t nTimeOffset = nTime - GetTime();
-        pfrom.nTimeOffset = nTimeOffset;
+        peer->m_time_offset = nTime - GetTime();
         if (!pfrom.IsInboundConn()) {
             // Don't use timedata samples from inbound peers to make it
             // harder for others to tamper with our adjusted time.
-            AddTimeData(pfrom.addr, nTimeOffset);
+            AddTimeData(pfrom.addr, peer->m_time_offset);
         }
 
         // If the peer is old enough to have the old alert system, send it the final alert.
diff --git a/src/net_processing.h b/src/net_processing.h
index f8d7a8f511..e00946ea64 100644
--- a/src/net_processing.h
+++ b/src/net_processing.h
@@ -41,6 +41,7 @@ struct CNodeStateStats {
     bool m_addr_relay_enabled{false};
     ServiceFlags their_services;
     int64_t presync_height{-1};
+    int64_t time_offset{0};
 };
 
 class PeerManager : public CValidationInterface, public NetEventsInterface
diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
index 084b9a6615..5f5e002db7 100644
--- a/src/qt/guiutil.cpp
+++ b/src/qt/guiutil.cpp
@@ -771,9 +771,9 @@ QString formatPingTime(std::chrono::microseconds ping_time)
         QObject::tr("%1 ms").arg(QString::number((int)(count_microseconds(ping_time) / 1000), 10));
 }
 
-QString formatTimeOffset(int64_t nTimeOffset)
+QString formatTimeOffset(int64_t time_offset)
 {
-  return QObject::tr("%1 s").arg(QString::number((int)nTimeOffset, 10));
+  return QObject::tr("%1 s").arg(QString::number((int)time_offset, 10));
 }
 
 QString formatNiceTimeOffset(qint64 secs)
diff --git a/src/qt/guiutil.h b/src/qt/guiutil.h
index 7f06fdfe37..3e28e54557 100644
--- a/src/qt/guiutil.h
+++ b/src/qt/guiutil.h
@@ -240,8 +240,8 @@ namespace GUIUtil
     /** Format a CNodeStats.m_last_ping_time into a user-readable string or display N/A, if 0 */
     QString formatPingTime(std::chrono::microseconds ping_time);
 
-    /** Format a CNodeCombinedStats.nTimeOffset into a user-readable string */
-    QString formatTimeOffset(int64_t nTimeOffset);
+    /** Format a CNodeStateStats.time_offset into a user-readable string */
+    QString formatTimeOffset(int64_t time_offset);
 
     QString formatNiceTimeOffset(qint64 secs);
 
diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
index d2b184ebdf..cc51e413ee 100644
--- a/src/qt/rpcconsole.cpp
+++ b/src/qt/rpcconsole.cpp
@@ -1196,7 +1196,6 @@ void RPCConsole::updateDetailWidget()
     ui->peerBytesRecv->setText(GUIUtil::formatBytes(stats->nodeStats.nRecvBytes));
     ui->peerPingTime->setText(GUIUtil::formatPingTime(stats->nodeStats.m_last_ping_time));
     ui->peerMinPing->setText(GUIUtil::formatPingTime(stats->nodeStats.m_min_ping_time));
-    ui->timeoffset->setText(GUIUtil::formatTimeOffset(stats->nodeStats.nTimeOffset));
     if (stats->nodeStats.nVersion) {
         ui->peerVersion->setText(QString::number(stats->nodeStats.nVersion));
     }
@@ -1228,6 +1227,7 @@ void RPCConsole::updateDetailWidget()
     // This check fails for example if the lock was busy and
     // nodeStateStats couldn't be fetched.
     if (stats->fNodeStateStatsAvailable) {
+        ui->timeoffset->setText(GUIUtil::formatTimeOffset(stats->nodeStateStats.time_offset));
         ui->peerServices->setText(GUIUtil::formatServicesStr(stats->nodeStateStats.their_services));
         // Sync height is init to -1
         if (stats->nodeStateStats.nSyncHeight > -1) {
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index 3fa2b18495..14eae8c5df 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -239,7 +239,7 @@ static RPCHelpMan getpeerinfo()
         obj.pushKV("bytessent", stats.nSendBytes);
         obj.pushKV("bytesrecv", stats.nRecvBytes);
         obj.pushKV("conntime", count_seconds(stats.m_connected));
-        obj.pushKV("timeoffset", stats.nTimeOffset);
+        obj.pushKV("timeoffset", statestats.time_offset);
         if (stats.m_last_ping_time > 0us) {
             obj.pushKV("pingtime", Ticks<SecondsDouble>(stats.m_last_ping_time));
         }

From 55361a15d1aa6984051441bce88112000688fb43 Mon Sep 17 00:00:00 2001
From: stickies-v <stickies-v@protonmail.com>
Date: Sat, 3 Feb 2024 17:15:41 +0000
Subject: [PATCH 06/63] [net processing] Use std::chrono for type-safe time
 offsets

---
 src/net_processing.cpp | 6 +++---
 src/net_processing.h   | 4 +++-
 src/qt/rpcconsole.cpp  | 3 ++-
 src/rpc/net.cpp        | 2 +-
 4 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index fe48aa25a9..363de48022 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -392,7 +392,7 @@ struct Peer {
 
     /** Time offset computed during the version handshake based on the
      * timestamp the peer sent in the version message. */
-    std::atomic<int64_t> m_time_offset{0};
+    std::atomic<std::chrono::seconds> m_time_offset{0s};
 
     explicit Peer(NodeId id, ServiceFlags our_services)
         : m_id{id}
@@ -3671,11 +3671,11 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
                   peer->m_starting_height, addrMe.ToStringAddrPort(), fRelay, pfrom.GetId(),
                   remoteAddr, (mapped_as ? strprintf(", mapped_as=%d", mapped_as) : ""));
 
-        peer->m_time_offset = nTime - GetTime();
+        peer->m_time_offset = NodeSeconds{std::chrono::seconds{nTime}} - Now<NodeSeconds>();
         if (!pfrom.IsInboundConn()) {
             // Don't use timedata samples from inbound peers to make it
             // harder for others to tamper with our adjusted time.
-            AddTimeData(pfrom.addr, peer->m_time_offset);
+            AddTimeData(pfrom.addr, Ticks<std::chrono::seconds>(peer->m_time_offset.load()));
         }
 
         // If the peer is old enough to have the old alert system, send it the final alert.
diff --git a/src/net_processing.h b/src/net_processing.h
index e00946ea64..452a973d54 100644
--- a/src/net_processing.h
+++ b/src/net_processing.h
@@ -9,6 +9,8 @@
 #include <net.h>
 #include <validationinterface.h>
 
+#include <chrono>
+
 class AddrMan;
 class CChainParams;
 class CTxMemPool;
@@ -41,7 +43,7 @@ struct CNodeStateStats {
     bool m_addr_relay_enabled{false};
     ServiceFlags their_services;
     int64_t presync_height{-1};
-    int64_t time_offset{0};
+    std::chrono::seconds time_offset{0};
 };
 
 class PeerManager : public CValidationInterface, public NetEventsInterface
diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
index cc51e413ee..bafef62945 100644
--- a/src/qt/rpcconsole.cpp
+++ b/src/qt/rpcconsole.cpp
@@ -23,6 +23,7 @@
 #include <rpc/server.h>
 #include <util/strencodings.h>
 #include <util/string.h>
+#include <util/time.h>
 #include <util/threadnames.h>
 
 #include <univalue.h>
@@ -1227,7 +1228,7 @@ void RPCConsole::updateDetailWidget()
     // This check fails for example if the lock was busy and
     // nodeStateStats couldn't be fetched.
     if (stats->fNodeStateStatsAvailable) {
-        ui->timeoffset->setText(GUIUtil::formatTimeOffset(stats->nodeStateStats.time_offset));
+        ui->timeoffset->setText(GUIUtil::formatTimeOffset(Ticks<std::chrono::seconds>(stats->nodeStateStats.time_offset)));
         ui->peerServices->setText(GUIUtil::formatServicesStr(stats->nodeStateStats.their_services));
         // Sync height is init to -1
         if (stats->nodeStateStats.nSyncHeight > -1) {
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index 14eae8c5df..176cf0e404 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -239,7 +239,7 @@ static RPCHelpMan getpeerinfo()
         obj.pushKV("bytessent", stats.nSendBytes);
         obj.pushKV("bytesrecv", stats.nRecvBytes);
         obj.pushKV("conntime", count_seconds(stats.m_connected));
-        obj.pushKV("timeoffset", statestats.time_offset);
+        obj.pushKV("timeoffset", Ticks<std::chrono::seconds>(statestats.time_offset));
         if (stats.m_last_ping_time > 0us) {
             obj.pushKV("pingtime", Ticks<SecondsDouble>(stats.m_last_ping_time));
         }

From ee178dfcc1175e0af8163216c9c024f4bfc97965 Mon Sep 17 00:00:00 2001
From: stickies-v <stickies-v@protonmail.com>
Date: Thu, 7 Mar 2024 11:23:00 +0000
Subject: [PATCH 07/63] Add TimeOffsets helper class

This helper class is an alternative to CMedianFilter, but without a
lot of the special logic and exceptions that we needed while it was
still used for consensus.
---
 src/Makefile.am                      |  2 +
 src/Makefile.test.include            |  2 +
 src/net_processing.cpp               |  9 +++-
 src/node/timeoffsets.cpp             | 69 ++++++++++++++++++++++++++++
 src/node/timeoffsets.h               | 39 ++++++++++++++++
 src/test/fuzz/timeoffsets.cpp        | 28 +++++++++++
 src/test/timeoffsets_tests.cpp       | 69 ++++++++++++++++++++++++++++
 src/warnings.cpp                     | 11 +++++
 src/warnings.h                       |  3 ++
 test/functional/feature_maxtipage.py |  4 ++
 10 files changed, 234 insertions(+), 2 deletions(-)
 create mode 100644 src/node/timeoffsets.cpp
 create mode 100644 src/node/timeoffsets.h
 create mode 100644 src/test/fuzz/timeoffsets.cpp
 create mode 100644 src/test/timeoffsets_tests.cpp

diff --git a/src/Makefile.am b/src/Makefile.am
index 1f55bfbafd..383767a5a0 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -233,6 +233,7 @@ BITCOIN_CORE_H = \
   node/peerman_args.h \
   node/protocol_version.h \
   node/psbt.h \
+  node/timeoffsets.h \
   node/transaction.h \
   node/txreconciliation.h \
   node/utxo_snapshot.h \
@@ -435,6 +436,7 @@ libbitcoin_node_a_SOURCES = \
   node/minisketchwrapper.cpp \
   node/peerman_args.cpp \
   node/psbt.cpp \
+  node/timeoffsets.cpp \
   node/transaction.cpp \
   node/txreconciliation.cpp \
   node/utxo_snapshot.cpp \
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 9f9bdbbd0c..fb703a0b8c 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -152,6 +152,7 @@ BITCOIN_TESTS =\
   test/sync_tests.cpp \
   test/system_tests.cpp \
   test/timedata_tests.cpp \
+  test/timeoffsets_tests.cpp \
   test/torcontrol_tests.cpp \
   test/transaction_tests.cpp \
   test/translation_tests.cpp \
@@ -382,6 +383,7 @@ test_fuzz_fuzz_SOURCES = \
  test/fuzz/strprintf.cpp \
  test/fuzz/system.cpp \
  test/fuzz/timedata.cpp \
+ test/fuzz/timeoffsets.cpp \
  test/fuzz/torcontrol.cpp \
  test/fuzz/transaction.cpp \
  test/fuzz/tx_in.cpp \
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 363de48022..b549178677 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -23,6 +23,7 @@
 #include <netbase.h>
 #include <netmessagemaker.h>
 #include <node/blockstorage.h>
+#include <node/timeoffsets.h>
 #include <node/txreconciliation.h>
 #include <policy/fees.h>
 #include <policy/policy.h>
@@ -753,6 +754,8 @@ class PeerManagerImpl final : public PeerManager
     /** Next time to check for stale tip */
     std::chrono::seconds m_stale_tip_check_time GUARDED_BY(cs_main){0s};
 
+    TimeOffsets m_outbound_time_offsets;
+
     const Options m_opts;
 
     bool RejectIncomingTxs(const CNode& peer) const;
@@ -3673,9 +3676,11 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
 
         peer->m_time_offset = NodeSeconds{std::chrono::seconds{nTime}} - Now<NodeSeconds>();
         if (!pfrom.IsInboundConn()) {
-            // Don't use timedata samples from inbound peers to make it
-            // harder for others to tamper with our adjusted time.
+            // Don't use time offset samples from inbound peers to make it
+            // harder for others to create false warnings about our clock being out of sync.
             AddTimeData(pfrom.addr, Ticks<std::chrono::seconds>(peer->m_time_offset.load()));
+            m_outbound_time_offsets.Add(peer->m_time_offset);
+            m_outbound_time_offsets.WarnIfOutOfSync();
         }
 
         // If the peer is old enough to have the old alert system, send it the final alert.
diff --git a/src/node/timeoffsets.cpp b/src/node/timeoffsets.cpp
new file mode 100644
index 0000000000..62f527be8a
--- /dev/null
+++ b/src/node/timeoffsets.cpp
@@ -0,0 +1,69 @@
+// Copyright (c) 2024-present 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/interface_ui.h>
+#include <node/timeoffsets.h>
+#include <sync.h>
+#include <tinyformat.h>
+#include <util/time.h>
+#include <util/translation.h>
+#include <warnings.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cstdint>
+#include <deque>
+#include <limits>
+#include <optional>
+
+using namespace std::chrono_literals;
+
+void TimeOffsets::Add(std::chrono::seconds offset)
+{
+    LOCK(m_mutex);
+
+    if (m_offsets.size() >= MAX_SIZE) {
+        m_offsets.pop_front();
+    }
+    m_offsets.push_back(offset);
+    LogDebug(BCLog::NET, "Added time offset %+ds, total samples %d\n",
+             Ticks<std::chrono::seconds>(offset), m_offsets.size());
+}
+
+std::chrono::seconds TimeOffsets::Median() const
+{
+    LOCK(m_mutex);
+
+    // Only calculate the median if we have 5 or more offsets
+    if (m_offsets.size() < 5) return 0s;
+
+    auto sorted_copy = m_offsets;
+    std::sort(sorted_copy.begin(), sorted_copy.end());
+    return sorted_copy[sorted_copy.size() / 2];  // approximate median is good enough, keep it simple
+}
+
+bool TimeOffsets::WarnIfOutOfSync() const
+{
+    // when median == std::numeric_limits<int64_t>::min(), calling std::chrono::abs is UB
+    auto median{std::max(Median(), std::chrono::seconds(std::numeric_limits<int64_t>::min() + 1))};
+    if (std::chrono::abs(median) <= WARN_THRESHOLD) {
+        SetMedianTimeOffsetWarning(std::nullopt);
+        uiInterface.NotifyAlertChanged();
+        return false;
+    }
+
+    bilingual_str msg{strprintf(_(
+        "Your computer's date and time appear to be more than %d minutes out of sync with the network, "
+        "this may lead to consensus failure. After you've confirmed your computer's clock, this message "
+        "should no longer appear when you restart your node. Without a restart, it should stop showing "
+        "automatically after you've connected to a sufficient number of new outbound peers, which may "
+        "take some time. You can inspect the `timeoffset` field of the `getpeerinfo` and `getnetworkinfo` "
+        "RPC methods to get more info."
+    ), Ticks<std::chrono::minutes>(WARN_THRESHOLD))};
+    LogWarning("%s\n", msg.original);
+    SetMedianTimeOffsetWarning(msg);
+    uiInterface.NotifyAlertChanged();
+    return true;
+}
diff --git a/src/node/timeoffsets.h b/src/node/timeoffsets.h
new file mode 100644
index 0000000000..2b12584e12
--- /dev/null
+++ b/src/node/timeoffsets.h
@@ -0,0 +1,39 @@
+// Copyright (c) 2024-present 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_NODE_TIMEOFFSETS_H
+#define BITCOIN_NODE_TIMEOFFSETS_H
+
+#include <sync.h>
+
+#include <chrono>
+#include <cstddef>
+#include <deque>
+
+class TimeOffsets
+{
+    //! Maximum number of timeoffsets stored.
+    static constexpr size_t MAX_SIZE{50};
+    //! Minimum difference between system and network time for a warning to be raised.
+    static constexpr std::chrono::minutes WARN_THRESHOLD{10};
+
+    mutable Mutex m_mutex;
+    /** The observed time differences between our local clock and those of our outbound peers. A
+     * positive offset means our peer's clock is ahead of our local clock. */
+    std::deque<std::chrono::seconds> m_offsets GUARDED_BY(m_mutex){};
+
+public:
+    /** Add a new time offset sample. */
+    void Add(std::chrono::seconds offset) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
+
+    /** Compute and return the median of the collected time offset samples. The median is returned
+     * as 0 when there are less than 5 samples. */
+    std::chrono::seconds Median() const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
+
+    /** Raise warnings if the median time offset exceeds the warnings threshold. Returns true if
+     * warnings were raised. */
+    bool WarnIfOutOfSync() const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
+};
+
+#endif // BITCOIN_NODE_TIMEOFFSETS_H
diff --git a/src/test/fuzz/timeoffsets.cpp b/src/test/fuzz/timeoffsets.cpp
new file mode 100644
index 0000000000..019337a94a
--- /dev/null
+++ b/src/test/fuzz/timeoffsets.cpp
@@ -0,0 +1,28 @@
+// Copyright (c) 2024-present 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 <node/timeoffsets.h>
+#include <test/fuzz/FuzzedDataProvider.h>
+#include <test/fuzz/fuzz.h>
+#include <test/util/setup_common.h>
+
+#include <chrono>
+#include <cstdint>
+#include <functional>
+
+void initialize_timeoffsets()
+{
+    static const auto testing_setup = MakeNoLogFileContext<>(ChainType::MAIN);
+}
+
+FUZZ_TARGET(timeoffsets, .init = initialize_timeoffsets)
+{
+    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
+    TimeOffsets offsets{};
+    LIMITED_WHILE(fuzzed_data_provider.remaining_bytes() > 0, 4'000) {
+        (void)offsets.Median();
+        offsets.Add(std::chrono::seconds{fuzzed_data_provider.ConsumeIntegral<std::chrono::seconds::rep>()});
+        offsets.WarnIfOutOfSync();
+    }
+}
diff --git a/src/test/timeoffsets_tests.cpp b/src/test/timeoffsets_tests.cpp
new file mode 100644
index 0000000000..008f1a9db9
--- /dev/null
+++ b/src/test/timeoffsets_tests.cpp
@@ -0,0 +1,69 @@
+// Copyright (c) 2024-present 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 <node/timeoffsets.h>
+#include <test/util/setup_common.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <chrono>
+#include <vector>
+
+using namespace std::chrono_literals;
+
+static void AddMulti(TimeOffsets& offsets, const std::vector<std::chrono::seconds>& to_add)
+{
+    for (auto offset : to_add) {
+        offsets.Add(offset);
+    }
+}
+
+BOOST_FIXTURE_TEST_SUITE(timeoffsets_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(timeoffsets)
+{
+    TimeOffsets offsets{};
+    BOOST_CHECK(offsets.Median() == 0s);
+
+    AddMulti(offsets, {{0s, -1s, -2s, -3s}});
+    // median should be zero for < 5 offsets
+    BOOST_CHECK(offsets.Median() == 0s);
+
+    offsets.Add(-4s);
+    // we now have 5 offsets: [-4, -3, -2, -1, 0]
+    BOOST_CHECK(offsets.Median() == -2s);
+
+    AddMulti(offsets, {4, 5s});
+    // we now have 9 offsets: [-4, -3, -2, -1, 0, 5, 5, 5, 5]
+    BOOST_CHECK(offsets.Median() == 0s);
+
+    AddMulti(offsets, {41, 10s});
+    // the TimeOffsets is now at capacity with 50 offsets, oldest offsets is discarded for any additional offset
+    BOOST_CHECK(offsets.Median() == 10s);
+
+    AddMulti(offsets, {25, 15s});
+    // we now have 25 offsets of 10s followed by 25 offsets of 15s
+    BOOST_CHECK(offsets.Median() == 15s);
+}
+
+static bool IsWarningRaised(const std::vector<std::chrono::seconds>& check_offsets)
+{
+    TimeOffsets offsets{};
+    AddMulti(offsets, check_offsets);
+    return offsets.WarnIfOutOfSync();
+}
+
+
+BOOST_AUTO_TEST_CASE(timeoffsets_warning)
+{
+    BOOST_CHECK(IsWarningRaised({{-60min, -40min, -30min, 0min, 10min}}));
+    BOOST_CHECK(IsWarningRaised({5, 11min}));
+
+    BOOST_CHECK(!IsWarningRaised({4, 60min}));
+    BOOST_CHECK(!IsWarningRaised({100, 3min}));
+}
+
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/warnings.cpp b/src/warnings.cpp
index 84b021dad5..d55eecc48d 100644
--- a/src/warnings.cpp
+++ b/src/warnings.cpp
@@ -14,11 +14,13 @@
 #include <util/string.h>
 #include <util/translation.h>
 
+#include <optional>
 #include <vector>
 
 static GlobalMutex g_warnings_mutex;
 static bilingual_str g_misc_warnings GUARDED_BY(g_warnings_mutex);
 static bool fLargeWorkInvalidChainFound GUARDED_BY(g_warnings_mutex) = false;
+static std::optional<bilingual_str> g_timeoffset_warning GUARDED_BY(g_warnings_mutex){};
 
 void SetMiscWarning(const bilingual_str& warning)
 {
@@ -32,6 +34,11 @@ void SetfLargeWorkInvalidChainFound(bool flag)
     fLargeWorkInvalidChainFound = flag;
 }
 
+void SetMedianTimeOffsetWarning(std::optional<bilingual_str> warning)
+{
+    LOCK(g_warnings_mutex);
+    g_timeoffset_warning = warning;
+}
 bilingual_str GetWarnings(bool verbose)
 {
     bilingual_str warnings_concise;
@@ -56,6 +63,10 @@ bilingual_str GetWarnings(bool verbose)
         warnings_verbose.emplace_back(warnings_concise);
     }
 
+    if (g_timeoffset_warning) {
+        warnings_verbose.emplace_back(g_timeoffset_warning.value());
+    }
+
     if (verbose) {
         return Join(warnings_verbose, Untranslated("<hr />"));
     }
diff --git a/src/warnings.h b/src/warnings.h
index b21e2ea2b8..866bce6246 100644
--- a/src/warnings.h
+++ b/src/warnings.h
@@ -6,12 +6,15 @@
 #ifndef BITCOIN_WARNINGS_H
 #define BITCOIN_WARNINGS_H
 
+#include <optional>
 #include <string>
 
 struct bilingual_str;
 
 void SetMiscWarning(const bilingual_str& warning);
 void SetfLargeWorkInvalidChainFound(bool flag);
+/** Pass std::nullopt to disable the warning */
+void SetMedianTimeOffsetWarning(std::optional<bilingual_str> warning);
 /** Format a string that describes several potential problems detected by the core.
  * @param[in] verbose bool
  * - if true, get all warnings separated by <hr />
diff --git a/test/functional/feature_maxtipage.py b/test/functional/feature_maxtipage.py
index 51f37ef1e0..a1774a5395 100755
--- a/test/functional/feature_maxtipage.py
+++ b/test/functional/feature_maxtipage.py
@@ -43,6 +43,10 @@ def test_maxtipage(self, maxtipage, set_parameter=True, test_deltas=True):
         self.generate(node_miner, 1)
         assert_equal(node_ibd.getblockchaininfo()['initialblockdownload'], False)
 
+        # reset time to system time so we don't have a time offset with the ibd node the next
+        # time we connect to it, ensuring TimeOffsets::WarnIfOutOfSync() doesn't output to stderr
+        node_miner.setmocktime(0)
+
     def run_test(self):
         self.log.info("Test IBD with maximum tip age of 24 hours (default).")
         self.test_maxtipage(DEFAULT_MAX_TIP_AGE, set_parameter=False)

From 7d9c3ec622d73a98d07ab3cee78751718982a5bc Mon Sep 17 00:00:00 2001
From: dergoegge <n.goeggi@gmail.com>
Date: Mon, 27 Nov 2023 17:22:41 +0000
Subject: [PATCH 08/63] [net processing] Introduce PeerManagerInfo

For querying statistics/info from PeerManager. The median outbound time
offset is the only initial field.
---
 src/net_processing.cpp | 8 ++++++++
 src/net_processing.h   | 7 +++++++
 src/rpc/net.cpp        | 4 ++--
 3 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index b549178677..6289d13989 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -518,6 +518,7 @@ class PeerManagerImpl final : public PeerManager
     std::optional<std::string> FetchBlock(NodeId peer_id, const CBlockIndex& block_index) override
         EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     bool GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats) const override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
+    PeerManagerInfo GetInfo() const override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     bool IgnoresIncomingTxs() override { return m_opts.ignore_incoming_txs; }
     void SendPings() override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     void RelayTransaction(const uint256& txid, const uint256& wtxid) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
@@ -1804,6 +1805,13 @@ bool PeerManagerImpl::GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats) c
     return true;
 }
 
+PeerManagerInfo PeerManagerImpl::GetInfo() const
+{
+    return PeerManagerInfo{
+        .median_outbound_time_offset = m_outbound_time_offsets.Median(),
+    };
+}
+
 void PeerManagerImpl::AddToCompactExtraTransactions(const CTransactionRef& tx)
 {
     if (m_opts.max_extra_txs <= 0)
diff --git a/src/net_processing.h b/src/net_processing.h
index 452a973d54..d0ff02311b 100644
--- a/src/net_processing.h
+++ b/src/net_processing.h
@@ -46,6 +46,10 @@ struct CNodeStateStats {
     std::chrono::seconds time_offset{0};
 };
 
+struct PeerManagerInfo {
+    std::chrono::seconds median_outbound_time_offset{0s};
+};
+
 class PeerManager : public CValidationInterface, public NetEventsInterface
 {
 public:
@@ -86,6 +90,9 @@ class PeerManager : public CValidationInterface, public NetEventsInterface
     /** Get statistics from node state */
     virtual bool GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats) const = 0;
 
+    /** Get peer manager info. */
+    virtual PeerManagerInfo GetInfo() const = 0;
+
     /** Whether this node ignores txs received over p2p. */
     virtual bool IgnoresIncomingTxs() = 0;
 
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index 176cf0e404..823b6d620f 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -23,7 +23,6 @@
 #include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <sync.h>
-#include <timedata.h>
 #include <util/chaintype.h>
 #include <util/strencodings.h>
 #include <util/string.h>
@@ -679,9 +678,10 @@ static RPCHelpMan getnetworkinfo()
         obj.pushKV("localservicesnames", GetServicesNames(services));
     }
     if (node.peerman) {
+        auto peerman_info{node.peerman->GetInfo()};
         obj.pushKV("localrelay", !node.peerman->IgnoresIncomingTxs());
+        obj.pushKV("timeoffset", Ticks<std::chrono::seconds>(peerman_info.median_outbound_time_offset));
     }
-    obj.pushKV("timeoffset",    GetTimeOffset());
     if (node.connman) {
         obj.pushKV("networkactive", node.connman->GetNetworkActive());
         obj.pushKV("connections", node.connman->GetNodeCount(ConnectionDirection::Both));

From 92e72b5d0d49aa395e626c238bc28aba8e4c3d44 Mon Sep 17 00:00:00 2001
From: dergoegge <n.goeggi@gmail.com>
Date: Wed, 29 Nov 2023 12:03:49 +0000
Subject: [PATCH 09/63] [net processing] Move IgnoresIncomingTxs to
 PeerManagerInfo

---
 src/net_processing.cpp | 2 +-
 src/net_processing.h   | 4 +---
 src/rpc/net.cpp        | 2 +-
 3 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 6289d13989..0a6f180ab4 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -519,7 +519,6 @@ class PeerManagerImpl final : public PeerManager
         EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     bool GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats) const override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     PeerManagerInfo GetInfo() const override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
-    bool IgnoresIncomingTxs() override { return m_opts.ignore_incoming_txs; }
     void SendPings() override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     void RelayTransaction(const uint256& txid, const uint256& wtxid) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     void SetBestBlock(int height, std::chrono::seconds time) override
@@ -1809,6 +1808,7 @@ PeerManagerInfo PeerManagerImpl::GetInfo() const
 {
     return PeerManagerInfo{
         .median_outbound_time_offset = m_outbound_time_offsets.Median(),
+        .ignores_incoming_txs = m_opts.ignore_incoming_txs,
     };
 }
 
diff --git a/src/net_processing.h b/src/net_processing.h
index d0ff02311b..85e399d948 100644
--- a/src/net_processing.h
+++ b/src/net_processing.h
@@ -48,6 +48,7 @@ struct CNodeStateStats {
 
 struct PeerManagerInfo {
     std::chrono::seconds median_outbound_time_offset{0s};
+    bool ignores_incoming_txs{false};
 };
 
 class PeerManager : public CValidationInterface, public NetEventsInterface
@@ -93,9 +94,6 @@ class PeerManager : public CValidationInterface, public NetEventsInterface
     /** Get peer manager info. */
     virtual PeerManagerInfo GetInfo() const = 0;
 
-    /** Whether this node ignores txs received over p2p. */
-    virtual bool IgnoresIncomingTxs() = 0;
-
     /** Relay transaction to all peers. */
     virtual void RelayTransaction(const uint256& txid, const uint256& wtxid) = 0;
 
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index 823b6d620f..e3d50917a5 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -679,7 +679,7 @@ static RPCHelpMan getnetworkinfo()
     }
     if (node.peerman) {
         auto peerman_info{node.peerman->GetInfo()};
-        obj.pushKV("localrelay", !node.peerman->IgnoresIncomingTxs());
+        obj.pushKV("localrelay", !peerman_info.ignores_incoming_txs);
         obj.pushKV("timeoffset", Ticks<std::chrono::seconds>(peerman_info.median_outbound_time_offset));
     }
     if (node.connman) {

From c6be144c4b774a03a8bcab5a165768cf81e9b06b Mon Sep 17 00:00:00 2001
From: stickies-v <stickies-v@protonmail.com>
Date: Sun, 4 Feb 2024 05:08:26 +0000
Subject: [PATCH 10/63] Remove timedata

With the introduction and usage of TimeOffsets, there is no more need
for this file. Remove it.
---
 src/Makefile.am                    |   2 -
 src/Makefile.test.include          |   2 -
 src/addrman_impl.h                 |   1 -
 src/init.cpp                       |   2 -
 src/net_processing.cpp             |   4 +-
 src/test/denialofservice_tests.cpp |   2 -
 src/test/fuzz/timedata.cpp         |  31 --------
 src/test/net_tests.cpp             |   5 --
 src/test/timedata_tests.cpp        | 105 --------------------------
 src/timedata.cpp                   | 116 -----------------------------
 src/timedata.h                     |  82 --------------------
 11 files changed, 1 insertion(+), 351 deletions(-)
 delete mode 100644 src/test/fuzz/timedata.cpp
 delete mode 100644 src/test/timedata_tests.cpp
 delete mode 100644 src/timedata.cpp
 delete mode 100644 src/timedata.h

diff --git a/src/Makefile.am b/src/Makefile.am
index 383767a5a0..43d487c6dc 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -284,7 +284,6 @@ BITCOIN_CORE_H = \
   support/lockedpool.h \
   sync.h \
   threadsafety.h \
-  timedata.h \
   torcontrol.h \
   txdb.h \
   txmempool.h \
@@ -464,7 +463,6 @@ libbitcoin_node_a_SOURCES = \
   rpc/txoutproof.cpp \
   script/sigcache.cpp \
   signet.cpp \
-  timedata.cpp \
   torcontrol.cpp \
   txdb.cpp \
   txmempool.cpp \
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index fb703a0b8c..c20b531032 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -151,7 +151,6 @@ BITCOIN_TESTS =\
   test/streams_tests.cpp \
   test/sync_tests.cpp \
   test/system_tests.cpp \
-  test/timedata_tests.cpp \
   test/timeoffsets_tests.cpp \
   test/torcontrol_tests.cpp \
   test/transaction_tests.cpp \
@@ -382,7 +381,6 @@ test_fuzz_fuzz_SOURCES = \
  test/fuzz/string.cpp \
  test/fuzz/strprintf.cpp \
  test/fuzz/system.cpp \
- test/fuzz/timedata.cpp \
  test/fuzz/timeoffsets.cpp \
  test/fuzz/torcontrol.cpp \
  test/fuzz/transaction.cpp \
diff --git a/src/addrman_impl.h b/src/addrman_impl.h
index 867c894d01..dd7f7b318f 100644
--- a/src/addrman_impl.h
+++ b/src/addrman_impl.h
@@ -11,7 +11,6 @@
 #include <protocol.h>
 #include <serialize.h>
 #include <sync.h>
-#include <timedata.h>
 #include <uint256.h>
 #include <util/time.h>
 
diff --git a/src/init.cpp b/src/init.cpp
index 0aa04755cb..bc49a14c6c 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -67,7 +67,6 @@
 #include <scheduler.h>
 #include <script/sigcache.h>
 #include <sync.h>
-#include <timedata.h>
 #include <torcontrol.h>
 #include <txdb.h>
 #include <txmempool.h>
@@ -523,7 +522,6 @@ void SetupServerArgs(ArgsManager& argsman)
     argsman.AddArg("-maxconnections=<n>", strprintf("Maintain at most <n> automatic connections to peers (default: %u). This limit does not apply to connections manually added via -addnode or the addnode RPC, which have a separate limit of %u.", DEFAULT_MAX_PEER_CONNECTIONS, MAX_ADDNODE_CONNECTIONS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-maxreceivebuffer=<n>", strprintf("Maximum per-connection receive buffer, <n>*1000 bytes (default: %u)", DEFAULT_MAXRECEIVEBUFFER), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-maxsendbuffer=<n>", strprintf("Maximum per-connection memory usage for the send buffer, <n>*1000 bytes (default: %u)", DEFAULT_MAXSENDBUFFER), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
-    argsman.AddArg("-maxtimeadjustment", strprintf("Maximum allowed median peer time offset adjustment. Local perspective of time may be influenced by outbound peers forward or backward by this amount (default: %u seconds).", DEFAULT_MAX_TIME_ADJUSTMENT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-maxuploadtarget=<n>", strprintf("Tries to keep outbound traffic under the given target per 24h. Limit does not apply to peers with 'download' permission or blocks created within past week. 0 = no limit (default: %s). Optional suffix units [k|K|m|M|g|G|t|T] (default: M). Lowercase is 1000 base while uppercase is 1024 base", DEFAULT_MAX_UPLOAD_TARGET), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 #if HAVE_SOCKADDR_UN
     argsman.AddArg("-onion=<ip:port|path>", "Use separate SOCKS5 proxy to reach peers via Tor onion services, set -noonion to disable (default: -proxy). May be a local file path prefixed with 'unix:'.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 0a6f180ab4..42e085ccef 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -35,7 +35,6 @@
 #include <scheduler.h>
 #include <streams.h>
 #include <sync.h>
-#include <timedata.h>
 #include <tinyformat.h>
 #include <txmempool.h>
 #include <txorphanage.h>
@@ -3684,9 +3683,8 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
 
         peer->m_time_offset = NodeSeconds{std::chrono::seconds{nTime}} - Now<NodeSeconds>();
         if (!pfrom.IsInboundConn()) {
-            // Don't use time offset samples from inbound peers to make it
+            // Don't use timedata samples from inbound peers to make it
             // harder for others to create false warnings about our clock being out of sync.
-            AddTimeData(pfrom.addr, Ticks<std::chrono::seconds>(peer->m_time_offset.load()));
             m_outbound_time_offsets.Add(peer->m_time_offset);
             m_outbound_time_offsets.WarnIfOutOfSync();
         }
diff --git a/src/test/denialofservice_tests.cpp b/src/test/denialofservice_tests.cpp
index 0fef8c5906..5e9ae78681 100644
--- a/src/test/denialofservice_tests.cpp
+++ b/src/test/denialofservice_tests.cpp
@@ -16,7 +16,6 @@
 #include <test/util/net.h>
 #include <test/util/random.h>
 #include <test/util/setup_common.h>
-#include <timedata.h>
 #include <util/string.h>
 #include <util/time.h>
 #include <validation.h>
@@ -72,7 +71,6 @@ BOOST_AUTO_TEST_CASE(outbound_slow_chain_eviction)
         /*local_services=*/ServiceFlags(NODE_NETWORK | NODE_WITNESS),
         /*version=*/PROTOCOL_VERSION,
         /*relay_txs=*/true);
-    TestOnlyResetTimeData();
 
     // This test requires that we have a chain with non-zero work.
     {
diff --git a/src/test/fuzz/timedata.cpp b/src/test/fuzz/timedata.cpp
deleted file mode 100644
index f5d005296b..0000000000
--- a/src/test/fuzz/timedata.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) 2020-2021 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 <test/fuzz/FuzzedDataProvider.h>
-#include <test/fuzz/fuzz.h>
-#include <test/fuzz/util.h>
-#include <timedata.h>
-
-#include <cstdint>
-#include <string>
-#include <vector>
-
-FUZZ_TARGET(timedata)
-{
-    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
-    const unsigned int max_size = fuzzed_data_provider.ConsumeIntegralInRange<unsigned int>(0, 1000);
-    // A max_size of 0 implies no limit, so cap the max number of insertions to avoid timeouts
-    auto max_to_insert = fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 4000);
-    // Divide by 2 to avoid signed integer overflow in .median()
-    const int64_t initial_value = fuzzed_data_provider.ConsumeIntegral<int64_t>() / 2;
-    CMedianFilter<int64_t> median_filter{max_size, initial_value};
-    while (fuzzed_data_provider.remaining_bytes() > 0 && --max_to_insert >= 0) {
-        (void)median_filter.median();
-        assert(median_filter.size() > 0);
-        assert(static_cast<size_t>(median_filter.size()) == median_filter.sorted().size());
-        assert(static_cast<unsigned int>(median_filter.size()) <= max_size || max_size == 0);
-        // Divide by 2 to avoid signed integer overflow in .median()
-        median_filter.input(fuzzed_data_provider.ConsumeIntegral<int64_t>() / 2);
-    }
-}
diff --git a/src/test/net_tests.cpp b/src/test/net_tests.cpp
index 70a8279f04..b9dff96610 100644
--- a/src/test/net_tests.cpp
+++ b/src/test/net_tests.cpp
@@ -19,7 +19,6 @@
 #include <test/util/random.h>
 #include <test/util/setup_common.h>
 #include <test/util/validation.h>
-#include <timedata.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <validation.h>
@@ -902,10 +901,6 @@ BOOST_AUTO_TEST_CASE(initial_advertise_from_version_message)
     chainman.ResetIbd();
     m_node.args->ForceSetArg("-capturemessages", "0");
     m_node.args->ForceSetArg("-bind", "");
-    // PeerManager::ProcessMessage() calls AddTimeData() which changes the internal state
-    // in timedata.cpp and later confuses the test "timedata_tests/addtimedata". Thus reset
-    // that state as it was before our test was run.
-    TestOnlyResetTimeData();
 }
 
 
diff --git a/src/test/timedata_tests.cpp b/src/test/timedata_tests.cpp
deleted file mode 100644
index 2814dbf4c0..0000000000
--- a/src/test/timedata_tests.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-// Copyright (c) 2011-2021 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 <netaddress.h>
-#include <noui.h>
-#include <test/util/logging.h>
-#include <test/util/setup_common.h>
-#include <timedata.h>
-#include <util/string.h>
-#include <util/translation.h>
-#include <warnings.h>
-
-#include <string>
-
-#include <boost/test/unit_test.hpp>
-
-BOOST_FIXTURE_TEST_SUITE(timedata_tests, BasicTestingSetup)
-
-BOOST_AUTO_TEST_CASE(util_MedianFilter)
-{
-    CMedianFilter<int> filter(5, 15);
-
-    BOOST_CHECK_EQUAL(filter.median(), 15);
-
-    filter.input(20); // [15 20]
-    BOOST_CHECK_EQUAL(filter.median(), 17);
-
-    filter.input(30); // [15 20 30]
-    BOOST_CHECK_EQUAL(filter.median(), 20);
-
-    filter.input(3); // [3 15 20 30]
-    BOOST_CHECK_EQUAL(filter.median(), 17);
-
-    filter.input(7); // [3 7 15 20 30]
-    BOOST_CHECK_EQUAL(filter.median(), 15);
-
-    filter.input(18); // [3 7 18 20 30]
-    BOOST_CHECK_EQUAL(filter.median(), 18);
-
-    filter.input(0); // [0 3 7 18 30]
-    BOOST_CHECK_EQUAL(filter.median(), 7);
-}
-
-static void MultiAddTimeData(int n, int64_t offset)
-{
-    static int cnt = 0;
-    for (int i = 0; i < n; ++i) {
-        CNetAddr addr;
-        addr.SetInternal(ToString(++cnt));
-        AddTimeData(addr, offset);
-    }
-}
-
-
-BOOST_AUTO_TEST_CASE(addtimedata)
-{
-    BOOST_CHECK_EQUAL(GetTimeOffset(), 0);
-
-    //Part 1: Add large offsets to test a warning message that our clock may be wrong.
-    MultiAddTimeData(3, DEFAULT_MAX_TIME_ADJUSTMENT + 1);
-    // Filter size is 1 + 3 = 4: It is always initialized with a single element (offset 0)
-
-    {
-        ASSERT_DEBUG_LOG("Please check that your computer's date and time are correct!");
-        MultiAddTimeData(1, DEFAULT_MAX_TIME_ADJUSTMENT + 1); //filter size 5
-    }
-
-    BOOST_CHECK(GetWarnings(true).original.find("clock is wrong") != std::string::npos);
-
-    // nTimeOffset is not changed if the median of offsets exceeds DEFAULT_MAX_TIME_ADJUSTMENT
-    BOOST_CHECK_EQUAL(GetTimeOffset(), 0);
-
-    // Part 2: Test positive and negative medians by adding more offsets
-    MultiAddTimeData(4, 100); // filter size 9
-    BOOST_CHECK_EQUAL(GetTimeOffset(), 100);
-    MultiAddTimeData(10, -100); //filter size 19
-    BOOST_CHECK_EQUAL(GetTimeOffset(), -100);
-
-    // Part 3: Test behaviour when filter has reached maximum number of offsets
-    const int MAX_SAMPLES = 200;
-    int nfill = (MAX_SAMPLES - 3 - 19) / 2; //89
-    MultiAddTimeData(nfill, 100);
-    MultiAddTimeData(nfill, -100); //filter size MAX_SAMPLES - 3
-    BOOST_CHECK_EQUAL(GetTimeOffset(), -100);
-
-    MultiAddTimeData(2, 100);
-    //filter size MAX_SAMPLES -1, median is the initial 0 offset
-    //since we added same number of positive/negative offsets
-
-    BOOST_CHECK_EQUAL(GetTimeOffset(), 0);
-
-    // After the number of offsets has reached MAX_SAMPLES -1 (=199), nTimeOffset will never change
-    // because it is only updated when the number of elements in the filter becomes odd. It was decided
-    // not to fix this because it prevents possible attacks. See the comment in AddTimeData() or issue #4521
-    // for a more detailed explanation.
-    MultiAddTimeData(2, 100); // filter median is 100 now, but nTimeOffset will not change
-    // We want this test to end with nTimeOffset==0, otherwise subsequent tests of the suite will fail.
-    BOOST_CHECK_EQUAL(GetTimeOffset(), 0);
-
-    TestOnlyResetTimeData();
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/timedata.cpp b/src/timedata.cpp
deleted file mode 100644
index d948de976f..0000000000
--- a/src/timedata.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright (c) 2014-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.
-
-#if defined(HAVE_CONFIG_H)
-#include <config/bitcoin-config.h>
-#endif
-
-#include <timedata.h>
-
-#include <common/args.h>
-#include <logging.h>
-#include <netaddress.h>
-#include <node/interface_ui.h>
-#include <sync.h>
-#include <tinyformat.h>
-#include <util/translation.h>
-#include <warnings.h>
-
-static GlobalMutex g_timeoffset_mutex;
-static int64_t nTimeOffset GUARDED_BY(g_timeoffset_mutex) = 0;
-
-/**
- * "Never go to sea with two chronometers; take one or three."
- * Our three time sources are:
- *  - System clock
- *  - Median of other nodes clocks
- *  - The user (asking the user to fix the system clock if the first two disagree)
- */
-int64_t GetTimeOffset()
-{
-    LOCK(g_timeoffset_mutex);
-    return nTimeOffset;
-}
-
-#define BITCOIN_TIMEDATA_MAX_SAMPLES 200
-
-static std::set<CNetAddr> g_sources;
-static CMedianFilter<int64_t> g_time_offsets{BITCOIN_TIMEDATA_MAX_SAMPLES, 0};
-static bool g_warning_emitted;
-
-void AddTimeData(const CNetAddr& ip, int64_t nOffsetSample)
-{
-    LOCK(g_timeoffset_mutex);
-    // Ignore duplicates
-    if (g_sources.size() == BITCOIN_TIMEDATA_MAX_SAMPLES)
-        return;
-    if (!g_sources.insert(ip).second)
-        return;
-
-    // Add data
-    g_time_offsets.input(nOffsetSample);
-    LogPrint(BCLog::NET, "added time data, samples %d, offset %+d (%+d minutes)\n", g_time_offsets.size(), nOffsetSample, nOffsetSample / 60);
-
-    // There is a known issue here (see issue #4521):
-    //
-    // - The structure g_time_offsets contains up to 200 elements, after which
-    // any new element added to it will not increase its size, replacing the
-    // oldest element.
-    //
-    // - The condition to update nTimeOffset includes checking whether the
-    // number of elements in g_time_offsets is odd, which will never happen after
-    // there are 200 elements.
-    //
-    // But in this case the 'bug' is protective against some attacks, and may
-    // actually explain why we've never seen attacks which manipulate the
-    // clock offset.
-    //
-    // So we should hold off on fixing this and clean it up as part of
-    // a timing cleanup that strengthens it in a number of other ways.
-    //
-    if (g_time_offsets.size() >= 5 && g_time_offsets.size() % 2 == 1) {
-        int64_t nMedian = g_time_offsets.median();
-        std::vector<int64_t> vSorted = g_time_offsets.sorted();
-        // Only let other nodes change our time by so much
-        int64_t max_adjustment = std::max<int64_t>(0, gArgs.GetIntArg("-maxtimeadjustment", DEFAULT_MAX_TIME_ADJUSTMENT));
-        if (nMedian >= -max_adjustment && nMedian <= max_adjustment) {
-            nTimeOffset = nMedian;
-        } else {
-            nTimeOffset = 0;
-
-            if (!g_warning_emitted) {
-                // If nobody has a time different than ours but within 5 minutes of ours, give a warning
-                bool fMatch = false;
-                for (const int64_t nOffset : vSorted) {
-                    if (nOffset != 0 && nOffset > -5 * 60 && nOffset < 5 * 60) fMatch = true;
-                }
-
-                if (!fMatch) {
-                    g_warning_emitted = true;
-                    bilingual_str strMessage = strprintf(_("Please check that your computer's date and time are correct! If your clock is wrong, %s will not work properly."), PACKAGE_NAME);
-                    SetMiscWarning(strMessage);
-                    uiInterface.ThreadSafeMessageBox(strMessage, "", CClientUIInterface::MSG_WARNING);
-                }
-            }
-        }
-
-        if (LogAcceptCategory(BCLog::NET, BCLog::Level::Debug)) {
-            std::string log_message{"time data samples: "};
-            for (const int64_t n : vSorted) {
-                log_message += strprintf("%+d  ", n);
-            }
-            log_message += strprintf("|  median offset = %+d  (%+d minutes)", nTimeOffset, nTimeOffset / 60);
-            LogPrint(BCLog::NET, "%s\n", log_message);
-        }
-    }
-}
-
-void TestOnlyResetTimeData()
-{
-    LOCK(g_timeoffset_mutex);
-    nTimeOffset = 0;
-    g_sources.clear();
-    g_time_offsets = CMedianFilter<int64_t>{BITCOIN_TIMEDATA_MAX_SAMPLES, 0};
-    g_warning_emitted = false;
-}
diff --git a/src/timedata.h b/src/timedata.h
deleted file mode 100644
index 3e76f80452..0000000000
--- a/src/timedata.h
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright (c) 2014-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_TIMEDATA_H
-#define BITCOIN_TIMEDATA_H
-
-#include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <vector>
-
-static const int64_t DEFAULT_MAX_TIME_ADJUSTMENT = 70 * 60;
-
-class CNetAddr;
-
-/**
- * Median filter over a stream of values.
- * Returns the median of the last N numbers
- */
-template <typename T>
-class CMedianFilter
-{
-private:
-    std::vector<T> vValues;
-    std::vector<T> vSorted;
-    unsigned int nSize;
-
-public:
-    CMedianFilter(unsigned int _size, T initial_value) : nSize(_size)
-    {
-        vValues.reserve(_size);
-        vValues.push_back(initial_value);
-        vSorted = vValues;
-    }
-
-    void input(T value)
-    {
-        if (vValues.size() == nSize) {
-            vValues.erase(vValues.begin());
-        }
-        vValues.push_back(value);
-
-        vSorted.resize(vValues.size());
-        std::copy(vValues.begin(), vValues.end(), vSorted.begin());
-        std::sort(vSorted.begin(), vSorted.end());
-    }
-
-    T median() const
-    {
-        int vSortedSize = vSorted.size();
-        assert(vSortedSize > 0);
-        if (vSortedSize & 1) // Odd number of elements
-        {
-            return vSorted[vSortedSize / 2];
-        } else // Even number of elements
-        {
-            return (vSorted[vSortedSize / 2 - 1] + vSorted[vSortedSize / 2]) / 2;
-        }
-    }
-
-    int size() const
-    {
-        return vValues.size();
-    }
-
-    std::vector<T> sorted() const
-    {
-        return vSorted;
-    }
-};
-
-/** Functions to keep track of adjusted P2P time */
-int64_t GetTimeOffset();
-void AddTimeData(const CNetAddr& ip, int64_t nTime);
-
-/**
- * Reset the internal state of GetTimeOffset() and AddTimeData().
- */
-void TestOnlyResetTimeData();
-
-#endif // BITCOIN_TIMEDATA_H

From fa382d3dd0592f3cbd6e1de791449f49e06dae86 Mon Sep 17 00:00:00 2001
From: MarcoFalke <*~=`'#}+{/-|&$^_@721217.xyz>
Date: Mon, 15 Apr 2024 12:57:17 +0200
Subject: [PATCH 11/63] test: Add missing Assert(mock_time_in >= 0s) to
 SetMockTime

Also, inline the deprecated alias to avoid having the two go out of sync
again in the future.
---
 src/util/time.cpp | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/util/time.cpp b/src/util/time.cpp
index 456662bd84..e46a127b14 100644
--- a/src/util/time.cpp
+++ b/src/util/time.cpp
@@ -29,14 +29,10 @@ NodeClock::time_point NodeClock::now() noexcept
     return time_point{ret};
 };
 
-void SetMockTime(int64_t nMockTimeIn)
-{
-    Assert(nMockTimeIn >= 0);
-    nMockTime.store(nMockTimeIn, std::memory_order_relaxed);
-}
-
+void SetMockTime(int64_t nMockTimeIn) { SetMockTime(std::chrono::seconds{nMockTimeIn}); }
 void SetMockTime(std::chrono::seconds mock_time_in)
 {
+    Assert(mock_time_in >= 0s);
     nMockTime.store(mock_time_in.count(), std::memory_order_relaxed);
 }
 

From fae0db555c12dca75fb09e5fa7bbabdf39b8c1df Mon Sep 17 00:00:00 2001
From: MarcoFalke <*~=`'#}+{/-|&$^_@721217.xyz>
Date: Mon, 15 Apr 2024 13:21:03 +0200
Subject: [PATCH 12/63] refactor: Use chrono type for g_mock_time

This avoids verbose casts in the lines where the symbol is used.
---
 src/util/time.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/util/time.cpp b/src/util/time.cpp
index e46a127b14..f08eb5300a 100644
--- a/src/util/time.cpp
+++ b/src/util/time.cpp
@@ -16,11 +16,11 @@
 
 void UninterruptibleSleep(const std::chrono::microseconds& n) { std::this_thread::sleep_for(n); }
 
-static std::atomic<int64_t> nMockTime(0); //!< For testing
+static std::atomic<std::chrono::seconds> g_mock_time{}; //!< For testing
 
 NodeClock::time_point NodeClock::now() noexcept
 {
-    const std::chrono::seconds mocktime{nMockTime.load(std::memory_order_relaxed)};
+    const auto mocktime{g_mock_time.load(std::memory_order_relaxed)};
     const auto ret{
         mocktime.count() ?
             mocktime :
@@ -33,12 +33,12 @@ void SetMockTime(int64_t nMockTimeIn) { SetMockTime(std::chrono::seconds{nMockTi
 void SetMockTime(std::chrono::seconds mock_time_in)
 {
     Assert(mock_time_in >= 0s);
-    nMockTime.store(mock_time_in.count(), std::memory_order_relaxed);
+    g_mock_time.store(mock_time_in, std::memory_order_relaxed);
 }
 
 std::chrono::seconds GetMockTime()
 {
-    return std::chrono::seconds(nMockTime.load(std::memory_order_relaxed));
+    return g_mock_time.load(std::memory_order_relaxed);
 }
 
 int64_t GetTime() { return GetTime<std::chrono::seconds>().count(); }

From 6f4da19cc3b1b7cd23cb4be95a6bb9acb79eb3bf Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Wed, 13 Mar 2024 11:25:24 +0000
Subject: [PATCH 13/63] guard against
 MempoolAcceptResult::m_replaced_transactions

It should never be a nullopt when the transaction result is valid -
Assume() this is the case. However, as a belt-and-suspenders just in
case it is nullopt, use an empty list.
---
 src/net_processing.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 39ffff97d2..07ac1cfec7 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -4354,7 +4354,9 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
         const TxValidationState& state = result.m_state;
 
         if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
-            ProcessValidTx(pfrom.GetId(), ptx, result.m_replaced_transactions.value());
+            Assume(result.m_replaced_transactions.has_value());
+            std::list<CTransactionRef> empty_replacement_list;
+            ProcessValidTx(pfrom.GetId(), ptx, result.m_replaced_transactions.value_or(empty_replacement_list));
             pfrom.m_last_tx_time = GetTime<std::chrono::seconds>();
         }
         else if (state.GetResult() == TxValidationResult::TX_MISSING_INPUTS)

From c3c1e15831c463df7968b028a77e787da7e6256d Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Wed, 13 Mar 2024 11:45:33 +0000
Subject: [PATCH 14/63] [doc] restore comment about why we check if ptx
 HasWitness before caching rejected txid

---
 src/net_processing.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 07ac1cfec7..577ed5cd3f 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -3107,6 +3107,8 @@ void PeerManagerImpl::ProcessInvalidTx(NodeId nodeid, const CTransactionRef& ptx
         // processing of this transaction in the event that child
         // transactions are later received (resulting in
         // parent-fetching by txid via the orphan-handling logic).
+        // We only add the txid if it differs from the wtxid, to avoid wasting entries in the
+        // rolling bloom filter.
         if (state.GetResult() == TxValidationResult::TX_INPUTS_NOT_STANDARD && ptx->HasWitness()) {
             m_recent_rejects.insert(ptx->GetHash().ToUint256());
             m_txrequest.ForgetTxHash(ptx->GetHash());

From 976e5d8f7b2bc77cb1443b8bf0f38cb07db70e9b Mon Sep 17 00:00:00 2001
From: Hennadii Stepanov <32963518+hebasto@users.noreply.github.com>
Date: Thu, 18 Apr 2024 10:53:32 +0100
Subject: [PATCH 15/63] test: Fix `test/streams_tests.cpp` compilation on SunOS
 / illumos

On systems where `int8_t` is defined as `char`, the
`{S,Uns}erialize(Stream&, signed char)` functions become undefined.

This change resolves the issue by testing
`{S,Uns}erialize(Stream&, int8_t)` instead.

No behavior change on systems where `int8_t` is defined as
`signed char`, which is the case for most other systems.
---
 src/test/streams_tests.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/test/streams_tests.cpp b/src/test/streams_tests.cpp
index 0903f987f6..e666e11758 100644
--- a/src/test/streams_tests.cpp
+++ b/src/test/streams_tests.cpp
@@ -143,8 +143,8 @@ BOOST_AUTO_TEST_CASE(streams_vector_reader)
     BOOST_CHECK_EQUAL(reader.size(), 5U);
     BOOST_CHECK(!reader.empty());
 
-    // Read a single byte as a signed char.
-    signed char b;
+    // Read a single byte as a int8_t.
+    int8_t b;
     reader >> b;
     BOOST_CHECK_EQUAL(b, -1);
     BOOST_CHECK_EQUAL(reader.size(), 4U);

From 1ea8674316f2dce0005f6094b6ee111b045dd770 Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Tue, 20 Feb 2024 16:29:08 +0000
Subject: [PATCH 16/63] [doc] update release-process.md and backports section
 of CONTRIBUTING

- Mention which directories contain the respective unsigned tarballs
- Clarify that bitcoin.conf might not need to be updated
- Specify where to put historical release notes if there is already
  something in release-notes.md
- Clarify what exactly is the problem with running guix-codesign more
  than once
- Correct number: 6 codesigned attestations are needed before uploading
  binaries
- Remove scp command which is outdated
- Remove server path which is outdated
- Specify that translations update should happen before branch-off, not
  before each release candidate
- Mention that you should notify lists when RCs are available
- Put "Archive the release notes" as a separate step, since creating the
  github release has a dependency on it.
- Put bitcoincore.org website updates as a separate step, since
  updating packaging repos may have a dependency on it.
- Update "bitcoin-dev mailing list" to "bitcoin-dev group"
- Document that maintainers should create PRs to collect backports
- Remove section about not uploading `*-debug` files, reader should
  upload all build artifacts.
- Torrent is created automatically, so delete instructions.
- Mention that server also generates ots file automatically.
---
 CONTRIBUTING.md        |  7 +---
 doc/release-process.md | 83 +++++++++++++++++++++---------------------
 2 files changed, 44 insertions(+), 46 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0ae4ff1a92..3c1d3d9568 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -417,11 +417,8 @@ Backporting
 
 Security and bug fixes can be backported from `master` to release
 branches.
-If the backport is non-trivial, it may be appropriate to open an
-additional PR to backport the change, but only after the original PR
-has been merged.
-Otherwise, backports will be done in batches and
-the maintainers will use the proper `Needs backport (...)` labels
+Maintainers will do backports in batches and
+use the proper `Needs backport (...)` labels
 when needed (the original author does not need to worry about it).
 
 A backport should contain the following metadata in the commit body:
diff --git a/doc/release-process.md b/doc/release-process.md
index 95ef08a26f..1e6d49100e 100644
--- a/doc/release-process.md
+++ b/doc/release-process.md
@@ -5,17 +5,17 @@ Release Process
 
 ### Before every release candidate
 
-* Update translations see [translation_process.md](https://github.com/bitcoin/bitcoin/blob/master/doc/translation_process.md#synchronising-translations).
 * Update release candidate version in `configure.ac` (`CLIENT_VERSION_RC`).
 * Update manpages (after rebuilding the binaries), see [gen-manpages.py](https://github.com/bitcoin/bitcoin/blob/master/contrib/devtools/README.md#gen-manpagespy).
-* Update bitcoin.conf and commit, see [gen-bitcoin-conf.sh](https://github.com/bitcoin/bitcoin/blob/master/contrib/devtools/README.md#gen-bitcoin-confsh).
+* Update bitcoin.conf and commit changes if they exist, see [gen-bitcoin-conf.sh](https://github.com/bitcoin/bitcoin/blob/master/contrib/devtools/README.md#gen-bitcoin-confsh).
 
 ### Before every major and minor release
 
 * Update [bips.md](bips.md) to account for changes since the last release.
 * Update version in `configure.ac` (don't forget to set `CLIENT_VERSION_RC` to `0`).
 * Update manpages (see previous section)
-* Write release notes (see "Write the release notes" below).
+* Write release notes (see "Write the release notes" below) in doc/release-notes.md. If necessary,
+  archive the previous release notes as doc/release-notes/release-notes-${VERSION}.md.
 
 ### Before every major release
 
@@ -28,6 +28,7 @@ Release Process
 
 #### Before branch-off
 
+* Update translations see [translation_process.md](https://github.com/bitcoin/bitcoin/blob/master/doc/translation_process.md#synchronising-translations).
 * Update hardcoded [seeds](/contrib/seeds/README.md), see [this pull request](https://github.com/bitcoin/bitcoin/pull/27488) for an example.
 * Update the following variables in [`src/kernel/chainparams.cpp`](/src/kernel/chainparams.cpp) for mainnet, testnet, and signet:
   - `m_assumed_blockchain_size` and `m_assumed_chain_state_size` with the current size plus some overhead (see
@@ -161,6 +162,8 @@ Then open a Pull Request to the [guix.sigs repository](https://github.com/bitcoi
 
 ### macOS codesigner only: Create detached macOS signatures (assuming [signapple](https://github.com/achow101/signapple/) is installed and up to date with master branch)
 
+In the `guix-build-${VERSION}/output/x86_64-apple-darwin` and `guix-build-${VERSION}/output/arm64-apple-darwin` directories:
+
     tar xf bitcoin-osx-unsigned.tar.gz
     ./detached-sig-create.sh /path/to/codesign.p12
     Enter the keychain password and authorize the signature
@@ -168,6 +171,8 @@ Then open a Pull Request to the [guix.sigs repository](https://github.com/bitcoi
 
 ### Windows codesigner only: Create detached Windows signatures
 
+In the `guix-build-${VERSION}/output/x86_64-w64-mingw32` directory:
+
     tar xf bitcoin-win-unsigned.tar.gz
     ./detached-sig-create.sh -key /path/to/codesign.key
     Enter the passphrase for the key when prompted
@@ -175,18 +180,22 @@ Then open a Pull Request to the [guix.sigs repository](https://github.com/bitcoi
 
 ### Windows and macOS codesigners only: test code signatures
 It is advised to test that the code signature attaches properly prior to tagging by performing the `guix-codesign` step.
-However if this is done, once the release has been tagged in the bitcoin-detached-sigs repo, the `guix-codesign` step must be performed again in order for the guix attestation to be valid when compared against the attestations of non-codesigner builds.
+However if this is done, once the release has been tagged in the bitcoin-detached-sigs repo, the `guix-codesign` step must be performed again in order for the guix attestation to be valid when compared against the attestations of non-codesigner builds. The directories created by `guix-codesign` will need to be cleared prior to running `guix-codesign` again.
 
 ### Windows and macOS codesigners only: Commit the detached codesign payloads
 
 ```sh
 pushd ./bitcoin-detached-sigs
-# checkout the appropriate branch for this release series
-rm -rf ./*
+# checkout or create the appropriate branch for this release series
+git checkout --orphan <branch>
+# if you are the macOS codesigner
+rm -rf osx
 tar xf signature-osx.tar.gz
+# if you are the windows codesigner
+rm -rf win
 tar xf signature-win.tar.gz
 git add -A
-git commit -m "point to ${VERSION}"
+git commit -m "<version>: {osx,win} signature for {rc,final}"
 git tag -s "v${VERSION}" HEAD
 git push the current branch and new tag
 popd
@@ -216,45 +225,36 @@ popd
 
 Then open a Pull Request to the [guix.sigs repository](https://github.com/bitcoin-core/guix.sigs).
 
-## After 3 or more people have guix-built and their results match
+## After 6 or more people have guix-built and their results match
 
-Combine the `all.SHA256SUMS.asc` file from all signers into `SHA256SUMS.asc`:
+After verifying signatures, combine the `all.SHA256SUMS.asc` file from all signers into `SHA256SUMS.asc`:
 
 ```bash
 cat "$VERSION"/*/all.SHA256SUMS.asc > SHA256SUMS.asc
 ```
 
 
-- Upload to the bitcoincore.org server (`/var/www/bin/bitcoin-core-${VERSION}/`):
-    1. The contents of each `./bitcoin/guix-build-${VERSION}/output/${HOST}/` directory, except for
-       `*-debug*` files.
+- Upload to the bitcoincore.org server:
+    1. The contents of each `./bitcoin/guix-build-${VERSION}/output/${HOST}/` directory.
 
        Guix will output all of the results into host subdirectories, but the SHA256SUMS
        file does not include these subdirectories. In order for downloads via torrent
        to verify without directory structure modification, all of the uploaded files
        need to be in the same directory as the SHA256SUMS file.
 
-       The `*-debug*` files generated by the guix build contain debug symbols
-       for troubleshooting by developers. It is assumed that anyone that is
-       interested in debugging can run guix to generate the files for
-       themselves. To avoid end-user confusion about which file to pick, as well
-       as save storage space *do not upload these to the bitcoincore.org server,
-       nor put them in the torrent*.
-
-       ```sh
-       find guix-build-${VERSION}/output/ -maxdepth 2 -type f -not -name "SHA256SUMS.part" -and -not -name "*debug*" -exec scp {} user@bitcoincore.org:/var/www/bin/bitcoin-core-${VERSION} \;
-       ```
+       Wait until all of these files have finished uploading before uploading the SHA256SUMS(.asc) files.
 
     2. The `SHA256SUMS` file
 
-    3. The `SHA256SUMS.asc` combined signature file you just created
+    3. The `SHA256SUMS.asc` combined signature file you just created.
 
-- Create a torrent of the `/var/www/bin/bitcoin-core-${VERSION}` directory such
-  that at the top level there is only one file: the `bitcoin-core-${VERSION}`
-  directory containing everything else. Name the torrent
-  `bitcoin-${VERSION}.torrent` (note that there is no `-core-` in this name).
+- After uploading release candidate binaries, notify the bitcoin-core-dev mailing list and
+  bitcoin-dev group that a release candidate is available for testing. Include a link to the release
+  notes draft.
 
-  Optionally help seed this torrent. To get the `magnet:` URI use:
+- The server will automatically create an OpenTimestamps file and torrent of the directory.
+
+- Optionally help seed this torrent. To get the `magnet:` URI use:
 
   ```sh
   transmission-show -m <torrent file>
@@ -265,32 +265,33 @@ cat "$VERSION"/*/all.SHA256SUMS.asc > SHA256SUMS.asc
   Also put it into the `optional_magnetlink:` slot in the YAML file for
   bitcoincore.org.
 
-- Update other repositories and websites for new version
-
-  - bitcoincore.org blog post
+- Archive the release notes for the new version to `doc/release-notes/release-notes-${VERSION}.md`
+  (branch `master` and branch of the release).
 
-  - bitcoincore.org maintained versions update:
-    [table](https://github.com/bitcoin-core/bitcoincore.org/commits/master/_includes/posts/maintenance-table.md)
+- Update the bitcoincore.org website
 
-  - Delete post-EOL [release branches](https://github.com/bitcoin/bitcoin/branches/all) and create a tag `v${branch_name}-final`.
+  - blog post
 
-  - Delete ["Needs backport" labels](https://github.com/bitcoin/bitcoin/labels?q=backport) for non-existing branches.
+  - maintained versions [table](https://github.com/bitcoin-core/bitcoincore.org/commits/master/_includes/posts/maintenance-table.md)
 
-  - bitcoincore.org RPC documentation update
+  - RPC documentation update
 
       - See https://github.com/bitcoin-core/bitcoincore.org/blob/master/contrib/doc-gen/
 
+
+- Update repositories
+
+  - Delete post-EOL [release branches](https://github.com/bitcoin/bitcoin/branches/all) and create a tag `v${branch_name}-final`.
+
+  - Delete ["Needs backport" labels](https://github.com/bitcoin/bitcoin/labels?q=backport) for non-existing branches.
+
   - Update packaging repo
 
       - Push the flatpak to flathub, e.g. https://github.com/flathub/org.bitcoincore.bitcoin-qt/pull/2
 
       - Push the snap, see https://github.com/bitcoin-core/packaging/blob/main/snap/local/build.md
 
-  - This repo
-
-      - Archive the release notes for the new version to `doc/release-notes/` (branch `master` and branch of the release)
-
-      - Create a [new GitHub release](https://github.com/bitcoin/bitcoin/releases/new) with a link to the archived release notes
+  - Create a [new GitHub release](https://github.com/bitcoin/bitcoin/releases/new) with a link to the archived release notes
 
 - Announce the release:
 

From 3120a4678ab2a71a381e847688f44068749cfa97 Mon Sep 17 00:00:00 2001
From: Sergi Delgado Segura <sergi.delgado.s@gmail.com>
Date: Wed, 28 Jun 2023 14:51:09 -0400
Subject: [PATCH 17/63] Gives seednode priority over dnsseed if both are
 provided

---
 src/net.cpp | 207 ++++++++++++++++++++++++++++++----------------------
 src/net.h   |   2 +
 2 files changed, 123 insertions(+), 86 deletions(-)

diff --git a/src/net.cpp b/src/net.cpp
index 3e959c187c..c5055c1241 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -2172,7 +2172,30 @@ void CConnman::ThreadDNSAddressSeed()
     std::vector<std::string> seeds = m_params.DNSSeeds();
     Shuffle(seeds.begin(), seeds.end(), rng);
     int seeds_right_now = 0; // Number of seeds left before testing if we have enough connections
-    int found = 0;
+    int target_outbound_connections = 2;
+    int outbound_connection_count = 0;
+
+    auto start = NodeClock::now();
+    if (gArgs.IsArgSet("-seednode")) {
+        LogPrintf("-seednode enabled. Trying the provided seeds before defaulting to the dnsseeds.\n");
+        while (!interruptNet) {
+            if (!interruptNet.sleep_for(std::chrono::milliseconds(500)))
+                return;
+
+            // Abort if we have spent enough time without reaching our target.
+            // Giving seed nodes 30 seconds so this does not become a race against fixedseeds (which triggers after 1 min)
+            if (NodeClock::now() > start + 30s) {
+                LogPrintf("Couldn't connect to enough peers via seed nodes. Handing fetch logic to the DNS seeds.\n");
+                break;
+            }
+
+            outbound_connection_count = GetFullOutboundConnCount();
+            if (outbound_connection_count >= target_outbound_connections) {
+                    LogPrintf("P2P peers available. Finished fetching data from seed nodes.\n");
+                break;
+            }
+        }
+    }
 
     if (gArgs.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED)) {
         // When -forcednsseed is provided, query all.
@@ -2184,102 +2207,101 @@ void CConnman::ThreadDNSAddressSeed()
         seeds_right_now = seeds.size();
     }
 
-    // goal: only query DNS seed if address need is acute
-    // * If we have a reasonable number of peers in addrman, spend
-    //   some time trying them first. This improves user privacy by
-    //   creating fewer identifying DNS requests, reduces trust by
-    //   giving seeds less influence on the network topology, and
-    //   reduces traffic to the seeds.
-    // * When querying DNS seeds query a few at once, this ensures
-    //   that we don't give DNS seeds the ability to eclipse nodes
-    //   that query them.
-    // * If we continue having problems, eventually query all the
-    //   DNS seeds, and if that fails too, also try the fixed seeds.
-    //   (done in ThreadOpenConnections)
-    const std::chrono::seconds seeds_wait_time = (addrman.Size() >= DNSSEEDS_DELAY_PEER_THRESHOLD ? DNSSEEDS_DELAY_MANY_PEERS : DNSSEEDS_DELAY_FEW_PEERS);
-
-    for (const std::string& seed : seeds) {
-        if (seeds_right_now == 0) {
-            seeds_right_now += DNSSEEDS_TO_QUERY_AT_ONCE;
-
-            if (addrman.Size() > 0) {
-                LogPrintf("Waiting %d seconds before querying DNS seeds.\n", seeds_wait_time.count());
-                std::chrono::seconds to_wait = seeds_wait_time;
-                while (to_wait.count() > 0) {
-                    // if sleeping for the MANY_PEERS interval, wake up
-                    // early to see if we have enough peers and can stop
-                    // this thread entirely freeing up its resources
-                    std::chrono::seconds w = std::min(DNSSEEDS_DELAY_FEW_PEERS, to_wait);
-                    if (!interruptNet.sleep_for(w)) return;
-                    to_wait -= w;
-
-                    int nRelevant = 0;
-                    {
-                        LOCK(m_nodes_mutex);
-                        for (const CNode* pnode : m_nodes) {
-                            if (pnode->fSuccessfullyConnected && pnode->IsFullOutboundConn()) ++nRelevant;
+    // Proceed with dnsseeds if seednodes hasn't reached the target or if forcednsseed is set
+    if (outbound_connection_count < target_outbound_connections || seeds_right_now) {
+        // goal: only query DNS seed if address need is acute
+        // * If we have a reasonable number of peers in addrman, spend
+        //   some time trying them first. This improves user privacy by
+        //   creating fewer identifying DNS requests, reduces trust by
+        //   giving seeds less influence on the network topology, and
+        //   reduces traffic to the seeds.
+        // * When querying DNS seeds query a few at once, this ensures
+        //   that we don't give DNS seeds the ability to eclipse nodes
+        //   that query them.
+        // * If we continue having problems, eventually query all the
+        //   DNS seeds, and if that fails too, also try the fixed seeds.
+        //   (done in ThreadOpenConnections)
+        int found = 0;
+        const std::chrono::seconds seeds_wait_time = (addrman.Size() >= DNSSEEDS_DELAY_PEER_THRESHOLD ? DNSSEEDS_DELAY_MANY_PEERS : DNSSEEDS_DELAY_FEW_PEERS);
+
+        for (const std::string& seed : seeds) {
+            if (seeds_right_now == 0) {
+                seeds_right_now += DNSSEEDS_TO_QUERY_AT_ONCE;
+
+                if (addrman.Size() > 0) {
+                    LogPrintf("Waiting %d seconds before querying DNS seeds.\n", seeds_wait_time.count());
+                    std::chrono::seconds to_wait = seeds_wait_time;
+                    while (to_wait.count() > 0) {
+                        // if sleeping for the MANY_PEERS interval, wake up
+                        // early to see if we have enough peers and can stop
+                        // this thread entirely freeing up its resources
+                        std::chrono::seconds w = std::min(DNSSEEDS_DELAY_FEW_PEERS, to_wait);
+                        if (!interruptNet.sleep_for(w)) return;
+                        to_wait -= w;
+
+                        if (GetFullOutboundConnCount() >= target_outbound_connections) {
+                            if (found > 0) {
+                                LogPrintf("%d addresses found from DNS seeds\n", found);
+                                LogPrintf("P2P peers available. Finished DNS seeding.\n");
+                            } else {
+                                LogPrintf("P2P peers available. Skipped DNS seeding.\n");
+                            }
+                            return;
                         }
                     }
-                    if (nRelevant >= 2) {
-                        if (found > 0) {
-                            LogPrintf("%d addresses found from DNS seeds\n", found);
-                            LogPrintf("P2P peers available. Finished DNS seeding.\n");
-                        } else {
-                            LogPrintf("P2P peers available. Skipped DNS seeding.\n");
-                        }
-                        return;
-                    }
                 }
             }
-        }
-
-        if (interruptNet) return;
 
-        // hold off on querying seeds if P2P network deactivated
-        if (!fNetworkActive) {
-            LogPrintf("Waiting for network to be reactivated before querying DNS seeds.\n");
-            do {
-                if (!interruptNet.sleep_for(std::chrono::seconds{1})) return;
-            } while (!fNetworkActive);
-        }
+            if (interruptNet) return;
 
-        LogPrintf("Loading addresses from DNS seed %s\n", seed);
-        // If -proxy is in use, we make an ADDR_FETCH connection to the DNS resolved peer address
-        // for the base dns seed domain in chainparams
-        if (HaveNameProxy()) {
-            AddAddrFetch(seed);
-        } else {
-            std::vector<CAddress> vAdd;
-            constexpr ServiceFlags requiredServiceBits{SeedsServiceFlags()};
-            std::string host = strprintf("x%x.%s", requiredServiceBits, seed);
-            CNetAddr resolveSource;
-            if (!resolveSource.SetInternal(host)) {
-                continue;
+            // hold off on querying seeds if P2P network deactivated
+            if (!fNetworkActive) {
+                LogPrintf("Waiting for network to be reactivated before querying DNS seeds.\n");
+                do {
+                    if (!interruptNet.sleep_for(std::chrono::seconds{1})) return;
+                } while (!fNetworkActive);
             }
-            // Limit number of IPs learned from a single DNS seed. This limit exists to prevent the results from
-            // one DNS seed from dominating AddrMan. Note that the number of results from a UDP DNS query is
-            // bounded to 33 already, but it is possible for it to use TCP where a larger number of results can be
-            // returned.
-            unsigned int nMaxIPs = 32;
-            const auto addresses{LookupHost(host, nMaxIPs, true)};
-            if (!addresses.empty()) {
-                for (const CNetAddr& ip : addresses) {
-                    CAddress addr = CAddress(CService(ip, m_params.GetDefaultPort()), requiredServiceBits);
-                    addr.nTime = rng.rand_uniform_delay(Now<NodeSeconds>() - 3 * 24h, -4 * 24h); // use a random age between 3 and 7 days old
-                    vAdd.push_back(addr);
-                    found++;
-                }
-                addrman.Add(vAdd, resolveSource);
-            } else {
-                // If the seed does not support a subdomain with our desired service bits,
-                // we make an ADDR_FETCH connection to the DNS resolved peer address for the
-                // base dns seed domain in chainparams
+
+            LogPrintf("Loading addresses from DNS seed %s\n", seed);
+            // If -proxy is in use, we make an ADDR_FETCH connection to the DNS resolved peer address
+            // for the base dns seed domain in chainparams
+            if (HaveNameProxy()) {
                 AddAddrFetch(seed);
+            } else {
+                std::vector<CAddress> vAdd;
+                constexpr ServiceFlags requiredServiceBits{SeedsServiceFlags()};
+                std::string host = strprintf("x%x.%s", requiredServiceBits, seed);
+                CNetAddr resolveSource;
+                if (!resolveSource.SetInternal(host)) {
+                    continue;
+                }
+                // Limit number of IPs learned from a single DNS seed. This limit exists to prevent the results from
+                // one DNS seed from dominating AddrMan. Note that the number of results from a UDP DNS query is
+                // bounded to 33 already, but it is possible for it to use TCP where a larger number of results can be
+                // returned.
+                unsigned int nMaxIPs = 32;
+                const auto addresses{LookupHost(host, nMaxIPs, true)};
+                if (!addresses.empty()) {
+                    for (const CNetAddr& ip : addresses) {
+                        CAddress addr = CAddress(CService(ip, m_params.GetDefaultPort()), requiredServiceBits);
+                        addr.nTime = rng.rand_uniform_delay(Now<NodeSeconds>() - 3 * 24h, -4 * 24h); // use a random age between 3 and 7 days old
+                        vAdd.push_back(addr);
+                        found++;
+                    }
+                    addrman.Add(vAdd, resolveSource);
+                } else {
+                    // If the seed does not support a subdomain with our desired service bits,
+                    // we make an ADDR_FETCH connection to the DNS resolved peer address for the
+                    // base dns seed domain in chainparams
+                    AddAddrFetch(seed);
+                }
             }
+            --seeds_right_now;
         }
-        --seeds_right_now;
+        LogPrintf("%d addresses found from DNS seeds\n", found);
+    } else {
+        LogPrintf("Skipping DNS seeds. Enough peers have been found\n");
     }
-    LogPrintf("%d addresses found from DNS seeds\n", found);
 }
 
 void CConnman::DumpAddresses()
@@ -2330,6 +2352,19 @@ void CConnman::StartExtraBlockRelayPeers()
     m_start_extra_block_relay_peers = true;
 }
 
+// Return the number of outbound connections that are full relay (not blocks only)
+int CConnman::GetFullOutboundConnCount() const
+{
+    int nRelevant = 0;
+    {
+        LOCK(m_nodes_mutex);
+        for (const CNode* pnode : m_nodes) {
+            if (pnode->fSuccessfullyConnected && pnode->IsFullOutboundConn()) ++nRelevant;
+        }
+    }
+    return nRelevant;
+}
+
 // Return the number of peers we have over our outbound connection limit
 // Exclude peers that are marked for disconnect, or are going to be
 // disconnected soon (eg ADDR_FETCH and FEELER)
diff --git a/src/net.h b/src/net.h
index 46d9422695..90562ecf01 100644
--- a/src/net.h
+++ b/src/net.h
@@ -1175,6 +1175,8 @@ class CConnman
 
     void StartExtraBlockRelayPeers();
 
+    // Count the number of full-relay peer we have.
+    int GetFullOutboundConnCount() const;
     // Return the number of outbound peers we have in excess of our target (eg,
     // if we previously called SetTryNewOutboundPeer(true), and have since set
     // to false, we may have extra peers that we wish to disconnect). This may

From 82f41d76f1c6ad38290917dad5499ffbe6b3974d Mon Sep 17 00:00:00 2001
From: tdb3 <106488469+tdb3@users.noreply.github.com>
Date: Fri, 23 Feb 2024 14:00:53 -0500
Subject: [PATCH 18/63] Added seednode prioritization message to help output

---
 src/init.cpp |  2 +-
 src/net.cpp  | 26 ++++++++++++++------------
 2 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index c19d596c7f..b8c9988c3f 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -546,7 +546,7 @@ void SetupServerArgs(ArgsManager& argsman)
     argsman.AddArg("-proxy=<ip:port>", "Connect through SOCKS5 proxy, set -noproxy to disable (default: disabled)", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_ELISION, OptionsCategory::CONNECTION);
 #endif
     argsman.AddArg("-proxyrandomize", strprintf("Randomize credentials for every proxy connection. This enables Tor stream isolation (default: %u)", DEFAULT_PROXYRANDOMIZE), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
-    argsman.AddArg("-seednode=<ip>", "Connect to a node to retrieve peer addresses, and disconnect. This option can be specified multiple times to connect to multiple nodes.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
+    argsman.AddArg("-seednode=<ip>", "Connect to a node to retrieve peer addresses, and disconnect. This option can be specified multiple times to connect to multiple nodes. During startup, seednodes will be tried before dnsseeds.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-networkactive", "Enable all P2P network activity (default: 1). Can be changed by the setnetworkactive RPC command", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-timeout=<n>", strprintf("Specify socket connection timeout in milliseconds. If an initial attempt to connect is unsuccessful after this amount of time, drop it (minimum: 1, default: %d)", DEFAULT_CONNECT_TIMEOUT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-peertimeout=<n>", strprintf("Specify a p2p connection timeout delay in seconds. After connecting to a peer, wait this amount of time before considering disconnection based on inactivity (minimum: 1, default: %d)", DEFAULT_PEER_CONNECT_TIMEOUT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CONNECTION);
diff --git a/src/net.cpp b/src/net.cpp
index c5055c1241..b4806a6fd8 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -2168,35 +2168,37 @@ void CConnman::WakeMessageHandler()
 
 void CConnman::ThreadDNSAddressSeed()
 {
-    FastRandomContext rng;
-    std::vector<std::string> seeds = m_params.DNSSeeds();
-    Shuffle(seeds.begin(), seeds.end(), rng);
-    int seeds_right_now = 0; // Number of seeds left before testing if we have enough connections
-    int target_outbound_connections = 2;
+    constexpr int TARGET_OUTBOUND_CONNECTIONS = 2;
     int outbound_connection_count = 0;
 
-    auto start = NodeClock::now();
     if (gArgs.IsArgSet("-seednode")) {
-        LogPrintf("-seednode enabled. Trying the provided seeds before defaulting to the dnsseeds.\n");
+        auto start = NodeClock::now();
+        constexpr std::chrono::seconds SEEDNODE_TIMEOUT = 30s;
+        LogPrintf("-seednode enabled. Trying the provided seeds for %d seconds before defaulting to the dnsseeds.\n", SEEDNODE_TIMEOUT.count());
         while (!interruptNet) {
             if (!interruptNet.sleep_for(std::chrono::milliseconds(500)))
                 return;
 
             // Abort if we have spent enough time without reaching our target.
             // Giving seed nodes 30 seconds so this does not become a race against fixedseeds (which triggers after 1 min)
-            if (NodeClock::now() > start + 30s) {
+            if (NodeClock::now() > start + SEEDNODE_TIMEOUT) {
                 LogPrintf("Couldn't connect to enough peers via seed nodes. Handing fetch logic to the DNS seeds.\n");
                 break;
             }
 
             outbound_connection_count = GetFullOutboundConnCount();
-            if (outbound_connection_count >= target_outbound_connections) {
-                    LogPrintf("P2P peers available. Finished fetching data from seed nodes.\n");
+            if (outbound_connection_count >= TARGET_OUTBOUND_CONNECTIONS) {
+                LogPrintf("P2P peers available. Finished fetching data from seed nodes.\n");
                 break;
             }
         }
     }
 
+    FastRandomContext rng;
+    std::vector<std::string> seeds = m_params.DNSSeeds();
+    Shuffle(seeds.begin(), seeds.end(), rng);
+    int seeds_right_now = 0; // Number of seeds left before testing if we have enough connections
+
     if (gArgs.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED)) {
         // When -forcednsseed is provided, query all.
         seeds_right_now = seeds.size();
@@ -2208,7 +2210,7 @@ void CConnman::ThreadDNSAddressSeed()
     }
 
     // Proceed with dnsseeds if seednodes hasn't reached the target or if forcednsseed is set
-    if (outbound_connection_count < target_outbound_connections || seeds_right_now) {
+    if (outbound_connection_count < TARGET_OUTBOUND_CONNECTIONS || seeds_right_now) {
         // goal: only query DNS seed if address need is acute
         // * If we have a reasonable number of peers in addrman, spend
         //   some time trying them first. This improves user privacy by
@@ -2239,7 +2241,7 @@ void CConnman::ThreadDNSAddressSeed()
                         if (!interruptNet.sleep_for(w)) return;
                         to_wait -= w;
 
-                        if (GetFullOutboundConnCount() >= target_outbound_connections) {
+                        if (GetFullOutboundConnCount() >= TARGET_OUTBOUND_CONNECTIONS) {
                             if (found > 0) {
                                 LogPrintf("%d addresses found from DNS seeds\n", found);
                                 LogPrintf("P2P peers available. Finished DNS seeding.\n");

From ec1f1abfefa281e62bb876aa1c4738d576ef9a47 Mon Sep 17 00:00:00 2001
From: jrakibi <j.errakibi@gmail.com>
Date: Mon, 11 Mar 2024 02:47:03 +0000
Subject: [PATCH 19/63] test:Validate UTXO snapshot with coin_height >
 base_height & amount > money_supply
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

You can use this tool to decode the utxo snapshot https://github.com/jrakibi/utxo-live
Here’s an overview of how it’s done:
The serialization forma for a UTXO in the snapshot is as follows:
1. Transaction ID (txid) - 32 bytes
2. Output Index (outnum)- 4 bytes
3. VARINT (code) - A varible-length integer encoding the height and whether the transaction is a coinbase. The format of this VARINT is (height << 1) | coinbase_flag.
4. VARINT (amount_v) - A variable-length integer that represents a compressed format of the output amount (in satoshis).

For the test cases mentioned:
* b"\x84\x58" - This value corresponds to a VARINT representing the height and coinbase flag. Once we decode this code, we can extract the height and coinbase using height = code_decoded >> 1 and coinbase = code_decoded & 0x01. In our case, with code_decoded = 728, it results in height = 364 and coinbase = 0.
* b"\xCA\xD2\x8F\x5A" - This byte sequence represents a compressed amount value. The decompression function takes this value and translates it into a full amount in satoshis. In our case, the decompression of this amount translates to a number larger than the maximum allowed value of coins (21 million BTC)

test:Validate UTXO snapshot with coin_height > base_height & amount > money_supply

test:Validate UTXO snapshot with coin_height > base_height & amount > money_supply
---
 test/functional/feature_assumeutxo.py | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/test/functional/feature_assumeutxo.py b/test/functional/feature_assumeutxo.py
index 19cbbcffdb..2842d82d80 100755
--- a/test/functional/feature_assumeutxo.py
+++ b/test/functional/feature_assumeutxo.py
@@ -13,8 +13,6 @@
 
 Interesting test cases could be loading an assumeutxo snapshot file with:
 
-- TODO: Valid hash but invalid snapshot file (bad coin height or
-      bad other serialization)
 - TODO: Valid snapshot file, but referencing a snapshot block that turns out to be
       invalid, or has an invalid parent
 - TODO: Valid snapshot file and snapshot block, but the block is not on the
@@ -98,18 +96,23 @@ def expected_error(log_msg="", rpc_details=""):
 
         self.log.info("  - snapshot file with alternated UTXO data")
         cases = [
-            [b"\xff" * 32, 0, "7d52155c9a9fdc4525b637ef6170568e5dad6fabd0b1fdbb9432010b8453095b"],  # wrong outpoint hash
-            [(1).to_bytes(4, "little"), 32, "9f4d897031ab8547665b4153317ae2fdbf0130c7840b66427ebc48b881cb80ad"],  # wrong outpoint index
-            [b"\x81", 36, "3da966ba9826fb6d2604260e01607b55ba44e1a5de298606b08704bc62570ea8"],  # wrong coin code VARINT((coinbase ? 1 : 0) | (height << 1))
-            [b"\x80", 36, "091e893b3ccb4334378709578025356c8bcb0a623f37c7c4e493133c988648e5"],  # another wrong coin code
+            # (content, offset, wrong_hash, custom_message)
+            [b"\xff" * 32, 0, "7d52155c9a9fdc4525b637ef6170568e5dad6fabd0b1fdbb9432010b8453095b", None],  # wrong outpoint hash
+            [(1).to_bytes(4, "little"), 32, "9f4d897031ab8547665b4153317ae2fdbf0130c7840b66427ebc48b881cb80ad", None],  # wrong outpoint index
+            [b"\x81", 36, "3da966ba9826fb6d2604260e01607b55ba44e1a5de298606b08704bc62570ea8", None],  # wrong coin code VARINT
+            [b"\x80", 36, "091e893b3ccb4334378709578025356c8bcb0a623f37c7c4e493133c988648e5", None],  # another wrong coin code
+            [b"\x84\x58", 36, None, "[snapshot] bad snapshot data after deserializing 0 coins"],  # wrong coin case with height 364 and coinbase 0
+            [b"\xCA\xD2\x8F\x5A", 41, None, "[snapshot] bad snapshot data after deserializing 0 coins - bad tx out value"],  # Amount exceeds MAX_MONEY
         ]
 
-        for content, offset, wrong_hash in cases:
+        for content, offset, wrong_hash, custom_message in cases:
             with open(bad_snapshot_path, "wb") as f:
                 f.write(valid_snapshot_contents[:(32 + 8 + offset)])
                 f.write(content)
                 f.write(valid_snapshot_contents[(32 + 8 + offset + len(content)):])
-            expected_error(log_msg=f"[snapshot] bad snapshot content hash: expected a4bf3407ccb2cc0145c49ebba8fa91199f8a3903daf0883875941497d2493c27, got {wrong_hash}")
+
+            log_msg = custom_message if custom_message is not None else f"[snapshot] bad snapshot content hash: expected a4bf3407ccb2cc0145c49ebba8fa91199f8a3903daf0883875941497d2493c27, got {wrong_hash}"
+            expected_error(log_msg=log_msg)
 
     def test_headers_not_synced(self, valid_snapshot_path):
         for node in self.nodes[1:]:

From ff79adbe056220202f7a56d67f788c38fc49ef9f Mon Sep 17 00:00:00 2001
From: Sebastian Falbesoner <sebastian.falbesoner@gmail.com>
Date: Thu, 25 Apr 2024 02:04:31 +0200
Subject: [PATCH 20/63] remove unused templates from cpp-subprocess

The templates `is_ready`, `param_pack`, and `has_type` are not used
anywhere, so let's remove them.
---
 src/util/subprocess.h | 35 -----------------------------------
 1 file changed, 35 deletions(-)

diff --git a/src/util/subprocess.h b/src/util/subprocess.h
index 4acfa8ff83..4c31a23d41 100644
--- a/src/util/subprocess.h
+++ b/src/util/subprocess.h
@@ -159,12 +159,6 @@ class OSError: public std::runtime_error
 //--------------------------------------------------------------------
 namespace util
 {
-  template <typename R>
-  inline bool is_ready(std::shared_future<R> const &f)
-  {
-    return f.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
-  }
-
   inline void quote_argument(const std::wstring &argument, std::wstring &command_line,
                       bool force)
   {
@@ -724,35 +718,6 @@ class Popen;
  */
 
 namespace detail {
-
-// Metaprogram for searching a type within
-// a variadic parameter pack
-// This is particularly required to do a compile time
-// checking of the arguments provided to 'check_output' function
-// wherein the user is not expected to provide an 'output' option.
-
-template <typename... T> struct param_pack{};
-
-template <typename F, typename T> struct has_type;
-
-template <typename F>
-struct has_type<F, param_pack<>> {
-  static constexpr bool value = false;
-};
-
-template <typename F, typename... T>
-struct has_type<F, param_pack<F, T...>> {
-  static constexpr bool value = true;
-};
-
-template <typename F, typename H, typename... T>
-struct has_type<F, param_pack<H,T...>> {
-  static constexpr bool value =
-    std::is_same<F, typename std::decay<H>::type>::value ? true : has_type<F, param_pack<T...>>::value;
-};
-
-//----
-
 /*!
  * A helper class to Popen class for setting
  * options as provided in the Popen constructor

From 7c69baf227252511455bc06e315f6a3c7fc5a398 Mon Sep 17 00:00:00 2001
From: Max Edwards <youwontforgetthis@gmail.com>
Date: Thu, 25 Apr 2024 14:00:10 +0100
Subject: [PATCH 21/63] depends: pass verbose through to cmake based make

When running depends with V=1 this will now enable verbose output from makefiles generated by cmake.
---
 depends/funcs.mk | 1 +
 1 file changed, 1 insertion(+)

diff --git a/depends/funcs.mk b/depends/funcs.mk
index 494ed5d324..d8a72421b4 100644
--- a/depends/funcs.mk
+++ b/depends/funcs.mk
@@ -182,6 +182,7 @@ $(1)_cmake=env CC="$$($(1)_cc)" \
                cmake -DCMAKE_INSTALL_PREFIX:PATH="$$($($(1)_type)_prefix)" \
                -DCMAKE_INSTALL_LIBDIR=lib/ \
                -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
+               -DCMAKE_VERBOSE_MAKEFILE:BOOL=$(V) \
                $$($(1)_config_opts)
 ifeq ($($(1)_type),build)
 $(1)_cmake += -DCMAKE_INSTALL_RPATH:PATH="$$($($(1)_type)_prefix)/lib"

From e504b1fa1fa4d014b329dea81bfdf1aa55db238f Mon Sep 17 00:00:00 2001
From: Brandon Odiwuor <brandon.odiwuor@gmail.com>
Date: Wed, 20 Dec 2023 16:58:53 +0300
Subject: [PATCH 22/63] test: Add test case for spending bare multisig

Co-authored-by: Anthony Towns <aj@erisian.com.au>
---
 src/init.cpp                      |  2 +-
 test/functional/mempool_accept.py | 21 +++++++++++++++++++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/init.cpp b/src/init.cpp
index c19d596c7f..b4bd07fb1b 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -636,7 +636,7 @@ void SetupServerArgs(ArgsManager& argsman)
                              MAX_OP_RETURN_RELAY),
                    ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     argsman.AddArg("-mempoolfullrbf", strprintf("Accept transaction replace-by-fee without requiring replaceability signaling (default: %u)", DEFAULT_MEMPOOL_FULL_RBF), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
-    argsman.AddArg("-permitbaremultisig", strprintf("Relay non-P2SH multisig (default: %u)", DEFAULT_PERMIT_BAREMULTISIG), ArgsManager::ALLOW_ANY,
+    argsman.AddArg("-permitbaremultisig", strprintf("Relay transactions creating non-P2SH multisig outputs (default: %u)", DEFAULT_PERMIT_BAREMULTISIG), ArgsManager::ALLOW_ANY,
                    OptionsCategory::NODE_RELAY);
     argsman.AddArg("-minrelaytxfee=<amt>", strprintf("Fees (in %s/kvB) smaller than this are considered zero fee for relaying, mining and transaction creation (default: %s)",
         CURRENCY_UNIT, FormatMoney(DEFAULT_MIN_RELAY_TX_FEE)), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
diff --git a/test/functional/mempool_accept.py b/test/functional/mempool_accept.py
index 272e932fcc..b00be5f4f0 100755
--- a/test/functional/mempool_accept.py
+++ b/test/functional/mempool_accept.py
@@ -28,6 +28,8 @@
     OP_HASH160,
     OP_RETURN,
     OP_TRUE,
+    SIGHASH_ALL,
+    sign_input_legacy,
 )
 from test_framework.script_util import (
     DUMMY_MIN_OP_RETURN_SCRIPT,
@@ -386,5 +388,24 @@ def run_test(self):
             maxfeerate=0,
         )
 
+        self.log.info('Spending a confirmed bare multisig is okay')
+        address = self.wallet.get_address()
+        tx = tx_from_hex(raw_tx_reference)
+        privkey, pubkey = generate_keypair()
+        tx.vout[0].scriptPubKey = keys_to_multisig_script([pubkey] * 3, k=1)  # Some bare multisig script (1-of-3)
+        tx.rehash()
+        self.generateblock(node, address, [tx.serialize().hex()])
+        tx_spend = CTransaction()
+        tx_spend.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
+        tx_spend.vout.append(CTxOut(tx.vout[0].nValue - int(fee*COIN), script_to_p2wsh_script(CScript([OP_TRUE]))))
+        tx_spend.rehash()
+        sign_input_legacy(tx_spend, 0, tx.vout[0].scriptPubKey, privkey, sighash_type=SIGHASH_ALL)
+        tx_spend.vin[0].scriptSig = bytes(CScript([OP_0])) + tx_spend.vin[0].scriptSig
+        self.check_mempool_result(
+            result_expected=[{'txid': tx_spend.rehash(), 'allowed': True, 'vsize': tx_spend.get_vsize(), 'fees': { 'base': Decimal('0.00000700')}}],
+            rawtxs=[tx_spend.serialize().hex()],
+            maxfeerate=0,
+        )
+
 if __name__ == '__main__':
     MempoolAcceptanceTest().main()

From 908c51fe4afeba0af500c6275027b1afa1b3bd19 Mon Sep 17 00:00:00 2001
From: Sebastian Falbesoner <sebastian.falbesoner@gmail.com>
Date: Thu, 25 Apr 2024 17:44:39 +0200
Subject: [PATCH 23/63] remove commented out code in cpp-subprocess

---
 src/util/subprocess.h | 25 -------------------------
 1 file changed, 25 deletions(-)

diff --git a/src/util/subprocess.h b/src/util/subprocess.h
index 4c31a23d41..dfe6e63c1a 100644
--- a/src/util/subprocess.h
+++ b/src/util/subprocess.h
@@ -682,22 +682,6 @@ class Buffer
   explicit Buffer(size_t cap) { buf.resize(cap); }
   void add_cap(size_t cap) { buf.resize(cap); }
 
-#if 0
-  Buffer(const Buffer& other):
-    buf(other.buf),
-    length(other.length)
-  {
-    std::cout << "COPY" << std::endl;
-  }
-
-  Buffer(Buffer&& other):
-    buf(std::move(other.buf)),
-    length(other.length)
-  {
-    std::cout << "MOVE" << std::endl;
-  }
-#endif
-
 public:
   std::vector<char> buf;
   size_t length = 0;
@@ -974,15 +958,6 @@ class Popen
     execute_process();
   }
 
-/*
-  ~Popen()
-  {
-#ifdef __USING_WINDOWS__
-    CloseHandle(this->process_handle_);
-#endif
-  }
-*/
-
   int pid() const noexcept { return child_pid_; }
 
   int retcode() const noexcept { return retcode_; }

From 834f65e82405bbed336f98996bc8cef366bbed0f Mon Sep 17 00:00:00 2001
From: Ryan Ofsky <ryan@ofsky.org>
Date: Thu, 15 Sep 2022 11:15:06 -0400
Subject: [PATCH 24/63] refactor: Drop util::Result operator=

`util::Result` objects are aggregates that can hold multiple fields with
different information. Currently Result objects can only hold a success value
of an arbitrary type or a single bilingual_str error message. In followup PR
https://github.com/bitcoin/bitcoin/pull/25722, Result objects may be able to
hold both success and failure values of different types, plus error and warning
messages.

Having a Result::operator= assignment operator that completely erases all
existing Result information before assigning new information is potentially
dangerous in this case. For example, code that looks like it is assigning a
warning value could erase previously-assigned success or failure values.
Conversely, code that looks like it is just assigning a success or failure
value could erase previously assigned error and warning messages.

To prevent potential bugs like this, disable Result::operator= assignment
operator.

It is possible in the future we may want to re-enable operator= in limited
cases (such as when implicit conversions are not used) or add a Replace() or
Reset() method that mimicks default operator= behavior. Followup PR
https://github.com/bitcoin/bitcoin/pull/25722 also adds a Result::Update()
method providing another way to update an existing Result object.

Co-authored-by: stickies-v <stickies-v@protonmail.com>
---
 src/init.cpp                           |  6 ++----
 src/qt/addresstablemodel.cpp           | 11 ++++++-----
 src/test/mempool_tests.cpp             | 16 ++++++++++------
 src/util/result.h                      | 10 ++++++++++
 src/validation.cpp                     | 13 ++++++++-----
 src/wallet/test/fuzz/notifications.cpp |  6 ++----
 src/wallet/test/spend_tests.cpp        |  6 ++----
 7 files changed, 40 insertions(+), 28 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index c19d596c7f..47d649be3d 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -992,10 +992,8 @@ bool AppInitParameterInteraction(const ArgsManager& args)
         InitWarning(strprintf(_("Reducing -maxconnections from %d to %d, because of system limitations."), nUserMaxConnections, nMaxConnections));
 
     // ********************************************************* Step 3: parameter-to-internal-flags
-    auto result = init::SetLoggingCategories(args);
-    if (!result) return InitError(util::ErrorString(result));
-    result = init::SetLoggingLevel(args);
-    if (!result) return InitError(util::ErrorString(result));
+    if (auto result{init::SetLoggingCategories(args)}; !result) return InitError(util::ErrorString(result));
+    if (auto result{init::SetLoggingLevel(args)}; !result) return InitError(util::ErrorString(result));
 
     nConnectTimeout = args.GetIntArg("-timeout", DEFAULT_CONNECT_TIMEOUT);
     if (nConnectTimeout <= 0) {
diff --git a/src/qt/addresstablemodel.cpp b/src/qt/addresstablemodel.cpp
index c52ef7cd67..efdc3966d1 100644
--- a/src/qt/addresstablemodel.cpp
+++ b/src/qt/addresstablemodel.cpp
@@ -369,21 +369,22 @@ QString AddressTableModel::addRow(const QString &type, const QString &label, con
     else if(type == Receive)
     {
         // Generate a new address to associate with given label
-        auto op_dest = walletModel->wallet().getNewDestination(address_type, strLabel);
-        if (!op_dest) {
+        if (auto dest{walletModel->wallet().getNewDestination(address_type, strLabel)}) {
+            strAddress = EncodeDestination(*dest);
+        } else {
             WalletModel::UnlockContext ctx(walletModel->requestUnlock());
             if (!ctx.isValid()) {
                 // Unlock wallet failed or was cancelled
                 editStatus = WALLET_UNLOCK_FAILURE;
                 return QString();
             }
-            op_dest = walletModel->wallet().getNewDestination(address_type, strLabel);
-            if (!op_dest) {
+            if (auto dest_retry{walletModel->wallet().getNewDestination(address_type, strLabel)}) {
+                strAddress = EncodeDestination(*dest_retry);
+            } else {
                 editStatus = KEY_GENERATION_FAILURE;
                 return QString();
             }
         }
-        strAddress = EncodeDestination(*op_dest);
     }
     else
     {
diff --git a/src/test/mempool_tests.cpp b/src/test/mempool_tests.cpp
index 217e4a6d22..9f8d434213 100644
--- a/src/test/mempool_tests.cpp
+++ b/src/test/mempool_tests.cpp
@@ -202,9 +202,11 @@ BOOST_AUTO_TEST_CASE(MempoolIndexingTest)
     tx7.vout[1].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx7.vout[1].nValue = 1 * COIN;
 
-    auto ancestors_calculated{pool.CalculateMemPoolAncestors(entry.Fee(2000000LL).FromTx(tx7), CTxMemPool::Limits::NoLimits())};
-    BOOST_REQUIRE(ancestors_calculated.has_value());
-    BOOST_CHECK(*ancestors_calculated == setAncestors);
+    {
+        auto ancestors_calculated{pool.CalculateMemPoolAncestors(entry.Fee(2000000LL).FromTx(tx7), CTxMemPool::Limits::NoLimits())};
+        BOOST_REQUIRE(ancestors_calculated.has_value());
+        BOOST_CHECK(*ancestors_calculated == setAncestors);
+    }
 
     pool.addUnchecked(entry.FromTx(tx7), setAncestors);
     BOOST_CHECK_EQUAL(pool.size(), 7U);
@@ -260,9 +262,11 @@ BOOST_AUTO_TEST_CASE(MempoolIndexingTest)
     tx10.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
     tx10.vout[0].nValue = 10 * COIN;
 
-    ancestors_calculated = pool.CalculateMemPoolAncestors(entry.Fee(200000LL).Time(NodeSeconds{4s}).FromTx(tx10), CTxMemPool::Limits::NoLimits());
-    BOOST_REQUIRE(ancestors_calculated);
-    BOOST_CHECK(*ancestors_calculated == setAncestors);
+    {
+        auto ancestors_calculated{pool.CalculateMemPoolAncestors(entry.Fee(200000LL).Time(NodeSeconds{4s}).FromTx(tx10), CTxMemPool::Limits::NoLimits())};
+        BOOST_REQUIRE(ancestors_calculated);
+        BOOST_CHECK(*ancestors_calculated == setAncestors);
+    }
 
     pool.addUnchecked(entry.FromTx(tx10), setAncestors);
 
diff --git a/src/util/result.h b/src/util/result.h
index b99995c7e5..11fe89af25 100644
--- a/src/util/result.h
+++ b/src/util/result.h
@@ -39,6 +39,13 @@ class Result
 
     std::variant<bilingual_str, T> m_variant;
 
+    //! Disallow operator= to avoid confusion in the future when the Result
+    //! class gains support for richer error reporting, and callers should have
+    //! ability to set a new result value without clearing existing error
+    //! messages.
+    Result& operator=(const Result&) = delete;
+    Result& operator=(Result&&) = delete;
+
     template <typename FT>
     friend bilingual_str ErrorString(const Result<FT>& result);
 
@@ -46,6 +53,9 @@ class Result
     Result() : m_variant{std::in_place_index_t<1>{}, std::monostate{}} {}  // constructor for void
     Result(T obj) : m_variant{std::in_place_index_t<1>{}, std::move(obj)} {}
     Result(Error error) : m_variant{std::in_place_index_t<0>{}, std::move(error.message)} {}
+    Result(const Result&) = default;
+    Result(Result&&) = default;
+    ~Result() = default;
 
     //! std::optional methods, so functions returning optional<T> can change to
     //! return Result<T> with minimal changes to existing code, and vice versa.
diff --git a/src/validation.cpp b/src/validation.cpp
index 903f9caf13..f57851b4f7 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -946,8 +946,9 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
         maybe_rbf_limits.descendant_size_vbytes += conflict->GetSizeWithDescendants();
     }
 
-    auto ancestors{m_pool.CalculateMemPoolAncestors(*entry, maybe_rbf_limits)};
-    if (!ancestors) {
+    if (auto ancestors{m_pool.CalculateMemPoolAncestors(*entry, maybe_rbf_limits)}) {
+        ws.m_ancestors = std::move(*ancestors);
+    } else {
         // If CalculateMemPoolAncestors fails second time, we want the original error string.
         // Contracting/payment channels CPFP carve-out:
         // If the new transaction is relatively small (up to 40k weight)
@@ -970,11 +971,13 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
         if (ws.m_vsize > EXTRA_DESCENDANT_TX_SIZE_LIMIT) {
             return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", error_message);
         }
-        ancestors = m_pool.CalculateMemPoolAncestors(*entry, cpfp_carve_out_limits);
-        if (!ancestors) return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", error_message);
+        if (auto ancestors_retry{m_pool.CalculateMemPoolAncestors(*entry, cpfp_carve_out_limits)}) {
+            ws.m_ancestors = std::move(*ancestors_retry);
+        } else {
+            return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", error_message);
+        }
     }
 
-    ws.m_ancestors = *ancestors;
     // Even though just checking direct mempool parents for inheritance would be sufficient, we
     // check using the full ancestor set here because it's more convenient to use what we have
     // already calculated.
diff --git a/src/wallet/test/fuzz/notifications.cpp b/src/wallet/test/fuzz/notifications.cpp
index 9a515828fe..792079e6c6 100644
--- a/src/wallet/test/fuzz/notifications.cpp
+++ b/src/wallet/test/fuzz/notifications.cpp
@@ -106,13 +106,11 @@ struct FuzzedWallet {
     CTxDestination GetDestination(FuzzedDataProvider& fuzzed_data_provider)
     {
         auto type{fuzzed_data_provider.PickValueInArray(OUTPUT_TYPES)};
-        util::Result<CTxDestination> op_dest{util::Error{}};
         if (fuzzed_data_provider.ConsumeBool()) {
-            op_dest = wallet->GetNewDestination(type, "");
+            return *Assert(wallet->GetNewDestination(type, ""));
         } else {
-            op_dest = wallet->GetNewChangeDestination(type);
+            return *Assert(wallet->GetNewChangeDestination(type));
         }
-        return *Assert(op_dest);
     }
     CScript GetScriptPubKey(FuzzedDataProvider& fuzzed_data_provider) { return GetScriptForDestination(GetDestination(fuzzed_data_provider)); }
     void FundTx(FuzzedDataProvider& fuzzed_data_provider, CMutableTransaction tx)
diff --git a/src/wallet/test/spend_tests.cpp b/src/wallet/test/spend_tests.cpp
index 3509bc116f..963c0f838b 100644
--- a/src/wallet/test/spend_tests.cpp
+++ b/src/wallet/test/spend_tests.cpp
@@ -97,13 +97,11 @@ BOOST_FIXTURE_TEST_CASE(wallet_duplicated_preset_inputs_test, TestChain100Setup)
     // so that the recipient's amount is no longer equal to the user's selected target of 299 BTC.
 
     // First case, use 'subtract_fee_from_outputs=true'
-    util::Result<CreatedTransactionResult> res_tx = CreateTransaction(*wallet, recipients, /*change_pos=*/std::nullopt, coin_control);
-    BOOST_CHECK(!res_tx.has_value());
+    BOOST_CHECK(!CreateTransaction(*wallet, recipients, /*change_pos=*/std::nullopt, coin_control));
 
     // Second case, don't use 'subtract_fee_from_outputs'.
     recipients[0].fSubtractFeeFromAmount = false;
-    res_tx = CreateTransaction(*wallet, recipients, /*change_pos=*/std::nullopt, coin_control);
-    BOOST_CHECK(!res_tx.has_value());
+    BOOST_CHECK(!CreateTransaction(*wallet, recipients, /*change_pos=*/std::nullopt, coin_control));
 }
 
 BOOST_AUTO_TEST_SUITE_END()

From 6a8b2befeab25e4e92d8e947a23e78014695e06c Mon Sep 17 00:00:00 2001
From: Ryan Ofsky <ryan@ofsky.org>
Date: Mon, 25 Mar 2024 18:44:23 -0400
Subject: [PATCH 25/63] refactor: Avoid copying util::Result values

Copying util::Result values is less efficient than moving them because they
allocate memory and contain strings. Also this is needed to avoid compile
errors in https://github.com/bitcoin/bitcoin/pull/25722 which adds a
std::unique_ptr member to util::Result which implicity disables copying.
---
 src/util/result.h                      |  4 +++-
 src/wallet/spend.cpp                   | 30 ++++++++++++--------------
 src/wallet/test/fuzz/coinselection.cpp |  5 ++++-
 3 files changed, 21 insertions(+), 18 deletions(-)

diff --git a/src/util/result.h b/src/util/result.h
index 11fe89af25..122a7638fa 100644
--- a/src/util/result.h
+++ b/src/util/result.h
@@ -39,6 +39,9 @@ class Result
 
     std::variant<bilingual_str, T> m_variant;
 
+    //! Disallow copy constructor, require Result to be moved for efficiency.
+    Result(const Result&) = delete;
+
     //! Disallow operator= to avoid confusion in the future when the Result
     //! class gains support for richer error reporting, and callers should have
     //! ability to set a new result value without clearing existing error
@@ -53,7 +56,6 @@ class Result
     Result() : m_variant{std::in_place_index_t<1>{}, std::monostate{}} {}  // constructor for void
     Result(T obj) : m_variant{std::in_place_index_t<1>{}, std::move(obj)} {}
     Result(Error error) : m_variant{std::in_place_index_t<0>{}, std::move(error.message)} {}
-    Result(const Result&) = default;
     Result(Result&&) = default;
     ~Result() = default;
 
diff --git a/src/wallet/spend.cpp b/src/wallet/spend.cpp
index 5d23ebd35a..9a7e166e68 100644
--- a/src/wallet/spend.cpp
+++ b/src/wallet/spend.cpp
@@ -683,11 +683,11 @@ util::Result<SelectionResult> ChooseSelectionResult(interfaces::Chain& chain, co
     // Vector of results. We will choose the best one based on waste.
     std::vector<SelectionResult> results;
     std::vector<util::Result<SelectionResult>> errors;
-    auto append_error = [&] (const util::Result<SelectionResult>& result) {
+    auto append_error = [&] (util::Result<SelectionResult>&& result) {
         // If any specific error message appears here, then something different from a simple "no selection found" happened.
         // Let's save it, so it can be retrieved to the user if no other selection algorithm succeeded.
         if (HasErrorMsg(result)) {
-            errors.emplace_back(result);
+            errors.emplace_back(std::move(result));
         }
     };
 
@@ -698,7 +698,7 @@ util::Result<SelectionResult> ChooseSelectionResult(interfaces::Chain& chain, co
     if (!coin_selection_params.m_subtract_fee_outputs) {
         if (auto bnb_result{SelectCoinsBnB(groups.positive_group, nTargetValue, coin_selection_params.m_cost_of_change, max_inputs_weight)}) {
             results.push_back(*bnb_result);
-        } else append_error(bnb_result);
+        } else append_error(std::move(bnb_result));
     }
 
     // As Knapsack and SRD can create change, also deduce change weight.
@@ -707,25 +707,25 @@ util::Result<SelectionResult> ChooseSelectionResult(interfaces::Chain& chain, co
     // The knapsack solver has some legacy behavior where it will spend dust outputs. We retain this behavior, so don't filter for positive only here.
     if (auto knapsack_result{KnapsackSolver(groups.mixed_group, nTargetValue, coin_selection_params.m_min_change_target, coin_selection_params.rng_fast, max_inputs_weight)}) {
         results.push_back(*knapsack_result);
-    } else append_error(knapsack_result);
+    } else append_error(std::move(knapsack_result));
 
     if (coin_selection_params.m_effective_feerate > CFeeRate{3 * coin_selection_params.m_long_term_feerate}) { // Minimize input set for feerates of at least 3×LTFRE (default: 30 ṩ/vB+)
         if (auto cg_result{CoinGrinder(groups.positive_group, nTargetValue, coin_selection_params.m_min_change_target, max_inputs_weight)}) {
             cg_result->ComputeAndSetWaste(coin_selection_params.min_viable_change, coin_selection_params.m_cost_of_change, coin_selection_params.m_change_fee);
             results.push_back(*cg_result);
         } else {
-            append_error(cg_result);
+            append_error(std::move(cg_result));
         }
     }
 
     if (auto srd_result{SelectCoinsSRD(groups.positive_group, nTargetValue, coin_selection_params.m_change_fee, coin_selection_params.rng_fast, max_inputs_weight)}) {
         results.push_back(*srd_result);
-    } else append_error(srd_result);
+    } else append_error(std::move(srd_result));
 
     if (results.empty()) {
         // No solution found, retrieve the first explicit error (if any).
         // future: add 'severity level' to errors so the worst one can be retrieved instead of the first one.
-        return errors.empty() ? util::Error() : errors.front();
+        return errors.empty() ? util::Error() : std::move(errors.front());
     }
 
     // If the chosen input set has unconfirmed inputs, check for synergies from overlapping ancestry
@@ -818,7 +818,7 @@ util::Result<SelectionResult> AutomaticCoinSelection(const CWallet& wallet, Coin
     // Coin Selection attempts to select inputs from a pool of eligible UTXOs to fund the
     // transaction at a target feerate. If an attempt fails, more attempts may be made using a more
     // permissive CoinEligibilityFilter.
-    util::Result<SelectionResult> res = [&] {
+    {
         // Place coins eligibility filters on a scope increasing order.
         std::vector<SelectionFilter> ordered_filters{
                 // If possible, fund the transaction with confirmed UTXOs only. Prefer at least six
@@ -866,9 +866,9 @@ util::Result<SelectionResult> AutomaticCoinSelection(const CWallet& wallet, Coin
         if (CAmount total_amount = available_coins.GetTotalAmount() - total_discarded < value_to_select) {
             // Special case, too-long-mempool cluster.
             if (total_amount + total_unconf_long_chain > value_to_select) {
-                return util::Result<SelectionResult>({_("Unconfirmed UTXOs are available, but spending them creates a chain of transactions that will be rejected by the mempool")});
+                return util::Error{_("Unconfirmed UTXOs are available, but spending them creates a chain of transactions that will be rejected by the mempool")};
             }
-            return util::Result<SelectionResult>(util::Error()); // General "Insufficient Funds"
+            return util::Error{}; // General "Insufficient Funds"
         }
 
         // Walk-through the filters until the solution gets found.
@@ -885,19 +885,17 @@ util::Result<SelectionResult> AutomaticCoinSelection(const CWallet& wallet, Coin
                 // If any specific error message appears here, then something particularly wrong might have happened.
                 // Save the error and continue the selection process. So if no solutions gets found, we can return
                 // the detailed error to the upper layers.
-                if (HasErrorMsg(res)) res_detailed_errors.emplace_back(res);
+                if (HasErrorMsg(res)) res_detailed_errors.emplace_back(std::move(res));
             }
         }
 
         // Return right away if we have a detailed error
-        if (!res_detailed_errors.empty()) return res_detailed_errors.front();
+        if (!res_detailed_errors.empty()) return std::move(res_detailed_errors.front());
 
 
         // General "Insufficient Funds"
-        return util::Result<SelectionResult>(util::Error());
-    }();
-
-    return res;
+        return util::Error{};
+    }
 }
 
 static bool IsCurrentForAntiFeeSniping(interfaces::Chain& chain, const uint256& block_hash)
diff --git a/src/wallet/test/fuzz/coinselection.cpp b/src/wallet/test/fuzz/coinselection.cpp
index 297432de9e..331590df7f 100644
--- a/src/wallet/test/fuzz/coinselection.cpp
+++ b/src/wallet/test/fuzz/coinselection.cpp
@@ -291,7 +291,10 @@ FUZZ_TARGET(coinselection)
     }
 
     std::vector<COutput> utxos;
-    std::vector<util::Result<SelectionResult>> results{result_srd, result_knapsack, result_bnb};
+    std::vector<util::Result<SelectionResult>> results;
+    results.emplace_back(std::move(result_srd));
+    results.emplace_back(std::move(result_knapsack));
+    results.emplace_back(std::move(result_bnb));
     CAmount new_total_balance{CreateCoins(fuzzed_data_provider, utxos, coin_params, next_locktime)};
     if (new_total_balance > 0) {
         std::set<std::shared_ptr<COutput>> new_utxo_pool;

From 092c978a42e8f4a02291b994713505ba8aac8b28 Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Tue, 16 Apr 2024 11:58:25 +0100
Subject: [PATCH 26/63] [txpackages] add canonical way to get hash of package

---
 src/policy/packages.cpp      | 18 +++++++
 src/policy/packages.h        |  5 ++
 src/test/txpackage_tests.cpp | 98 +++++++++++++++++++++++++++++++++++-
 3 files changed, 120 insertions(+), 1 deletion(-)

diff --git a/src/policy/packages.cpp b/src/policy/packages.cpp
index 3a63a9fe46..99d2a6d514 100644
--- a/src/policy/packages.cpp
+++ b/src/policy/packages.cpp
@@ -147,3 +147,21 @@ bool IsChildWithParentsTree(const Package& package)
         return true;
     });
 }
+
+uint256 GetPackageHash(const std::vector<CTransactionRef>& transactions)
+{
+    // Create a vector of the wtxids.
+    std::vector<Wtxid> wtxids_copy;
+    std::transform(transactions.cbegin(), transactions.cend(), std::back_inserter(wtxids_copy),
+        [](const auto& tx){ return tx->GetWitnessHash(); });
+
+    // Sort in ascending order
+    std::sort(wtxids_copy.begin(), wtxids_copy.end(), [](const auto& lhs, const auto& rhs) { return lhs.GetHex() < rhs.GetHex(); });
+
+    // Get sha256 hash of the wtxids concatenated in this order
+    HashWriter hashwriter;
+    for (const auto& wtxid : wtxids_copy) {
+        hashwriter << wtxid;
+    }
+    return hashwriter.GetSHA256();
+}
diff --git a/src/policy/packages.h b/src/policy/packages.h
index 537d8476e2..3050320122 100644
--- a/src/policy/packages.h
+++ b/src/policy/packages.h
@@ -88,4 +88,9 @@ bool IsChildWithParents(const Package& package);
  * other (the package is a "tree").
  */
 bool IsChildWithParentsTree(const Package& package);
+
+/** Get the hash of these transactions' wtxids, concatenated in lexicographical order (treating the
+ * wtxids as little endian encoded uint256, smallest to largest). */
+uint256 GetPackageHash(const std::vector<CTransactionRef>& transactions);
+
 #endif // BITCOIN_POLICY_PACKAGES_H
diff --git a/src/test/txpackage_tests.cpp b/src/test/txpackage_tests.cpp
index b948ea8acb..8112f5f685 100644
--- a/src/test/txpackage_tests.cpp
+++ b/src/test/txpackage_tests.cpp
@@ -8,9 +8,12 @@
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
+#include <serialize.h>
+#include <streams.h>
 #include <test/util/random.h>
 #include <test/util/script.h>
 #include <test/util/setup_common.h>
+#include <util/strencodings.h>
 #include <test/util/txmempool.h>
 #include <validation.h>
 
@@ -40,6 +43,93 @@ inline CTransactionRef create_placeholder_tx(size_t num_inputs, size_t num_outpu
     return MakeTransactionRef(mtx);
 }
 
+// Create a Wtxid from a hex string
+inline Wtxid WtxidFromString(std::string_view str)
+{
+    return Wtxid::FromUint256(uint256S(str.data()));
+}
+
+BOOST_FIXTURE_TEST_CASE(package_hash_tests, TestChain100Setup)
+{
+    // Random real segwit transaction
+    DataStream stream_1{
+        ParseHex("02000000000101964b8aa63509579ca6086e6012eeaa4c2f4dd1e283da29b67c8eea38b3c6fd220000000000fdffffff0294c618000000000017a9145afbbb42f4e83312666d0697f9e66259912ecde38768fa2c0000000000160014897388a0889390fd0e153a22bb2cf9d8f019faf50247304402200547406380719f84d68cf4e96cc3e4a1688309ef475b150be2b471c70ea562aa02206d255f5acc40fd95981874d77201d2eb07883657ce1c796513f32b6079545cdf0121023ae77335cefcb5ab4c1dc1fb0d2acfece184e593727d7d5906c78e564c7c11d125cf0c00"),
+    };
+    CTransaction tx_1(deserialize, TX_WITH_WITNESS, stream_1);
+    CTransactionRef ptx_1{MakeTransactionRef(tx_1)};
+
+    // Random real nonsegwit transaction
+    DataStream stream_2{
+        ParseHex("01000000010b26e9b7735eb6aabdf358bab62f9816a21ba9ebdb719d5299e88607d722c190000000008b4830450220070aca44506c5cef3a16ed519d7c3c39f8aab192c4e1c90d065f37b8a4af6141022100a8e160b856c2d43d27d8fba71e5aef6405b8643ac4cb7cb3c462aced7f14711a0141046d11fee51b0e60666d5049a9101a72741df480b96ee26488a4d3466b95c9a40ac5eeef87e10a5cd336c19a84565f80fa6c547957b7700ff4dfbdefe76036c339ffffffff021bff3d11000000001976a91404943fdd508053c75000106d3bc6e2754dbcff1988ac2f15de00000000001976a914a266436d2965547608b9e15d9032a7b9d64fa43188ac00000000"),
+    };
+    CTransaction tx_2(deserialize, TX_WITH_WITNESS, stream_2);
+    CTransactionRef ptx_2{MakeTransactionRef(tx_2)};
+
+    // Random real segwit transaction
+    DataStream stream_3{
+        ParseHex("0200000000010177862801f77c2c068a70372b4c435ef8dd621291c36a64eb4dd491f02218f5324600000000fdffffff014a0100000000000022512035ea312034cfac01e956a269f3bf147f569c2fbb00180677421262da042290d803402be713325ff285e66b0380f53f2fae0d0fb4e16f378a440fed51ce835061437566729d4883bc917632f3cff474d6384bc8b989961a1d730d4a87ed38ad28bd337b20f1d658c6c138b1c312e072b4446f50f01ae0da03a42e6274f8788aae53416a7fac0063036f7264010118746578742f706c61696e3b636861727365743d7574662d3800357b2270223a226272632d3230222c226f70223a226d696e74222c227469636b223a224342414c222c22616d74223a2236393639227d6821c1f1d658c6c138b1c312e072b4446f50f01ae0da03a42e6274f8788aae53416a7f00000000"),
+    };
+    CTransaction tx_3(deserialize, TX_WITH_WITNESS, stream_3);
+    CTransactionRef ptx_3{MakeTransactionRef(tx_3)};
+
+    // It's easy to see that wtxids are sorted in lexicographical order:
+    Wtxid wtxid_1{WtxidFromString("0x85cd1a31eb38f74ed5742ec9cb546712ab5aaf747de28a9168b53e846cbda17f")};
+    Wtxid wtxid_2{WtxidFromString("0xb4749f017444b051c44dfd2720e88f314ff94f3dd6d56d40ef65854fcd7fff6b")};
+    Wtxid wtxid_3{WtxidFromString("0xe065bac15f62bb4e761d761db928ddee65a47296b2b776785abb912cdec474e3")};
+    BOOST_CHECK_EQUAL(tx_1.GetWitnessHash(), wtxid_1);
+    BOOST_CHECK_EQUAL(tx_2.GetWitnessHash(), wtxid_2);
+    BOOST_CHECK_EQUAL(tx_3.GetWitnessHash(), wtxid_3);
+
+    BOOST_CHECK(wtxid_1.GetHex() < wtxid_2.GetHex());
+    BOOST_CHECK(wtxid_2.GetHex() < wtxid_3.GetHex());
+
+    // The txids are not (we want to test that sorting and hashing use wtxid, not txid):
+    Txid txid_1{TxidFromString("0xbd0f71c1d5e50589063e134fad22053cdae5ab2320db5bf5e540198b0b5a4e69")};
+    Txid txid_2{TxidFromString("0xb4749f017444b051c44dfd2720e88f314ff94f3dd6d56d40ef65854fcd7fff6b")};
+    Txid txid_3{TxidFromString("0xee707be5201160e32c4fc715bec227d1aeea5940fb4295605e7373edce3b1a93")};
+    BOOST_CHECK_EQUAL(tx_1.GetHash(), txid_1);
+    BOOST_CHECK_EQUAL(tx_2.GetHash(), txid_2);
+    BOOST_CHECK_EQUAL(tx_3.GetHash(), txid_3);
+
+    BOOST_CHECK(txid_2.GetHex() < txid_1.GetHex());
+
+    BOOST_CHECK(txid_1.ToUint256() != wtxid_1.ToUint256());
+    BOOST_CHECK(txid_2.ToUint256() == wtxid_2.ToUint256());
+    BOOST_CHECK(txid_3.ToUint256() != wtxid_3.ToUint256());
+
+    // We are testing that both functions compare using GetHex() and not uint256.
+    // (in this pair of wtxids, hex string order != uint256 order)
+    BOOST_CHECK(wtxid_2 < wtxid_1);
+    // (in this pair of wtxids, hex string order == uint256 order)
+    BOOST_CHECK(wtxid_2 < wtxid_3);
+
+    // All permutations of the package containing ptx_1, ptx_2, ptx_3 have the same package hash
+    std::vector<CTransactionRef> package_123{ptx_1, ptx_2, ptx_3};
+    std::vector<CTransactionRef> package_132{ptx_1, ptx_3, ptx_2};
+    std::vector<CTransactionRef> package_231{ptx_2, ptx_3, ptx_1};
+    std::vector<CTransactionRef> package_213{ptx_2, ptx_1, ptx_3};
+    std::vector<CTransactionRef> package_312{ptx_3, ptx_1, ptx_2};
+    std::vector<CTransactionRef> package_321{ptx_3, ptx_2, ptx_1};
+
+    uint256 calculated_hash_123 = (HashWriter() << wtxid_1 << wtxid_2 << wtxid_3).GetSHA256();
+
+    uint256 hash_if_by_txid = (HashWriter() << wtxid_2 << wtxid_1 << wtxid_3).GetSHA256();
+    BOOST_CHECK(hash_if_by_txid != calculated_hash_123);
+
+    uint256 hash_if_use_txid = (HashWriter() << txid_2 << txid_1 << txid_3).GetSHA256();
+    BOOST_CHECK(hash_if_use_txid != calculated_hash_123);
+
+    uint256 hash_if_use_int_order = (HashWriter() << wtxid_2 << wtxid_1 << wtxid_3).GetSHA256();
+    BOOST_CHECK(hash_if_use_int_order != calculated_hash_123);
+
+    BOOST_CHECK_EQUAL(calculated_hash_123, GetPackageHash(package_123));
+    BOOST_CHECK_EQUAL(calculated_hash_123, GetPackageHash(package_132));
+    BOOST_CHECK_EQUAL(calculated_hash_123, GetPackageHash(package_231));
+    BOOST_CHECK_EQUAL(calculated_hash_123, GetPackageHash(package_213));
+    BOOST_CHECK_EQUAL(calculated_hash_123, GetPackageHash(package_312));
+    BOOST_CHECK_EQUAL(calculated_hash_123, GetPackageHash(package_321));
+}
+
 BOOST_FIXTURE_TEST_CASE(package_sanitization_tests, TestChain100Setup)
 {
     // Packages can't have more than 25 transactions.
@@ -190,6 +280,9 @@ BOOST_FIXTURE_TEST_CASE(noncontextual_package_tests, TestChain100Setup)
         BOOST_CHECK_EQUAL(state.GetRejectReason(), "package-not-sorted");
         BOOST_CHECK(IsChildWithParents({tx_parent, tx_child}));
         BOOST_CHECK(IsChildWithParentsTree({tx_parent, tx_child}));
+        BOOST_CHECK(GetPackageHash({tx_parent}) != GetPackageHash({tx_child}));
+        BOOST_CHECK(GetPackageHash({tx_child, tx_child}) != GetPackageHash({tx_child}));
+        BOOST_CHECK(GetPackageHash({tx_child, tx_parent}) != GetPackageHash({tx_child, tx_child}));
     }
 
     // 24 Parents and 1 Child
@@ -450,6 +543,8 @@ BOOST_FIXTURE_TEST_CASE(package_witness_swap_tests, TestChain100Setup)
     BOOST_CHECK_EQUAL(ptx_child1->GetHash(), ptx_child2->GetHash());
     // child1 and child2 have different wtxids
     BOOST_CHECK(ptx_child1->GetWitnessHash() != ptx_child2->GetWitnessHash());
+    // Check that they have different package hashes
+    BOOST_CHECK(GetPackageHash({ptx_parent, ptx_child1}) != GetPackageHash({ptx_parent, ptx_child2}));
 
     // Try submitting Package1{parent, child1} and Package2{parent, child2} where the children are
     // same-txid-different-witness.
@@ -503,7 +598,8 @@ BOOST_FIXTURE_TEST_CASE(package_witness_swap_tests, TestChain100Setup)
                                                         /*output_destination=*/grandchild_locking_script,
                                                         /*output_amount=*/CAmount(47 * COIN), /*submit=*/false);
     CTransactionRef ptx_grandchild = MakeTransactionRef(mtx_grandchild);
-
+    // Check that they have different package hashes
+    BOOST_CHECK(GetPackageHash({ptx_child1, ptx_grandchild}) != GetPackageHash({ptx_child2, ptx_grandchild}));
     // We already submitted child1 above.
     {
         Package package_child2_grandchild{ptx_child2, ptx_grandchild};

From 2f51cd680fb4323f1c792dae37d4c4e0e0e35804 Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Thu, 28 Mar 2024 17:14:38 +0000
Subject: [PATCH 27/63] [txorphanage] add method to get all orphans spending a
 tx

---
 src/txorphanage.cpp | 74 +++++++++++++++++++++++++++++++++++++++++++++
 src/txorphanage.h   |  8 +++++
 2 files changed, 82 insertions(+)

diff --git a/src/txorphanage.cpp b/src/txorphanage.cpp
index e907fffd4f..82206e56c3 100644
--- a/src/txorphanage.cpp
+++ b/src/txorphanage.cpp
@@ -241,3 +241,77 @@ void TxOrphanage::EraseForBlock(const CBlock& block)
         LogPrint(BCLog::TXPACKAGES, "Erased %d orphan tx included or conflicted by block\n", nErased);
     }
 }
+
+std::vector<CTransactionRef> TxOrphanage::GetChildrenFromSamePeer(const CTransactionRef& parent, NodeId nodeid) const
+{
+    LOCK(m_mutex);
+
+    // First construct a vector of iterators to ensure we do not return duplicates of the same tx
+    // and so we can sort by nTimeExpire.
+    std::vector<OrphanMap::iterator> iters;
+
+    // For each output, get all entries spending this prevout, filtering for ones from the specified peer.
+    for (unsigned int i = 0; i < parent->vout.size(); i++) {
+        const auto it_by_prev = m_outpoint_to_orphan_it.find(COutPoint(parent->GetHash(), i));
+        if (it_by_prev != m_outpoint_to_orphan_it.end()) {
+            for (const auto& elem : it_by_prev->second) {
+                if (elem->second.fromPeer == nodeid) {
+                    iters.emplace_back(elem);
+                }
+            }
+        }
+    }
+
+    // Sort by address so that duplicates can be deleted. At the same time, sort so that more recent
+    // orphans (which expire later) come first.  Break ties based on address, as nTimeExpire is
+    // quantified in seconds and it is possible for orphans to have the same expiry.
+    std::sort(iters.begin(), iters.end(), [](const auto& lhs, const auto& rhs) {
+        if (lhs->second.nTimeExpire == rhs->second.nTimeExpire) {
+            return &(*lhs) < &(*rhs);
+        } else {
+            return lhs->second.nTimeExpire > rhs->second.nTimeExpire;
+        }
+    });
+    // Erase duplicates
+    iters.erase(std::unique(iters.begin(), iters.end()), iters.end());
+
+    // Convert to a vector of CTransactionRef
+    std::vector<CTransactionRef> children_found;
+    children_found.reserve(iters.size());
+    for (const auto child_iter : iters) {
+        children_found.emplace_back(child_iter->second.tx);
+    }
+    return children_found;
+}
+
+std::vector<std::pair<CTransactionRef, NodeId>> TxOrphanage::GetChildrenFromDifferentPeer(const CTransactionRef& parent, NodeId nodeid) const
+{
+    LOCK(m_mutex);
+
+    // First construct vector of iterators to ensure we do not return duplicates of the same tx.
+    std::vector<OrphanMap::iterator> iters;
+
+    // For each output, get all entries spending this prevout, filtering for ones not from the specified peer.
+    for (unsigned int i = 0; i < parent->vout.size(); i++) {
+        const auto it_by_prev = m_outpoint_to_orphan_it.find(COutPoint(parent->GetHash(), i));
+        if (it_by_prev != m_outpoint_to_orphan_it.end()) {
+            for (const auto& elem : it_by_prev->second) {
+                if (elem->second.fromPeer != nodeid) {
+                    iters.emplace_back(elem);
+                }
+            }
+        }
+    }
+
+    // Erase duplicates
+    std::sort(iters.begin(), iters.end(), IteratorComparator());
+    iters.erase(std::unique(iters.begin(), iters.end()), iters.end());
+
+    // Convert iterators to pair<CTransactionRef, NodeId>
+    std::vector<std::pair<CTransactionRef, NodeId>> children_found;
+    children_found.reserve(iters.size());
+    for (const auto child_iter : iters) {
+        children_found.emplace_back(child_iter->second.tx, child_iter->second.fromPeer);
+    }
+    return children_found;
+}
diff --git a/src/txorphanage.h b/src/txorphanage.h
index 2fd14e6fd2..a3c8edaa2a 100644
--- a/src/txorphanage.h
+++ b/src/txorphanage.h
@@ -51,6 +51,14 @@ class TxOrphanage {
     /** Does this peer have any work to do? */
     bool HaveTxToReconsider(NodeId peer) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);;
 
+    /** Get all children that spend from this tx and were received from nodeid. Sorted from most
+     * recent to least recent. */
+    std::vector<CTransactionRef> GetChildrenFromSamePeer(const CTransactionRef& parent, NodeId nodeid) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
+
+    /** Get all children that spend from this tx but were not received from nodeid. Also return
+     * which peer provided each tx. */
+    std::vector<std::pair<CTransactionRef, NodeId>> GetChildrenFromDifferentPeer(const CTransactionRef& parent, NodeId nodeid) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
+
     /** Return how many entries exist in the orphange */
     size_t Size() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
     {

From d095316c1c23e9460dfbd9fdbaf292063adcd080 Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Thu, 28 Mar 2024 17:14:50 +0000
Subject: [PATCH 28/63] [unit test] TxOrphanage::GetChildrenFrom*

---
 src/test/orphanage_tests.cpp | 147 ++++++++++++++++++++++++++++++++++-
 1 file changed, 145 insertions(+), 2 deletions(-)

diff --git a/src/test/orphanage_tests.cpp b/src/test/orphanage_tests.cpp
index 4231fcc909..b2643cf678 100644
--- a/src/test/orphanage_tests.cpp
+++ b/src/test/orphanage_tests.cpp
@@ -38,14 +38,56 @@ class TxOrphanageTest : public TxOrphanage
     }
 };
 
-static void MakeNewKeyWithFastRandomContext(CKey& key)
+static void MakeNewKeyWithFastRandomContext(CKey& key, FastRandomContext& rand_ctx = g_insecure_rand_ctx)
 {
     std::vector<unsigned char> keydata;
-    keydata = g_insecure_rand_ctx.randbytes(32);
+    keydata = rand_ctx.randbytes(32);
     key.Set(keydata.data(), keydata.data() + keydata.size(), /*fCompressedIn=*/true);
     assert(key.IsValid());
 }
 
+// Creates a transaction with 2 outputs. Spends all outpoints. If outpoints is empty, spends a random one.
+static CTransactionRef MakeTransactionSpending(const std::vector<COutPoint>& outpoints, FastRandomContext& det_rand)
+{
+    CKey key;
+    MakeNewKeyWithFastRandomContext(key, det_rand);
+    CMutableTransaction tx;
+    // If no outpoints are given, create a random one.
+    if (outpoints.empty()) {
+        tx.vin.emplace_back(Txid::FromUint256(det_rand.rand256()), 0);
+    } else {
+        for (const auto& outpoint : outpoints) {
+            tx.vin.emplace_back(outpoint);
+        }
+    }
+    // Ensure txid != wtxid
+    tx.vin[0].scriptWitness.stack.push_back({1});
+    tx.vout.resize(2);
+    tx.vout[0].nValue = CENT;
+    tx.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
+    tx.vout[1].nValue = 3 * CENT;
+    tx.vout[1].scriptPubKey = GetScriptForDestination(WitnessV0KeyHash(key.GetPubKey()));
+    return MakeTransactionRef(tx);
+}
+
+static bool EqualTxns(const std::set<CTransactionRef>& set_txns, const std::vector<CTransactionRef>& vec_txns)
+{
+    if (vec_txns.size() != set_txns.size()) return false;
+    for (const auto& tx : vec_txns) {
+        if (!set_txns.contains(tx)) return false;
+    }
+    return true;
+}
+static bool EqualTxns(const std::set<CTransactionRef>& set_txns,
+                      const std::vector<std::pair<CTransactionRef, NodeId>>& vec_txns)
+{
+    if (vec_txns.size() != set_txns.size()) return false;
+    for (const auto& [tx, nodeid] : vec_txns) {
+        if (!set_txns.contains(tx)) return false;
+    }
+    return true;
+}
+
 BOOST_AUTO_TEST_CASE(DoS_mapOrphans)
 {
     // This test had non-deterministic coverage due to
@@ -138,4 +180,105 @@ BOOST_AUTO_TEST_CASE(DoS_mapOrphans)
     BOOST_CHECK(orphanage.CountOrphans() == 0);
 }
 
+BOOST_AUTO_TEST_CASE(get_children)
+{
+    FastRandomContext det_rand{true};
+    std::vector<COutPoint> empty_outpoints;
+
+    auto parent1 = MakeTransactionSpending(empty_outpoints, det_rand);
+    auto parent2 = MakeTransactionSpending(empty_outpoints, det_rand);
+
+    // Make sure these parents have different txids otherwise this test won't make sense.
+    while (parent1->GetHash() == parent2->GetHash()) {
+        parent2 = MakeTransactionSpending(empty_outpoints, det_rand);
+    }
+
+    // Create children to go into orphanage.
+    auto child_p1n0 = MakeTransactionSpending({{parent1->GetHash(), 0}}, det_rand);
+    auto child_p2n1 = MakeTransactionSpending({{parent2->GetHash(), 1}}, det_rand);
+    // Spends the same tx twice. Should not cause duplicates.
+    auto child_p1n0_p1n1 = MakeTransactionSpending({{parent1->GetHash(), 0}, {parent1->GetHash(), 1}}, det_rand);
+    // Spends the same outpoint as previous tx. Should still be returned; don't assume outpoints are unique.
+    auto child_p1n0_p2n0 = MakeTransactionSpending({{parent1->GetHash(), 0}, {parent2->GetHash(), 0}}, det_rand);
+
+    const NodeId node1{1};
+    const NodeId node2{2};
+
+    // All orphans provided by node1
+    {
+        TxOrphanage orphanage;
+        BOOST_CHECK(orphanage.AddTx(child_p1n0, node1));
+        BOOST_CHECK(orphanage.AddTx(child_p2n1, node1));
+        BOOST_CHECK(orphanage.AddTx(child_p1n0_p1n1, node1));
+        BOOST_CHECK(orphanage.AddTx(child_p1n0_p2n0, node1));
+
+        std::set<CTransactionRef> expected_parent1_children{child_p1n0, child_p1n0_p2n0, child_p1n0_p1n1};
+        std::set<CTransactionRef> expected_parent2_children{child_p2n1, child_p1n0_p2n0};
+
+        BOOST_CHECK(EqualTxns(expected_parent1_children, orphanage.GetChildrenFromSamePeer(parent1, node1)));
+        BOOST_CHECK(EqualTxns(expected_parent2_children, orphanage.GetChildrenFromSamePeer(parent2, node1)));
+
+        BOOST_CHECK(EqualTxns(expected_parent1_children, orphanage.GetChildrenFromDifferentPeer(parent1, node2)));
+        BOOST_CHECK(EqualTxns(expected_parent2_children, orphanage.GetChildrenFromDifferentPeer(parent2, node2)));
+
+        // The peer must match
+        BOOST_CHECK(orphanage.GetChildrenFromSamePeer(parent1, node2).empty());
+        BOOST_CHECK(orphanage.GetChildrenFromSamePeer(parent2, node2).empty());
+
+        // There shouldn't be any children of this tx in the orphanage
+        BOOST_CHECK(orphanage.GetChildrenFromSamePeer(child_p1n0_p2n0, node1).empty());
+        BOOST_CHECK(orphanage.GetChildrenFromSamePeer(child_p1n0_p2n0, node2).empty());
+        BOOST_CHECK(orphanage.GetChildrenFromDifferentPeer(child_p1n0_p2n0, node1).empty());
+        BOOST_CHECK(orphanage.GetChildrenFromDifferentPeer(child_p1n0_p2n0, node2).empty());
+    }
+
+    // Orphans provided by node1 and node2
+    {
+        TxOrphanage orphanage;
+        BOOST_CHECK(orphanage.AddTx(child_p1n0, node1));
+        BOOST_CHECK(orphanage.AddTx(child_p2n1, node1));
+        BOOST_CHECK(orphanage.AddTx(child_p1n0_p1n1, node2));
+        BOOST_CHECK(orphanage.AddTx(child_p1n0_p2n0, node2));
+
+        // +----------------+---------------+----------------------------------+
+        // |                | sender=node1  |           sender=node2           |
+        // +----------------+---------------+----------------------------------+
+        // | spends parent1 | child_p1n0    | child_p1n0_p1n1, child_p1n0_p2n0 |
+        // | spends parent2 | child_p2n1    | child_p1n0_p2n0                  |
+        // +----------------+---------------+----------------------------------+
+
+        // Children of parent1 from node1:
+        {
+            std::set<CTransactionRef> expected_parent1_node1{child_p1n0};
+
+            BOOST_CHECK(EqualTxns(expected_parent1_node1, orphanage.GetChildrenFromSamePeer(parent1, node1)));
+            BOOST_CHECK(EqualTxns(expected_parent1_node1, orphanage.GetChildrenFromDifferentPeer(parent1, node2)));
+        }
+
+        // Children of parent2 from node1:
+        {
+            std::set<CTransactionRef> expected_parent2_node1{child_p2n1};
+
+            BOOST_CHECK(EqualTxns(expected_parent2_node1, orphanage.GetChildrenFromSamePeer(parent2, node1)));
+            BOOST_CHECK(EqualTxns(expected_parent2_node1, orphanage.GetChildrenFromDifferentPeer(parent2, node2)));
+        }
+
+        // Children of parent1 from node2:
+        {
+            std::set<CTransactionRef> expected_parent1_node2{child_p1n0_p1n1, child_p1n0_p2n0};
+
+            BOOST_CHECK(EqualTxns(expected_parent1_node2, orphanage.GetChildrenFromSamePeer(parent1, node2)));
+            BOOST_CHECK(EqualTxns(expected_parent1_node2, orphanage.GetChildrenFromDifferentPeer(parent1, node1)));
+        }
+
+        // Children of parent2 from node2:
+        {
+            std::set<CTransactionRef> expected_parent2_node2{child_p1n0_p2n0};
+
+            BOOST_CHECK(EqualTxns(expected_parent2_node2, orphanage.GetChildrenFromSamePeer(parent2, node2)));
+            BOOST_CHECK(EqualTxns(expected_parent2_node2, orphanage.GetChildrenFromDifferentPeer(parent2, node1)));
+        }
+    }
+}
+
 BOOST_AUTO_TEST_SUITE_END()

From 410ebd6efaf20fe4715c9b825103b74db69f35ac Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Thu, 28 Mar 2024 17:15:11 +0000
Subject: [PATCH 29/63] [fuzz] break out parent functions and add
 GetChildrenFrom* coverage

It's very hard to randomly construct a transaction that would be the
parent of an existing orphanage tx. For functions like
AddChildrenToWorkSet and GetChildren that take orphan parents, use a tx
that was previously constructed.
---
 src/test/fuzz/txorphan.cpp | 32 +++++++++++++++++++++++++++++---
 1 file changed, 29 insertions(+), 3 deletions(-)

diff --git a/src/test/fuzz/txorphan.cpp b/src/test/fuzz/txorphan.cpp
index 5423ba8920..a44f47b00d 100644
--- a/src/test/fuzz/txorphan.cpp
+++ b/src/test/fuzz/txorphan.cpp
@@ -45,6 +45,8 @@ FUZZ_TARGET(txorphan, .init = initialize_orphanage)
     // if true, allow duplicate input when constructing tx
     const bool duplicate_input = fuzzed_data_provider.ConsumeBool();
 
+    CTransactionRef ptx_potential_parent = nullptr;
+
     LIMITED_WHILE(outpoints.size() < 200'000 && fuzzed_data_provider.ConsumeBool(), 10 * DEFAULT_MAX_ORPHAN_TRANSACTIONS)
     {
         // construct transaction
@@ -78,6 +80,27 @@ FUZZ_TARGET(txorphan, .init = initialize_orphanage)
             return new_tx;
         }();
 
+        // Trigger orphanage functions that are called using parents. ptx_potential_parent is a tx we constructed in a
+        // previous loop and potentially the parent of this tx.
+        if (ptx_potential_parent) {
+            // Set up future GetTxToReconsider call.
+            orphanage.AddChildrenToWorkSet(*ptx_potential_parent);
+
+            // Check that all txns returned from GetChildrenFrom* are indeed a direct child of this tx.
+            NodeId peer_id = fuzzed_data_provider.ConsumeIntegral<NodeId>();
+            for (const auto& child : orphanage.GetChildrenFromSamePeer(ptx_potential_parent, peer_id)) {
+                assert(std::any_of(child->vin.cbegin(), child->vin.cend(), [&](const auto& input) {
+                    return input.prevout.hash == ptx_potential_parent->GetHash();
+                }));
+            }
+            for (const auto& [child, peer] : orphanage.GetChildrenFromDifferentPeer(ptx_potential_parent, peer_id)) {
+                assert(std::any_of(child->vin.cbegin(), child->vin.cend(), [&](const auto& input) {
+                    return input.prevout.hash == ptx_potential_parent->GetHash();
+                }));
+                assert(peer != peer_id);
+            }
+        }
+
         // trigger orphanage functions
         LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10 * DEFAULT_MAX_ORPHAN_TRANSACTIONS)
         {
@@ -85,9 +108,6 @@ FUZZ_TARGET(txorphan, .init = initialize_orphanage)
 
             CallOneOf(
                 fuzzed_data_provider,
-                [&] {
-                    orphanage.AddChildrenToWorkSet(*tx);
-                },
                 [&] {
                     {
                         CTransactionRef ref = orphanage.GetTxToReconsider(peer_id);
@@ -136,6 +156,12 @@ FUZZ_TARGET(txorphan, .init = initialize_orphanage)
                     orphanage.LimitOrphans(limit, limit_orphans_rng);
                     Assert(orphanage.Size() <= limit);
                 });
+
+        }
+        // Set tx as potential parent to be used for future GetChildren() calls.
+        if (!ptx_potential_parent || fuzzed_data_provider.ConsumeBool()) {
+            ptx_potential_parent = tx;
         }
+
     }
 }

From 6c51e1d7d021ed6523107a6db87a865aaa8fc4c9 Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Thu, 9 Nov 2023 14:50:33 +0000
Subject: [PATCH 30/63] [p2p] add separate rejections cache for reconsiderable
 txns

---
 src/net_processing.cpp | 59 ++++++++++++++++++++++++++++++++++++------
 1 file changed, 51 insertions(+), 8 deletions(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 577ed5cd3f..37d9e169e1 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -586,7 +586,7 @@ class PeerManagerImpl final : public PeerManager
      * @param[in]   maybe_add_extra_compact_tx    Whether this tx should be added to vExtraTxnForCompact.
      *                                            Set to false if the tx has already been rejected before,
      *                                            e.g. is an orphan, to avoid adding duplicate entries.
-     * Updates m_txrequest, m_recent_rejects, m_orphanage, and vExtraTxnForCompact. */
+     * Updates m_txrequest, m_recent_rejects, m_recent_rejects_reconsiderable, m_orphanage, and vExtraTxnForCompact. */
     void ProcessInvalidTx(NodeId nodeid, const CTransactionRef& tx, const TxValidationState& result,
                           bool maybe_add_extra_compact_tx)
         EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, g_msgproc_mutex, cs_main);
@@ -806,7 +806,16 @@ class PeerManagerImpl final : public PeerManager
     /** Stalling timeout for blocks in IBD */
     std::atomic<std::chrono::seconds> m_block_stalling_timeout{BLOCK_STALLING_TIMEOUT_DEFAULT};
 
-    bool AlreadyHaveTx(const GenTxid& gtxid)
+    /** Check whether we already have this gtxid in:
+     *  - mempool
+     *  - orphanage
+     *  - m_recent_rejects
+     *  - m_recent_rejects_reconsiderable (if include_reconsiderable = true)
+     *  - m_recent_confirmed_transactions
+     * Also responsible for resetting m_recent_rejects and m_recent_rejects_reconsiderable if the
+     * chain tip has changed.
+     *  */
+    bool AlreadyHaveTx(const GenTxid& gtxid, bool include_reconsiderable)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main, !m_recent_confirmed_transactions_mutex);
 
     /**
@@ -844,8 +853,32 @@ class PeerManagerImpl final : public PeerManager
      * Memory used: 1.3 MB
      */
     CRollingBloomFilter m_recent_rejects GUARDED_BY(::cs_main){120'000, 0.000'001};
+    /** Block hash of chain tip the last time we reset m_recent_rejects and
+     * m_recent_rejects_reconsiderable. */
     uint256 hashRecentRejectsChainTip GUARDED_BY(cs_main);
 
+    /**
+     * Filter for:
+     * (1) wtxids of transactions that were recently rejected by the mempool but are
+     * eligible for reconsideration if submitted with other transactions.
+     * (2) packages (see GetPackageHash) we have already rejected before and should not retry.
+     *
+     * Similar to m_recent_rejects, this filter is used to save bandwidth when e.g. all of our peers
+     * have larger mempools and thus lower minimum feerates than us.
+     *
+     * When a transaction's error is TxValidationResult::TX_RECONSIDERABLE (in a package or by
+     * itself), add its wtxid to this filter. When a package fails for any reason, add the combined
+     * hash to this filter.
+     *
+     * Upon receiving an announcement for a transaction, if it exists in this filter, do not
+     * download the txdata. When considering packages, if it exists in this filter, drop it.
+     *
+     * Reset this filter when the chain tip changes.
+     *
+     * Parameters are picked to be the same as m_recent_rejects, with the same rationale.
+     */
+    CRollingBloomFilter m_recent_rejects_reconsiderable GUARDED_BY(::cs_main){120'000, 0.000'001};
+
     /*
      * Filter for transactions that have been recently confirmed.
      * We use this to avoid requesting transactions that have already been
@@ -2194,7 +2227,7 @@ void PeerManagerImpl::BlockChecked(const CBlock& block, const BlockValidationSta
 //
 
 
-bool PeerManagerImpl::AlreadyHaveTx(const GenTxid& gtxid)
+bool PeerManagerImpl::AlreadyHaveTx(const GenTxid& gtxid, bool include_reconsiderable)
 {
     if (m_chainman.ActiveChain().Tip()->GetBlockHash() != hashRecentRejectsChainTip) {
         // If the chain tip has changed previously rejected transactions
@@ -2203,12 +2236,15 @@ bool PeerManagerImpl::AlreadyHaveTx(const GenTxid& gtxid)
         // txs a second chance.
         hashRecentRejectsChainTip = m_chainman.ActiveChain().Tip()->GetBlockHash();
         m_recent_rejects.reset();
+        m_recent_rejects_reconsiderable.reset();
     }
 
     const uint256& hash = gtxid.GetHash();
 
     if (m_orphanage.HaveTx(gtxid)) return true;
 
+    if (include_reconsiderable && m_recent_rejects_reconsiderable.contains(hash)) return true;
+
     {
         LOCK(m_recent_confirmed_transactions_mutex);
         if (m_recent_confirmed_transactions.contains(hash)) return true;
@@ -3097,7 +3133,14 @@ void PeerManagerImpl::ProcessInvalidTx(NodeId nodeid, const CTransactionRef& ptx
         // See also comments in https://github.com/bitcoin/bitcoin/pull/18044#discussion_r443419034
         // for concerns around weakening security of unupgraded nodes
         // if we start doing this too early.
-        m_recent_rejects.insert(ptx->GetWitnessHash().ToUint256());
+        if (state.GetResult() == TxValidationResult::TX_RECONSIDERABLE) {
+            // If the result is TX_RECONSIDERABLE, add it to m_recent_rejects_reconsiderable
+            // because we should not download or submit this transaction by itself again, but may
+            // submit it as part of a package later.
+            m_recent_rejects_reconsiderable.insert(ptx->GetWitnessHash().ToUint256());
+        } else {
+            m_recent_rejects.insert(ptx->GetWitnessHash().ToUint256());
+        }
         m_txrequest.ForgetTxHash(ptx->GetWitnessHash());
         // If the transaction failed for TX_INPUTS_NOT_STANDARD,
         // then we know that the witness was irrelevant to the policy
@@ -4015,7 +4058,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
                     return;
                 }
                 const GenTxid gtxid = ToGenTxid(inv);
-                const bool fAlreadyHave = AlreadyHaveTx(gtxid);
+                const bool fAlreadyHave = AlreadyHaveTx(gtxid, /*include_reconsiderable=*/true);
                 LogPrint(BCLog::NET, "got inv: %s  %s peer=%d\n", inv.ToString(), fAlreadyHave ? "have" : "new", pfrom.GetId());
 
                 AddKnownTx(*peer, inv.hash);
@@ -4320,7 +4363,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
         // already; and an adversary can already relay us old transactions
         // (older than our recency filter) if trying to DoS us, without any need
         // for witness malleation.
-        if (AlreadyHaveTx(GenTxid::Wtxid(wtxid))) {
+        if (AlreadyHaveTx(GenTxid::Wtxid(wtxid), /*include_reconsiderable=*/true)) {
             if (pfrom.HasPermission(NetPermissionFlags::ForceRelay)) {
                 // Always relay transactions received from peers with forcerelay
                 // permission, even if they were already in the mempool, allowing
@@ -4392,7 +4435,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
                     // protocol for getting all unconfirmed parents.
                     const auto gtxid{GenTxid::Txid(parent_txid)};
                     AddKnownTx(*peer, parent_txid);
-                    if (!AlreadyHaveTx(gtxid)) AddTxAnnouncement(pfrom, gtxid, current_time);
+                    if (!AlreadyHaveTx(gtxid, /*include_reconsiderable=*/true)) AddTxAnnouncement(pfrom, gtxid, current_time);
                 }
 
                 if (m_orphanage.AddTx(ptx, pfrom.GetId())) {
@@ -6033,7 +6076,7 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                 entry.second.GetHash().ToString(), entry.first);
         }
         for (const GenTxid& gtxid : requestable) {
-            if (!AlreadyHaveTx(gtxid)) {
+            if (!AlreadyHaveTx(gtxid, /*include_reconsiderable=*/true)) {
                 LogPrint(BCLog::NET, "Requesting %s %s peer=%d\n", gtxid.IsWtxid() ? "wtx" : "tx",
                     gtxid.GetHash().ToString(), pto->GetId());
                 vGetData.emplace_back(gtxid.IsWtxid() ? MSG_WTX : (MSG_TX | GetFetchFlags(*peer)), gtxid.GetHash());

From 87c5c524d63c833cf490c7f2f73d72695ad480df Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Fri, 8 Mar 2024 13:15:47 +0000
Subject: [PATCH 31/63] [p2p] opportunistically accept 1-parent-1-child
 packages

---
 src/net_processing.cpp | 198 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 196 insertions(+), 2 deletions(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 37d9e169e1..da4f99fb99 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -596,6 +596,45 @@ class PeerManagerImpl final : public PeerManager
     void ProcessValidTx(NodeId nodeid, const CTransactionRef& tx, const std::list<CTransactionRef>& replaced_transactions)
         EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, g_msgproc_mutex, cs_main);
 
+    /** Handle the results of package validation: calls ProcessValidTx and ProcessInvalidTx for
+     * individual transactions, and caches rejection for the package as a group.
+     * @param[in]   senders     Must contain the nodeids of the peers that provided each transaction
+     *                          in package, in the same order.
+     *   */
+    void ProcessPackageResult(const Package& package, const PackageMempoolAcceptResult& package_result, const std::vector<NodeId>& senders)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, g_msgproc_mutex, cs_main);
+
+    /** A package to validate  */
+    struct PackageToValidate {
+        const Package m_txns;
+        const std::vector<NodeId> m_senders;
+        /** Construct a 1-parent-1-child package. */
+        explicit PackageToValidate(const CTransactionRef& parent,
+                                   const CTransactionRef& child,
+                                   NodeId parent_sender,
+                                   NodeId child_sender) :
+            m_txns{parent, child},
+            m_senders {parent_sender, child_sender}
+        {}
+
+        std::string ToString() const {
+            Assume(m_txns.size() == 2);
+            return strprintf("parent %s (wtxid=%s, sender=%d) + child %s (wtxid=%s, sender=%d)",
+                             m_txns.front()->GetHash().ToString(),
+                             m_txns.front()->GetWitnessHash().ToString(),
+                             m_senders.front(),
+                             m_txns.back()->GetHash().ToString(),
+                             m_txns.back()->GetWitnessHash().ToString(),
+                             m_senders.back());
+        }
+    };
+
+    /** Look for a child of this transaction in the orphanage to form a 1-parent-1-child package,
+     * skipping any combinations that have already been tried. Return the resulting package along with
+     * the senders of its respective transactions, or std::nullopt if no package is found. */
+    std::optional<PackageToValidate> Find1P1CPackage(const CTransactionRef& ptx, NodeId nodeid)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, g_msgproc_mutex, cs_main);
+
     /**
      * Reconsider orphan transactions after a parent has been accepted to the mempool.
      *
@@ -3198,6 +3237,117 @@ void PeerManagerImpl::ProcessValidTx(NodeId nodeid, const CTransactionRef& tx, c
     }
 }
 
+void PeerManagerImpl::ProcessPackageResult(const Package& package, const PackageMempoolAcceptResult& package_result, const std::vector<NodeId>& senders)
+{
+    AssertLockNotHeld(m_peer_mutex);
+    AssertLockHeld(g_msgproc_mutex);
+    AssertLockHeld(cs_main);
+
+    if (package_result.m_state.IsInvalid()) {
+        m_recent_rejects_reconsiderable.insert(GetPackageHash(package));
+    }
+    // We currently only expect to process 1-parent-1-child packages. Remove if this changes.
+    if (!Assume(package.size() == 2)) return;
+
+    // No package results to look through for PCKG_POLICY or PCKG_MEMPOOL_ERROR
+    if (package_result.m_state.GetResult() == PackageValidationResult::PCKG_POLICY ||
+        package_result.m_state.GetResult() == PackageValidationResult::PCKG_MEMPOOL_ERROR) return;
+
+    // Iterate backwards to erase in-package descendants from the orphanage before they become
+    // relevant in AddChildrenToWorkSet.
+    auto package_iter = package.rbegin();
+    auto senders_iter = senders.rbegin();
+    while (package_iter != package.rend()) {
+        const auto& tx = *package_iter;
+        const NodeId nodeid = *senders_iter;
+        const auto it_result{package_result.m_tx_results.find(tx->GetWitnessHash())};
+        if (Assume(it_result != package_result.m_tx_results.end())) {
+            const auto& tx_result = it_result->second;
+            switch (tx_result.m_result_type) {
+                case MempoolAcceptResult::ResultType::VALID:
+                {
+                    Assume(tx_result.m_replaced_transactions.has_value());
+                    std::list<CTransactionRef> empty_replacement_list;
+                    ProcessValidTx(nodeid, tx, tx_result.m_replaced_transactions.value_or(empty_replacement_list));
+                    break;
+                }
+                case MempoolAcceptResult::ResultType::INVALID:
+                case MempoolAcceptResult::ResultType::DIFFERENT_WITNESS:
+                {
+                    // Don't add to vExtraTxnForCompact, as these transactions should have already been
+                    // added there when added to the orphanage or rejected for TX_RECONSIDERABLE.
+                    // This should be updated if package submission is ever used for transactions
+                    // that haven't already been validated before.
+                    ProcessInvalidTx(nodeid, tx, tx_result.m_state, /*maybe_add_extra_compact_tx=*/false);
+                    break;
+                }
+                case MempoolAcceptResult::ResultType::MEMPOOL_ENTRY:
+                {
+                    // AlreadyHaveTx() should be catching transactions that are already in mempool.
+                    Assume(false);
+                    break;
+                }
+            }
+        }
+        package_iter++;
+        senders_iter++;
+    }
+}
+
+std::optional<PeerManagerImpl::PackageToValidate> PeerManagerImpl::Find1P1CPackage(const CTransactionRef& ptx, NodeId nodeid)
+{
+    AssertLockNotHeld(m_peer_mutex);
+    AssertLockHeld(g_msgproc_mutex);
+    AssertLockHeld(cs_main);
+
+    const auto& parent_wtxid{ptx->GetWitnessHash()};
+
+    Assume(m_recent_rejects_reconsiderable.contains(parent_wtxid.ToUint256()));
+
+    // Prefer children from this peer. This helps prevent censorship attempts in which an attacker
+    // sends lots of fake children for the parent, and we (unluckily) keep selecting the fake
+    // children instead of the real one provided by the honest peer.
+    const auto cpfp_candidates_same_peer{m_orphanage.GetChildrenFromSamePeer(ptx, nodeid)};
+
+    // These children should be sorted from newest to oldest. In the (probably uncommon) case
+    // of children that replace each other, this helps us accept the highest feerate (probably the
+    // most recent) one efficiently.
+    for (const auto& child : cpfp_candidates_same_peer) {
+        Package maybe_cpfp_package{ptx, child};
+        if (!m_recent_rejects_reconsiderable.contains(GetPackageHash(maybe_cpfp_package))) {
+            return PeerManagerImpl::PackageToValidate{ptx, child, nodeid, nodeid};
+        }
+    }
+
+    // If no suitable candidate from the same peer is found, also try children that were provided by
+    // a different peer. This is useful because sometimes multiple peers announce both transactions
+    // to us, and we happen to download them from different peers (we wouldn't have known that these
+    // 2 transactions are related). We still want to find 1p1c packages then.
+    //
+    // If we start tracking all announcers of orphans, we can restrict this logic to parent + child
+    // pairs in which both were provided by the same peer, i.e. delete this step.
+    const auto cpfp_candidates_different_peer{m_orphanage.GetChildrenFromDifferentPeer(ptx, nodeid)};
+
+    // Find the first 1p1c that hasn't already been rejected. We randomize the order to not
+    // create a bias that attackers can use to delay package acceptance.
+    //
+    // Create a random permutation of the indices.
+    std::vector<size_t> tx_indices(cpfp_candidates_different_peer.size());
+    std::iota(tx_indices.begin(), tx_indices.end(), 0);
+    Shuffle(tx_indices.begin(), tx_indices.end(), m_rng);
+
+    for (const auto index : tx_indices) {
+        // If we already tried a package and failed for any reason, the combined hash was
+        // cached in m_recent_rejects_reconsiderable.
+        const auto [child_tx, child_sender] = cpfp_candidates_different_peer.at(index);
+        Package maybe_cpfp_package{ptx, child_tx};
+        if (!m_recent_rejects_reconsiderable.contains(GetPackageHash(maybe_cpfp_package))) {
+            return PeerManagerImpl::PackageToValidate{ptx, child_tx, nodeid, child_sender};
+        }
+    }
+    return std::nullopt;
+}
+
 bool PeerManagerImpl::ProcessOrphanTx(Peer& peer)
 {
     AssertLockHeld(g_msgproc_mutex);
@@ -4377,6 +4527,20 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
                     RelayTransaction(tx.GetHash(), tx.GetWitnessHash());
                 }
             }
+
+            if (m_recent_rejects_reconsiderable.contains(wtxid)) {
+                // When a transaction is already in m_recent_rejects_reconsiderable, we shouldn't submit
+                // it by itself again. However, look for a matching child in the orphanage, as it is
+                // possible that they succeed as a package.
+                LogPrint(BCLog::TXPACKAGES, "found tx %s (wtxid=%s) in reconsiderable rejects, looking for child in orphanage\n",
+                         txid.ToString(), wtxid.ToString());
+                if (auto package_to_validate{Find1P1CPackage(ptx, pfrom.GetId())}) {
+                    const auto package_result{ProcessNewPackage(m_chainman.ActiveChainstate(), m_mempool, package_to_validate->m_txns, /*test_accept=*/false, /*client_maxfeerate=*/std::nullopt)};
+                    LogDebug(BCLog::TXPACKAGES, "package evaluation for %s: %s\n", package_to_validate->ToString(),
+                             package_result.m_state.IsValid() ? "package accepted" : "package rejected");
+                    ProcessPackageResult(package_to_validate->m_txns, package_result, package_to_validate->m_senders);
+                }
+            }
             // If a tx is detected by m_recent_rejects it is ignored. Because we haven't
             // submitted the tx to our mempool, we won't have computed a DoS
             // score for it or determined exactly why we consider it invalid.
@@ -4418,10 +4582,23 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
             }
             std::sort(unique_parents.begin(), unique_parents.end());
             unique_parents.erase(std::unique(unique_parents.begin(), unique_parents.end()), unique_parents.end());
+
+            // Distinguish between parents in m_recent_rejects and m_recent_rejects_reconsiderable.
+            // We can tolerate having up to 1 parent in m_recent_rejects_reconsiderable since we
+            // submit 1p1c packages. However, fail immediately if any are in m_recent_rejects.
+            std::optional<uint256> rejected_parent_reconsiderable;
             for (const uint256& parent_txid : unique_parents) {
                 if (m_recent_rejects.contains(parent_txid)) {
                     fRejectedParents = true;
                     break;
+                } else if (m_recent_rejects_reconsiderable.contains(parent_txid) && !m_mempool.exists(GenTxid::Txid(parent_txid))) {
+                    // More than 1 parent in m_recent_rejects_reconsiderable: 1p1c will not be
+                    // sufficient to accept this package, so just give up here.
+                    if (rejected_parent_reconsiderable.has_value()) {
+                        fRejectedParents = true;
+                        break;
+                    }
+                    rejected_parent_reconsiderable = parent_txid;
                 }
             }
             if (!fRejectedParents) {
@@ -4435,7 +4612,9 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
                     // protocol for getting all unconfirmed parents.
                     const auto gtxid{GenTxid::Txid(parent_txid)};
                     AddKnownTx(*peer, parent_txid);
-                    if (!AlreadyHaveTx(gtxid, /*include_reconsiderable=*/true)) AddTxAnnouncement(pfrom, gtxid, current_time);
+                    // Exclude m_recent_rejects_reconsiderable: the missing parent may have been
+                    // previously rejected for being too low feerate. This orphan might CPFP it.
+                    if (!AlreadyHaveTx(gtxid, /*include_reconsiderable=*/false)) AddTxAnnouncement(pfrom, gtxid, current_time);
                 }
 
                 if (m_orphanage.AddTx(ptx, pfrom.GetId())) {
@@ -4467,6 +4646,19 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
         if (state.IsInvalid()) {
             ProcessInvalidTx(pfrom.GetId(), ptx, state, /*maybe_add_extra_compact_tx=*/true);
         }
+        // When a transaction fails for TX_RECONSIDERABLE, look for a matching child in the
+        // orphanage, as it is possible that they succeed as a package.
+        if (state.GetResult() == TxValidationResult::TX_RECONSIDERABLE) {
+            LogPrint(BCLog::TXPACKAGES, "tx %s (wtxid=%s) failed but reconsiderable, looking for child in orphanage\n",
+                     txid.ToString(), wtxid.ToString());
+            if (auto package_to_validate{Find1P1CPackage(ptx, pfrom.GetId())}) {
+                const auto package_result{ProcessNewPackage(m_chainman.ActiveChainstate(), m_mempool, package_to_validate->m_txns, /*test_accept=*/false, /*client_maxfeerate=*/std::nullopt)};
+                LogDebug(BCLog::TXPACKAGES, "package evaluation for %s: %s\n", package_to_validate->ToString(),
+                         package_result.m_state.IsValid() ? "package accepted" : "package rejected");
+                ProcessPackageResult(package_to_validate->m_txns, package_result, package_to_validate->m_senders);
+            }
+        }
+
         return;
     }
 
@@ -6076,7 +6268,9 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                 entry.second.GetHash().ToString(), entry.first);
         }
         for (const GenTxid& gtxid : requestable) {
-            if (!AlreadyHaveTx(gtxid, /*include_reconsiderable=*/true)) {
+            // Exclude m_recent_rejects_reconsiderable: we may be requesting a missing parent
+            // that was previously rejected for being too low feerate.
+            if (!AlreadyHaveTx(gtxid, /*include_reconsiderable=*/false)) {
                 LogPrint(BCLog::NET, "Requesting %s %s peer=%d\n", gtxid.IsWtxid() ? "wtx" : "tx",
                     gtxid.GetHash().ToString(), pto->GetId());
                 vGetData.emplace_back(gtxid.IsWtxid() ? MSG_WTX : (MSG_TX | GetFetchFlags(*peer)), gtxid.GetHash());

From e518a8bf8abf3d7b83c9013f56d0dca18ae04d6f Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Mon, 3 Oct 2022 16:30:42 +0100
Subject: [PATCH 32/63] [functional test] opportunistic 1p1c package submission

---
 test/functional/p2p_1p1c_network.py       | 165 +++++++++
 test/functional/p2p_opportunistic_1p1c.py | 414 ++++++++++++++++++++++
 test/functional/test_runner.py            |   2 +
 3 files changed, 581 insertions(+)
 create mode 100755 test/functional/p2p_1p1c_network.py
 create mode 100755 test/functional/p2p_opportunistic_1p1c.py

diff --git a/test/functional/p2p_1p1c_network.py b/test/functional/p2p_1p1c_network.py
new file mode 100755
index 0000000000..e88c826962
--- /dev/null
+++ b/test/functional/p2p_1p1c_network.py
@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+# Copyright (c) 2024-present The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""
+Test that 1p1c package submission allows a 1p1c package to propagate in a "network" of nodes. Send
+various packages from different nodes on a network in which some nodes have already received some of
+the transactions (and submitted them to mempool, kept them as orphans or rejected them as
+too-low-feerate transactions). The packages should be received and accepted by all nodes.
+"""
+
+from decimal import Decimal
+from math import ceil
+
+from test_framework.messages import (
+    msg_tx,
+)
+from test_framework.p2p import (
+    P2PInterface,
+)
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+    assert_greater_than,
+    fill_mempool,
+)
+from test_framework.wallet import (
+    MiniWallet,
+    MiniWalletMode,
+)
+
+# 1sat/vB feerate denominated in BTC/KvB
+FEERATE_1SAT_VB = Decimal("0.00001000")
+
+class PackageRelayTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.setup_clean_chain = True
+        self.num_nodes = 4
+        # hugely speeds up the test, as it involves multiple hops of tx relay.
+        self.noban_tx_relay = True
+        self.extra_args = [[
+            "-datacarriersize=100000",
+            "-maxmempool=5",
+        ]] * self.num_nodes
+        self.supports_cli = False
+
+    def raise_network_minfee(self):
+        filler_wallet = MiniWallet(self.nodes[0])
+        fill_mempool(self, self.nodes[0], filler_wallet)
+
+        self.log.debug("Wait for the network to sync mempools")
+        self.sync_mempools()
+
+        self.log.debug("Check that all nodes' mempool minimum feerates are above min relay feerate")
+        for node in self.nodes:
+            assert_equal(node.getmempoolinfo()['minrelaytxfee'], FEERATE_1SAT_VB)
+            assert_greater_than(node.getmempoolinfo()['mempoolminfee'], FEERATE_1SAT_VB)
+
+    def create_basic_1p1c(self, wallet):
+        low_fee_parent = wallet.create_self_transfer(fee_rate=FEERATE_1SAT_VB, confirmed_only=True)
+        high_fee_child = wallet.create_self_transfer(utxo_to_spend=low_fee_parent["new_utxo"], fee_rate=999*FEERATE_1SAT_VB)
+        package_hex_basic = [low_fee_parent["hex"], high_fee_child["hex"]]
+        return package_hex_basic, low_fee_parent["tx"], high_fee_child["tx"]
+
+    def create_package_2outs(self, wallet):
+        # First create a tester tx to see the vsize, and then adjust the fees
+        utxo_for_2outs = wallet.get_utxo(confirmed_only=True)
+
+        low_fee_parent_2outs_tester = wallet.create_self_transfer_multi(
+            utxos_to_spend=[utxo_for_2outs],
+            num_outputs=2,
+        )
+
+        # Target 1sat/vB so the number of satoshis is equal to the vsize.
+        # Round up. The goal is to be between min relay feerate and mempool min feerate.
+        fee_2outs = ceil(low_fee_parent_2outs_tester["tx"].get_vsize() / 2)
+
+        low_fee_parent_2outs = wallet.create_self_transfer_multi(
+            utxos_to_spend=[utxo_for_2outs],
+            num_outputs=2,
+            fee_per_output=fee_2outs,
+        )
+
+        # Now create the child
+        high_fee_child_2outs = wallet.create_self_transfer_multi(
+            utxos_to_spend=low_fee_parent_2outs["new_utxos"][::-1],
+            fee_per_output=fee_2outs*100,
+        )
+        return [low_fee_parent_2outs["hex"], high_fee_child_2outs["hex"]], low_fee_parent_2outs["tx"], high_fee_child_2outs["tx"]
+
+    def create_package_2p1c(self, wallet):
+        parent1 = wallet.create_self_transfer(fee_rate=FEERATE_1SAT_VB*10, confirmed_only=True)
+        parent2 = wallet.create_self_transfer(fee_rate=FEERATE_1SAT_VB*20, confirmed_only=True)
+        child = wallet.create_self_transfer_multi(
+            utxos_to_spend=[parent1["new_utxo"], parent2["new_utxo"]],
+            fee_per_output=999*parent1["tx"].get_vsize(),
+        )
+        return [parent1["hex"], parent2["hex"], child["hex"]], parent1["tx"], parent2["tx"], child["tx"]
+
+    def create_packages(self):
+        # 1: Basic 1-parent-1-child package, parent 1sat/vB, child 999sat/vB
+        package_hex_1, parent_1, child_1 = self.create_basic_1p1c(self.wallet)
+
+        # 2: same as 1, parent's txid is the same as its wtxid.
+        package_hex_2, parent_2, child_2 = self.create_basic_1p1c(self.wallet_nonsegwit)
+
+        # 3: 2-parent-1-child package. Both parents are above mempool min feerate. No package submission happens.
+        # We require packages to be child-with-unconfirmed-parents and only allow 1-parent-1-child packages.
+        package_hex_3, parent_31, parent_32, child_3 = self.create_package_2p1c(self.wallet)
+
+        # 4: parent + child package where the child spends 2 different outputs from the parent.
+        package_hex_4, parent_4, child_4 = self.create_package_2outs(self.wallet)
+
+        # Assemble return results
+        packages_to_submit = [package_hex_1, package_hex_2, package_hex_3, package_hex_4]
+        # node0: sender
+        # node1: pre-received the children (orphan)
+        # node3: pre-received the parents (too low fee)
+        # All nodes receive parent_31 ahead of time.
+        txns_to_send = [
+            [],
+            [child_1, child_2, parent_31, child_3, child_4],
+            [parent_31],
+            [parent_1, parent_2, parent_31, parent_4]
+        ]
+
+        return packages_to_submit, txns_to_send
+
+    def run_test(self):
+        self.wallet = MiniWallet(self.nodes[1])
+        self.wallet_nonsegwit = MiniWallet(self.nodes[2], mode=MiniWalletMode.RAW_P2PK)
+        self.generate(self.wallet_nonsegwit, 10)
+        self.generate(self.wallet, 120)
+
+        self.log.info("Fill mempools with large transactions to raise mempool minimum feerates")
+        self.raise_network_minfee()
+
+        # Create the transactions.
+        self.wallet.rescan_utxos(include_mempool=True)
+        packages_to_submit, transactions_to_presend = self.create_packages()
+
+        self.peers = [self.nodes[i].add_p2p_connection(P2PInterface()) for i in range(self.num_nodes)]
+
+        self.log.info("Pre-send some transactions to nodes")
+        for (i, peer) in enumerate(self.peers):
+            for tx in transactions_to_presend[i]:
+                peer.send_and_ping(msg_tx(tx))
+            # This disconnect removes any sent orphans from the orphanage (EraseForPeer) and times
+            # out the in-flight requests.  It is currently required for the test to pass right now,
+            # because the node will not reconsider an orphan tx and will not (re)try requesting
+            # orphan parents from multiple peers if the first one didn't respond.
+            # TODO: remove this in the future if the node tries orphan resolution with multiple peers.
+            peer.peer_disconnect()
+
+        self.log.info("Submit full packages to node0")
+        for package_hex in packages_to_submit:
+            submitpackage_result = self.nodes[0].submitpackage(package_hex)
+            assert_equal(submitpackage_result["package_msg"], "success")
+
+        self.log.info("Wait for mempools to sync")
+        self.sync_mempools(timeout=20)
+
+
+if __name__ == '__main__':
+    PackageRelayTest().main()
diff --git a/test/functional/p2p_opportunistic_1p1c.py b/test/functional/p2p_opportunistic_1p1c.py
new file mode 100755
index 0000000000..e07acd5481
--- /dev/null
+++ b/test/functional/p2p_opportunistic_1p1c.py
@@ -0,0 +1,414 @@
+#!/usr/bin/env python3
+# Copyright (c) 2024-present The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""
+Test opportunistic 1p1c package submission logic.
+"""
+
+from decimal import Decimal
+import time
+from test_framework.messages import (
+    CInv,
+    CTxInWitness,
+    MAX_BIP125_RBF_SEQUENCE,
+    MSG_WTX,
+    msg_inv,
+    msg_tx,
+    tx_from_hex,
+)
+from test_framework.p2p import (
+    P2PInterface,
+)
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+    assert_greater_than,
+    fill_mempool,
+)
+from test_framework.wallet import (
+    MiniWallet,
+    MiniWalletMode,
+)
+
+# 1sat/vB feerate denominated in BTC/KvB
+FEERATE_1SAT_VB = Decimal("0.00001000")
+# Number of seconds to wait to ensure no getdata is received
+GETDATA_WAIT = 60
+
+def cleanup(func):
+    def wrapper(self, *args, **kwargs):
+        try:
+            func(self, *args, **kwargs)
+        finally:
+            self.nodes[0].disconnect_p2ps()
+            # Do not clear the node's mempool, as each test requires mempool min feerate > min
+            # relay feerate. However, do check that this is the case.
+            assert self.nodes[0].getmempoolinfo()["mempoolminfee"] > self.nodes[0].getnetworkinfo()["relayfee"]
+            # Ensure we do not try to spend the same UTXOs in subsequent tests, as they will look like RBF attempts.
+            self.wallet.rescan_utxos(include_mempool=True)
+
+            # Resets if mocktime was used
+            self.nodes[0].setmocktime(0)
+    return wrapper
+
+class PackageRelayTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.setup_clean_chain = True
+        self.num_nodes = 1
+        self.extra_args = [[
+            "-datacarriersize=100000",
+            "-maxmempool=5",
+        ]]
+        self.supports_cli = False
+
+    def create_tx_below_mempoolminfee(self, wallet):
+        """Create a 1-input 1sat/vB transaction using a confirmed UTXO. Decrement and use
+        self.sequence so that subsequent calls to this function result in unique transactions."""
+
+        self.sequence -= 1
+        assert_greater_than(self.nodes[0].getmempoolinfo()["mempoolminfee"], FEERATE_1SAT_VB)
+
+        return wallet.create_self_transfer(fee_rate=FEERATE_1SAT_VB, sequence=self.sequence, confirmed_only=True)
+
+    @cleanup
+    def test_basic_child_then_parent(self):
+        node = self.nodes[0]
+        self.log.info("Check that opportunistic 1p1c logic works when child is received before parent")
+
+        low_fee_parent = self.create_tx_below_mempoolminfee(self.wallet)
+        high_fee_child = self.wallet.create_self_transfer(utxo_to_spend=low_fee_parent["new_utxo"], fee_rate=20*FEERATE_1SAT_VB)
+
+        peer_sender = node.add_p2p_connection(P2PInterface())
+
+        # 1. Child is received first (perhaps the low feerate parent didn't meet feefilter or the requests were sent to different nodes). It is missing an input.
+        high_child_wtxid_int = int(high_fee_child["tx"].getwtxid(), 16)
+        peer_sender.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=high_child_wtxid_int)]))
+        peer_sender.wait_for_getdata([high_child_wtxid_int])
+        peer_sender.send_and_ping(msg_tx(high_fee_child["tx"]))
+
+        # 2. Node requests the missing parent by txid.
+        parent_txid_int = int(low_fee_parent["txid"], 16)
+        peer_sender.wait_for_getdata([parent_txid_int])
+
+        # 3. Sender relays the parent. Parent+Child are evaluated as a package and accepted.
+        peer_sender.send_and_ping(msg_tx(low_fee_parent["tx"]))
+
+        # 4. Both transactions should now be in mempool.
+        node_mempool = node.getrawmempool()
+        assert low_fee_parent["txid"] in node_mempool
+        assert high_fee_child["txid"] in node_mempool
+
+        node.disconnect_p2ps()
+
+    @cleanup
+    def test_basic_parent_then_child(self, wallet):
+        node = self.nodes[0]
+        low_fee_parent = self.create_tx_below_mempoolminfee(wallet)
+        high_fee_child = wallet.create_self_transfer(utxo_to_spend=low_fee_parent["new_utxo"], fee_rate=20*FEERATE_1SAT_VB)
+
+        peer_sender = node.add_outbound_p2p_connection(P2PInterface(), p2p_idx=1, connection_type="outbound-full-relay")
+        peer_ignored = node.add_outbound_p2p_connection(P2PInterface(), p2p_idx=2, connection_type="outbound-full-relay")
+
+        # 1. Parent is relayed first. It is too low feerate.
+        parent_wtxid_int = int(low_fee_parent["tx"].getwtxid(), 16)
+        peer_sender.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=parent_wtxid_int)]))
+        peer_sender.wait_for_getdata([parent_wtxid_int])
+        peer_sender.send_and_ping(msg_tx(low_fee_parent["tx"]))
+        assert low_fee_parent["txid"] not in node.getrawmempool()
+
+        # Send again from peer_ignored, check that it is ignored
+        peer_ignored.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=parent_wtxid_int)]))
+        assert "getdata" not in peer_ignored.last_message
+
+        # 2. Child is relayed next. It is missing an input.
+        high_child_wtxid_int = int(high_fee_child["tx"].getwtxid(), 16)
+        peer_sender.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=high_child_wtxid_int)]))
+        peer_sender.wait_for_getdata([high_child_wtxid_int])
+        peer_sender.send_and_ping(msg_tx(high_fee_child["tx"]))
+
+        # 3. Node requests the missing parent by txid.
+        # It should do so even if it has previously rejected that parent for being too low feerate.
+        parent_txid_int = int(low_fee_parent["txid"], 16)
+        peer_sender.wait_for_getdata([parent_txid_int])
+
+        # 4. Sender re-relays the parent. Parent+Child are evaluated as a package and accepted.
+        peer_sender.send_and_ping(msg_tx(low_fee_parent["tx"]))
+
+        # 5. Both transactions should now be in mempool.
+        node_mempool = node.getrawmempool()
+        assert low_fee_parent["txid"] in node_mempool
+        assert high_fee_child["txid"] in node_mempool
+
+    @cleanup
+    def test_low_and_high_child(self, wallet):
+        node = self.nodes[0]
+        low_fee_parent = self.create_tx_below_mempoolminfee(wallet)
+        # This feerate is above mempoolminfee, but not enough to also bump the low feerate parent.
+        feerate_just_above = node.getmempoolinfo()["mempoolminfee"]
+        med_fee_child = wallet.create_self_transfer(utxo_to_spend=low_fee_parent["new_utxo"], fee_rate=feerate_just_above)
+        high_fee_child = wallet.create_self_transfer(utxo_to_spend=low_fee_parent["new_utxo"], fee_rate=999*FEERATE_1SAT_VB)
+
+        peer_sender = node.add_outbound_p2p_connection(P2PInterface(), p2p_idx=1, connection_type="outbound-full-relay")
+        peer_ignored = node.add_outbound_p2p_connection(P2PInterface(), p2p_idx=2, connection_type="outbound-full-relay")
+
+        self.log.info("Check that tx caches low fee parent + low fee child package rejections")
+
+        # 1. Send parent, rejected for being low feerate.
+        parent_wtxid_int = int(low_fee_parent["tx"].getwtxid(), 16)
+        peer_sender.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=parent_wtxid_int)]))
+        peer_sender.wait_for_getdata([parent_wtxid_int])
+        peer_sender.send_and_ping(msg_tx(low_fee_parent["tx"]))
+        assert low_fee_parent["txid"] not in node.getrawmempool()
+
+        # Send again from peer_ignored, check that it is ignored
+        peer_ignored.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=parent_wtxid_int)]))
+        assert "getdata" not in peer_ignored.last_message
+
+        # 2. Send an (orphan) child that has a higher feerate, but not enough to bump the parent.
+        med_child_wtxid_int = int(med_fee_child["tx"].getwtxid(), 16)
+        peer_sender.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=med_child_wtxid_int)]))
+        peer_sender.wait_for_getdata([med_child_wtxid_int])
+        peer_sender.send_and_ping(msg_tx(med_fee_child["tx"]))
+
+        # 3. Node requests the orphan's missing parent.
+        parent_txid_int = int(low_fee_parent["txid"], 16)
+        peer_sender.wait_for_getdata([parent_txid_int])
+
+        # 4. The low parent + low child are submitted as a package. They are not accepted due to low package feerate.
+        peer_sender.send_and_ping(msg_tx(low_fee_parent["tx"]))
+
+        assert low_fee_parent["txid"] not in node.getrawmempool()
+        assert med_fee_child["txid"] not in node.getrawmempool()
+
+        # If peer_ignored announces the low feerate child, it should be ignored
+        peer_ignored.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=med_child_wtxid_int)]))
+        assert "getdata" not in peer_ignored.last_message
+        # If either peer sends the parent again, package evaluation should not be attempted
+        peer_sender.send_and_ping(msg_tx(low_fee_parent["tx"]))
+        peer_ignored.send_and_ping(msg_tx(low_fee_parent["tx"]))
+
+        assert low_fee_parent["txid"] not in node.getrawmempool()
+        assert med_fee_child["txid"] not in node.getrawmempool()
+
+        # 5. Send the high feerate (orphan) child
+        high_child_wtxid_int = int(high_fee_child["tx"].getwtxid(), 16)
+        peer_sender.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=high_child_wtxid_int)]))
+        peer_sender.wait_for_getdata([high_child_wtxid_int])
+        peer_sender.send_and_ping(msg_tx(high_fee_child["tx"]))
+
+        # 6. Node requests the orphan's parent, even though it has already been rejected, both by
+        # itself and with a child. This is necessary, otherwise high_fee_child can be censored.
+        parent_txid_int = int(low_fee_parent["txid"], 16)
+        peer_sender.wait_for_getdata([parent_txid_int])
+
+        # 7. The low feerate parent + high feerate child are submitted as a package.
+        peer_sender.send_and_ping(msg_tx(low_fee_parent["tx"]))
+
+        # 8. Both transactions should now be in mempool
+        node_mempool = node.getrawmempool()
+        assert low_fee_parent["txid"] in node_mempool
+        assert high_fee_child["txid"] in node_mempool
+        assert med_fee_child["txid"] not in node_mempool
+
+    @cleanup
+    def test_orphan_consensus_failure(self):
+        self.log.info("Check opportunistic 1p1c logic with consensus-invalid orphan causes disconnect of the correct peer")
+        node = self.nodes[0]
+        low_fee_parent = self.create_tx_below_mempoolminfee(self.wallet)
+        coin = low_fee_parent["new_utxo"]
+        address = node.get_deterministic_priv_key().address
+        # Create raw transaction spending the parent, but with no signature (a consensus error).
+        hex_orphan_no_sig = node.createrawtransaction([{"txid": coin["txid"], "vout": coin["vout"]}], {address : coin["value"] - Decimal("0.0001")})
+        tx_orphan_bad_wit = tx_from_hex(hex_orphan_no_sig)
+        tx_orphan_bad_wit.wit.vtxinwit.append(CTxInWitness())
+        tx_orphan_bad_wit.wit.vtxinwit[0].scriptWitness.stack = [b'garbage']
+
+        bad_orphan_sender = node.add_p2p_connection(P2PInterface())
+        parent_sender = node.add_p2p_connection(P2PInterface())
+
+        # 1. Child is received first. It is missing an input.
+        child_wtxid_int = int(tx_orphan_bad_wit.getwtxid(), 16)
+        bad_orphan_sender.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=child_wtxid_int)]))
+        bad_orphan_sender.wait_for_getdata([child_wtxid_int])
+        bad_orphan_sender.send_and_ping(msg_tx(tx_orphan_bad_wit))
+
+        # 2. Node requests the missing parent by txid.
+        parent_txid_int = int(low_fee_parent["txid"], 16)
+        bad_orphan_sender.wait_for_getdata([parent_txid_int])
+
+        # 3. A different peer relays the parent. Parent+Child are evaluated as a package and rejected.
+        parent_sender.send_message(msg_tx(low_fee_parent["tx"]))
+
+        # 4. Transactions should not be in mempool.
+        node_mempool = node.getrawmempool()
+        assert low_fee_parent["txid"] not in node_mempool
+        assert tx_orphan_bad_wit.rehash() not in node_mempool
+
+        # 5. Peer that sent a consensus-invalid transaction should be disconnected.
+        bad_orphan_sender.wait_for_disconnect()
+
+        # The peer that didn't provide the orphan should not be disconnected.
+        parent_sender.sync_with_ping()
+
+    @cleanup
+    def test_parent_consensus_failure(self):
+        self.log.info("Check opportunistic 1p1c logic with consensus-invalid parent causes disconnect of the correct peer")
+        node = self.nodes[0]
+        low_fee_parent = self.create_tx_below_mempoolminfee(self.wallet)
+        high_fee_child = self.wallet.create_self_transfer(utxo_to_spend=low_fee_parent["new_utxo"], fee_rate=999*FEERATE_1SAT_VB)
+
+        # Create invalid version of parent with a bad signature.
+        tx_parent_bad_wit = tx_from_hex(low_fee_parent["hex"])
+        tx_parent_bad_wit.wit.vtxinwit.append(CTxInWitness())
+        tx_parent_bad_wit.wit.vtxinwit[0].scriptWitness.stack = [b'garbage']
+
+        package_sender = node.add_p2p_connection(P2PInterface())
+        fake_parent_sender = node.add_p2p_connection(P2PInterface())
+
+        # 1. Child is received first. It is missing an input.
+        child_wtxid_int = int(high_fee_child["tx"].getwtxid(), 16)
+        package_sender.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=child_wtxid_int)]))
+        package_sender.wait_for_getdata([child_wtxid_int])
+        package_sender.send_and_ping(msg_tx(high_fee_child["tx"]))
+
+        # 2. Node requests the missing parent by txid.
+        parent_txid_int = int(tx_parent_bad_wit.rehash(), 16)
+        package_sender.wait_for_getdata([parent_txid_int])
+
+        # 3. A different node relays the parent. The parent is first evaluated by itself and
+        # rejected for being too low feerate. Then it is evaluated as a package and, after passing
+        # feerate checks, rejected for having a bad signature (consensus error).
+        fake_parent_sender.send_message(msg_tx(tx_parent_bad_wit))
+
+        # 4. Transactions should not be in mempool.
+        node_mempool = node.getrawmempool()
+        assert tx_parent_bad_wit.rehash() not in node_mempool
+        assert high_fee_child["txid"] not in node_mempool
+
+        # 5. Peer sent a consensus-invalid transaction.
+        fake_parent_sender.wait_for_disconnect()
+
+        self.log.info("Check that fake parent does not cause orphan to be deleted and real package can still be submitted")
+        # 6. Child-sending should not have been punished and the orphan should remain in orphanage.
+        # It can send the "real" parent transaction, and the package is accepted.
+        parent_wtxid_int = int(low_fee_parent["tx"].getwtxid(), 16)
+        package_sender.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=parent_wtxid_int)]))
+        package_sender.wait_for_getdata([parent_wtxid_int])
+        package_sender.send_and_ping(msg_tx(low_fee_parent["tx"]))
+
+        node_mempool = node.getrawmempool()
+        assert low_fee_parent["txid"] in node_mempool
+        assert high_fee_child["txid"] in node_mempool
+
+    @cleanup
+    def test_multiple_parents(self):
+        self.log.info("Check that node does not request more than 1 previously-rejected low feerate parent")
+
+        node = self.nodes[0]
+        node.setmocktime(int(time.time()))
+
+        # 2-parent-1-child package where both parents are below mempool min feerate
+        parent_low_1 = self.create_tx_below_mempoolminfee(self.wallet_nonsegwit)
+        parent_low_2 = self.create_tx_below_mempoolminfee(self.wallet_nonsegwit)
+        child_bumping = self.wallet_nonsegwit.create_self_transfer_multi(
+            utxos_to_spend=[parent_low_1["new_utxo"], parent_low_2["new_utxo"]],
+            fee_per_output=999*parent_low_1["tx"].get_vsize(),
+        )
+
+        peer_sender = node.add_outbound_p2p_connection(P2PInterface(), p2p_idx=1, connection_type="outbound-full-relay")
+
+        # 1. Send both parents. Each should be rejected for being too low feerate.
+        # Send unsolicited so that we can later check that no "getdata" was ever received.
+        peer_sender.send_and_ping(msg_tx(parent_low_1["tx"]))
+        peer_sender.send_and_ping(msg_tx(parent_low_2["tx"]))
+
+        # parent_low_1 and parent_low_2 are rejected for being low feerate.
+        assert parent_low_1["txid"] not in node.getrawmempool()
+        assert parent_low_2["txid"] not in node.getrawmempool()
+
+        # 2. Send child.
+        peer_sender.send_and_ping(msg_tx(child_bumping["tx"]))
+
+        # 3. Node should not request any parents, as it should recognize that it will not accept
+        # multi-parent-1-child packages.
+        node.bumpmocktime(GETDATA_WAIT)
+        peer_sender.sync_with_ping()
+        assert "getdata" not in peer_sender.last_message
+
+    @cleanup
+    def test_other_parent_in_mempool(self):
+        self.log.info("Check opportunistic 1p1c fails if child already has another parent in mempool")
+        node = self.nodes[0]
+
+        # This parent needs CPFP
+        parent_low = self.create_tx_below_mempoolminfee(self.wallet)
+        # This parent does not need CPFP and can be submitted alone ahead of time
+        parent_high = self.wallet.create_self_transfer(fee_rate=FEERATE_1SAT_VB*10, confirmed_only=True)
+        child = self.wallet.create_self_transfer_multi(
+            utxos_to_spend=[parent_high["new_utxo"], parent_low["new_utxo"]],
+            fee_per_output=999*parent_low["tx"].get_vsize(),
+        )
+
+        peer_sender = node.add_outbound_p2p_connection(P2PInterface(), p2p_idx=1, connection_type="outbound-full-relay")
+
+        # 1. Send first parent which will be accepted.
+        peer_sender.send_and_ping(msg_tx(parent_high["tx"]))
+        assert parent_high["txid"] in node.getrawmempool()
+
+        # 2. Send child.
+        peer_sender.send_and_ping(msg_tx(child["tx"]))
+
+        # 3. Node requests parent_low. However, 1p1c fails because package-not-child-with-unconfirmed-parents
+        parent_low_txid_int = int(parent_low["txid"], 16)
+        peer_sender.wait_for_getdata([parent_low_txid_int])
+        peer_sender.send_and_ping(msg_tx(parent_low["tx"]))
+
+        node_mempool = node.getrawmempool()
+        assert parent_high["txid"] in node_mempool
+        assert parent_low["txid"] not in node_mempool
+        assert child["txid"] not in node_mempool
+
+        # Same error if submitted through submitpackage without parent_high
+        package_hex_missing_parent = [parent_low["hex"], child["hex"]]
+        result_missing_parent = node.submitpackage(package_hex_missing_parent)
+        assert_equal(result_missing_parent["package_msg"], "package-not-child-with-unconfirmed-parents")
+
+    def run_test(self):
+        node = self.nodes[0]
+        # To avoid creating transactions with the same txid (can happen if we set the same feerate
+        # and reuse the same input as a previous transaction that wasn't successfully submitted),
+        # we give each subtest a different nSequence for its transactions.
+        self.sequence = MAX_BIP125_RBF_SEQUENCE
+
+        self.wallet = MiniWallet(node)
+        self.wallet_nonsegwit = MiniWallet(node, mode=MiniWalletMode.RAW_P2PK)
+        self.generate(self.wallet_nonsegwit, 10)
+        self.generate(self.wallet, 20)
+
+        filler_wallet = MiniWallet(node)
+        fill_mempool(self, node, filler_wallet)
+
+        self.log.info("Check opportunistic 1p1c logic when parent (txid != wtxid) is received before child")
+        self.test_basic_parent_then_child(self.wallet)
+
+        self.log.info("Check opportunistic 1p1c logic when parent (txid == wtxid) is received before child")
+        self.test_basic_parent_then_child(self.wallet_nonsegwit)
+
+        self.log.info("Check opportunistic 1p1c logic when child is received before parent")
+        self.test_basic_child_then_parent()
+
+        self.log.info("Check opportunistic 1p1c logic when 2 candidate children exist (parent txid != wtxid)")
+        self.test_low_and_high_child(self.wallet)
+
+        self.log.info("Check opportunistic 1p1c logic when 2 candidate children exist (parent txid == wtxid)")
+        self.test_low_and_high_child(self.wallet_nonsegwit)
+
+        self.test_orphan_consensus_failure()
+        self.test_parent_consensus_failure()
+        self.test_multiple_parents()
+        self.test_other_parent_in_mempool()
+
+
+if __name__ == '__main__':
+    PackageRelayTest().main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 3f6e47d410..629c9d025a 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -199,6 +199,8 @@
     'wallet_txn_clone.py --segwit',
     'rpc_getchaintips.py',
     'rpc_misc.py',
+    'p2p_1p1c_network.py',
+    'p2p_opportunistic_1p1c.py',
     'interface_rest.py',
     'mempool_spend_coinbase.py',
     'wallet_avoid_mixing_output_types.py --descriptors',

From fa1964c5b80ee28b0e06abdbd9a26e8e8c6f5acd Mon Sep 17 00:00:00 2001
From: MarcoFalke <*~=`'#}+{/-|&$^_@721217.xyz>
Date: Tue, 2 Jan 2024 12:30:44 +0100
Subject: [PATCH 33/63] build: Bump clang minimum supported version to 15

---
 ci/test/00_setup_env_native_nowallet_libbitcoinkernel.sh | 6 +++---
 doc/dependencies.md                                      | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/ci/test/00_setup_env_native_nowallet_libbitcoinkernel.sh b/ci/test/00_setup_env_native_nowallet_libbitcoinkernel.sh
index 6f0b9cc285..6425120afb 100755
--- a/ci/test/00_setup_env_native_nowallet_libbitcoinkernel.sh
+++ b/ci/test/00_setup_env_native_nowallet_libbitcoinkernel.sh
@@ -8,8 +8,8 @@ export LC_ALL=C.UTF-8
 
 export CONTAINER_NAME=ci_native_nowallet_libbitcoinkernel
 export CI_IMAGE_NAME_TAG="docker.io/ubuntu:22.04"
-# Use minimum supported python3.9 (or best-effort 3.10) and clang-14, see doc/dependencies.md
-export PACKAGES="python3-zmq clang-14 llvm-14 libc++abi-14-dev libc++-14-dev"
-export DEP_OPTS="NO_WALLET=1 CC=clang-14 CXX='clang++-14 -stdlib=libc++'"
+# Use minimum supported python3.9 (or best-effort 3.10) and clang-15, see doc/dependencies.md
+export PACKAGES="python3-zmq clang-15 llvm-15 libc++abi-15-dev libc++-15-dev"
+export DEP_OPTS="NO_WALLET=1 CC=clang-15 CXX='clang++-15 -stdlib=libc++'"
 export GOAL="install"
 export BITCOIN_CONFIG="--enable-reduce-exports --enable-experimental-util-chainstate --with-experimental-kernel-lib --enable-shared"
diff --git a/doc/dependencies.md b/doc/dependencies.md
index 4003f22b91..43973d0c15 100644
--- a/doc/dependencies.md
+++ b/doc/dependencies.md
@@ -8,7 +8,7 @@ You can find installation instructions in the `build-*.md` file for your platfor
 | --- | --- |
 | [Autoconf](https://www.gnu.org/software/autoconf/) | [2.69](https://github.com/bitcoin/bitcoin/pull/17769) |
 | [Automake](https://www.gnu.org/software/automake/) | [1.13](https://github.com/bitcoin/bitcoin/pull/18290) |
-| [Clang](https://clang.llvm.org) | [14.0](https://github.com/bitcoin/bitcoin/pull/29208) |
+| [Clang](https://clang.llvm.org) | [15.0](https://github.com/bitcoin/bitcoin/pull/29165) |
 | [GCC](https://gcc.gnu.org) | [11.1](https://github.com/bitcoin/bitcoin/pull/29091) |
 | [Python](https://www.python.org) (scripts, tests) | [3.9](https://github.com/bitcoin/bitcoin/pull/28211) |
 | [systemtap](https://sourceware.org/systemtap/) ([tracing](tracing.md))| N/A |

From 85f50a46c50e7e56b5ee2d7258021939cd80c550 Mon Sep 17 00:00:00 2001
From: Hennadii Stepanov <32963518+hebasto@users.noreply.github.com>
Date: Sun, 28 Apr 2024 07:11:24 +0100
Subject: [PATCH 34/63] refactor: Fix "error C2248: cannot access private
 member" on MSVC

---
 src/util/bitdeque.h | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/util/bitdeque.h b/src/util/bitdeque.h
index 1e34b72475..ac9d302420 100644
--- a/src/util/bitdeque.h
+++ b/src/util/bitdeque.h
@@ -14,18 +14,17 @@
 
 /** Class that mimics std::deque<bool>, but with std::vector<bool>'s bit packing.
  *
- * BlobSize selects the (minimum) number of bits that are allocated at once.
+ * BITS_PER_WORD selects the (minimum) number of bits that are allocated at once.
  * Larger values reduce the asymptotic memory usage overhead, at the cost of
  * needing larger up-front allocations. The default is 4096 bytes.
  */
-template<int BlobSize = 4096 * 8>
+template<int BITS_PER_WORD = 4096 * 8>
 class bitdeque
 {
     // Internal definitions
-    using word_type = std::bitset<BlobSize>;
+    using word_type = std::bitset<BITS_PER_WORD>;
     using deque_type = std::deque<word_type>;
-    static_assert(BlobSize > 0);
-    static constexpr int BITS_PER_WORD = BlobSize;
+    static_assert(BITS_PER_WORD > 0);
 
     // Forward and friend declarations of iterator types.
     template<bool Const> class Iterator;

From 774359b4a96d2724dc70f900cb71e084a77164da Mon Sep 17 00:00:00 2001
From: Hennadii Stepanov <32963518+hebasto@users.noreply.github.com>
Date: Sun, 28 Apr 2024 07:11:32 +0100
Subject: [PATCH 35/63] build, msvc: Compile `test\fuzz\bitdeque.cpp`

---
 build_msvc/fuzz/fuzz.vcxproj | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/build_msvc/fuzz/fuzz.vcxproj b/build_msvc/fuzz/fuzz.vcxproj
index fb77251a17..e7ee211b2d 100644
--- a/build_msvc/fuzz/fuzz.vcxproj
+++ b/build_msvc/fuzz/fuzz.vcxproj
@@ -9,8 +9,8 @@
     <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
   </PropertyGroup>
   <ItemGroup>
-    <!-- TODO: Fix the code and remove bitdeque.cpp and miniscript.cpp exclusion. -->
-    <ClCompile Include="..\..\src\test\fuzz\*.cpp" Exclude="..\..\src\test\fuzz\bitdeque.cpp;..\..\src\test\fuzz\miniscript.cpp" />
+    <!-- TODO: Fix the code and remove miniscript.cpp exclusion. -->
+    <ClCompile Include="..\..\src\test\fuzz\*.cpp" Exclude="..\..\src\test\fuzz\miniscript.cpp" />
     <ClCompile Include="..\..\src\test\fuzz\util\descriptor.cpp">
       <ObjectFileName>$(IntDir)test_fuzz_util_descriptor.obj</ObjectFileName>
     </ClCompile>

From 97f159776ec06f767df1d4990aa7d0859140f52f Mon Sep 17 00:00:00 2001
From: Sebastian Falbesoner <sebastian.falbesoner@gmail.com>
Date: Sat, 27 Apr 2024 14:36:32 +0200
Subject: [PATCH 36/63] remove unused method `Popen::kill` from cpp-subprocess

---
 src/util/subprocess.h | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/src/util/subprocess.h b/src/util/subprocess.h
index dfe6e63c1a..8c5f074918 100644
--- a/src/util/subprocess.h
+++ b/src/util/subprocess.h
@@ -905,7 +905,6 @@ class Streams
  * 4. retcode()          - The return code of the exited child.
  * 5. pid()              - PID of the spawned child.
  * 6. poll()             - Check the status of the running child.
- * 7. kill(sig_num)      - Kill the child. SIGTERM used by default.
  * 8. send(...)          - Send input to the input channel of the child.
  * 9. communicate(...)   - Get the output/error from the child and close the channels
  *                         from the parent side.
@@ -966,10 +965,6 @@ class Popen
 
   int poll() noexcept(false);
 
-  // Does not fail, Caller is expected to recheck the
-  // status with a call to poll()
-  void kill(int sig_num = 9);
-
   void set_out_buf_cap(size_t cap) { stream_.set_out_buf_cap(cap); }
 
   void set_err_buf_cap(size_t cap) { stream_.set_err_buf_cap(cap); }
@@ -1137,18 +1132,6 @@ inline int Popen::poll() noexcept(false)
 #endif
 }
 
-inline void Popen::kill(int sig_num)
-{
-#ifdef __USING_WINDOWS__
-  if (!TerminateProcess(this->process_handle_, (UINT)sig_num)) {
-    throw OSError("TerminateProcess", 0);
-  }
-#else
-  ::kill(child_pid_, sig_num);
-#endif
-}
-
-
 inline void Popen::execute_process() noexcept(false)
 {
 #ifdef __USING_WINDOWS__

From 8b52e7f628304e83b0e36fd97e617de0f71c5a62 Mon Sep 17 00:00:00 2001
From: Sebastian Falbesoner <sebastian.falbesoner@gmail.com>
Date: Sat, 27 Apr 2024 14:43:44 +0200
Subject: [PATCH 37/63] update comments in cpp-subprocess (check_output
 references)

Remove obsolete `check_output` references in the comments and remove
the numbering of the Popen API methods, as they don't seem to provide a
value and just make diffs larger for future changes.
---
 src/util/subprocess.h | 37 ++++++++++++++++++-------------------
 1 file changed, 18 insertions(+), 19 deletions(-)

diff --git a/src/util/subprocess.h b/src/util/subprocess.h
index 8c5f074918..af408b31d4 100644
--- a/src/util/subprocess.h
+++ b/src/util/subprocess.h
@@ -670,8 +670,8 @@ struct error
  * This is basically used to determine the length of the actual
  * data stored inside the dynamically resized vector.
  *
- * This is what is returned as the output to communicate and check_output
- * functions, so, users must know about this class.
+ * This is what is returned as the output to the communicate
+ * function, so, users must know about this class.
  *
  * OutBuffer and ErrBuffer are just different typedefs to this class.
  */
@@ -704,8 +704,7 @@ class Popen;
 namespace detail {
 /*!
  * A helper class to Popen class for setting
- * options as provided in the Popen constructor
- * or in check_output arguments.
+ * options as provided in the Popen constructor.
  * This design allows us to _not_ have any fixed position
  * to any arguments and specify them in a way similar to what
  * can be done in python.
@@ -897,23 +896,23 @@ class Streams
  * interface to the client.
  *
  * API's provided by the class:
- * 1. Popen({"cmd"}, output{..}, error{..}, ....)
+ * Popen({"cmd"}, output{..}, error{..}, ....)
  *    Command provided as a sequence.
- * 2. Popen("cmd arg1"m output{..}, error{..}, ....)
+ * Popen("cmd arg1", output{..}, error{..}, ....)
  *    Command provided in a single string.
- * 3. wait()             - Wait for the child to exit.
- * 4. retcode()          - The return code of the exited child.
- * 5. pid()              - PID of the spawned child.
- * 6. poll()             - Check the status of the running child.
- * 8. send(...)          - Send input to the input channel of the child.
- * 9. communicate(...)   - Get the output/error from the child and close the channels
- *                         from the parent side.
- *10. input()            - Get the input channel/File pointer. Can be used for
- *                         customizing the way of sending input to child.
- *11. output()           - Get the output channel/File pointer. Usually used
-                           in case of redirection. See piping examples.
- *12. error()            - Get the error channel/File pointer. Usually used
-                           in case of redirection.
+ * wait()             - Wait for the child to exit.
+ * retcode()          - The return code of the exited child.
+ * pid()              - PID of the spawned child.
+ * poll()             - Check the status of the running child.
+ * send(...)          - Send input to the input channel of the child.
+ * communicate(...)   - Get the output/error from the child and close the channels
+ *                      from the parent side.
+ * input()            - Get the input channel/File pointer. Can be used for
+ *                      customizing the way of sending input to child.
+ * output()           - Get the output channel/File pointer. Usually used
+                        in case of redirection. See piping examples.
+ * error()            - Get the error channel/File pointer. Usually used
+                        in case of redirection.
  */
 class Popen
 {

From cc15c5bfd1eb3903de246c124702a7c66c687008 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Sun, 28 Apr 2024 15:35:45 -0400
Subject: [PATCH 38/63] fuzz: don't allow adding duplicate transactions to the
 mempool

---
 src/test/fuzz/partially_downloaded_block.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/test/fuzz/partially_downloaded_block.cpp b/src/test/fuzz/partially_downloaded_block.cpp
index ab75afe066..2bf47930f4 100644
--- a/src/test/fuzz/partially_downloaded_block.cpp
+++ b/src/test/fuzz/partially_downloaded_block.cpp
@@ -72,7 +72,7 @@ FUZZ_TARGET(partially_downloaded_block, .init = initialize_pdb)
             available.insert(i);
         }
 
-        if (add_to_mempool) {
+        if (add_to_mempool && !pool.exists(GenTxid::Txid(tx->GetHash()))) {
             LOCK2(cs_main, pool.cs);
             pool.addUnchecked(ConsumeTxMemPoolEntry(fuzzed_data_provider, *tx));
             available.insert(i);

From 2e266f33b5d2be5c233c2c692481f75785714fa1 Mon Sep 17 00:00:00 2001
From: laanwj <126646+laanwj@users.noreply.github.com>
Date: Sun, 28 Apr 2024 13:40:22 +0200
Subject: [PATCH 39/63] depends: Fix build of Qt for 32-bit platforms

The 32 to 64-bit time_t transition causes a build failure in the built-in
zlib about conflicting _TIME_BITS and _FILE_OFFSET_BITS.

Note that zlib doesn't use time_t at all, so it is a false alarm.

Take the following patch from upstream zlib:
https://github.com/madler/zlib/commit/a566e156b3fa07b566ddbf6801b517a9dba04fa3.patch

Closes #29980.
---
 depends/packages/qt.mk                   |  2 ++
 depends/patches/qt/zlib-timebits64.patch | 31 ++++++++++++++++++++++++
 2 files changed, 33 insertions(+)
 create mode 100644 depends/patches/qt/zlib-timebits64.patch

diff --git a/depends/packages/qt.mk b/depends/packages/qt.mk
index 0acf4cf565..d057b2d410 100644
--- a/depends/packages/qt.mk
+++ b/depends/packages/qt.mk
@@ -22,6 +22,7 @@ $(package)_patches += fix-macos-linker.patch
 $(package)_patches += memory_resource.patch
 $(package)_patches += utc_from_string_no_optimize.patch
 $(package)_patches += windows_lto.patch
+$(package)_patches += zlib-timebits64.patch
 
 $(package)_qttranslations_file_name=qttranslations-$($(package)_suffix)
 $(package)_qttranslations_sha256_hash=24d4c58bc2a40c0f44f59ee64af4192c7d0038c1e45af61646cfc5b65058f271
@@ -251,6 +252,7 @@ define $(package)_preprocess_cmds
   patch -p1 -i $($(package)_patch_dir)/utc_from_string_no_optimize.patch && \
   patch -p1 -i $($(package)_patch_dir)/guix_cross_lib_path.patch && \
   patch -p1 -i $($(package)_patch_dir)/windows_lto.patch && \
+  patch -p1 -i $($(package)_patch_dir)/zlib-timebits64.patch && \
   mkdir -p qtbase/mkspecs/macx-clang-linux &&\
   cp -f qtbase/mkspecs/macx-clang/qplatformdefs.h qtbase/mkspecs/macx-clang-linux/ &&\
   cp -f $($(package)_patch_dir)/mac-qmake.conf qtbase/mkspecs/macx-clang-linux/qmake.conf && \
diff --git a/depends/patches/qt/zlib-timebits64.patch b/depends/patches/qt/zlib-timebits64.patch
new file mode 100644
index 0000000000..139c1dfa77
--- /dev/null
+++ b/depends/patches/qt/zlib-timebits64.patch
@@ -0,0 +1,31 @@
+From a566e156b3fa07b566ddbf6801b517a9dba04fa3 Mon Sep 17 00:00:00 2001
+From: Mark Adler <madler@alumni.caltech.edu>
+Date: Sat, 29 Jul 2023 22:13:09 -0700
+Subject: [PATCH] Avoid compiler complaints if _TIME_BITS defined when building
+ zlib.
+
+zlib does not use time_t, so _TIME_BITS is irrelevant. However it
+may be defined anyway as part of a sledgehammer indiscriminately
+applied to all builds.
+
+From https://github.com/madler/zlib/commit/a566e156b3fa07b566ddbf6801b517a9dba04fa3.patch
+---
+ qtbase/src/3rdparty/zlib/src/gzguts.h | 5 ++---
+ 1 file changed, 2 insertions(+), 3 deletions(-)
+
+diff --git a/qtbase/src/3rdparty/zlib/src/gzguts.h b/qtbase/src/3rdparty/zlib/src/gzguts.h
+index e23f831f5..f9375047e 100644
+--- a/qtbase/src/3rdparty/zlib/src/gzguts.h
++++ b/qtbase/src/3rdparty/zlib/src/gzguts.h
+@@ -26,9 +26,8 @@
+ #  ifndef _LARGEFILE_SOURCE
+ #    define _LARGEFILE_SOURCE 1
+ #  endif
+-#  ifdef _FILE_OFFSET_BITS
+-#    undef _FILE_OFFSET_BITS
+-#  endif
++#  undef _FILE_OFFSET_BITS
++#  undef _TIME_BITS
+ #endif
+ 
+ #ifdef HAVE_HIDDEN

From 22574046c90c0662f3aa9b1baea074aff54f92a9 Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Mon, 29 Apr 2024 10:33:21 +0200
Subject: [PATCH 40/63] doc: add LLVM instruction for macOS < 13

---
 doc/build-osx.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/doc/build-osx.md b/doc/build-osx.md
index 5c3dc1ac7f..20c92ab7a4 100644
--- a/doc/build-osx.md
+++ b/doc/build-osx.md
@@ -51,6 +51,20 @@ To install, run the following from your terminal:
 brew install automake libtool boost pkg-config libevent
 ```
 
+For macOS 11 (Big Sur) and 12 (Monterey) you need to install a more recent version of llvm.
+
+``` bash
+brew install llvm
+```
+
+And append the following to the configure commands below:
+
+``` bash
+CC=$(brew --prefix llvm)/bin/clang CXX=$(brew --prefix llvm)/bin/clang++
+```
+
+Try `llvm@17` if compilation fails with the default version of llvm.
+
 ### 4. Clone Bitcoin repository
 
 `git` should already be installed by default on your system.

From f8a141c2dae2471a7ce7248e28a0bbeb8a291acd Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Sun, 28 Apr 2024 08:42:28 -0400
Subject: [PATCH 41/63] test: Don't rely on incentive incompatible replacement
 in mempool_accept_v3.py

---
 test/functional/mempool_accept_v3.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/functional/mempool_accept_v3.py b/test/functional/mempool_accept_v3.py
index 1b55cd0a0d..8285b82c19 100755
--- a/test/functional/mempool_accept_v3.py
+++ b/test/functional/mempool_accept_v3.py
@@ -533,10 +533,10 @@ def test_v3_sibling_eviction(self):
         tx_unrelated_replacee = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=utxo_unrelated_conflict)
         assert tx_unrelated_replacee["txid"] in node.getrawmempool()
 
-        fee_to_beat_child2 = int(tx_v3_child_2["fee"] * COIN)
+        fee_to_beat = max(int(tx_v3_child_2["fee"] * COIN), int(tx_unrelated_replacee["fee"]*COIN))
 
         tx_v3_child_3 = self.wallet.create_self_transfer_multi(
-            utxos_to_spend=[tx_v3_parent["new_utxos"][0], utxo_unrelated_conflict], fee_per_output=fee_to_beat_child2*5, version=3
+            utxos_to_spend=[tx_v3_parent["new_utxos"][0], utxo_unrelated_conflict], fee_per_output=fee_to_beat*2, version=3
         )
         node.sendrawtransaction(tx_v3_child_3["hex"])
         self.check_mempool(txids_v2_100 + [tx_v3_parent["txid"], tx_v3_child_3["txid"]])

From 6866b571ab96f03ca0775424e45458c5731f230f Mon Sep 17 00:00:00 2001
From: fanquake <fanquake@gmail.com>
Date: Thu, 2 Feb 2023 14:29:07 +0000
Subject: [PATCH 42/63] depends: miniupnpc 2.2.7

Includes a temporary patch to fix the Windows Autotools build.

See
https://miniupnp.tuxfamily.org/files/changelog.php?file=miniupnpc-2.2.7.tar.gz.
---
 depends/packages/miniupnpc.mk                 |  20 ++-
 .../patches/miniupnpc/dont_leak_info.patch    |  26 ++--
 .../patches/miniupnpc/fix_windows_build.patch | 143 ++++++++++++++++++
 .../miniupnpc/respect_mingw_cflags.patch      |  23 ---
 doc/dependencies.md                           |   2 +-
 5 files changed, 166 insertions(+), 48 deletions(-)
 create mode 100644 depends/patches/miniupnpc/fix_windows_build.patch
 delete mode 100644 depends/patches/miniupnpc/respect_mingw_cflags.patch

diff --git a/depends/packages/miniupnpc.mk b/depends/packages/miniupnpc.mk
index 5698a7cbb1..39c640f1e7 100644
--- a/depends/packages/miniupnpc.mk
+++ b/depends/packages/miniupnpc.mk
@@ -1,30 +1,28 @@
 package=miniupnpc
-$(package)_version=2.2.2
+$(package)_version=2.2.7
 $(package)_download_path=https://miniupnp.tuxfamily.org/files/
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
-$(package)_sha256_hash=888fb0976ba61518276fe1eda988589c700a3f2a69d71089260d75562afd3687
-$(package)_patches=dont_leak_info.patch respect_mingw_cflags.patch no_libtool.patch
+$(package)_sha256_hash=b0c3a27056840fd0ec9328a5a9bac3dc5e0ec6d2e8733349cf577b0aa1e70ac1
+$(package)_patches=dont_leak_info.patch no_libtool.patch fix_windows_build.patch
 
-# Next time this package is updated, ensure that _WIN32_WINNT is still properly set.
-# See discussion in https://github.com/bitcoin/bitcoin/pull/25964.
 define $(package)_set_vars
 $(package)_build_opts=CC="$($(package)_cc)"
-$(package)_build_opts_mingw32=-f Makefile.mingw CFLAGS="$($(package)_cflags) -D_WIN32_WINNT=0x0601"
+$(package)_build_opts_mingw32=-f Makefile.mingw CFLAGS="$($(package)_cflags)"
 $(package)_build_env+=CFLAGS="$($(package)_cflags) $($(package)_cppflags)" AR="$($(package)_ar)"
 endef
 
 define $(package)_preprocess_cmds
   patch -p1 < $($(package)_patch_dir)/dont_leak_info.patch && \
-  patch -p1 < $($(package)_patch_dir)/respect_mingw_cflags.patch && \
-  patch -p1 < $($(package)_patch_dir)/no_libtool.patch
+  patch -p1 < $($(package)_patch_dir)/no_libtool.patch && \
+  patch -p1 < $($(package)_patch_dir)/fix_windows_build.patch
 endef
 
 define $(package)_build_cmds
-	$(MAKE) libminiupnpc.a $($(package)_build_opts)
+	$(MAKE) build/libminiupnpc.a $($(package)_build_opts)
 endef
 
 define $(package)_stage_cmds
 	mkdir -p $($(package)_staging_prefix_dir)/include/miniupnpc $($(package)_staging_prefix_dir)/lib &&\
-	install *.h $($(package)_staging_prefix_dir)/include/miniupnpc &&\
-	install libminiupnpc.a $($(package)_staging_prefix_dir)/lib
+	install include/*.h $($(package)_staging_prefix_dir)/include/miniupnpc &&\
+	install build/libminiupnpc.a $($(package)_staging_prefix_dir)/lib
 endef
diff --git a/depends/patches/miniupnpc/dont_leak_info.patch b/depends/patches/miniupnpc/dont_leak_info.patch
index 512f9c50ea..95a09a26dc 100644
--- a/depends/patches/miniupnpc/dont_leak_info.patch
+++ b/depends/patches/miniupnpc/dont_leak_info.patch
@@ -1,31 +1,31 @@
-commit 8815452257437ba36607d0e2381c01142d1c7bb0
+commit 51f6dd991c29af66fb4f64c6feb2787cce23a1a7
 Author: fanquake <fanquake@gmail.com>
-Date:   Thu Nov 19 10:51:19 2020 +0800
+Date:   Mon Jan 8 11:21:40 2024 +0000
 
     Don't leak OS and miniupnpc version info in User-Agent
 
-diff --git a//minisoap.c b/minisoap.c
-index 7860667..775580b 100644
---- a/minisoap.c
-+++ b/minisoap.c
+diff --git a/src/minisoap.c b/src/minisoap.c
+index 903ac5f..046e0ea 100644
+--- a/src/minisoap.c
++++ b/src/minisoap.c
 @@ -90,7 +90,7 @@ int soapPostSubmit(SOCKET fd,
  	headerssize = snprintf(headerbuf, sizeof(headerbuf),
                         "POST %s HTTP/%s\r\n"
  	                   "Host: %s%s\r\n"
--					   "User-Agent: " OS_STRING ", " UPNP_VERSION_STRING ", MiniUPnPc/" MINIUPNPC_VERSION_STRING "\r\n"
+-					   "User-Agent: " OS_STRING " " UPNP_VERSION_STRING " MiniUPnPc/" MINIUPNPC_VERSION_STRING "\r\n"
 +					   "User-Agent: " UPNP_VERSION_STRING "\r\n"
  	                   "Content-Length: %d\r\n"
+ #if (UPNP_VERSION_MAJOR == 1) && (UPNP_VERSION_MINOR == 0)
  					   "Content-Type: text/xml\r\n"
- 					   "SOAPAction: \"%s\"\r\n"
-diff --git a/miniwget.c b/miniwget.c
-index d5b7970..05aeb9c 100644
---- a/miniwget.c
-+++ b/miniwget.c
+diff --git a/src/miniwget.c b/src/miniwget.c
+index e76a5e5..0cc36fe 100644
+--- a/src/miniwget.c
++++ b/src/miniwget.c
 @@ -444,7 +444,7 @@ miniwget3(const char * host,
                   "GET %s HTTP/%s\r\n"
  			     "Host: %s:%d\r\n"
  				 "Connection: Close\r\n"
--				 "User-Agent: " OS_STRING ", " UPNP_VERSION_STRING ", MiniUPnPc/" MINIUPNPC_VERSION_STRING "\r\n"
+-				 "User-Agent: " OS_STRING " " UPNP_VERSION_STRING " MiniUPnPc/" MINIUPNPC_VERSION_STRING "\r\n"
 +				 "User-Agent: " UPNP_VERSION_STRING "\r\n"
  
  				 "\r\n",
diff --git a/depends/patches/miniupnpc/fix_windows_build.patch b/depends/patches/miniupnpc/fix_windows_build.patch
new file mode 100644
index 0000000000..6a4467b7e3
--- /dev/null
+++ b/depends/patches/miniupnpc/fix_windows_build.patch
@@ -0,0 +1,143 @@
+build: Temporary patch to make Windows compile
+
+--- a/Makefile.mingw
++++ b/Makefile.mingw
+@@ -9,10 +9,12 @@
+ #
+ SRCDIR = src
+ INCDIR = include
++BUILD = build
+ 
+ CC ?= gcc
+ SETUP_COMPILER_FLAG?=
+ DLLWRAP = dllwrap
++MKDIR = mkdir -p
+ WINDRES = windres
+ SH = /bin/sh
+ ZIP = zip
+@@ -26,24 +28,25 @@ CFLAGS ?= -Os
+ CFLAGS += -Wall
+ CFLAGS += -W -Wstrict-prototypes
+ 
+-CPPFLAGS += -DNDEBUG -D_WIN32_WINNT=0x501
++CPPFLAGS += -DNDEBUG -D_WIN32_WINNT=0x601
+ CPPFLAGS += -Iinclude
+ CPPFLAGS += -I.
++CPPFLAGS += -I$(BUILD)
+ 
+ # -liphlpapi is needed for GetBestRoute() and GetIpAddrTable()
+ LDLIBS = -lws2_32 -liphlpapi
+ 
+ PYTHON=\utils\python25\python
+-OBJS=miniwget.o minixml.o igd_desc_parse.o minisoap.o \
++OBJS=$(addprefix $(BUILD)/,miniwget.o minixml.o igd_desc_parse.o minisoap.o \
+      minissdpc.o \
+      miniupnpc.o upnpreplyparse.o upnpcommands.o upnperrors.o \
+      connecthostport.o portlistingparse.o receivedata.o \
+-     upnpdev.o addr_is_reserved.o
++     upnpdev.o addr_is_reserved.o)
+ OBJSDLL=$(addprefix dll-, $(OBJS)) winres.o
+-BINARIES=upnpc-static.exe upnpc-shared.exe \
++BINARIES=$(addprefix $(BUILD)/,upnpc-static.exe upnpc-shared.exe \
+          upnp-listdevices-static.exe upnp-listdevices-shared.exe \
+          miniupnpc.dll libminiupnpc.a \
+-         testminixml.exe
++         testminixml.exe)
+ ifneq ($(GITHUB_SHA),)
+ COMMITREF=$(GITHUB_SHA)
+ else
+@@ -76,11 +79,12 @@ clean:
+ 	$(RM) miniupnpc.dll miniupnpc.lib miniupnpc.dll.def
+ 	$(RM) libminiupnpc.a
+ 	$(RM) $(DISTFILE)
++	$(RM) -r build/
+ 
+ $(DISTFILE):	$(BINARIES)
+ 	$(ZIP) $@ *.exe *.dll *.lib *.def *.a LICENSE README Changelog.txt
+ 
+-libminiupnpc.a:	$(OBJS)
++$(BUILD)/libminiupnpc.a: $(OBJS)
+ 	$(AR) cr $@ $?
+ 
+ pythonmodule:	libminiupnpc.a
+@@ -97,13 +101,13 @@ miniupnpc.dll:	miniupnpc.def $(OBJSDLL)
+ 
+ miniupnpc.lib:	miniupnpc.dll
+ 
+-%.o:	$(SRCDIR)/%.c
++$(BUILD)/%.o:	$(SRCDIR)/%.c
+ 	$(CC) $(CFLAGS) $(CPPFLAGS) -DMINIUPNP_STATICLIB -c -o $@ $<
+ 
+-dll-%.o:	$(SRCDIR)/%.c
++$(BUILD)/dll-%.o:	$(SRCDIR)/%.c
+ 	$(CC) $(CFLAGS) $(CPPFLAGS) -DMINIUPNP_EXPORTS -c -o $@ $<
+ 
+-%-shared.o:	$(SRCDIR)/%.c
++$(BUILD)/%-shared.o:	$(SRCDIR)/%.c
+ 	$(CC) $(CFLAGS) $(CPPFLAGS) -c -o $@ $<
+ 
+ # --enable-stdcall-fixup
+@@ -131,7 +135,8 @@ miniupnpcstrings.h: miniupnpcstrings.h.in wingenminiupnpcstrings.exe VERSION
+ 
+ rc_version.h:	miniupnpcstrings.h
+ else
+-miniupnpcstrings.h:	miniupnpcstrings.h.in VERSION
++$(BUILD)/miniupnpcstrings.h:	miniupnpcstrings.h.in VERSION
++	@$(MKDIR) $(@D)
+ 	sed 's|OS_STRING ".*"|OS_STRING "Windows/Mingw32"|' $< | \
+ 	sed 's|MINIUPNPC_VERSION_STRING ".*"|MINIUPNPC_VERSION_STRING "$(shell cat VERSION)"|' > $@
+ 
+@@ -143,7 +148,7 @@ rc_version.h:	VERSION
+ 	mv $@.tmp $@
+ endif
+ 
+-miniupnpc.pc:	VERSION
++$(BUILD)/miniupnpc.pc:	VERSION
+ 	$(RM) $@
+ 	echo "prefix=$(INSTALLPREFIX)" >> $@
+ 	echo "exec_prefix=\$${prefix}" >> $@
+@@ -156,32 +161,32 @@ miniupnpc.pc:	VERSION
+ 	echo "Libs: -L\$${libdir} -lminiupnpc" >> $@
+ 	echo "Cflags: -I\$${includedir}" >> $@
+ 
+-winres.o:	miniupnpc.rc rc_version.h
++$(BUILD)/winres.o:	miniupnpc.rc rc_version.h
+ 	$(WINDRES) -D INTERNAL_NAME=\\\"miniupnpc.dll\\0\\\" -i $< -o $@
+ 
+ testminixml.exe:	testminixml.o minixml.o igd_desc_parse.o
+ 	$(CC) -static -o $@ $^
+ 
+-minixml.o:	$(SRCDIR)/minixml.c $(SRCDIR)/minixml.h
++$(BUILD)/minixml.o:	$(SRCDIR)/minixml.c $(SRCDIR)/minixml.h
+ 
+-upnpc.o:	include/miniwget.h $(SRCDIR)/minisoap.h include/miniupnpc.h include/igd_desc_parse.h
+-upnpc.o:	include/upnpreplyparse.h include/upnpcommands.h include/upnperrors.h miniupnpcstrings.h
++$(BUILD)/upnpc.o:	include/miniwget.h $(SRCDIR)/minisoap.h include/miniupnpc.h include/igd_desc_parse.h
++$(BUILD)/upnpc.o:	include/upnpreplyparse.h include/upnpcommands.h include/upnperrors.h miniupnpcstrings.h
+ 
+-miniwget.o:	$(SRCDIR)/miniwget.c include/miniwget.h miniupnpcstrings.h $(SRCDIR)/connecthostport.h
++$(BUILD)/miniwget.o:	$(SRCDIR)/miniwget.c include/miniwget.h $(BUILD)/miniupnpcstrings.h $(SRCDIR)/connecthostport.h
+ 
+-minisoap.o:	$(SRCDIR)/minisoap.c $(SRCDIR)/minisoap.h miniupnpcstrings.h
++$(BUILD)/minisoap.o:	$(SRCDIR)/minisoap.c $(SRCDIR)/minisoap.h $(BUILD)/miniupnpcstrings.h
+ 
+-miniupnpc.o:	$(SRCDIR)/miniupnpc.c include/miniupnpc.h $(SRCDIR)/minisoap.h \
++$(BUILD)/miniupnpc.o:	$(SRCDIR)/miniupnpc.c include/miniupnpc.h $(SRCDIR)/minisoap.h \
+ 	include/miniwget.h $(SRCDIR)/minixml.h $(SRCDIR)/addr_is_reserved.h
+ 
+-igd_desc_parse.o:	$(SRCDIR)/igd_desc_parse.c include/igd_desc_parse.h
++$(BUILD)/igd_desc_parse.o:	$(SRCDIR)/igd_desc_parse.c include/igd_desc_parse.h
+ 
+-upnpreplyparse.o:	$(SRCDIR)/upnpreplyparse.c include/upnpreplyparse.h $(SRCDIR)/minixml.h
++$(BUILD)/upnpreplyparse.o:	$(SRCDIR)/upnpreplyparse.c include/upnpreplyparse.h $(SRCDIR)/minixml.h
+ 
+-upnpcommands.o:	$(SRCDIR)/upnpcommands.c include/upnpcommands.h include/upnpreplyparse.h \
++$(BUILD)/upnpcommands.o:	$(SRCDIR)/upnpcommands.c include/upnpcommands.h include/upnpreplyparse.h \
+ 	include/miniupnpc.h include/portlistingparse.h
+ 
+-minissdpc.o:	$(SRCDIR)/minissdpc.c $(SRCDIR)/minissdpc.h $(SRCDIR)/receivedata.h
++$(BUILD)/minissdpc.o:	$(SRCDIR)/minissdpc.c $(SRCDIR)/minissdpc.h $(SRCDIR)/receivedata.h
+ 
+-upnpdev.o:	$(SRCDIR)/upnpdev.c include/upnpdev.h
++$(BUILD)/upnpdev.o:	$(SRCDIR)/upnpdev.c include/upnpdev.h
+ 
diff --git a/depends/patches/miniupnpc/respect_mingw_cflags.patch b/depends/patches/miniupnpc/respect_mingw_cflags.patch
deleted file mode 100644
index a44580ddab..0000000000
--- a/depends/patches/miniupnpc/respect_mingw_cflags.patch
+++ /dev/null
@@ -1,23 +0,0 @@
-commit fec515a7ac9991a0ee91068fda046b54b191155e
-Author: fanquake <fanquake@gmail.com>
-Date:   Wed Jul 27 15:52:37 2022 +0100
-
-    build: respect CFLAGS in makefile.mingw
-    
-    Similar to the other Makefile.
-
-    Cherry-pick of https://github.com/miniupnp/miniupnp/pull/619.
-
-diff --git a/Makefile.mingw b/Makefile.mingw
-index 2bff7bd..88430d2 100644
---- a/Makefile.mingw
-+++ b/Makefile.mingw
-@@ -19,7 +19,7 @@ else
- RM = rm -f
- endif
- #CFLAGS = -Wall -g -DDEBUG -D_WIN32_WINNT=0X501
--CFLAGS = -Wall -W -Wstrict-prototypes -Os -DNDEBUG -D_WIN32_WINNT=0X501
-+CFLAGS ?= -Wall -W -Wstrict-prototypes -Os -DNDEBUG -D_WIN32_WINNT=0X501
- LDLIBS = -lws2_32 -liphlpapi
- # -lwsock32
- # -liphlpapi is needed for GetBestRoute() and GetIpAddrTable()
diff --git a/doc/dependencies.md b/doc/dependencies.md
index 43973d0c15..2b9d9128d3 100644
--- a/doc/dependencies.md
+++ b/doc/dependencies.md
@@ -36,7 +36,7 @@ You can find installation instructions in the `build-*.md` file for your platfor
 | Dependency | Releases | Version used | Minimum required | Runtime |
 | --- | --- | --- | --- | --- |
 | [libnatpmp](../depends/packages/libnatpmp.mk) | [link](https://github.com/miniupnp/libnatpmp/) | commit [f2433be...](https://github.com/bitcoin/bitcoin/pull/29708) | | No |
-| [MiniUPnPc](../depends/packages/miniupnpc.mk) | [link](https://miniupnp.tuxfamily.org/) | [2.2.2](https://github.com/bitcoin/bitcoin/pull/20421) | 2.1 | No |
+| [MiniUPnPc](../depends/packages/miniupnpc.mk) | [link](https://miniupnp.tuxfamily.org/) | [2.2.7](https://github.com/bitcoin/bitcoin/pull/29707) | 2.1 | No |
 
 ### Notifications
 | Dependency | Releases | Version used | Minimum required | Runtime |

From f5618c79d9e7af05c2987044dc2da03697f8bb89 Mon Sep 17 00:00:00 2001
From: fanquake <fanquake@gmail.com>
Date: Fri, 22 Mar 2024 14:29:21 +0000
Subject: [PATCH 43/63] depends: add upstream CMake patch to miniupnpc

---
 depends/packages/miniupnpc.mk                 |  5 +++--
 .../miniupnpc/cmake_get_src_addr.patch        | 22 +++++++++++++++++++
 2 files changed, 25 insertions(+), 2 deletions(-)
 create mode 100644 depends/patches/miniupnpc/cmake_get_src_addr.patch

diff --git a/depends/packages/miniupnpc.mk b/depends/packages/miniupnpc.mk
index 39c640f1e7..93b29fe6ba 100644
--- a/depends/packages/miniupnpc.mk
+++ b/depends/packages/miniupnpc.mk
@@ -3,7 +3,7 @@ $(package)_version=2.2.7
 $(package)_download_path=https://miniupnp.tuxfamily.org/files/
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
 $(package)_sha256_hash=b0c3a27056840fd0ec9328a5a9bac3dc5e0ec6d2e8733349cf577b0aa1e70ac1
-$(package)_patches=dont_leak_info.patch no_libtool.patch fix_windows_build.patch
+$(package)_patches=dont_leak_info.patch no_libtool.patch fix_windows_build.patch cmake_get_src_addr.patch
 
 define $(package)_set_vars
 $(package)_build_opts=CC="$($(package)_cc)"
@@ -14,7 +14,8 @@ endef
 define $(package)_preprocess_cmds
   patch -p1 < $($(package)_patch_dir)/dont_leak_info.patch && \
   patch -p1 < $($(package)_patch_dir)/no_libtool.patch && \
-  patch -p1 < $($(package)_patch_dir)/fix_windows_build.patch
+  patch -p1 < $($(package)_patch_dir)/fix_windows_build.patch && \
+  patch -p1 < $($(package)_patch_dir)/cmake_get_src_addr.patch
 endef
 
 define $(package)_build_cmds
diff --git a/depends/patches/miniupnpc/cmake_get_src_addr.patch b/depends/patches/miniupnpc/cmake_get_src_addr.patch
new file mode 100644
index 0000000000..bae1b738f3
--- /dev/null
+++ b/depends/patches/miniupnpc/cmake_get_src_addr.patch
@@ -0,0 +1,22 @@
+commit cb2026239c2a3aff393952ccb0ee1c448189402d
+Author: fanquake <fanquake@gmail.com>
+Date:   Fri Mar 22 14:03:54 2024 +0000
+
+    build: add MINIUPNPC_GET_SRC_ADDR to CMake build
+    
+    This mirrors the autotools build.
+
+    See https://github.com/miniupnp/miniupnp/pull/721.
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 1aa95a8..0cacf3e 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -31,6 +31,7 @@ endif ()
+ if (NOT WIN32)
+   target_compile_definitions(miniupnpc-private INTERFACE
+     MINIUPNPC_SET_SOCKET_TIMEOUT
++    MINIUPNPC_GET_SRC_ADDR
+     _BSD_SOURCE _DEFAULT_SOURCE)
+   if (NOT APPLE AND NOT CMAKE_SYSTEM_NAME MATCHES ".*BSD" AND NOT CMAKE_SYSTEM_NAME STREQUAL "SunOS")
+     # add_definitions (-D_POSIX_C_SOURCE=200112L)

From 3c2d440f1497f60bb444326f51383df244dcdfe9 Mon Sep 17 00:00:00 2001
From: Cory Fields <cory-nospam-@coryfields.com>
Date: Wed, 19 Apr 2023 16:49:04 -0400
Subject: [PATCH 44/63] depends: switch miniupnpc to CMake

Co-authored-by: Hennadii Stepanov <32963518+hebasto@users.noreply.github.com>
Co-authored-by: fanquake <fanquake@gmail.com>
---
 depends/packages/miniupnpc.mk                 |  21 +--
 .../patches/miniupnpc/fix_windows_build.patch | 143 ------------------
 depends/patches/miniupnpc/no_libtool.patch    |  15 --
 3 files changed, 11 insertions(+), 168 deletions(-)
 delete mode 100644 depends/patches/miniupnpc/fix_windows_build.patch
 delete mode 100644 depends/patches/miniupnpc/no_libtool.patch

diff --git a/depends/packages/miniupnpc.mk b/depends/packages/miniupnpc.mk
index 93b29fe6ba..28916729c4 100644
--- a/depends/packages/miniupnpc.mk
+++ b/depends/packages/miniupnpc.mk
@@ -3,27 +3,28 @@ $(package)_version=2.2.7
 $(package)_download_path=https://miniupnp.tuxfamily.org/files/
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
 $(package)_sha256_hash=b0c3a27056840fd0ec9328a5a9bac3dc5e0ec6d2e8733349cf577b0aa1e70ac1
-$(package)_patches=dont_leak_info.patch no_libtool.patch fix_windows_build.patch cmake_get_src_addr.patch
+$(package)_patches=dont_leak_info.patch cmake_get_src_addr.patch
+$(package)_build_subdir=build
 
 define $(package)_set_vars
-$(package)_build_opts=CC="$($(package)_cc)"
-$(package)_build_opts_mingw32=-f Makefile.mingw CFLAGS="$($(package)_cflags)"
-$(package)_build_env+=CFLAGS="$($(package)_cflags) $($(package)_cppflags)" AR="$($(package)_ar)"
+$(package)_config_opts = -DUPNPC_BUILD_SAMPLE=OFF -DUPNPC_BUILD_SHARED=OFF
+$(package)_config_opts += -DUPNPC_BUILD_STATIC=ON -DUPNPC_BUILD_TESTS=OFF
+$(package)_config_opts_mingw32 += -DMINIUPNPC_TARGET_WINDOWS_VERSION=0x0601
 endef
 
 define $(package)_preprocess_cmds
   patch -p1 < $($(package)_patch_dir)/dont_leak_info.patch && \
-  patch -p1 < $($(package)_patch_dir)/no_libtool.patch && \
-  patch -p1 < $($(package)_patch_dir)/fix_windows_build.patch && \
   patch -p1 < $($(package)_patch_dir)/cmake_get_src_addr.patch
 endef
 
+define $(package)_config_cmds
+  $($(package)_cmake) -S .. -B .
+endef
+
 define $(package)_build_cmds
-	$(MAKE) build/libminiupnpc.a $($(package)_build_opts)
+  $(MAKE)
 endef
 
 define $(package)_stage_cmds
-	mkdir -p $($(package)_staging_prefix_dir)/include/miniupnpc $($(package)_staging_prefix_dir)/lib &&\
-	install include/*.h $($(package)_staging_prefix_dir)/include/miniupnpc &&\
-	install build/libminiupnpc.a $($(package)_staging_prefix_dir)/lib
+  cmake --install . --prefix $($(package)_staging_prefix_dir)
 endef
diff --git a/depends/patches/miniupnpc/fix_windows_build.patch b/depends/patches/miniupnpc/fix_windows_build.patch
deleted file mode 100644
index 6a4467b7e3..0000000000
--- a/depends/patches/miniupnpc/fix_windows_build.patch
+++ /dev/null
@@ -1,143 +0,0 @@
-build: Temporary patch to make Windows compile
-
---- a/Makefile.mingw
-+++ b/Makefile.mingw
-@@ -9,10 +9,12 @@
- #
- SRCDIR = src
- INCDIR = include
-+BUILD = build
- 
- CC ?= gcc
- SETUP_COMPILER_FLAG?=
- DLLWRAP = dllwrap
-+MKDIR = mkdir -p
- WINDRES = windres
- SH = /bin/sh
- ZIP = zip
-@@ -26,24 +28,25 @@ CFLAGS ?= -Os
- CFLAGS += -Wall
- CFLAGS += -W -Wstrict-prototypes
- 
--CPPFLAGS += -DNDEBUG -D_WIN32_WINNT=0x501
-+CPPFLAGS += -DNDEBUG -D_WIN32_WINNT=0x601
- CPPFLAGS += -Iinclude
- CPPFLAGS += -I.
-+CPPFLAGS += -I$(BUILD)
- 
- # -liphlpapi is needed for GetBestRoute() and GetIpAddrTable()
- LDLIBS = -lws2_32 -liphlpapi
- 
- PYTHON=\utils\python25\python
--OBJS=miniwget.o minixml.o igd_desc_parse.o minisoap.o \
-+OBJS=$(addprefix $(BUILD)/,miniwget.o minixml.o igd_desc_parse.o minisoap.o \
-      minissdpc.o \
-      miniupnpc.o upnpreplyparse.o upnpcommands.o upnperrors.o \
-      connecthostport.o portlistingparse.o receivedata.o \
--     upnpdev.o addr_is_reserved.o
-+     upnpdev.o addr_is_reserved.o)
- OBJSDLL=$(addprefix dll-, $(OBJS)) winres.o
--BINARIES=upnpc-static.exe upnpc-shared.exe \
-+BINARIES=$(addprefix $(BUILD)/,upnpc-static.exe upnpc-shared.exe \
-          upnp-listdevices-static.exe upnp-listdevices-shared.exe \
-          miniupnpc.dll libminiupnpc.a \
--         testminixml.exe
-+         testminixml.exe)
- ifneq ($(GITHUB_SHA),)
- COMMITREF=$(GITHUB_SHA)
- else
-@@ -76,11 +79,12 @@ clean:
- 	$(RM) miniupnpc.dll miniupnpc.lib miniupnpc.dll.def
- 	$(RM) libminiupnpc.a
- 	$(RM) $(DISTFILE)
-+	$(RM) -r build/
- 
- $(DISTFILE):	$(BINARIES)
- 	$(ZIP) $@ *.exe *.dll *.lib *.def *.a LICENSE README Changelog.txt
- 
--libminiupnpc.a:	$(OBJS)
-+$(BUILD)/libminiupnpc.a: $(OBJS)
- 	$(AR) cr $@ $?
- 
- pythonmodule:	libminiupnpc.a
-@@ -97,13 +101,13 @@ miniupnpc.dll:	miniupnpc.def $(OBJSDLL)
- 
- miniupnpc.lib:	miniupnpc.dll
- 
--%.o:	$(SRCDIR)/%.c
-+$(BUILD)/%.o:	$(SRCDIR)/%.c
- 	$(CC) $(CFLAGS) $(CPPFLAGS) -DMINIUPNP_STATICLIB -c -o $@ $<
- 
--dll-%.o:	$(SRCDIR)/%.c
-+$(BUILD)/dll-%.o:	$(SRCDIR)/%.c
- 	$(CC) $(CFLAGS) $(CPPFLAGS) -DMINIUPNP_EXPORTS -c -o $@ $<
- 
--%-shared.o:	$(SRCDIR)/%.c
-+$(BUILD)/%-shared.o:	$(SRCDIR)/%.c
- 	$(CC) $(CFLAGS) $(CPPFLAGS) -c -o $@ $<
- 
- # --enable-stdcall-fixup
-@@ -131,7 +135,8 @@ miniupnpcstrings.h: miniupnpcstrings.h.in wingenminiupnpcstrings.exe VERSION
- 
- rc_version.h:	miniupnpcstrings.h
- else
--miniupnpcstrings.h:	miniupnpcstrings.h.in VERSION
-+$(BUILD)/miniupnpcstrings.h:	miniupnpcstrings.h.in VERSION
-+	@$(MKDIR) $(@D)
- 	sed 's|OS_STRING ".*"|OS_STRING "Windows/Mingw32"|' $< | \
- 	sed 's|MINIUPNPC_VERSION_STRING ".*"|MINIUPNPC_VERSION_STRING "$(shell cat VERSION)"|' > $@
- 
-@@ -143,7 +148,7 @@ rc_version.h:	VERSION
- 	mv $@.tmp $@
- endif
- 
--miniupnpc.pc:	VERSION
-+$(BUILD)/miniupnpc.pc:	VERSION
- 	$(RM) $@
- 	echo "prefix=$(INSTALLPREFIX)" >> $@
- 	echo "exec_prefix=\$${prefix}" >> $@
-@@ -156,32 +161,32 @@ miniupnpc.pc:	VERSION
- 	echo "Libs: -L\$${libdir} -lminiupnpc" >> $@
- 	echo "Cflags: -I\$${includedir}" >> $@
- 
--winres.o:	miniupnpc.rc rc_version.h
-+$(BUILD)/winres.o:	miniupnpc.rc rc_version.h
- 	$(WINDRES) -D INTERNAL_NAME=\\\"miniupnpc.dll\\0\\\" -i $< -o $@
- 
- testminixml.exe:	testminixml.o minixml.o igd_desc_parse.o
- 	$(CC) -static -o $@ $^
- 
--minixml.o:	$(SRCDIR)/minixml.c $(SRCDIR)/minixml.h
-+$(BUILD)/minixml.o:	$(SRCDIR)/minixml.c $(SRCDIR)/minixml.h
- 
--upnpc.o:	include/miniwget.h $(SRCDIR)/minisoap.h include/miniupnpc.h include/igd_desc_parse.h
--upnpc.o:	include/upnpreplyparse.h include/upnpcommands.h include/upnperrors.h miniupnpcstrings.h
-+$(BUILD)/upnpc.o:	include/miniwget.h $(SRCDIR)/minisoap.h include/miniupnpc.h include/igd_desc_parse.h
-+$(BUILD)/upnpc.o:	include/upnpreplyparse.h include/upnpcommands.h include/upnperrors.h miniupnpcstrings.h
- 
--miniwget.o:	$(SRCDIR)/miniwget.c include/miniwget.h miniupnpcstrings.h $(SRCDIR)/connecthostport.h
-+$(BUILD)/miniwget.o:	$(SRCDIR)/miniwget.c include/miniwget.h $(BUILD)/miniupnpcstrings.h $(SRCDIR)/connecthostport.h
- 
--minisoap.o:	$(SRCDIR)/minisoap.c $(SRCDIR)/minisoap.h miniupnpcstrings.h
-+$(BUILD)/minisoap.o:	$(SRCDIR)/minisoap.c $(SRCDIR)/minisoap.h $(BUILD)/miniupnpcstrings.h
- 
--miniupnpc.o:	$(SRCDIR)/miniupnpc.c include/miniupnpc.h $(SRCDIR)/minisoap.h \
-+$(BUILD)/miniupnpc.o:	$(SRCDIR)/miniupnpc.c include/miniupnpc.h $(SRCDIR)/minisoap.h \
- 	include/miniwget.h $(SRCDIR)/minixml.h $(SRCDIR)/addr_is_reserved.h
- 
--igd_desc_parse.o:	$(SRCDIR)/igd_desc_parse.c include/igd_desc_parse.h
-+$(BUILD)/igd_desc_parse.o:	$(SRCDIR)/igd_desc_parse.c include/igd_desc_parse.h
- 
--upnpreplyparse.o:	$(SRCDIR)/upnpreplyparse.c include/upnpreplyparse.h $(SRCDIR)/minixml.h
-+$(BUILD)/upnpreplyparse.o:	$(SRCDIR)/upnpreplyparse.c include/upnpreplyparse.h $(SRCDIR)/minixml.h
- 
--upnpcommands.o:	$(SRCDIR)/upnpcommands.c include/upnpcommands.h include/upnpreplyparse.h \
-+$(BUILD)/upnpcommands.o:	$(SRCDIR)/upnpcommands.c include/upnpcommands.h include/upnpreplyparse.h \
- 	include/miniupnpc.h include/portlistingparse.h
- 
--minissdpc.o:	$(SRCDIR)/minissdpc.c $(SRCDIR)/minissdpc.h $(SRCDIR)/receivedata.h
-+$(BUILD)/minissdpc.o:	$(SRCDIR)/minissdpc.c $(SRCDIR)/minissdpc.h $(SRCDIR)/receivedata.h
- 
--upnpdev.o:	$(SRCDIR)/upnpdev.c include/upnpdev.h
-+$(BUILD)/upnpdev.o:	$(SRCDIR)/upnpdev.c include/upnpdev.h
- 
diff --git a/depends/patches/miniupnpc/no_libtool.patch b/depends/patches/miniupnpc/no_libtool.patch
deleted file mode 100644
index bb7d4a87ef..0000000000
--- a/depends/patches/miniupnpc/no_libtool.patch
+++ /dev/null
@@ -1,15 +0,0 @@
-diff -ruN miniupnpc-2.2.2/Makefile miniupnpc-2.2.2.new/Makefile
---- miniupnpc-2.2.2/Makefile	2020-11-27 18:25:02.000000000 +0000
-+++ miniupnpc-2.2.2.new/Makefile	2024-01-23 20:58:08.387188527 +0000
-@@ -298,11 +298,7 @@
- 	makedepend -Y -- $(CFLAGS) -- $(SRCS) 2>/dev/null
- 
- $(LIBRARY):	$(LIBOBJS)
--ifneq (, $(findstring darwin, $(OS)))
--	$(LIBTOOL) -static -o $@ $?
--else
- 	$(AR) crs $@ $?
--endif
- 
- $(SHAREDLIBRARY):	$(LIBOBJS)
- ifneq (, $(findstring darwin, $(OS)))

From 5195baa60087ee366290887ad982fc491e14c111 Mon Sep 17 00:00:00 2001
From: fanquake <fanquake@gmail.com>
Date: Tue, 30 Apr 2024 13:28:59 +0800
Subject: [PATCH 45/63] depends: fix miniupnpc snprintf usage on Windows

---
 depends/packages/miniupnpc.mk                 |  5 ++--
 .../miniupnpc/fix_windows_snprintf.patch      | 25 +++++++++++++++++++
 2 files changed, 28 insertions(+), 2 deletions(-)
 create mode 100644 depends/patches/miniupnpc/fix_windows_snprintf.patch

diff --git a/depends/packages/miniupnpc.mk b/depends/packages/miniupnpc.mk
index 28916729c4..077e3bb1ee 100644
--- a/depends/packages/miniupnpc.mk
+++ b/depends/packages/miniupnpc.mk
@@ -3,7 +3,7 @@ $(package)_version=2.2.7
 $(package)_download_path=https://miniupnp.tuxfamily.org/files/
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
 $(package)_sha256_hash=b0c3a27056840fd0ec9328a5a9bac3dc5e0ec6d2e8733349cf577b0aa1e70ac1
-$(package)_patches=dont_leak_info.patch cmake_get_src_addr.patch
+$(package)_patches=dont_leak_info.patch cmake_get_src_addr.patch fix_windows_snprintf.patch
 $(package)_build_subdir=build
 
 define $(package)_set_vars
@@ -14,7 +14,8 @@ endef
 
 define $(package)_preprocess_cmds
   patch -p1 < $($(package)_patch_dir)/dont_leak_info.patch && \
-  patch -p1 < $($(package)_patch_dir)/cmake_get_src_addr.patch
+  patch -p1 < $($(package)_patch_dir)/cmake_get_src_addr.patch && \
+  patch -p1 < $($(package)_patch_dir)/fix_windows_snprintf.patch
 endef
 
 define $(package)_config_cmds
diff --git a/depends/patches/miniupnpc/fix_windows_snprintf.patch b/depends/patches/miniupnpc/fix_windows_snprintf.patch
new file mode 100644
index 0000000000..ff9e26231e
--- /dev/null
+++ b/depends/patches/miniupnpc/fix_windows_snprintf.patch
@@ -0,0 +1,25 @@
+commit a1e9de80ab99b4c956a6a4e21d3e0de6f7a1014d
+Author: Hennadii Stepanov <32963518+hebasto@users.noreply.github.com>
+Date:   Sat Apr 20 15:14:47 2024 +0100
+
+    Fix macro expression that guards `snprintf` for Windows
+
+    Otherwise, the `snprintf` is still wrongly emulated for the following
+    cases:
+     - mingw-w64 6.0.0 or new with ucrt
+     - mingw-w64 8.0.0 or new with iso c ext
+
+--- a/src/win32_snprintf.h
++++ b/src/win32_snprintf.h
+@@ -23,9 +23,9 @@
+ 	(defined(_MSC_VER) && _MSC_VER < 1900) /* Visual Studio older than 2015 */ || \
+ 	(defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR) && defined(__NO_ISOCEXT)) /* mingw32 without iso c ext */ || \
+ 	(defined(__MINGW64_VERSION_MAJOR) && /* mingw-w64 not ... */ !( \
+-		(defined (__USE_MINGW_ANSI_STDIO) && __USE_MINGW_ANSI_STDIO != 0)) /* ... with ansi stdio */ || \
++		(defined (__USE_MINGW_ANSI_STDIO) && __USE_MINGW_ANSI_STDIO != 0) /* ... with ansi stdio */ || \
+ 		(__MINGW64_VERSION_MAJOR >= 6 && defined(_UCRT)) /* ... at least 6.0.0 with ucrt */ || \
+-		(__MINGW64_VERSION_MAJOR >= 8 && !defined(__NO_ISOCEXT)) /* ... at least 8.0.0 with iso c ext */ || \
++		(__MINGW64_VERSION_MAJOR >= 8 && !defined(__NO_ISOCEXT))) /* ... at least 8.0.0 with iso c ext */ || \
+ 	0) || \
+ 0)
+ 

From fa9be2f79520fff9cfe2ed35ace05cb322680af3 Mon Sep 17 00:00:00 2001
From: MarcoFalke <*~=`'#}+{/-|&$^_@721217.xyz>
Date: Wed, 1 May 2024 08:19:57 +0200
Subject: [PATCH 46/63] lint: [doc] Clarify Windows line endings (CR LF) not to
 be used

---
 test/lint/test_runner/src/main.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/lint/test_runner/src/main.rs b/test/lint/test_runner/src/main.rs
index e22e047e4b..f054f99011 100644
--- a/test/lint/test_runner/src/main.rs
+++ b/test/lint/test_runner/src/main.rs
@@ -137,9 +137,9 @@ fn lint_trailing_whitespace() -> LintResult {
     if trailing_space {
         Err(r#"
 ^^^
-Trailing whitespace is problematic, because git may warn about it, or editors may remove it by
-default, forcing developers in the future to either undo the changes manually or spend time on
-review.
+Trailing whitespace (including Windows line endings [CR LF]) is problematic, because git may warn
+about it, or editors may remove it by default, forcing developers in the future to either undo the
+changes manually or spend time on review.
 
 Thus, it is best to remove the trailing space now.
 

From 8496f69e1c2d1961db2604829cb6a289eb8dd3d6 Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Mon, 29 Apr 2024 17:53:59 +0100
Subject: [PATCH 47/63] [refactor] make
 MempoolAcceptResult::m_replaced_transactions non-optional

---
 src/net_processing.cpp      | 12 +++---------
 src/rpc/mempool.cpp         |  6 ++----
 src/test/fuzz/tx_pool.cpp   |  2 --
 src/test/util/txmempool.cpp |  6 ------
 src/validation.h            |  3 +--
 5 files changed, 6 insertions(+), 23 deletions(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index bdbf077ab5..6aefd6aa79 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -3281,9 +3281,7 @@ void PeerManagerImpl::ProcessPackageResult(const Package& package, const Package
             switch (tx_result.m_result_type) {
                 case MempoolAcceptResult::ResultType::VALID:
                 {
-                    Assume(tx_result.m_replaced_transactions.has_value());
-                    std::list<CTransactionRef> empty_replacement_list;
-                    ProcessValidTx(nodeid, tx, tx_result.m_replaced_transactions.value_or(empty_replacement_list));
+                    ProcessValidTx(nodeid, tx, tx_result.m_replaced_transactions);
                     break;
                 }
                 case MempoolAcceptResult::ResultType::INVALID:
@@ -3378,9 +3376,7 @@ bool PeerManagerImpl::ProcessOrphanTx(Peer& peer)
 
         if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
             LogPrint(BCLog::TXPACKAGES, "   accepted orphan tx %s (wtxid=%s)\n", orphanHash.ToString(), orphan_wtxid.ToString());
-            Assume(result.m_replaced_transactions.has_value());
-            std::list<CTransactionRef> empty_replacement_list;
-            ProcessValidTx(peer.m_id, porphanTx, result.m_replaced_transactions.value_or(empty_replacement_list));
+            ProcessValidTx(peer.m_id, porphanTx, result.m_replaced_transactions);
             return true;
         } else if (state.GetResult() != TxValidationResult::TX_MISSING_INPUTS) {
             LogPrint(BCLog::TXPACKAGES, "   invalid orphan tx %s (wtxid=%s) from peer=%d. %s\n",
@@ -4578,9 +4574,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
         const TxValidationState& state = result.m_state;
 
         if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
-            Assume(result.m_replaced_transactions.has_value());
-            std::list<CTransactionRef> empty_replacement_list;
-            ProcessValidTx(pfrom.GetId(), ptx, result.m_replaced_transactions.value_or(empty_replacement_list));
+            ProcessValidTx(pfrom.GetId(), ptx, result.m_replaced_transactions);
             pfrom.m_last_tx_time = GetTime<std::chrono::seconds>();
         }
         else if (state.GetResult() == TxValidationResult::TX_MISSING_INPUTS)
diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index 920bb9ea7f..e6fe3c7ebd 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -994,10 +994,8 @@ static RPCHelpMan submitpackage()
                         fees.pushKV("effective-includes", effective_includes_res);
                     }
                     result_inner.pushKV("fees", fees);
-                    if (it->second.m_replaced_transactions.has_value()) {
-                        for (const auto& ptx : it->second.m_replaced_transactions.value()) {
-                            replaced_txids.insert(ptx->GetHash());
-                        }
+                    for (const auto& ptx : it->second.m_replaced_transactions) {
+                        replaced_txids.insert(ptx->GetHash());
                     }
                     break;
                 }
diff --git a/src/test/fuzz/tx_pool.cpp b/src/test/fuzz/tx_pool.cpp
index 0b4019d5eb..9f0aedf29b 100644
--- a/src/test/fuzz/tx_pool.cpp
+++ b/src/test/fuzz/tx_pool.cpp
@@ -139,7 +139,6 @@ void CheckATMPInvariants(const MempoolAcceptResult& res, bool txid_in_mempool, b
         Assert(wtxid_in_mempool);
         Assert(res.m_state.IsValid());
         Assert(!res.m_state.IsInvalid());
-        Assert(res.m_replaced_transactions);
         Assert(res.m_vsize);
         Assert(res.m_base_fees);
         Assert(res.m_effective_feerate);
@@ -154,7 +153,6 @@ void CheckATMPInvariants(const MempoolAcceptResult& res, bool txid_in_mempool, b
         Assert(res.m_state.IsInvalid());
 
         const bool is_reconsiderable{res.m_state.GetResult() == TxValidationResult::TX_RECONSIDERABLE};
-        Assert(!res.m_replaced_transactions);
         Assert(!res.m_vsize);
         Assert(!res.m_base_fees);
         // Fee information is provided if the failure is TX_RECONSIDERABLE.
diff --git a/src/test/util/txmempool.cpp b/src/test/util/txmempool.cpp
index 71cf8aca60..870cdd0b32 100644
--- a/src/test/util/txmempool.cpp
+++ b/src/test/util/txmempool.cpp
@@ -68,12 +68,6 @@ std::optional<std::string> CheckPackageMempoolAcceptResult(const Package& txns,
             return strprintf("tx %s unexpectedly failed: %s", wtxid.ToString(), atmp_result.m_state.ToString());
         }
 
-        //m_replaced_transactions should exist iff the result was VALID
-        if (atmp_result.m_replaced_transactions.has_value() != valid) {
-            return strprintf("tx %s result should %shave m_replaced_transactions",
-                                    wtxid.ToString(), valid ? "" : "not ");
-        }
-
         // m_vsize and m_base_fees should exist iff the result was VALID or MEMPOOL_ENTRY
         const bool mempool_entry{atmp_result.m_result_type == MempoolAcceptResult::ResultType::MEMPOOL_ENTRY};
         if (atmp_result.m_base_fees.has_value() != (valid || mempool_entry)) {
diff --git a/src/validation.h b/src/validation.h
index e3b2a2d59b..28b045fe80 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -113,7 +113,6 @@ void PruneBlockFilesManual(Chainstate& active_chainstate, int nManualPruneHeight
 *| txid in mempool?          | yes            | no                | no*              | yes            | yes               |
 *| wtxid in mempool?         | yes            | no                | no*              | yes            | no                |
 *| m_state                   | yes, IsValid() | yes, IsInvalid()  | yes, IsInvalid() | yes, IsValid() | yes, IsValid()    |
-*| m_replaced_transactions   | yes            | no                | no               | no             | no                |
 *| m_vsize                   | yes            | no                | no               | yes            | no                |
 *| m_base_fees               | yes            | no                | no               | yes            | no                |
 *| m_effective_feerate       | yes            | yes               | no               | no             | no                |
@@ -139,7 +138,7 @@ struct MempoolAcceptResult {
     const TxValidationState m_state;
 
     /** Mempool transactions replaced by the tx. */
-    const std::optional<std::list<CTransactionRef>> m_replaced_transactions;
+    const std::list<CTransactionRef> m_replaced_transactions;
     /** Virtual size as used by the mempool, calculated using serialized size and sigops. */
     const std::optional<int64_t> m_vsize;
     /** Raw base fees in satoshis. */

From 9a762efc7a118c44556fa9ad404f6b54103bad41 Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Wed, 1 May 2024 13:33:30 +0100
Subject: [PATCH 48/63] [txpackages] use std::lexicographical_compare instead
 of sorting hex strings

No behavior change, but getting the hex string is more expensive than
necessary.
---
 src/policy/packages.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/policy/packages.cpp b/src/policy/packages.cpp
index 99d2a6d514..693adcdfd0 100644
--- a/src/policy/packages.cpp
+++ b/src/policy/packages.cpp
@@ -156,7 +156,10 @@ uint256 GetPackageHash(const std::vector<CTransactionRef>& transactions)
         [](const auto& tx){ return tx->GetWitnessHash(); });
 
     // Sort in ascending order
-    std::sort(wtxids_copy.begin(), wtxids_copy.end(), [](const auto& lhs, const auto& rhs) { return lhs.GetHex() < rhs.GetHex(); });
+    std::sort(wtxids_copy.begin(), wtxids_copy.end(), [](const auto& lhs, const auto& rhs) {
+        return std::lexicographical_compare(std::make_reverse_iterator(lhs.end()), std::make_reverse_iterator(lhs.begin()),
+                                            std::make_reverse_iterator(rhs.end()), std::make_reverse_iterator(rhs.begin()));
+    });
 
     // Get sha256 hash of the wtxids concatenated in this order
     HashWriter hashwriter;

From c2ada0530719e044bb498e0d78907a208214a71e Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Wed, 1 May 2024 13:35:12 +0100
Subject: [PATCH 49/63] [doc] remove redundant PackageToValidate comment

---
 src/net_processing.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 6aefd6aa79..ec334abf35 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -608,7 +608,6 @@ class PeerManagerImpl final : public PeerManager
     void ProcessPackageResult(const Package& package, const PackageMempoolAcceptResult& package_result, const std::vector<NodeId>& senders)
         EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, g_msgproc_mutex, cs_main);
 
-    /** A package to validate  */
     struct PackageToValidate {
         const Package m_txns;
         const std::vector<NodeId> m_senders;

From 2b482dc1f3fb248ccbe7eeb8c9c07d4bf1295a70 Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Wed, 1 May 2024 13:38:19 +0100
Subject: [PATCH 50/63] [refactor] have ProcessPackageResult take a
 PackageToValidate

---
 src/net_processing.cpp | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index ec334abf35..d64c85ae9a 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -600,14 +600,6 @@ class PeerManagerImpl final : public PeerManager
     void ProcessValidTx(NodeId nodeid, const CTransactionRef& tx, const std::list<CTransactionRef>& replaced_transactions)
         EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, g_msgproc_mutex, cs_main);
 
-    /** Handle the results of package validation: calls ProcessValidTx and ProcessInvalidTx for
-     * individual transactions, and caches rejection for the package as a group.
-     * @param[in]   senders     Must contain the nodeids of the peers that provided each transaction
-     *                          in package, in the same order.
-     *   */
-    void ProcessPackageResult(const Package& package, const PackageMempoolAcceptResult& package_result, const std::vector<NodeId>& senders)
-        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, g_msgproc_mutex, cs_main);
-
     struct PackageToValidate {
         const Package m_txns;
         const std::vector<NodeId> m_senders;
@@ -632,6 +624,12 @@ class PeerManagerImpl final : public PeerManager
         }
     };
 
+    /** Handle the results of package validation: calls ProcessValidTx and ProcessInvalidTx for
+     * individual transactions, and caches rejection for the package as a group.
+     */
+    void ProcessPackageResult(const PackageToValidate& package_to_validate, const PackageMempoolAcceptResult& package_result)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, g_msgproc_mutex, cs_main);
+
     /** Look for a child of this transaction in the orphanage to form a 1-parent-1-child package,
      * skipping any combinations that have already been tried. Return the resulting package along with
      * the senders of its respective transactions, or std::nullopt if no package is found. */
@@ -3251,12 +3249,15 @@ void PeerManagerImpl::ProcessValidTx(NodeId nodeid, const CTransactionRef& tx, c
     }
 }
 
-void PeerManagerImpl::ProcessPackageResult(const Package& package, const PackageMempoolAcceptResult& package_result, const std::vector<NodeId>& senders)
+void PeerManagerImpl::ProcessPackageResult(const PackageToValidate& package_to_validate, const PackageMempoolAcceptResult& package_result)
 {
     AssertLockNotHeld(m_peer_mutex);
     AssertLockHeld(g_msgproc_mutex);
     AssertLockHeld(cs_main);
 
+    const auto& package = package_to_validate.m_txns;
+    const auto& senders = package_to_validate.m_senders;
+
     if (package_result.m_state.IsInvalid()) {
         m_recent_rejects_reconsiderable.insert(GetPackageHash(package));
     }
@@ -4548,7 +4549,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
                     const auto package_result{ProcessNewPackage(m_chainman.ActiveChainstate(), m_mempool, package_to_validate->m_txns, /*test_accept=*/false, /*client_maxfeerate=*/std::nullopt)};
                     LogDebug(BCLog::TXPACKAGES, "package evaluation for %s: %s\n", package_to_validate->ToString(),
                              package_result.m_state.IsValid() ? "package accepted" : "package rejected");
-                    ProcessPackageResult(package_to_validate->m_txns, package_result, package_to_validate->m_senders);
+                    ProcessPackageResult(package_to_validate.value(), package_result);
                 }
             }
             // If a tx is detected by m_recent_rejects it is ignored. Because we haven't
@@ -4663,7 +4664,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
                 const auto package_result{ProcessNewPackage(m_chainman.ActiveChainstate(), m_mempool, package_to_validate->m_txns, /*test_accept=*/false, /*client_maxfeerate=*/std::nullopt)};
                 LogDebug(BCLog::TXPACKAGES, "package evaluation for %s: %s\n", package_to_validate->ToString(),
                          package_result.m_state.IsValid() ? "package accepted" : "package rejected");
-                ProcessPackageResult(package_to_validate->m_txns, package_result, package_to_validate->m_senders);
+                ProcessPackageResult(package_to_validate.value(), package_result);
             }
         }
 

From 6119f76ef72c1adc55c1a384c20f8ba9e1a01206 Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Wed, 1 May 2024 13:48:03 +0100
Subject: [PATCH 51/63] Process every MempoolAcceptResult regardless of
 PackageValidationResult

---
 src/net_processing.cpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index d64c85ae9a..34f108f901 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -3264,10 +3264,6 @@ void PeerManagerImpl::ProcessPackageResult(const PackageToValidate& package_to_v
     // We currently only expect to process 1-parent-1-child packages. Remove if this changes.
     if (!Assume(package.size() == 2)) return;
 
-    // No package results to look through for PCKG_POLICY or PCKG_MEMPOOL_ERROR
-    if (package_result.m_state.GetResult() == PackageValidationResult::PCKG_POLICY ||
-        package_result.m_state.GetResult() == PackageValidationResult::PCKG_MEMPOOL_ERROR) return;
-
     // Iterate backwards to erase in-package descendants from the orphanage before they become
     // relevant in AddChildrenToWorkSet.
     auto package_iter = package.rbegin();
@@ -3276,7 +3272,9 @@ void PeerManagerImpl::ProcessPackageResult(const PackageToValidate& package_to_v
         const auto& tx = *package_iter;
         const NodeId nodeid = *senders_iter;
         const auto it_result{package_result.m_tx_results.find(tx->GetWitnessHash())};
-        if (Assume(it_result != package_result.m_tx_results.end())) {
+
+        // It is not guaranteed that a result exists for every transaction.
+        if (it_result != package_result.m_tx_results.end()) {
             const auto& tx_result = it_result->second;
             switch (tx_result.m_result_type) {
                 case MempoolAcceptResult::ResultType::VALID:

From b50d127a7710d790c2ba4a08f01b832c2a0b1203 Mon Sep 17 00:00:00 2001
From: Hennadii Stepanov <32963518+hebasto@users.noreply.github.com>
Date: Wed, 1 May 2024 23:09:13 +0100
Subject: [PATCH 52/63] refactor: Make 64-bit shift explicit

This change fixes MSVC level-3 warning C4334.
See: https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-3-c4334

All `DisableSpecificWarnings` dropped from `fuzz.vcxproj` as all
remained are inherited from `common.init.vcxproj`.
---
 build_msvc/fuzz/fuzz.vcxproj   | 5 -----
 src/test/fuzz/poolresource.cpp | 4 ++--
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/build_msvc/fuzz/fuzz.vcxproj b/build_msvc/fuzz/fuzz.vcxproj
index e7ee211b2d..d1311fe9d9 100644
--- a/build_msvc/fuzz/fuzz.vcxproj
+++ b/build_msvc/fuzz/fuzz.vcxproj
@@ -80,11 +80,6 @@
       <Project>{18430fef-6b61-4c53-b396-718e02850f1b}</Project>
     </ProjectReference>
   </ItemGroup>
-  <ItemDefinitionGroup>
-     <ClCompile>
-       <DisableSpecificWarnings>4018;4244;4267;4334;4715;4805</DisableSpecificWarnings>
-     </ClCompile>
-  </ItemDefinitionGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <Import Project="..\common.vcxproj" />
diff --git a/src/test/fuzz/poolresource.cpp b/src/test/fuzz/poolresource.cpp
index ce64ef6472..f764d9f8db 100644
--- a/src/test/fuzz/poolresource.cpp
+++ b/src/test/fuzz/poolresource.cpp
@@ -63,9 +63,9 @@ class PoolResourceFuzzer
     {
         if (m_total_allocated > 0x1000000) return;
         size_t alignment_bits = m_provider.ConsumeIntegralInRange<size_t>(0, 7);
-        size_t alignment = 1 << alignment_bits;
+        size_t alignment = size_t{1} << alignment_bits;
         size_t size_bits = m_provider.ConsumeIntegralInRange<size_t>(0, 16 - alignment_bits);
-        size_t size = m_provider.ConsumeIntegralInRange<size_t>(1U << size_bits, (1U << (size_bits + 1)) - 1U) << alignment_bits;
+        size_t size = m_provider.ConsumeIntegralInRange<size_t>(size_t{1} << size_bits, (size_t{1} << (size_bits + 1)) - 1U) << alignment_bits;
         Allocate(size, alignment);
     }
 

From 7f6fb73c82fdff2afe5edefcc335ba6707d5627d Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Thu, 2 May 2024 11:24:36 +0100
Subject: [PATCH 53/63] [refactor] use reference in for loop through iters

---
 src/txorphanage.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/txorphanage.cpp b/src/txorphanage.cpp
index 82206e56c3..92055ded72 100644
--- a/src/txorphanage.cpp
+++ b/src/txorphanage.cpp
@@ -278,7 +278,7 @@ std::vector<CTransactionRef> TxOrphanage::GetChildrenFromSamePeer(const CTransac
     // Convert to a vector of CTransactionRef
     std::vector<CTransactionRef> children_found;
     children_found.reserve(iters.size());
-    for (const auto child_iter : iters) {
+    for (const auto& child_iter : iters) {
         children_found.emplace_back(child_iter->second.tx);
     }
     return children_found;
@@ -310,7 +310,7 @@ std::vector<std::pair<CTransactionRef, NodeId>> TxOrphanage::GetChildrenFromDiff
     // Convert iterators to pair<CTransactionRef, NodeId>
     std::vector<std::pair<CTransactionRef, NodeId>> children_found;
     children_found.reserve(iters.size());
-    for (const auto child_iter : iters) {
+    for (const auto& child_iter : iters) {
         children_found.emplace_back(child_iter->second.tx, child_iter->second.fromPeer);
     }
     return children_found;

From fa9abf968840745e428a86a9545aaa6c923415e2 Mon Sep 17 00:00:00 2001
From: MarcoFalke <*~=`'#}+{/-|&$^_@721217.xyz>
Date: Fri, 26 Apr 2024 10:20:02 +0200
Subject: [PATCH 54/63] refactor: Avoid unused-variable warning in init.cpp

---
 src/init.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index d7bdd49b70..1e6d296551 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1297,7 +1297,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         }
     }
 
-    for (const auto &port_option : std::vector<std::pair<std::string, bool>>{
+    for ([[maybe_unused]] const auto& [arg, unix] : std::vector<std::pair<std::string, bool>>{
         // arg name            UNIX socket support
         {"-i2psam",                 false},
         {"-onion",                  true},
@@ -1309,10 +1309,8 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         {"-zmqpubhashtx",           true},
         {"-zmqpubrawblock",         true},
         {"-zmqpubrawtx",            true},
-        {"-zmqpubsequence",         true}
+        {"-zmqpubsequence",         true},
     }) {
-        const std::string arg{port_option.first};
-        const bool unix{port_option.second};
         for (const std::string& socket_addr : args.GetArgs(arg)) {
             std::string host_out;
             uint16_t port_out{0};

From ffc674595cb19b2fdc5705b355bdd3e7f724b860 Mon Sep 17 00:00:00 2001
From: Jon Atack <jon@atack.com>
Date: Thu, 2 May 2024 11:21:02 -0600
Subject: [PATCH 55/63] Replace remaining "520" magic numbers with
 MAX_SCRIPT_ELEMENT_SIZE

---
 src/net_processing.cpp        | 2 +-
 src/outputtype.cpp            | 2 +-
 src/policy/policy.cpp         | 2 +-
 test/functional/p2p_segwit.py | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index bdbf077ab5..0caabc5ea3 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -5205,7 +5205,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
         std::vector<unsigned char> vData;
         vRecv >> vData;
 
-        // Nodes must NEVER send a data item > 520 bytes (the max size for a script data object,
+        // Nodes must NEVER send a data item > MAX_SCRIPT_ELEMENT_SIZE bytes (the max size for a script data object,
         // and thus, the maximum size any matched object can have) in a filteradd message
         bool bad = false;
         if (vData.size() > MAX_SCRIPT_ELEMENT_SIZE) {
diff --git a/src/outputtype.cpp b/src/outputtype.cpp
index 566e5ec55a..c72d9deacb 100644
--- a/src/outputtype.cpp
+++ b/src/outputtype.cpp
@@ -85,7 +85,7 @@ CTxDestination AddAndGetDestinationForScript(FillableSigningProvider& keystore,
 {
     // Add script to keystore
     keystore.AddCScript(script);
-    // Note that scripts over 520 bytes are not yet supported.
+    // Note that scripts over MAX_SCRIPT_ELEMENT_SIZE bytes are not yet supported.
     switch (type) {
     case OutputType::LEGACY:
         return ScriptHash(script);
diff --git a/src/policy/policy.cpp b/src/policy/policy.cpp
index d08ec4fb7f..d8b4b907e4 100644
--- a/src/policy/policy.cpp
+++ b/src/policy/policy.cpp
@@ -111,7 +111,7 @@ bool IsStandardTx(const CTransaction& tx, const std::optional<unsigned>& max_dat
     for (const CTxIn& txin : tx.vin)
     {
         // Biggest 'standard' txin involving only keys is a 15-of-15 P2SH
-        // multisig with compressed keys (remember the 520 byte limit on
+        // multisig with compressed keys (remember the MAX_SCRIPT_ELEMENT_SIZE byte limit on
         // redeemScript size). That works out to a (15*(33+1))+3=513 byte
         // redeemScript, 513+1+15*(73+1)+3=1627 bytes of scriptSig, which
         // we round off to 1650(MAX_STANDARD_SCRIPTSIG_SIZE) bytes for
diff --git a/test/functional/p2p_segwit.py b/test/functional/p2p_segwit.py
index 213c748eda..45bbd7f1c3 100755
--- a/test/functional/p2p_segwit.py
+++ b/test/functional/p2p_segwit.py
@@ -1054,7 +1054,7 @@ def test_extra_witness_data(self):
 
     @subtest
     def test_max_witness_push_length(self):
-        """Test that witness stack can only allow up to 520 byte pushes."""
+        """Test that witness stack can only allow up to MAX_SCRIPT_ELEMENT_SIZE byte pushes."""
 
         block = self.build_next_block()
 

From bd2de7ac591d7704b79304089ad1fb57e085da8b Mon Sep 17 00:00:00 2001
From: Hennadii Stepanov <32963518+hebasto@users.noreply.github.com>
Date: Thu, 2 May 2024 21:52:46 +0100
Subject: [PATCH 56/63] refactor, test: Always initialize pointer

This change fixes MSVC warning C4703.
See: https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-4-c4703

All `DisableSpecificWarnings` dropped from `test_bitcoin.vcxproj` as all
remained are inherited from `common.init.vcxproj`.
---
 build_msvc/test_bitcoin/test_bitcoin.vcxproj | 5 -----
 src/test/validation_chainstate_tests.cpp     | 7 ++++---
 2 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/build_msvc/test_bitcoin/test_bitcoin.vcxproj b/build_msvc/test_bitcoin/test_bitcoin.vcxproj
index 0ae3819e50..b5aa58057f 100644
--- a/build_msvc/test_bitcoin/test_bitcoin.vcxproj
+++ b/build_msvc/test_bitcoin/test_bitcoin.vcxproj
@@ -59,11 +59,6 @@
       <Project>{18430fef-6b61-4c53-b396-718e02850f1b}</Project>
     </ProjectReference>
   </ItemGroup>
-  <ItemDefinitionGroup>
-     <ClCompile>
-       <DisableSpecificWarnings>4018;4244;4267;4703;4715;4805</DisableSpecificWarnings>
-     </ClCompile>
-  </ItemDefinitionGroup>
   <Target Name="RawBenchHeaderGen" BeforeTargets="PrepareForBuild">
     <PropertyGroup>
       <ErrorText>There was an error executing the JSON test header generation task.</ErrorText>
diff --git a/src/test/validation_chainstate_tests.cpp b/src/test/validation_chainstate_tests.cpp
index fe2d2ba592..1c02066047 100644
--- a/src/test/validation_chainstate_tests.cpp
+++ b/src/test/validation_chainstate_tests.cpp
@@ -12,6 +12,7 @@
 #include <test/util/random.h>
 #include <test/util/setup_common.h>
 #include <uint256.h>
+#include <util/check.h>
 #include <validation.h>
 
 #include <vector>
@@ -102,14 +103,14 @@ BOOST_FIXTURE_TEST_CASE(chainstate_update_tip, TestChain100Setup)
 
     BOOST_CHECK_EQUAL(chainman.GetAll().size(), 2);
 
-    Chainstate& background_cs{*[&] {
+    Chainstate& background_cs{*Assert([&]() -> Chainstate* {
         for (Chainstate* cs : chainman.GetAll()) {
             if (cs != &chainman.ActiveChainstate()) {
                 return cs;
             }
         }
-        assert(false);
-    }()};
+        return nullptr;
+    }())};
 
     // Append the first block to the background chain.
     BlockValidationState state;

From 7469ac7032e26fe805c5d15ecded2d44253bc9c1 Mon Sep 17 00:00:00 2001
From: fanquake <fanquake@gmail.com>
Date: Tue, 26 Sep 2023 10:07:49 +0100
Subject: [PATCH 57/63] ci: disable -Werror=maybe-uninitialized for Windows
 builds
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This produces false positives, such as:
```bash
torcontrol.cpp: In static member function ‘static void TorControlConnection::readcb(bufferevent*, void*)’:
torcontrol.cpp:94:28: error: ‘result’ may be used uninitialized [-Werror=maybe-uninitialized]
   94 |         self->message.code = ToIntegral<int>(s.substr(0, 3)).value_or(0);
      |         ~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from ./netaddress.h:18,
                 from ./torcontrol.h:11,
                 from torcontrol.cpp:6:
./util/strencodings.h:184:7: note: ‘result’ was declared here
  184 |     T result;
      |       ^~~~~~
cc1plus: all warnings being treated as errors
make[2]: *** [Makefile:11088: libbitcoin_node_a-torcontrol.o] Error 1
```
---
 ci/test/00_setup_env_win64.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ci/test/00_setup_env_win64.sh b/ci/test/00_setup_env_win64.sh
index bce5ee74b6..7d2a17bd75 100755
--- a/ci/test/00_setup_env_win64.sh
+++ b/ci/test/00_setup_env_win64.sh
@@ -16,4 +16,4 @@ export GOAL="deploy"
 # Prior to 11.0.0, the mingw-w64 headers were missing noreturn attributes, causing warnings when
 # cross-compiling for Windows. https://sourceforge.net/p/mingw-w64/bugs/306/
 # https://github.com/mingw-w64/mingw-w64/commit/1690994f515910a31b9fb7c7bd3a52d4ba987abe
-export BITCOIN_CONFIG="--enable-reduce-exports --disable-gui-tests CXXFLAGS=-Wno-return-type"
+export BITCOIN_CONFIG="--enable-reduce-exports --disable-gui-tests CXXFLAGS='-Wno-return-type -Wno-error=maybe-uninitialized'"

From bec6a88fbcff0bd974e820cefd2be2d00b6f6c56 Mon Sep 17 00:00:00 2001
From: fanquake <fanquake@gmail.com>
Date: Wed, 20 Mar 2024 09:46:12 +0000
Subject: [PATCH 58/63] ci: remove -Warray-bounds from -Werror for win64

These warnings are coming from leveldb, and appear to be fixed starting
with GCC 13.
---
 ci/test/00_setup_env_win64.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ci/test/00_setup_env_win64.sh b/ci/test/00_setup_env_win64.sh
index 7d2a17bd75..bf80d5d435 100755
--- a/ci/test/00_setup_env_win64.sh
+++ b/ci/test/00_setup_env_win64.sh
@@ -16,4 +16,4 @@ export GOAL="deploy"
 # Prior to 11.0.0, the mingw-w64 headers were missing noreturn attributes, causing warnings when
 # cross-compiling for Windows. https://sourceforge.net/p/mingw-w64/bugs/306/
 # https://github.com/mingw-w64/mingw-w64/commit/1690994f515910a31b9fb7c7bd3a52d4ba987abe
-export BITCOIN_CONFIG="--enable-reduce-exports --disable-gui-tests CXXFLAGS='-Wno-return-type -Wno-error=maybe-uninitialized'"
+export BITCOIN_CONFIG="--enable-reduce-exports --disable-gui-tests CXXFLAGS='-Wno-return-type -Wno-error=maybe-uninitialized -Wno-error=array-bounds'"

From b088062e687d95deff28b0715fd4859449b56584 Mon Sep 17 00:00:00 2001
From: fanquake <fanquake@gmail.com>
Date: Tue, 19 Mar 2024 14:52:24 +0000
Subject: [PATCH 59/63] ci: remove -Wdocumentation from -Werror in multiprocess
 CI

The issues here are coming from Boost Test code.
---
 ci/test/00_setup_env_i686_multiprocess.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ci/test/00_setup_env_i686_multiprocess.sh b/ci/test/00_setup_env_i686_multiprocess.sh
index 00a4d781c2..f6463438d3 100755
--- a/ci/test/00_setup_env_i686_multiprocess.sh
+++ b/ci/test/00_setup_env_i686_multiprocess.sh
@@ -14,5 +14,5 @@ export DEP_OPTS="DEBUG=1 MULTIPROCESS=1"
 export GOAL="install"
 export TEST_RUNNER_EXTRA="--v2transport"
 export BITCOIN_CONFIG="--enable-debug CC='clang -m32' CXX='clang++ -m32' \
-CPPFLAGS='-DBOOST_MULTI_INDEX_ENABLE_SAFE_MODE'"
+CPPFLAGS='-DBOOST_MULTI_INDEX_ENABLE_SAFE_MODE' CXXFLAGS='-Wno-error=documentation'"
 export BITCOIND=bitcoin-node  # Used in functional tests

From f0e22be69a15248c42964d57f44ce8c37a36081d Mon Sep 17 00:00:00 2001
From: fanquake <fanquake@gmail.com>
Date: Mon, 15 Aug 2022 14:59:05 +0100
Subject: [PATCH 60/63] build: no-longer disable WARN_CXXFLAGS when CXXFLAGS is
 set

Now that CXXFLAGS are back in user control, I don't think there's a
reason to no-longer use our warning flags when CXXFLAGS has been
overriden (this includes when building from depends).

Anyone can suppress warnings from third-party code by
passing the relevant `-Wno-` options in CXXFLAGS.

Fixes: #18092.
---
 configure.ac | 60 +++++++++++++++++++++++++---------------------------
 1 file changed, 29 insertions(+), 31 deletions(-)

diff --git a/configure.ac b/configure.ac
index c7d124a1f1..ee4400f21a 100644
--- a/configure.ac
+++ b/configure.ac
@@ -401,37 +401,35 @@ if test "$enable_werror" = "yes"; then
   ERROR_CXXFLAGS=$CXXFLAG_WERROR
 fi
 
-if test "$CXXFLAGS_overridden" = "no"; then
-  AX_CHECK_COMPILE_FLAG([-Wall], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wall"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wextra], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wextra"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wgnu], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wgnu"], [], [$CXXFLAG_WERROR])
-  dnl some compilers will ignore -Wformat-security without -Wformat, so just combine the two here.
-  AX_CHECK_COMPILE_FLAG([-Wformat -Wformat-security], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wformat -Wformat-security"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wvla], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wvla"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wshadow-field], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wshadow-field"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wthread-safety], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wthread-safety"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wloop-analysis], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wloop-analysis"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wredundant-decls], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wredundant-decls"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wunused-member-function], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wunused-member-function"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wdate-time], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wdate-time"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wconditional-uninitialized], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wconditional-uninitialized"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wduplicated-branches], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wduplicated-branches"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wduplicated-cond], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wduplicated-cond"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wlogical-op], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wlogical-op"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Woverloaded-virtual], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Woverloaded-virtual"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wsuggest-override], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wsuggest-override"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wimplicit-fallthrough], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wimplicit-fallthrough"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wunreachable-code], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wunreachable-code"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wdocumentation], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wdocumentation"], [], [$CXXFLAG_WERROR])
-
-  dnl Some compilers (gcc) ignore unknown -Wno-* options, but warn about all
-  dnl unknown options if any other warning is produced. Test the -Wfoo case, and
-  dnl set the -Wno-foo case if it works.
-  AX_CHECK_COMPILE_FLAG([-Wunused-parameter], [NOWARN_CXXFLAGS="$NOWARN_CXXFLAGS -Wno-unused-parameter"], [], [$CXXFLAG_WERROR])
-  AX_CHECK_COMPILE_FLAG([-Wself-assign], [NOWARN_CXXFLAGS="$NOWARN_CXXFLAGS -Wno-self-assign"], [], [$CXXFLAG_WERROR])
-  if test "$suppress_external_warnings" != "yes" ; then
-    AX_CHECK_COMPILE_FLAG([-Wdeprecated-copy], [NOWARN_CXXFLAGS="$NOWARN_CXXFLAGS -Wno-deprecated-copy"], [], [$CXXFLAG_WERROR])
-  fi
+AX_CHECK_COMPILE_FLAG([-Wall], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wall"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wextra], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wextra"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wgnu], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wgnu"], [], [$CXXFLAG_WERROR])
+dnl some compilers will ignore -Wformat-security without -Wformat, so just combine the two here.
+AX_CHECK_COMPILE_FLAG([-Wformat -Wformat-security], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wformat -Wformat-security"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wvla], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wvla"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wshadow-field], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wshadow-field"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wthread-safety], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wthread-safety"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wloop-analysis], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wloop-analysis"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wredundant-decls], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wredundant-decls"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wunused-member-function], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wunused-member-function"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wdate-time], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wdate-time"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wconditional-uninitialized], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wconditional-uninitialized"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wduplicated-branches], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wduplicated-branches"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wduplicated-cond], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wduplicated-cond"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wlogical-op], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wlogical-op"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Woverloaded-virtual], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Woverloaded-virtual"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wsuggest-override], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wsuggest-override"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wimplicit-fallthrough], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wimplicit-fallthrough"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wunreachable-code], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wunreachable-code"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wdocumentation], [WARN_CXXFLAGS="$WARN_CXXFLAGS -Wdocumentation"], [], [$CXXFLAG_WERROR])
+
+dnl Some compilers (gcc) ignore unknown -Wno-* options, but warn about all
+dnl unknown options if any other warning is produced. Test the -Wfoo case, and
+dnl set the -Wno-foo case if it works.
+AX_CHECK_COMPILE_FLAG([-Wunused-parameter], [NOWARN_CXXFLAGS="$NOWARN_CXXFLAGS -Wno-unused-parameter"], [], [$CXXFLAG_WERROR])
+AX_CHECK_COMPILE_FLAG([-Wself-assign], [NOWARN_CXXFLAGS="$NOWARN_CXXFLAGS -Wno-self-assign"], [], [$CXXFLAG_WERROR])
+if test "$suppress_external_warnings" != "yes" ; then
+  AX_CHECK_COMPILE_FLAG([-Wdeprecated-copy], [NOWARN_CXXFLAGS="$NOWARN_CXXFLAGS -Wno-deprecated-copy"], [], [$CXXFLAG_WERROR])
 fi
 
 dnl Don't allow extended (non-ASCII) symbols in identifiers. This is easier for code review.

From af3c18169a075222fe0795ab24b8b20ad5e30ae4 Mon Sep 17 00:00:00 2001
From: ismaelsadeeq <ask4ismailsadiq@gmail.com>
Date: Fri, 3 May 2024 10:30:50 +0100
Subject: [PATCH 61/63] [test]: remove duplicate WITNESS_SCALE_FACTOR

---
 test/functional/feature_taproot.py           | 2 +-
 test/functional/test_framework/blocktools.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/functional/feature_taproot.py b/test/functional/feature_taproot.py
index e85541d0ec..e7d65b4539 100755
--- a/test/functional/feature_taproot.py
+++ b/test/functional/feature_taproot.py
@@ -10,7 +10,6 @@
     create_block,
     add_witness_commitment,
     MAX_BLOCK_SIGOPS_WEIGHT,
-    WITNESS_SCALE_FACTOR,
 )
 from test_framework.messages import (
     COutPoint,
@@ -20,6 +19,7 @@
     CTxOut,
     SEQUENCE_FINAL,
     tx_from_hex,
+    WITNESS_SCALE_FACTOR,
 )
 from test_framework.script import (
     ANNEX_TAG,
diff --git a/test/functional/test_framework/blocktools.py b/test/functional/test_framework/blocktools.py
index cfd923bab3..f0dc866f69 100644
--- a/test/functional/test_framework/blocktools.py
+++ b/test/functional/test_framework/blocktools.py
@@ -28,6 +28,7 @@
     ser_uint256,
     tx_from_hex,
     uint256_from_str,
+    WITNESS_SCALE_FACTOR,
 )
 from .script import (
     CScript,
@@ -45,7 +46,6 @@
 )
 from .util import assert_equal
 
-WITNESS_SCALE_FACTOR = 4
 MAX_BLOCK_SIGOPS = 20000
 MAX_BLOCK_SIGOPS_WEIGHT = MAX_BLOCK_SIGOPS * WITNESS_SCALE_FACTOR
 

From 63317103c9f2b0635558da814567bb79c17ae851 Mon Sep 17 00:00:00 2001
From: Pieter Wuille <pieter@wuille.net>
Date: Mon, 16 Oct 2023 10:17:12 -0400
Subject: [PATCH 62/63] miniscript: make operator_mst consteval

It seems modern compilers don't realize that all invocations of operator""_mst
can be evaluated at compile time, despite the constexpr keyword.

Since C++20, we can force them to evaluate at compile time, turning all the
miniscript type constants into actual compile-time constants.

It appears that MSVC does not support consteval operator"" when used inside
certain expressions. For the few places where this happens, define a
constant outside the operator call.

Co-Authored-By: Hennadii Stepanov <32963518+hebasto@users.noreply.github.com>
---
 src/script/miniscript.cpp    |  3 ++-
 src/script/miniscript.h      | 24 +++++++++++----------
 src/test/fuzz/miniscript.cpp | 42 ++++++++++++++++++++----------------
 3 files changed, 38 insertions(+), 31 deletions(-)

diff --git a/src/script/miniscript.cpp b/src/script/miniscript.cpp
index 344a81bdf0..455bd56283 100644
--- a/src/script/miniscript.cpp
+++ b/src/script/miniscript.cpp
@@ -231,7 +231,8 @@ Type ComputeType(Fragment fragment, Type x, Type y, Type z, const std::vector<Ty
             Type acc_tl = "k"_mst;
             for (size_t i = 0; i < sub_types.size(); ++i) {
                 Type t = sub_types[i];
-                if (!(t << (i ? "Wdu"_mst : "Bdu"_mst))) return ""_mst; // Require Bdu, Wdu, Wdu, ...
+                static constexpr auto WDU{"Wdu"_mst}, BDU{"Bdu"_mst};
+                if (!(t << (i ? WDU : BDU))) return ""_mst; // Require Bdu, Wdu, Wdu, ...
                 if (!(t << "e"_mst)) all_e = false;
                 if (!(t << "m"_mst)) all_m = false;
                 if (t << "s"_mst) num_s += 1;
diff --git a/src/script/miniscript.h b/src/script/miniscript.h
index f635fa7340..4880f32410 100644
--- a/src/script/miniscript.h
+++ b/src/script/miniscript.h
@@ -123,12 +123,12 @@ class Type {
     //! Internal bitmap of properties (see ""_mst operator for details).
     uint32_t m_flags;
 
-    //! Internal constructor used by the ""_mst operator.
-    explicit constexpr Type(uint32_t flags) : m_flags(flags) {}
+    //! Internal constructor.
+    explicit constexpr Type(uint32_t flags) noexcept : m_flags(flags) {}
 
 public:
-    //! The only way to publicly construct a Type is using this literal operator.
-    friend constexpr Type operator"" _mst(const char* c, size_t l);
+    //! Construction function used by the ""_mst operator.
+    static consteval Type Make(uint32_t flags) noexcept { return Type(flags); }
 
     //! Compute the type with the union of properties.
     constexpr Type operator|(Type x) const { return Type(m_flags | x.m_flags); }
@@ -150,11 +150,11 @@ class Type {
 };
 
 //! Literal operator to construct Type objects.
-inline constexpr Type operator"" _mst(const char* c, size_t l) {
-    Type typ{0};
+inline consteval Type operator"" _mst(const char* c, size_t l) {
+    Type typ{Type::Make(0)};
 
     for (const char *p = c; p < c + l; p++) {
-        typ = typ | Type(
+        typ = typ | Type::Make(
             *p == 'B' ? 1 << 0 : // Base type
             *p == 'V' ? 1 << 1 : // Verify type
             *p == 'K' ? 1 << 2 : // Key type
@@ -548,7 +548,8 @@ struct Node {
         for (const auto& sub : subs) {
             subsize += sub->ScriptSize();
         }
-        Type sub0type = subs.size() > 0 ? subs[0]->GetType() : ""_mst;
+        static constexpr auto NONE_MST{""_mst};
+        Type sub0type = subs.size() > 0 ? subs[0]->GetType() : NONE_MST;
         return internal::ComputeScriptLen(fragment, sub0type, subsize, k, subs.size(), keys.size(), m_script_ctx);
     }
 
@@ -712,9 +713,10 @@ struct Node {
             for (const auto& sub : subs) sub_types.push_back(sub->GetType());
         }
         // All other nodes than THRESH can be computed just from the types of the 0-3 subexpressions.
-        Type x = subs.size() > 0 ? subs[0]->GetType() : ""_mst;
-        Type y = subs.size() > 1 ? subs[1]->GetType() : ""_mst;
-        Type z = subs.size() > 2 ? subs[2]->GetType() : ""_mst;
+        static constexpr auto NONE_MST{""_mst};
+        Type x = subs.size() > 0 ? subs[0]->GetType() : NONE_MST;
+        Type y = subs.size() > 1 ? subs[1]->GetType() : NONE_MST;
+        Type z = subs.size() > 2 ? subs[2]->GetType() : NONE_MST;
 
         return SanitizeType(ComputeType(fragment, x, y, z, sub_types, k, data.size(), subs.size(), keys.size(), m_script_ctx));
     }
diff --git a/src/test/fuzz/miniscript.cpp b/src/test/fuzz/miniscript.cpp
index 0d0ee59ab3..947424c4ac 100644
--- a/src/test/fuzz/miniscript.cpp
+++ b/src/test/fuzz/miniscript.cpp
@@ -391,6 +391,7 @@ std::optional<NodeInfo> ConsumeNodeStable(MsCtx script_ctx, FuzzedDataProvider&
     bool allow_K = (type_needed == ""_mst) || (type_needed << "K"_mst);
     bool allow_V = (type_needed == ""_mst) || (type_needed << "V"_mst);
     bool allow_W = (type_needed == ""_mst) || (type_needed << "W"_mst);
+    static constexpr auto B{"B"_mst}, K{"K"_mst}, V{"V"_mst}, W{"W"_mst};
 
     switch (provider.ConsumeIntegral<uint8_t>()) {
         case 0:
@@ -440,22 +441,22 @@ std::optional<NodeInfo> ConsumeNodeStable(MsCtx script_ctx, FuzzedDataProvider&
         }
         case 11:
             if (!(allow_B || allow_K || allow_V)) return {};
-            return {{{"B"_mst, type_needed, type_needed}, Fragment::ANDOR}};
+            return {{{B, type_needed, type_needed}, Fragment::ANDOR}};
         case 12:
             if (!(allow_B || allow_K || allow_V)) return {};
-            return {{{"V"_mst, type_needed}, Fragment::AND_V}};
+            return {{{V, type_needed}, Fragment::AND_V}};
         case 13:
             if (!allow_B) return {};
-            return {{{"B"_mst, "W"_mst}, Fragment::AND_B}};
+            return {{{B, W}, Fragment::AND_B}};
         case 15:
             if (!allow_B) return {};
-            return {{{"B"_mst, "W"_mst}, Fragment::OR_B}};
+            return {{{B, W}, Fragment::OR_B}};
         case 16:
             if (!allow_V) return {};
-            return {{{"B"_mst, "V"_mst}, Fragment::OR_C}};
+            return {{{B, V}, Fragment::OR_C}};
         case 17:
             if (!allow_B) return {};
-            return {{{"B"_mst, "B"_mst}, Fragment::OR_D}};
+            return {{{B, B}, Fragment::OR_D}};
         case 18:
             if (!(allow_B || allow_K || allow_V)) return {};
             return {{{type_needed, type_needed}, Fragment::OR_I}};
@@ -472,25 +473,25 @@ std::optional<NodeInfo> ConsumeNodeStable(MsCtx script_ctx, FuzzedDataProvider&
         }
         case 20:
             if (!allow_W) return {};
-            return {{{"B"_mst}, Fragment::WRAP_A}};
+            return {{{B}, Fragment::WRAP_A}};
         case 21:
             if (!allow_W) return {};
-            return {{{"B"_mst}, Fragment::WRAP_S}};
+            return {{{B}, Fragment::WRAP_S}};
         case 22:
             if (!allow_B) return {};
-            return {{{"K"_mst}, Fragment::WRAP_C}};
+            return {{{K}, Fragment::WRAP_C}};
         case 23:
             if (!allow_B) return {};
-            return {{{"V"_mst}, Fragment::WRAP_D}};
+            return {{{V}, Fragment::WRAP_D}};
         case 24:
             if (!allow_V) return {};
-            return {{{"B"_mst}, Fragment::WRAP_V}};
+            return {{{B}, Fragment::WRAP_V}};
         case 25:
             if (!allow_B) return {};
-            return {{{"B"_mst}, Fragment::WRAP_J}};
+            return {{{B}, Fragment::WRAP_J}};
         case 26:
             if (!allow_B) return {};
-            return {{{"B"_mst}, Fragment::WRAP_N}};
+            return {{{B}, Fragment::WRAP_N}};
         case 27: {
             if (!allow_B || !IsTapscript(script_ctx)) return {};
             const auto k = provider.ConsumeIntegral<uint16_t>();
@@ -528,20 +529,23 @@ struct SmartInfo
     {
         /* Construct a set of interesting type requirements to reason with (sections of BKVWzondu). */
         std::vector<Type> types;
+        static constexpr auto B_mst{"B"_mst}, K_mst{"K"_mst}, V_mst{"V"_mst}, W_mst{"W"_mst};
+        static constexpr auto d_mst{"d"_mst}, n_mst{"n"_mst}, o_mst{"o"_mst}, u_mst{"u"_mst}, z_mst{"z"_mst};
+        static constexpr auto NONE_mst{""_mst};
         for (int base = 0; base < 4; ++base) { /* select from B,K,V,W */
-            Type type_base = base == 0 ? "B"_mst : base == 1 ? "K"_mst : base == 2 ? "V"_mst : "W"_mst;
+            Type type_base = base == 0 ? B_mst : base == 1 ? K_mst : base == 2 ? V_mst : W_mst;
             for (int zo = 0; zo < 3; ++zo) { /* select from z,o,(none) */
-                Type type_zo = zo == 0 ? "z"_mst : zo == 1 ? "o"_mst : ""_mst;
+                Type type_zo = zo == 0 ? z_mst : zo == 1 ? o_mst : NONE_mst;
                 for (int n = 0; n < 2; ++n) { /* select from (none),n */
                     if (zo == 0 && n == 1) continue; /* z conflicts with n */
                     if (base == 3 && n == 1) continue; /* W conflicts with n */
-                    Type type_n = n == 0 ? ""_mst : "n"_mst;
+                    Type type_n = n == 0 ? NONE_mst : n_mst;
                     for (int d = 0; d < 2; ++d) { /* select from (none),d */
                         if (base == 2 && d == 1) continue; /* V conflicts with d */
-                        Type type_d = d == 0 ? ""_mst : "d"_mst;
+                        Type type_d = d == 0 ? NONE_mst : d_mst;
                         for (int u = 0; u < 2; ++u) { /* select from (none),u */
                             if (base == 2 && u == 1) continue; /* V conflicts with u */
-                            Type type_u = u == 0 ? ""_mst : "u"_mst;
+                            Type type_u = u == 0 ? NONE_mst : u_mst;
                             Type type = type_base | type_zo | type_n | type_d | type_u;
                             types.push_back(type);
                         }
@@ -683,7 +687,7 @@ struct SmartInfo
         /* Find which types are useful. The fuzzer logic only cares about constructing
          * B,V,K,W nodes, so any type that isn't needed in any recipe (directly or
          * indirectly) for the construction of those is uninteresting. */
-        std::set<Type> useful_types{"B"_mst, "V"_mst, "K"_mst, "W"_mst};
+        std::set<Type> useful_types{B_mst, V_mst, K_mst, W_mst};
         // Find the transitive closure by adding types until the set of types does not change.
         while (true) {
             size_t set_size = useful_types.size();

From 9155b733e153e799f09cc7f7e9199ad776b2cbb1 Mon Sep 17 00:00:00 2001
From: Hennadii Stepanov <32963518+hebasto@users.noreply.github.com>
Date: Fri, 3 May 2024 13:12:12 +0100
Subject: [PATCH 63/63] build, msvc: Compile test\fuzz\miniscript.cpp

---
 build_msvc/fuzz/fuzz.vcxproj | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/build_msvc/fuzz/fuzz.vcxproj b/build_msvc/fuzz/fuzz.vcxproj
index d1311fe9d9..7c72703c93 100644
--- a/build_msvc/fuzz/fuzz.vcxproj
+++ b/build_msvc/fuzz/fuzz.vcxproj
@@ -9,8 +9,7 @@
     <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
   </PropertyGroup>
   <ItemGroup>
-    <!-- TODO: Fix the code and remove miniscript.cpp exclusion. -->
-    <ClCompile Include="..\..\src\test\fuzz\*.cpp" Exclude="..\..\src\test\fuzz\miniscript.cpp" />
+    <ClCompile Include="..\..\src\test\fuzz\*.cpp" />
     <ClCompile Include="..\..\src\test\fuzz\util\descriptor.cpp">
       <ObjectFileName>$(IntDir)test_fuzz_util_descriptor.obj</ObjectFileName>
     </ClCompile>