From ae8239641978ed59d5d781a04ddfb6bde6470a2c Mon Sep 17 00:00:00 2001
From: merge-script <fanquake@gmail.com>
Date: Fri, 22 May 2026 11:09:26 +0100
Subject: [PATCH 01/10] Merge bitcoin/bitcoin#34801: ci: Enable pipefail in
 03_test_script.sh

fa99a3ccacead02c26ea74c0e12cd845c4dafb91 ci: Enable pipefail in 03_test_script.sh (MarcoFalke)

Pull request description:

  The CI script is problematic, because it is written in Bash, without pipefail enabled. Thus, some failures are silently ignored.

  Enabling pipefail is a bit tedious, because:

  * The IWYU task has no (`--verbose`) ccache output, so the pipe fails after `grep` [1]. Also, right now on master, the if silently skips: `ci/test/03_test_script.sh: line 122: [: : integer expression expected`.
  * The Alpine task has `Hits:` twice in the output, so the pipe fails after `head -1` [2]

  Not sure what the easiest way to fix this would be. Some options are:

  * Just use `tail -1` and `0` as fallback: `hit_rate=$(ccache --show-stats | grep "Hits:" | tail -1 | sed 's/.*(\(.*\)%).*/\1/' || echo "0")`
  * Properly parse, using Python and `--print-stats` (this pull)

  [1]

  ```
  + ccache --version
  + head -n 1
  ccache version 4.11.2
  + ccache --show-stats --verbose
  Cache directory:    /home/admin/actions-runner/_work/_temp/ccache_dir
  Config file:        /home/admin/actions-runner/_work/_temp/ccache_dir/ccache.conf
  System config file: /etc/ccache.conf
  Stats updated:      Tue Feb 17 08:40:20 2026
  Local storage:
    Cache size (GB):  0.0 / 2.0 ( 0.00%)
    Files:              0
    Hits:               0
    Misses:             0
    Reads:              0
    Writes:             0
  ++ ccache --show-stats
  ++ grep Hits:
  ++ head -1
  ++ sed 's/.*(\(.*\)%).*/\1/'
  + hit_rate=
  Command '['docker', 'exec', '--env', 'DANGER_RUN_CI_ON_HOST=1', 'f5e8f319c22101ada5be9d4c5fd7d883ce37b830e86ec64627cb7d2b96749053', '/home/admin/actions-runner/_work/_temp/ci/test/03_test_script.sh']' returned non-zero exit status 1.
  Error: Process completed with exit code 1.
  ```

  [2]

  ```
  + ccache --version
  + head -n 1
  ccache version 4.12.1
  + ccache --show-stats --verbose
  Cache directory:    /home/admin/actions-runner/_work/_temp/ccache_dir
  Config file:        /home/admin/actions-runner/_work/_temp/ccache_dir/ccache.conf
  System config file: /etc/ccache.conf
  Stats updated:      Tue Feb 17 08:40:35 2026
  Cacheable calls:     873 / 873 (100.0%)
    Hits:              846 / 873 (96.91%)
      Direct:          822 / 846 (97.16%)
      Preprocessed:     24 / 846 ( 2.84%)
    Misses:             27 / 873 ( 3.09%)
  Successful lookups:
    Direct:            822 / 873 (94.16%)
    Preprocessed:       24 /  51 (47.06%)
  Local storage:
    Cache size (GB):   2.0 / 2.0 (99.95%)
    Files:            2580
    Cleanups:           13
    Hits:              846 / 873 (96.91%)
    Misses:             27 / 873 ( 3.09%)
    Reads:            1772
    Writes:             52
  ++ ccache --show-stats
  ++ grep Hits:
  ++ head -1
  ++ sed 's/.*(\(.*\)%).*/\1/'
  + hit_rate=96.91
  Command '['docker', 'exec', '--env', 'DANGER_RUN_CI_ON_HOST=1', '272a66a48206f1f6096612e196127ce46ea4dbff5dc14be3a4a20c4ee523956f', '/home/admin/actions-runner/_work/_temp/ci/test/03_test_script.sh']' returned non-zero exit status 141.
  Error: Process completed with exit code 1.
  ```

ACKs for top commit:
  willcl-ark:
    ACK fa99a3ccacead02c26ea74c0e12cd845c4dafb91

Tree-SHA512: e5b0ddad8f279bd48102543b0496fa2ecdfc6938d208078595a60b96680467a80504b21acdecd86204b82ce2770eede23e498f04c6a9cee59634f83d44cfe094
(cherry picked from commit 59918de329ae8773080e1a9f72ee6c1eb7b22a0a)
---
 ci/test/03_test_script.sh | 36 +++++++++++++++++++++++++++++-------
 1 file changed, 29 insertions(+), 7 deletions(-)

diff --git a/ci/test/03_test_script.sh b/ci/test/03_test_script.sh
index fd794b512cd4..9dfbbb0e5f5f 100755
--- a/ci/test/03_test_script.sh
+++ b/ci/test/03_test_script.sh
@@ -6,7 +6,7 @@
 
 export LC_ALL=C.UTF-8
 
-set -o errexit -o xtrace
+set -o errexit -o xtrace -o pipefail
 
 if [ "${DANGER_RUN_CI_ON_HOST}" != "1" ]; then
   echo "This script will make unsafe local and global modifications, so it can only be run inside a container and requires DANGER_RUN_CI_ON_HOST=1"
@@ -136,10 +136,30 @@ cmake --build "${BASE_BUILD_DIR}" "$MAKEJOBS" --target $GOAL || (
 )
 
 ccache --version | head -n 1 && ccache --show-stats --verbose
-hit_rate=$(ccache --show-stats | grep "Hits:" | head -1 | sed 's/.*(\(.*\)%).*/\1/')
-if [ "${hit_rate%.*}" -lt 75 ]; then
-  echo "::notice title=low ccache hitrate::Ccache hit-rate in $CONTAINER_NAME was $hit_rate%"
-fi
+ccache --print-stats | python3 -c '
+import os
+import sys
+
+for line in sys.stdin:
+    key, value = line.split("\t", 1)
+    # "primary storage" fallback only needed for ccache version 4.5.1
+    if key in ("local_storage_hit", "primary_storage_hit"):
+        hits = int(value)
+    elif key in ("local_storage_miss", "primary_storage_miss"):
+        miss = int(value)
+
+calls = hits + miss
+# codegen has no calls, so skip that here
+if calls:
+    rate = (hits / calls * 100)
+    print(f"{rate:.2f}")
+    if rate < 75:
+        container = os.environ["CONTAINER_NAME"]
+        print(
+            "::notice title=low ccache hitrate::"
+            f"Ccache hit-rate in {container} was {rate:.2f}%"
+        )
+'
 du -sh "${DEPENDS_DIR}"/*/
 du -sh "${PREVIOUS_RELEASES_DIR}"
 
@@ -191,12 +211,14 @@ if [[ "${RUN_IWYU}" == true ]]; then
 
   run_iwyu() {
     mv "${BASE_BUILD_DIR}/$1" "${BASE_BUILD_DIR}/compile_commands.json"
-    python3 "/include-what-you-use/iwyu_tool.py" \
+    {
+      python3 "/include-what-you-use/iwyu_tool.py" \
              -p "${BASE_BUILD_DIR}" "${MAKEJOBS}" \
              -- -Xiwyu --cxx17ns -Xiwyu --mapping_file="${BASE_ROOT_DIR}/contrib/devtools/iwyu/bitcoin.core.imp" \
              -Xiwyu --max_line_length=160 \
              -Xiwyu --check_also="*/primitives/*.h" \
-             2>&1 | tee /tmp/iwyu_ci.out
+             2>&1 || true
+    } | tee /tmp/iwyu_ci.out
     python3 "/include-what-you-use/fix_includes.py" --nosafe_headers < /tmp/iwyu_ci.out
     git diff -U1 | ./contrib/devtools/clang-format-diff.py -binary="clang-format-${IWYU_LLVM_V}" -p1 -i -v
   }

From 4c0d1b3e58cbee79bb58859ea11b4afe56401f41 Mon Sep 17 00:00:00 2001
From: merge-script <seb.kung@gmail.com>
Date: Sat, 23 May 2026 13:11:28 +0200
Subject: [PATCH 02/10] Merge bitcoin/bitcoin#35141: fuzz: apply node context
 reset pattern to p2p_handshake
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

dfe5d6a81dc39fb1a5a26490e931a04874c2360d fuzz: apply node context reset pattern to p2p_handshake (frankomosh)

Pull request description:

  Follow-up to #34302. Applies the node context reset pattern from fabf8d1 to `p2p_handshake`.

  Previous code pattern created local `AddrMan` and `node::Warnings` objects, and passed them to `PeerManager::make`. `connman` was left holding a dangling `reference_wrapper<AddrMan>` across iterations, since the local objects destruct at iteration end while `connman` is global.

  Like in fabf8d1 , reset and reinstall `node.addrman` and `node.peerman` on each iteration. This PR also removes `includes` made unused by this or prior refactors.

ACKs for top commit:
  nervana21:
    tACK dfe5d6a81dc39fb1a5a26490e931a04874c2360d
  maflcko:
    review ACK dfe5d6a81dc39fb1a5a26490e931a04874c2360d 🦏
  sedited:
    ACK dfe5d6a81dc39fb1a5a26490e931a04874c2360d

Tree-SHA512: 141ddec03c6d37f76a3b2d94701d18c851e85ea74e57716abb69ecc955d30371e342c6e267d2669ad853fe2d95fb77dd2fb506e4233ae3a88501d59ee1bbae30
(cherry picked from commit de925455c8025fc1f75d65d981c28b9dfa20e9f7)
---
 src/test/fuzz/p2p_handshake.cpp | 37 ++++++++++++++++-----------------
 1 file changed, 18 insertions(+), 19 deletions(-)

diff --git a/src/test/fuzz/p2p_handshake.cpp b/src/test/fuzz/p2p_handshake.cpp
index 421aacd86671..85b18476f1e1 100644
--- a/src/test/fuzz/p2p_handshake.cpp
+++ b/src/test/fuzz/p2p_handshake.cpp
@@ -2,19 +2,15 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <addrman.h>
-#include <consensus/consensus.h>
+#include <banman.h>
 #include <net.h>
 #include <net_processing.h>
-#include <node/warnings.h>
 #include <protocol.h>
-#include <script/script.h>
 #include <sync.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 #include <test/fuzz/util/net.h>
-#include <test/util/mining.h>
 #include <test/util/net.h>
 #include <test/util/setup_common.h>
 #include <test/util/time.h>
@@ -23,16 +19,15 @@
 #include <validationinterface.h>
 
 #include <ios>
-#include <string>
 #include <utility>
 #include <vector>
 
 namespace {
-const TestingSetup* g_setup;
+TestingSetup* g_setup;
 
 void initialize()
 {
-    static const auto testing_setup = MakeNoLogFileContext<const TestingSetup>(
+    static const auto testing_setup = MakeNoLogFileContext<TestingSetup>(
         /*chain_type=*/ChainType::REGTEST);
     g_setup = testing_setup.get();
 }
@@ -43,22 +38,26 @@ FUZZ_TARGET(p2p_handshake, .init = ::initialize)
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
 
-    auto& connman = static_cast<ConnmanTestMsg&>(*g_setup->m_node.connman);
-    auto& chainman = static_cast<TestChainstateManager&>(*g_setup->m_node.chainman);
+    auto& node{g_setup->m_node};
+    auto& connman{static_cast<ConnmanTestMsg&>(*node.connman)};
+    auto& chainman{static_cast<TestChainstateManager&>(*node.chainman)};
     NodeClockContext clock_ctx{1610000000s}; // any time to successfully reset ibd
     chainman.ResetIbd();
 
-    node::Warnings warnings{};
-    auto netgroupman{NetGroupManager::NoAsmap()};
-    AddrMan addrman{netgroupman, /*deterministic=*/true, /*consistency_check_ratio=*/0};
-    auto peerman = PeerManager::make(connman, addrman,
+    node.banman.reset();
+    node.addrman.reset();
+    node.peerman.reset();
+    node.addrman = std::make_unique<AddrMan>(
+        *node.netgroupman, /*deterministic=*/true, /*consistency_check_ratio=*/0);
+    node.peerman = PeerManager::make(connman, *node.addrman,
                                      /*banman=*/nullptr, chainman,
-                                     *g_setup->m_node.mempool, warnings,
+                                     *node.mempool, *node.warnings,
                                      PeerManager::Options{
                                          .reconcile_txs = true,
                                          .deterministic_rng = true,
                                      });
-    connman.SetMsgProc(peerman.get());
+    connman.SetMsgProc(node.peerman.get());
+    connman.SetAddrman(*node.addrman);
 
     LOCK(NetEventsInterface::g_msgproc_mutex);
 
@@ -67,7 +66,7 @@ FUZZ_TARGET(p2p_handshake, .init = ::initialize)
     for (int i = 0; i < num_peers_to_add; ++i) {
         peers.push_back(ConsumeNodeAsUniquePtr(fuzzed_data_provider, i).release());
         connman.AddTestNode(*peers.back());
-        peerman->InitializeNode(
+        node.peerman->InitializeNode(
             *peers.back(),
             static_cast<ServiceFlags>(fuzzed_data_provider.ConsumeIntegral<uint64_t>()));
     }
@@ -102,9 +101,9 @@ FUZZ_TARGET(p2p_handshake, .init = ::initialize)
                 more_work = connman.ProcessMessagesOnce(connection);
             } catch (const std::ios_base::failure&) {
             }
-            peerman->SendMessages(connection);
+            node.peerman->SendMessages(connection);
         }
     }
 
-    g_setup->m_node.connman->StopNodes();
+    node.connman->StopNodes();
 }

From 1d69ac33925888120aa1e69e2c1537e11b1d8390 Mon Sep 17 00:00:00 2001
From: merge-script <seb.kung@gmail.com>
Date: Tue, 26 May 2026 15:19:19 +0200
Subject: [PATCH 03/10] Merge bitcoin/bitcoin#35337: doc: add feature
 deprecation and removal process to developer notes

2e9fdcc6da69238abbb1811a04c2beb6dba3b24a doc: add feature deprecation and removal process to developer notes (Guillermo Fernandes)

Pull request description:

  Closes #31980

  Adds a dedicated **"Feature deprecation and removal process"** section to `doc/developer-notes.md` covering the full deprecation lifecycle for all major feature categories.

  ## What's added

  **General principles**
  - Grace period is one major release (deprecated in N, removed in N+1)
  - Deprecation and removal both require release notes
  - Deprecated features should remain accessible via a re-enable flag during the grace period

  **Per-category guidance covering:**
  - RPC methods and fields (`-deprecatedrpc=<feature>` pattern, help text requirements, worked example pointing to #31278)
  - Startup options (`LogWarning`/`InitWarning` on use, help text update)
  - REST interface (document in `doc/REST-interface.md`)
  - ZMQ (document in `doc/zmq.md`)
  - Wallet settings (defer to RPC or startup option process depending on exposure)

  This consolidates the process that currently exists only implicitly across PRs and issue discussions into one place for contributors to reference.

ACKs for top commit:
  maflcko:
    lgtm ACK 2e9fdcc6da69238abbb1811a04c2beb6dba3b24a
  polespinasa:
    ACK 2e9fdcc6da69238abbb1811a04c2beb6dba3b24a
  stickies-v:
    ACK 2e9fdcc6da69238abbb1811a04c2beb6dba3b24a
  sedited:
    ACK 2e9fdcc6da69238abbb1811a04c2beb6dba3b24a

Tree-SHA512: 1d43df410664a45f937bcbd250664f13379168ca90e3024bea506e21a88177e201dcb4fadade705735099e3b8aaa2102a3080ad005bffb3aecb8f08d530d4277
(cherry picked from commit 9c150222604478431669b66b2caa0d75e8324d4c)
---
 doc/developer-notes.md | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/doc/developer-notes.md b/doc/developer-notes.md
index fb85e5bf0888..def957595d89 100644
--- a/doc/developer-notes.md
+++ b/doc/developer-notes.md
@@ -1343,6 +1343,46 @@ A few guidelines for modifying existing RPC interfaces:
 
   - *Rationale*: Changes in RPC JSON structure can break downstream application compatibility. Implementation of `deprecatedrpc` provides a grace period for downstream applications to migrate. Release notes provide notification to downstream users.
 
+## Feature deprecation and removal process
+
+Bitcoin Core uses a structured process for deprecating and removing features to give
+downstream users and applications time to migrate.
+
+### General principles
+
+- The minimum deprecation **grace period** for a feature that is going to be removed is one
+  major release.
+- Any deprecation or removal must come with a release note.
+
+### RPC methods and fields
+
+- To deprecate an entire RPC method, gate the old behavior behind `-deprecatedrpc=<feature>`.
+  Deprecated features should remain accessible via this flag during the grace period so
+  downstream users are not immediately broken.
+- The RPC help text must mention the deprecation and the `-deprecatedrpc=<feature>` flag
+  that re-enables it. For example:
+  ```
+  "\nDeprecated in v25.0, use the `newfoo` RPC instead. Start bitcoind with"
+  " `-deprecatedrpc=foo` to continue using this RPC.\n"
+  ```
+
+### Startup options
+
+- To deprecate a startup option, emit a warning via `LogWarning` or `InitWarning` when the
+  option is used, so users are notified at startup.
+- Update the option's help text to indicate it is deprecated and, if applicable, will be
+  removed in a future release.
+
+### REST interface
+
+- Deprecated REST endpoints or behaviors should be documented in `doc/REST-interface.md`
+  with the version they were deprecated.
+
+### ZMQ
+
+- Deprecated ZMQ topics or behaviors should be documented in `doc/zmq.md` with the version
+  they were deprecated.
+
 ## Internal interface guidelines
 
 Internal interfaces between parts of the codebase that are meant to be

From ce2fea39e9cbebb3952ef034f43ae6b47dfe0df4 Mon Sep 17 00:00:00 2001
From: merge-script <fanquake@gmail.com>
Date: Thu, 28 May 2026 10:00:09 +0100
Subject: [PATCH 04/10] Merge bitcoin/bitcoin#34948: guix: Split manifest into
 build and codesign manifests

d846444d012944dc3ce571582e39987576d45fc0 guix: Split manifest into build and codesign manifests (Hennadii Stepanov)
0b9e10ad404aaa5ab36874de8dd3d823cf759f1e guix: Update `python-signapple` and wrap with OpenSSL paths (Hennadii Stepanov)

Pull request description:

  This PR narrows the scope of the Guix environments to include only the minimum dependencies required for specific tasks, namely building and codesigning.

ACKs for top commit:
  fanquake:
    ACK d846444d012944dc3ce571582e39987576d45fc0

Tree-SHA512: f7b0dfc47e1c6c064738be9aeba69b8d553c7f61186b2c03fedf0a11015ab454cac45d6ee28bbabbbd53a3efabc230b77365edf9feb0d4a26c2805079389501d
(cherry picked from commit e3f5c189134260ca98ab1a5f3301b02166d407a4)
---
 contrib/guix/guix-build                       |   2 +-
 contrib/guix/guix-codesign                    |   2 +-
 .../guix/{manifest.scm => manifest_build.scm} | 151 +--------------
 contrib/guix/manifest_codesign.scm            | 179 ++++++++++++++++++
 4 files changed, 184 insertions(+), 150 deletions(-)
 rename contrib/guix/{manifest.scm => manifest_build.scm} (66%)
 create mode 100644 contrib/guix/manifest_codesign.scm

diff --git a/contrib/guix/guix-build b/contrib/guix/guix-build
index bef1c8412a7b..767ea9208f64 100755
--- a/contrib/guix/guix-build
+++ b/contrib/guix/guix-build
@@ -441,7 +441,7 @@ EOF
         #    more information.
         #
         # shellcheck disable=SC2086,SC2031
-        time-machine shell --manifest="${PWD}/contrib/guix/manifest.scm" \
+        time-machine shell --manifest="${PWD}/contrib/guix/manifest_build.scm" \
                                  --container \
                                  --writable-root \
                                  --pure \
diff --git a/contrib/guix/guix-codesign b/contrib/guix/guix-codesign
index 39291dfe9ceb..8c8682ddd0af 100755
--- a/contrib/guix/guix-codesign
+++ b/contrib/guix/guix-codesign
@@ -341,7 +341,7 @@ EOF
         #    more information.
         #
         # shellcheck disable=SC2086,SC2031
-        time-machine shell --manifest="${PWD}/contrib/guix/manifest.scm" \
+        time-machine shell --manifest="${PWD}/contrib/guix/manifest_codesign.scm" \
                                  --container \
                                  --writable-root \
                                  --pure \
diff --git a/contrib/guix/manifest.scm b/contrib/guix/manifest_build.scm
similarity index 66%
rename from contrib/guix/manifest.scm
rename to contrib/guix/manifest_build.scm
index 4fd901e57a5c..576021e60d7f 100644
--- a/contrib/guix/manifest.scm
+++ b/contrib/guix/manifest_build.scm
@@ -3,9 +3,8 @@
              (gnu packages bison)
              ((gnu packages cmake) #:select (cmake-minimal))
              (gnu packages commencement)
-             (gnu packages compression)
+             ((gnu packages compression) #:select (gzip xz zip))
              (gnu packages cross-base)
-             ((gnu packages crypto) #:select (osslsigncode))
              (gnu packages gawk)
              (gnu packages gcc)
              ((gnu packages installers) #:select (nsis-x86_64))
@@ -15,13 +14,8 @@
              (gnu packages ninja)
              (gnu packages pkg-config)
              ((gnu packages python) #:select (python-minimal))
-             ((gnu packages python-build) #:select (python-poetry-core))
-             ((gnu packages python-crypto) #:select (python-asn1crypto python-oscrypto))
              ((gnu packages python-xyz) #:select (python-lief))
-             ((gnu packages tls) #:select (openssl))
              ((gnu packages version-control) #:select (git-minimal))
-             (guix build-system python)
-             (guix build-system pyproject)
              (guix build-system trivial)
              (guix download)
              (guix gexp)
@@ -171,143 +165,6 @@ chain for " target " development."))
       (home-page (package-home-page pthreads-xgcc))
       (license (package-license pthreads-xgcc)))))
 
-(define-public python-elfesteem
-  (let ((commit "2eb1e5384ff7a220fd1afacd4a0170acff54fe56"))
-    (package
-      (name "python-elfesteem")
-      (version (git-version "0.1" "1" commit))
-      (source
-       (origin
-         (method git-fetch)
-         (uri (git-reference
-               (url "https://github.com/LRGH/elfesteem")
-               (commit commit)))
-         (file-name (git-file-name name commit))
-         (sha256
-          (base32
-           "07x6p8clh11z8s1n2kdxrqwqm2almgc5qpkcr9ckb6y5ivjdr5r6"))))
-      (build-system python-build-system)
-      ;; There are no tests, but attempting to run python setup.py test leads to
-      ;; PYTHONPATH problems, just disable the test
-      (arguments '(#:tests? #f))
-      (home-page "https://github.com/LRGH/elfesteem")
-      (synopsis "ELF/PE/Mach-O parsing library")
-      (description "elfesteem parses ELF, PE and Mach-O files.")
-      (license license:lgpl2.1))))
-
-(define-public python-oscryptotests
-  (package (inherit python-oscrypto)
-    (name "python-oscryptotests")
-    (propagated-inputs
-      (list python-oscrypto))
-    (arguments
-     `(#:tests? #f
-       #:phases
-       (modify-phases %standard-phases
-         (add-after 'unpack 'hard-code-path-to-libscrypt
-           (lambda* (#:key inputs #:allow-other-keys)
-             (chdir "tests")
-             #t)))))))
-
-(define-public python-certvalidator
-  (let ((commit "a145bf25eb75a9f014b3e7678826132efbba6213"))
-    (package
-      (name "python-certvalidator")
-      (version (git-version "0.1" "1" commit))
-      (source
-       (origin
-         (method git-fetch)
-         (uri (git-reference
-               (url "https://github.com/achow101/certvalidator")
-               (commit commit)))
-         (file-name (git-file-name name commit))
-         (sha256
-          (base32
-           "1qw2k7xis53179lpqdqyylbcmp76lj7sagp883wmxg5i7chhc96k"))))
-      (build-system python-build-system)
-      (propagated-inputs
-        (list openssl
-              python-asn1crypto
-              python-oscrypto
-              python-oscryptotests)) ;; certvalidator tests import oscryptotests
-      (arguments
-       `(#:phases
-         (modify-phases %standard-phases
-           (add-after 'unpack 'disable-broken-tests
-             (lambda _
-               (substitute* "tests/test_certificate_validator.py"
-                 (("^(.*)class CertificateValidatorTests" line indent)
-                  (string-append indent
-                                 "@unittest.skip(\"Disabled by Guix\")\n"
-                                 line)))
-               (substitute* "tests/test_crl_client.py"
-                 (("^(.*)def test_fetch_crl" line indent)
-                  (string-append indent
-                                 "@unittest.skip(\"Disabled by Guix\")\n"
-                                 line)))
-               (substitute* "tests/test_ocsp_client.py"
-                 (("^(.*)def test_fetch_ocsp" line indent)
-                  (string-append indent
-                                 "@unittest.skip(\"Disabled by Guix\")\n"
-                                 line)))
-               (substitute* "tests/test_registry.py"
-                 (("^(.*)def test_build_paths" line indent)
-                  (string-append indent
-                                 "@unittest.skip(\"Disabled by Guix\")\n"
-                                 line)))
-               (substitute* "tests/test_validate.py"
-                 (("^(.*)def test_revocation_mode_hard" line indent)
-                  (string-append indent
-                                 "@unittest.skip(\"Disabled by Guix\")\n"
-                                 line)))
-               (substitute* "tests/test_validate.py"
-                 (("^(.*)def test_revocation_mode_soft" line indent)
-                  (string-append indent
-                                 "@unittest.skip(\"Disabled by Guix\")\n"
-                                 line)))
-               #t))
-           (replace 'check
-             (lambda _
-               (invoke "python" "run.py" "tests")
-               #t)))))
-      (home-page "https://github.com/wbond/certvalidator")
-      (synopsis "Python library for validating X.509 certificates and paths")
-      (description "certvalidator is a Python library for validating X.509
-certificates or paths. Supports various options, including: validation at a
-specific moment in time, whitelisting and revocation checks.")
-      (license license:expat))))
-
-(define-public python-signapple
-  (let ((commit "85bfcecc33d2773bc09bc318cec0614af2c8e287"))
-    (package
-      (name "python-signapple")
-      (version (git-version "0.2.0" "1" commit))
-      (source
-       (origin
-         (method git-fetch)
-         (uri (git-reference
-               (url "https://github.com/achow101/signapple")
-               (commit commit)))
-         (file-name (git-file-name name commit))
-         (sha256
-          (base32
-           "17yqjll8nw83q6dhgqhkl7w502z5vy9sln8m6mlx0f1c10isg8yg"))))
-      (build-system pyproject-build-system)
-      (propagated-inputs
-        (list python-asn1crypto
-              python-oscrypto
-              python-certvalidator
-              python-elfesteem))
-      (native-inputs (list python-poetry-core))
-      ;; There are no tests, but attempting to run python setup.py test leads to
-      ;; problems, just disable the test
-      (arguments '(#:tests? #f))
-      (home-page "https://github.com/achow101/signapple")
-      (synopsis "Mach-O binary signature tool")
-      (description "signapple is a Python tool for creating, verifying, and
-inspecting signatures in Mach-O binaries.")
-      (license license:expat))))
-
 (define-public mingw-w64-base-gcc
   (package
     (inherit base-gcc)
@@ -428,10 +285,9 @@ inspecting signatures in Mach-O binaries.")
         python-lief)
   (let ((target (getenv "HOST")))
     (cond ((string-suffix? "-mingw32" target)
-           (list zip
-                 (make-mingw-pthreads-cross-toolchain "x86_64-w64-mingw32")
+           (list (make-mingw-pthreads-cross-toolchain "x86_64-w64-mingw32")
                  nsis-x86_64
-                 osslsigncode))
+                 zip))
           ((string-contains target "-linux-")
            (list bison
                  pkg-config
@@ -441,6 +297,5 @@ inspecting signatures in Mach-O binaries.")
            (list clang-toolchain-19
                  lld-19
                  (make-lld-wrapper lld-19 #:lld-as-ld? #t)
-                 python-signapple
                  zip))
           (else '())))))
diff --git a/contrib/guix/manifest_codesign.scm b/contrib/guix/manifest_codesign.scm
new file mode 100644
index 000000000000..652f40ac3f07
--- /dev/null
+++ b/contrib/guix/manifest_codesign.scm
@@ -0,0 +1,179 @@
+(use-modules ((gnu packages bash) #:select (bash-minimal))
+             ((gnu packages compression) #:select (gzip zip))
+             ((gnu packages crypto) #:select (osslsigncode))
+             ((gnu packages python-build) #:select (python-poetry-core))
+             ((gnu packages python-crypto) #:select (python-asn1crypto python-oscrypto))
+             ((gnu packages tls) #:select (openssl))
+             ((gnu packages version-control) #:select (git-minimal))
+             (guix build-system python)
+             (guix build-system pyproject)
+             (guix git-download)
+             ((guix licenses) #:prefix license:)
+             (guix packages))
+
+(define-public python-elfesteem
+  (let ((commit "2eb1e5384ff7a220fd1afacd4a0170acff54fe56"))
+    (package
+      (name "python-elfesteem")
+      (version (git-version "0.1" "1" commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/LRGH/elfesteem")
+               (commit commit)))
+         (file-name (git-file-name name commit))
+         (sha256
+          (base32
+           "07x6p8clh11z8s1n2kdxrqwqm2almgc5qpkcr9ckb6y5ivjdr5r6"))))
+      (build-system python-build-system)
+      ;; There are no tests, but attempting to run python setup.py test leads to
+      ;; PYTHONPATH problems, just disable the test
+      (arguments '(#:tests? #f))
+      (home-page "https://github.com/LRGH/elfesteem")
+      (synopsis "ELF/PE/Mach-O parsing library")
+      (description "elfesteem parses ELF, PE and Mach-O files.")
+      (license license:lgpl2.1))))
+
+(define-public python-oscryptotests
+  (package (inherit python-oscrypto)
+    (name "python-oscryptotests")
+    (propagated-inputs
+      (list python-oscrypto))
+    (arguments
+     `(#:tests? #f
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'hard-code-path-to-libscrypt
+           (lambda* (#:key inputs #:allow-other-keys)
+             (chdir "tests")
+             #t)))))))
+
+(define-public python-certvalidator
+  (let ((commit "a145bf25eb75a9f014b3e7678826132efbba6213"))
+    (package
+      (name "python-certvalidator")
+      (version (git-version "0.1" "1" commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/achow101/certvalidator")
+               (commit commit)))
+         (file-name (git-file-name name commit))
+         (sha256
+          (base32
+           "1qw2k7xis53179lpqdqyylbcmp76lj7sagp883wmxg5i7chhc96k"))))
+      (build-system python-build-system)
+      (propagated-inputs
+        (list openssl
+              python-asn1crypto
+              python-oscrypto
+              python-oscryptotests)) ;; certvalidator tests import oscryptotests
+      (arguments
+       `(#:phases
+         (modify-phases %standard-phases
+           (add-after 'unpack 'disable-broken-tests
+             (lambda _
+               (substitute* "tests/test_certificate_validator.py"
+                 (("^(.*)class CertificateValidatorTests" line indent)
+                  (string-append indent
+                                 "@unittest.skip(\"Disabled by Guix\")\n"
+                                 line)))
+               (substitute* "tests/test_crl_client.py"
+                 (("^(.*)def test_fetch_crl" line indent)
+                  (string-append indent
+                                 "@unittest.skip(\"Disabled by Guix\")\n"
+                                 line)))
+               (substitute* "tests/test_ocsp_client.py"
+                 (("^(.*)def test_fetch_ocsp" line indent)
+                  (string-append indent
+                                 "@unittest.skip(\"Disabled by Guix\")\n"
+                                 line)))
+               (substitute* "tests/test_registry.py"
+                 (("^(.*)def test_build_paths" line indent)
+                  (string-append indent
+                                 "@unittest.skip(\"Disabled by Guix\")\n"
+                                 line)))
+               (substitute* "tests/test_validate.py"
+                 (("^(.*)def test_revocation_mode_hard" line indent)
+                  (string-append indent
+                                 "@unittest.skip(\"Disabled by Guix\")\n"
+                                 line)))
+               (substitute* "tests/test_validate.py"
+                 (("^(.*)def test_revocation_mode_soft" line indent)
+                  (string-append indent
+                                 "@unittest.skip(\"Disabled by Guix\")\n"
+                                 line)))
+               #t))
+           (replace 'check
+             (lambda _
+               (invoke "python" "run.py" "tests")
+               #t)))))
+      (home-page "https://github.com/wbond/certvalidator")
+      (synopsis "Python library for validating X.509 certificates and paths")
+      (description "certvalidator is a Python library for validating X.509
+certificates or paths. Supports various options, including: validation at a
+specific moment in time, whitelisting and revocation checks.")
+      (license license:expat))))
+
+(define-public python-signapple
+  (let ((commit "3fab3bb57f227f0dd31007b417683035f5204838"))
+    (package
+      (name "python-signapple")
+      (version (git-version "0.2.0" "1" commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/achow101/signapple")
+               (commit commit)))
+         (file-name (git-file-name name commit))
+         (sha256
+          (base32
+           "0qpr78bs50rw79dbihr9ifjq19y6819ih5pn9jd2rbjyifimzf7p"))))
+      (build-system pyproject-build-system)
+      (propagated-inputs
+        (list python-asn1crypto
+              python-oscrypto
+              python-certvalidator
+              python-elfesteem))
+      (native-inputs (list python-poetry-core))
+      (arguments
+       ;; There are no tests, but attempting to run python setup.py test leads to
+       ;; problems, just disable the test
+       (list #:tests? #f
+             #:phases
+             #~(modify-phases %standard-phases
+                 ;; Add a phase to inject OpenSSL paths for oscrypto.
+                 (add-after 'wrap 'wrap-openssl-paths
+                   (lambda* (#:key inputs #:allow-other-keys)
+                     (let ((openssl (assoc-ref inputs "openssl")))
+                       (wrap-program (string-append #$output "/bin/signapple")
+                         `("SIGNAPPLE_OSCRYPTO_SSL_PATHS" =
+                           (,(string-append openssl "/lib/libcrypto.so" "," openssl "/lib/libssl.so"))))))))))
+      (home-page "https://github.com/achow101/signapple")
+      (synopsis "Mach-O binary signature tool")
+      (description "signapple is a Python tool for creating, verifying, and
+inspecting signatures in Mach-O binaries.")
+      (license license:expat))))
+
+(packages->manifest
+ (append
+  (list ;; The Basics
+        bash-minimal
+        coreutils-minimal
+        ;; File(system) inspection
+        findutils
+        ;; Compression and archiving
+        tar
+        gzip
+        zip
+        ;; Git
+        git-minimal)
+  (let ((target (getenv "HOST")))
+    (cond ((string-suffix? "-mingw32" target)
+           (list osslsigncode))
+          ((string-contains target "darwin")
+           (list python-signapple))
+          (else '())))))

From 43a159f27729cafa0ef034ae6e93608da6e42889 Mon Sep 17 00:00:00 2001
From: merge-script <fanquake@gmail.com>
Date: Fri, 22 May 2026 11:11:28 +0100
Subject: [PATCH 05/10] Merge bitcoin/bitcoin#35348: ci: switch to GitHub cache
 for all runners
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

c03107acf50aeada1bacdfdbf632ffce2957bff0 ci: switch to GitHub cache for all runners (willcl-ark)

Pull request description:

  Cirrus is winding down, and github now offers more than 10GB cache.

  Switch to GH cache for all runner-types. Simplify configure-docker action.

ACKs for top commit:
  maflcko:
    review ACK c03107acf50aeada1bacdfdbf632ffce2957bff0 🚴

Tree-SHA512: b6111c7559a86eed8488a4b0775df812a303a99eed5c80297593936e61d1d5e2ce72fe2fa615625816672414e6947ac4d93b9fd2925522fba06417ea4711ce79
(cherry picked from commit f28cd7587b0fd86964a224db30d927f1fb7429c6)
---
 .github/actions/configure-docker/action.yml | 39 ++++-----------------
 .github/actions/restore-caches/action.yml   |  8 ++---
 .github/actions/save-caches/action.yml      |  8 ++---
 .github/workflows/ci.yml                    |  9 ++---
 ci/README.md                                |  6 ++--
 5 files changed, 20 insertions(+), 50 deletions(-)

diff --git a/.github/actions/configure-docker/action.yml b/.github/actions/configure-docker/action.yml
index b4abf7c274ab..6f89dc8bd045 100644
--- a/.github/actions/configure-docker/action.yml
+++ b/.github/actions/configure-docker/action.yml
@@ -1,27 +1,14 @@
 name: 'Configure Docker'
 description: 'Set up Docker build driver and configure build cache args'
-inputs:
-  cache-provider:
-    description: 'gha or cirrus cache provider'
-    required: true
 runs:
   using: 'composite'
   steps:
-    - name: Check inputs
-      shell: python
-      run: |
-        # We expect only gha or cirrus as inputs to cache-provider
-        if "${{ inputs.cache-provider }}" not in ("gha", "cirrus"):
-          print("::warning title=Unknown input to configure docker action::Provided value was ${{ inputs.cache-provider }}")
-
     - name: Set up Docker Buildx
       uses: docker/setup-buildx-action@v4
-      with:
-        # Use host network to allow access to cirrus gha cache running on the host
-        driver-opts: |
-          network=host
 
-    # This is required to allow buildkit to access the actions cache
+    # This is required when using the gha cache backend with a manual docker buildx invocation.
+    # Docker will check for variables $ACTIONS_CACHE_URL, $ACTIONS_RESULTS_URL and $ACTIONS_RUNTIME_TOKEN
+    # which are set automatically when running on GitHub infra: https://docs.docker.com/build/cache/backends/gha/#synopsis
     - name: Expose actions cache variables
       uses: actions/github-script@v8
       with:
@@ -37,24 +24,12 @@ runs:
       shell: bash
       run: |
         # Configure docker build cache backend
-        #
-        # On forks the gha cache will work but will use Github's cache backend.
-        # Docker will check for variables $ACTIONS_CACHE_URL, $ACTIONS_RESULTS_URL and $ACTIONS_RUNTIME_TOKEN
-        # which are set automatically when running on GitHub infra: https://docs.docker.com/build/cache/backends/gha/#synopsis
-
-        # Use cirrus cache host
-        if [[ ${{ inputs.cache-provider }} == 'cirrus' ]]; then
-          url_args="url=${CIRRUS_CACHE_HOST},url_v2=${CIRRUS_CACHE_HOST}"
-        else
-          url_args=""
-        fi
-
         # Always optimistically --cache‑from in case a cache blob exists
-        args=(--cache-from "type=gha${url_args:+,${url_args}},scope=${CONTAINER_NAME}")
+        args=(--cache-from "type=gha,scope=${CONTAINER_NAME}")
 
-        # Only add --cache-to when using the Cirrus cache provider and pushing to the default branch.
-        if [[ ${{ inputs.cache-provider }} == 'cirrus' && ${{ github.event_name }} == "push" && ${{ github.ref_name }} == ${{ github.event.repository.default_branch }} ]]; then
-          args+=(--cache-to "type=gha${url_args:+,${url_args}},mode=max,ignore-error=true,scope=${CONTAINER_NAME}")
+        # Only add --cache-to when pushing to the default branch.
+        if [[ ${{ github.event_name }} == "push" && ${{ github.ref_name }} == ${{ github.event.repository.default_branch }} ]]; then
+          args+=(--cache-to "type=gha,mode=max,ignore-error=true,scope=${CONTAINER_NAME}")
         fi
 
         # Always `--load` into docker images (needed when using the `docker-container` build driver).
diff --git a/.github/actions/restore-caches/action.yml b/.github/actions/restore-caches/action.yml
index 21f2807f4c72..ee07d68b9070 100644
--- a/.github/actions/restore-caches/action.yml
+++ b/.github/actions/restore-caches/action.yml
@@ -5,7 +5,7 @@ runs:
   steps:
     - name: Restore Ccache cache
       id: ccache-cache
-      uses: cirruslabs/cache/restore@v5
+      uses: actions/cache/restore@v5
       with:
         path: ${{ env.CCACHE_DIR }}
         key: ccache-${{ env.CONTAINER_NAME }}-${{ github.run_id }}
@@ -14,7 +14,7 @@ runs:
 
     - name: Restore depends sources cache
       id: depends-sources
-      uses: cirruslabs/cache/restore@v5
+      uses: actions/cache/restore@v5
       with:
         path: ${{ env.SOURCES_PATH }}
         key: depends-sources-${{ env.CONTAINER_NAME }}-${{ env.DEPENDS_HASH }}
@@ -23,7 +23,7 @@ runs:
 
     - name: Restore built depends cache
       id: depends-built
-      uses: cirruslabs/cache/restore@v5
+      uses: actions/cache/restore@v5
       with:
         path: ${{ env.BASE_CACHE }}
         key: depends-built-${{ env.CONTAINER_NAME }}-${{ env.DEPENDS_HASH }}
@@ -32,7 +32,7 @@ runs:
 
     - name: Restore previous releases cache
       id: previous-releases
-      uses: cirruslabs/cache/restore@v5
+      uses: actions/cache/restore@v5
       with:
         path: ${{ env.PREVIOUS_RELEASES_DIR }}
         key: previous-releases-${{ env.CONTAINER_NAME }}-${{ env.PREVIOUS_RELEASES_HASH }}
diff --git a/.github/actions/save-caches/action.yml b/.github/actions/save-caches/action.yml
index 3072ab3f224a..8667c91473df 100644
--- a/.github/actions/save-caches/action.yml
+++ b/.github/actions/save-caches/action.yml
@@ -11,28 +11,28 @@ runs:
         echo "previous releases direct cache hit to primary key: ${{ env.previous-releases-cache-hit }}"
 
     - name: Save Ccache cache
-      uses: cirruslabs/cache/save@v5
+      uses: actions/cache/save@v5
       if: ${{ (github.event_name == 'push') && (github.ref_name == github.event.repository.default_branch) }}
       with:
         path: ${{ env.CCACHE_DIR }}
         key: ccache-${{ env.CONTAINER_NAME }}-${{ github.run_id }}
 
     - name: Save depends sources cache
-      uses: cirruslabs/cache/save@v5
+      uses: actions/cache/save@v5
       if: ${{ (github.event_name == 'push') && (github.ref_name == github.event.repository.default_branch) && (env.depends-sources-cache-hit != 'true') }}
       with:
         path: ${{ env.SOURCES_PATH }}
         key: depends-sources-${{ env.CONTAINER_NAME }}-${{ env.DEPENDS_HASH }}
 
     - name: Save built depends cache
-      uses: cirruslabs/cache/save@v5
+      uses: actions/cache/save@v5
       if: ${{ (github.event_name == 'push') && (github.ref_name == github.event.repository.default_branch) && (env.depends-built-cache-hit != 'true' )}}
       with:
         path: ${{ env.BASE_CACHE }}
         key: depends-built-${{ env.CONTAINER_NAME }}-${{ env.DEPENDS_HASH }}
 
     - name: Save previous releases cache
-      uses: cirruslabs/cache/save@v5
+      uses: actions/cache/save@v5
       if: ${{ (github.event_name == 'push') && (github.ref_name == github.event.repository.default_branch) && (env.previous-releases-cache-hit != 'true' )}}
       with:
         path: ${{ env.PREVIOUS_RELEASES_DIR }}
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 734b9f38c762..920c1f46047d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -19,8 +19,7 @@ concurrency:
 
 env:
   CI_FAILFAST_TEST_LEAVE_DANGLING: 1  # GHA does not care about dangling processes and setting this variable avoids killing the CI script itself on error
-  CIRRUS_CACHE_HOST: http://127.0.0.1:12321/ # When using Cirrus Runners this host can be used by the docker `gha` build cache type.
-  REPO_USE_CIRRUS_RUNNERS: 'bitcoin/bitcoin' # Use cirrus runners and cache for this repo, instead of falling back to the slow GHA runners
+  REPO_USE_CIRRUS_RUNNERS: 'bitcoin/bitcoin' # Use cirrus runners for this repo, instead of falling back to the slow GHA runners
 
 defaults:
   run:
@@ -60,7 +59,7 @@ jobs:
     needs: runners
     runs-on: ${{ needs.runners.outputs.provider == 'cirrus' && 'ghcr.io/cirruslabs/ubuntu-runner-amd64:24.04-md' || 'ubuntu-24.04' }}
     env:
-      TEST_RUNNER_PORT_MIN: "14000"  # Use a larger port, to avoid colliding with CIRRUS_CACHE_HOST port 12321.
+      TEST_RUNNER_PORT_MIN: "14000"  # Use a larger port range to avoid colliding with other CI services.
     if: github.event_name == 'pull_request' && github.event.pull_request.commits != 1
     timeout-minutes: 360  # Use maximum time, see https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions#jobsjob_idtimeout-minutes.
     steps:
@@ -327,8 +326,6 @@ jobs:
 
       - name: Configure Docker
         uses: ./.github/actions/configure-docker
-        with:
-          cache-provider: ${{ matrix.provider || needs.runners.outputs.provider }}
 
       - name: Clear unnecessary files
         if: ${{ needs.runners.outputs.provider == 'gha' && true || false }} # Only needed on GHA runners
@@ -370,8 +367,6 @@ jobs:
 
       - name: Configure Docker
         uses: ./.github/actions/configure-docker
-        with:
-          cache-provider: ${{ needs.runners.outputs.provider }}
 
       - name: CI script
         run: |
diff --git a/ci/README.md b/ci/README.md
index 293294a559c5..0f43b4f1f630 100644
--- a/ci/README.md
+++ b/ci/README.md
@@ -85,15 +85,15 @@ To configure the primary repository, follow these steps:
 3. Enable organisation-level runners to be used in public repositories:
    1. `Org settings -> Actions -> Runner Groups -> Default -> Allow public repos`
 4. Permit the following actions to run:
-   1. cirruslabs/cache/restore@\*
-   1. cirruslabs/cache/save@\*
+   1. actions/cache/restore@\*
+   1. actions/cache/save@\*
    1. docker/setup-buildx-action@\*
    1. actions/github-script@\*
 
 ### Forked repositories
 
 When used in a fork the CI will run on GitHub's free hosted runners by default.
-In this case, due to GitHub's 10GB-per-repo cache size limitations caches will be frequently evicted and missed, but the workflows will run (slowly).
+In this case, GitHub's cache size limitations may cause caches to be frequently evicted and missed, but the workflows will run (slowly).
 
 It is also possible to use your own Cirrus Runners in your own fork with an appropriate patch to the `REPO_USE_CIRRUS_RUNNERS` variable in ../.github/workflows/ci.yml
 NB that Cirrus Runners only work at an organisation level, therefore in order to use your own Cirrus Runners, *the fork must be within your own organisation*.

From a90bbf03dfba0248a22d93973dc47bf5d1ab698d Mon Sep 17 00:00:00 2001
From: merge-script <seb.kung@gmail.com>
Date: Tue, 26 May 2026 12:45:37 +0200
Subject: [PATCH 06/10] Merge bitcoin/bitcoin#35296: doc: Fix broken links in
 dev notes, move sections

faf6afd99df457c5298d1867b84d448bd18b5a23 doc: Move mutex and thread section into guideline section (MarcoFalke)
fa514caad75def4286593c5f9a0a97a1552736f1 doc: move-only Valgrind section (MarcoFalke)
fa0202f31da3302348db37b235991f4a3832ef8f doc: move-only Python section (MarcoFalke)
fa37606c656f52966e932b6dababe3bb00034ac8 doc: Regroup clang-tidy rules (MarcoFalke)
fa9c2ddea9b494b571dfdc218a888218752359d7 doc: Fix to use lower-case anchors in links to C++ Core Guidelines (MarcoFalke)

Pull request description:

  The anchors in isocpp links were recently broken, so fix them to point to the correct anchor.

  Also, move/regroup 3 sections while touching the file.

ACKs for top commit:
  fanquake:
    ACK faf6afd99df457c5298d1867b84d448bd18b5a23
  sedited:
    ACK faf6afd99df457c5298d1867b84d448bd18b5a23

Tree-SHA512: 0067eb23a6a8cccfaee5df0df347529f17db39473602fa51bc2f3e53c9709934bb25fca51f6ed58c4896437c890789f29facf54d15a7ebbbd247a2ebb1c0b5cd
(cherry picked from commit 9767e80b213818fcb614ff5b99f3be4e4186eed8)
---
 doc/developer-notes.md | 49 +++++++++++++++++++++++++++++++-----------
 src/node/context.h     |  4 ++++
 src/node/miner.cpp     |  1 +
 3 files changed, 41 insertions(+), 13 deletions(-)

diff --git a/doc/developer-notes.md b/doc/developer-notes.md
index def957595d89..80301ec01c41 100644
--- a/doc/developer-notes.md
+++ b/doc/developer-notes.md
@@ -42,7 +42,7 @@ code.
   - Constant names are all uppercase, and use `_` to separate words.
   - Enumerator constants may be `snake_case`, `PascalCase` or `ALL_CAPS`.
     This is a more tolerant policy than the [C++ Core
-    Guidelines](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Renum-caps),
+    Guidelines](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#renum-caps),
     which recommend using `snake_case`.  Please use what seems appropriate.
   - Class names, function names, and method names are UpperCamelCase
     (PascalCase). Do not prefix class names with `C`. See [Internal interface
@@ -55,16 +55,13 @@ code.
 
 - **Miscellaneous**
   - `++i` is preferred over `i++`.
-  - `nullptr` is preferred over `NULL` or `(void*)0`.
   - `static_assert` is preferred over `assert` where possible. Generally; compile-time checking is preferred over run-time checking.
   - Use a named cast or functional cast, not a C-Style cast. When casting
     between integer types, use functional casts such as `int(x)` or `int{x}`
     instead of `(int) x`. When casting between more complex types, use `static_cast`.
     Use `reinterpret_cast` and `const_cast` as appropriate.
-  - Prefer [`list initialization ({})`](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-list) where possible.
+  - Prefer [`list initialization ({})`](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#res-list) where possible.
     For example `int x{0};` instead of `int x = 0;` or `int x(0);`
-  - Recursion is checked by clang-tidy and thus must be made explicit. Use
-    `NOLINTNEXTLINE(misc-no-recursion)` to suppress the check.
 
 For function calls a namespace should be specified explicitly, unless such functions have been declared within it.
 Otherwise, [argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl), also known as ADL, could be
@@ -140,7 +137,18 @@ public:
   non-optional in-out and output parameters should usually be references, as
   they cannot be null.
 
-### Coding Style (C++ named arguments)
+### Coding Style (clang-tidy rules)
+
+The clang-tidy tool is used to check some rules. Please refer to the [upstream
+documentation](https://clang.llvm.org/extra/clang-tidy/checks/list.html) about
+the details and rationale for each rule.
+
+#### C++ Recursive Functions
+
+Recursion is checked by clang-tidy and thus must be made explicit. Use
+`NOLINTNEXTLINE(misc-no-recursion)` to suppress the check.
+
+#### C++ named arguments
 
 When passing named arguments, use a format that clang-tidy understands. The
 argument names can otherwise not be verified by clang-tidy.
@@ -156,7 +164,7 @@ int main()
 }
 ```
 
-### Running clang-tidy
+#### Running clang-tidy
 
 To run clang-tidy on Ubuntu/Debian, install the dependencies:
 
@@ -603,6 +611,21 @@ or using a graphical tool like [Hotspot](https://github.com/KDAB/hotspot).
 
 See the functional test documentation for how to invoke perf within tests.
 
+### Valgrind
+
+Valgrind is a programming tool for memory debugging, memory leak detection, and
+profiling. The repo contains a Valgrind suppressions file
+([`valgrind.supp`](/test/sanitizer_suppressions/valgrind.supp))
+which includes known Valgrind warnings in our dependencies that cannot be fixed
+in-tree. Example use:
+
+```shell
+$ valgrind --suppressions=test/sanitizer_suppressions/valgrind.supp build/bin/test_bitcoin
+$ valgrind --suppressions=test/sanitizer_suppressions/valgrind.supp --leak-check=full \
+      --show-leak-kinds=all build/bin/test_bitcoin --log_level=test_suite
+$ valgrind -v --leak-check=full build/bin/bitcoind -printtoconsole
+$ ./build/test/functional/test_runner.py --valgrind
+```
 
 ### Sanitizers
 
@@ -658,6 +681,11 @@ Additional resources:
  * [GCC Instrumentation Options](https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html)
  * [Google Sanitizers Wiki](https://github.com/google/sanitizers/wiki)
 
+# Development guidelines
+
+A few non-style-related recommendations for developers, as well as points to
+pay attention to for reviewers of Bitcoin Core code.
+
 ## Locking/mutex usage notes
 
 The code is multi-threaded and uses mutexes and the
@@ -723,11 +751,6 @@ done by the components.
   - [ThreadI2PAcceptIncoming (`b-i2paccept`)](https://doxygen.bitcoincore.org/class_c_connman.html#a57787b4f9ac847d24065fbb0dd6e70f8)
     : Listens for and accepts incoming I2P connections through the I2P SAM proxy.
 
-# Development guidelines
-
-A few non-style-related recommendations for developers, as well as points to
-pay attention to for reviewers of Bitcoin Core code.
-
 ## General Bitcoin Core
 
 - New features should be exposed on RPC first, then can be made available in the GUI.
@@ -780,7 +803,7 @@ Guidelines](https://isocpp.github.io/CppCoreGuidelines/).
 Common misconceptions are clarified in those sections:
 
 - Passing (non-)fundamental types in the [C++ Core
-  Guideline](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-conventional).
+  Guidelines](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#rf-conventional).
 
 - If you use the `.h`, you must link the `.cpp`.
 
diff --git a/src/node/context.h b/src/node/context.h
index 36e0b05e291d..4c6564ef6ff6 100644
--- a/src/node/context.h
+++ b/src/node/context.h
@@ -5,6 +5,8 @@
 #ifndef BITCOIN_NODE_CONTEXT_H
 #define BITCOIN_NODE_CONTEXT_H
 
+#include <node/types.h>
+
 #include <atomic>
 #include <cstdlib>
 #include <functional>
@@ -73,6 +75,8 @@ struct NodeContext {
     ArgsManager* args{nullptr}; // Currently a raw pointer because the memory is not managed by this struct
     std::unique_ptr<interfaces::Chain> chain;
     std::unique_ptr<interfaces::Mining> mining;
+    //! Mining options used to create block templates.
+    BlockCreateOptions mining_args;
     std::unique_ptr<CScheduler> scheduler;
     std::function<void()> rpc_interruption_point = [] {};
     //! Issues blocking calls about sync status, errors and warnings
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index 8dc58b39795d..e97e0c82665f 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -7,6 +7,7 @@
 
 #include <block_validation.h>
 #include <chain.h>
+#include <interfaces/types.h>
 #include <chainparams.h>
 #include <coins.h>
 #include <common/args.h>

From f817ad82937c18de20934ca1ccdbce7504376ef1 Mon Sep 17 00:00:00 2001
From: Ryan Ofsky <ryan@ofsky.org>
Date: Tue, 26 May 2026 08:14:01 -0400
Subject: [PATCH 07/10] Merge bitcoin/bitcoin#33966: refactor: disentangle
 miner startup defaults from runtime options

1e5d3b4f0da41d38305b8c8ff654396ed451cc2c doc: add release note for mining option validation (Sjors Provoost)
0317f52022cd34a2fb6647f0a85ad6537d7cc820 ci: enforce iwyu for touched files (Sjors Provoost)
8c58f63578a44c8b4ebdda4637d1b198d8a67d08 refactor: have mining files include what they use (Sjors Provoost)
3bb6498fb0f6ac611ba4093ef774a3152b93a2c6 mining: store block create options in NodeContext (Sjors Provoost)
4637cd157da836ef377fb35e40956a0226d0baac mining: reject invalid block create options (Sjors Provoost)
8daac1d6eba79991a1d2758ec24d314f3874cf66 mining: add block create option helpers (Sjors Provoost)
128da7c3ff8071b0f2decddfbe50797c5134e41a miner: add block_max_weight to BlockCreateOptions (Sjors Provoost)
fa81e51eaeeabb5e3e1b1419fad912af4cde40a4 mining: parse block creation args in mining_args (Sjors Provoost)
020166080cf57e6eb869abc56d603eb1d6e5e45b mining: use interface for tests, bench and fuzzers (Sjors Provoost)
44082bea47942072992cbde4d6f96253c7f79284 interfaces: make Mining use const NodeContext (Sjors Provoost)
d4368e059cfe09d973a238d08cbe6812511366d3 move-only: add node/mining_types.h (Sjors Provoost)
6aeb1fbea2399bf28b00d128126cd28409e9b0c0 test: cover IPC blockmaxweight policy (Sjors Provoost)
63b23ea1e94f8f1f74e24abbadf2e5de3148f396 test: regression test for waitNext mining policy (Sjors Provoost)
24750f8b31a42c468e49baa2c584ebddb4bc15fb test: add createNewBlock failure helper (Sjors Provoost)
63ee9cd15b628abe3f1ce1427938c945fe1534d6 test: misc interface_ipc_mining.py improvements (Sjors Provoost)

Pull request description:

  Although this PR is primarily a refactor, _there are behavior changes_ documented in the release note:
  - the IPC mining interface now rejects out-of-range block template options instead of silently clamping them;
  - startup now rejects `-blockmaxweight` values lower than `-blockreservedweight`, instead of allowing them to be clamped later.

  The interaction between node startup options like `-blockreservedweight` and runtime options, especially those passed via IPC, is confusing.

  They're combined in `BlockAssembler::Options`, which this PR gets rid of in favour of `BlockCreateOptions`.

  `BlockCreateOptions` is used by interface clients. As before, IPC clients have access to a safe / sane subset, whereas RPC and test code can use all fields. The same type is also used to store mining defaults parsed once during node startup in `NodeContext`.

  The maximum block weight setting (`block_max_weight`) is optional. When read from startup options it matches `-blockmaxweight`; when provided by callers it is a runtime override. `Merge()` fills unset fields from startup defaults while preserving caller-provided values.

  This all happens in commits `mining: add block create option helpers` and `mining: store block create options in NodeContext`, and requires some preparation to keep things easy to review.

  We get rid of `BlockAssembler::Options` but this is used in many tests. Since large churn is inevitable, we might as well switch all tests, bench and fuzzers over to the Mining interface. The `mining: use interface for tests, bench and fuzzers` commit does that, dramatically reducing direct use of `BlockAssembler`. Two exceptions are documented in the commit message. Because `test_block_validity` wasn't available via the interface and the block_assemble benchmark needs it, it's moved from `BlockAssembler::Options` to `BlockCreateOptions` (still not exposed via IPC).

  We need access to mining related structs from both the miner and node initialization code. To avoid having to pull in all of `BlockAssembler` for the latter, the `move-only: add node/mining_types.h` commit introduces `node/mining_types.h` and moves `BlockCreateOptions`, `BlockWaitOptions` and `BlockCheckOptions` there from `src/node/types.h`.

  I considered also moving `DEFAULT_BLOCK_MAX_WEIGHT`, `DEFAULT_BLOCK_RESERVED_WEIGHT`, `MINIMUM_BLOCK_RESERVED_WEIGHT` and `DEFAULT_BLOCK_MIN_TX_FEE` there from `policy.h`, since they are distinct from relay policy and not needed by the kernel. But this seems more appropriate for a follow-up and requires additional discussion.

  ---

  I kept variable renaming and other formatting changes to a minimum to ease review with `--color-moved=dimmed-zebra`.

  ## Commit summary

  Tests and test cleanup:
  - `test: misc interface_ipc_mining.py improvements`
  - `test: add assert_create_fails helper`
  - `test: regression test for waitNext mining policy`
  - `test: cover IPC blockmaxweight policy`

  Refactoring test/bench/fuzz callers:
  - `interfaces: make Mining use const NodeContext`
  - `mining: use interface for tests, bench and fuzzers`

  Moving mining interface types:
  - `move-only: add node/mining_types.h`

  Separating startup defaults from runtime options:
  - `mining: parse block creation args in mining_args`: adds `node/mining_args.{h,cpp}` and moves mining option parsing out of `init.cpp`, without storing the parsed values yet.
  - `miner: add block_max_weight to BlockCreateOptions`: moves the runtime maximum block weight setting into `BlockCreateOptions` as an optional value, so it can later be defaulted from startup args when unset.
  - `mining: add block create option helpers`: centralizes block template option defaulting and merging, removes `BlockAssembler::Options`, and preserves behavior except for dropping the `Specified ` prefix from startup option error messages.
  - `mining: reject invalid block create options`: checks typed `BlockCreateOptions` before block template creation, so invalid runtime options are rejected instead of silently clamped. Startup validation also rejects `-blockmaxweight` values lower than `-blockreservedweight`.
  - `mining: store block create options in NodeContext`: stores the startup mining options in `NodeContext` as `BlockCreateOptions`, so startup defaults and runtime overrides can be merged with the same option type.

  Include hygiene, CI and release note:
  - `refactor: have mining files include what they use`
  - `ci: enforce iwyu for touched files`
  - `doc: add release note for mining option validation`

ACKs for top commit:
  w0xlt:
    reACK 1e5d3b4f0da41d38305b8c8ff654396ed451cc2c
  sedited:
    ACK 1e5d3b4f0da41d38305b8c8ff654396ed451cc2c
  ryanofsky:
    Code review ACK 1e5d3b4f0da41d38305b8c8ff654396ed451cc2c. Looks good, thanks for the updates!

Tree-SHA512: 28c715023cb78f02775caa787b243c994bd0f8ce4559afc8db9301e93400ebbc74963626a4afe65ae15bcc16b9192d051a745839f4c804848d50746ea5a224b4
(cherry picked from commit a4157fc24a29118b1c9d1ac5b7977104217bcee9)
---
 ci/test/03_test_script.sh                |   2 +-
 doc/release-notes-33966.md               |   9 ++
 src/CMakeLists.txt                       |   1 +
 src/bench/block_assemble.cpp             |  16 +-
 src/bench/connectblock.cpp               |   9 +-
 src/init.cpp                             |  55 +++----
 src/interfaces/mining.h                  |  10 +-
 src/node/context.h                       |   2 +-
 src/node/interfaces.cpp                  |  84 ++++++-----
 src/node/miner.cpp                       |  90 ++++++------
 src/node/miner.h                         |  49 +++----
 src/node/mini_miner.h                    |   3 +-
 src/node/mining_args.cpp                 |  99 +++++++++++++
 src/node/mining_args.h                   |  37 +++++
 src/node/mining_types.h                  | 178 +++++++++++++++++++++++
 src/node/types.h                         | 129 ----------------
 src/test/fuzz/cmpctblock.cpp             |   7 +-
 src/test/fuzz/mini_miner.cpp             |  26 ++--
 src/test/fuzz/package_eval.cpp           |  33 ++++-
 src/test/fuzz/process_message.cpp        |  15 +-
 src/test/fuzz/process_messages.cpp       |  14 +-
 src/test/fuzz/tx_pool.cpp                |  45 +++++-
 src/test/fuzz/utxo_total_supply.cpp      |  23 ++-
 src/test/miner_tests.cpp                 |  62 ++++++--
 src/test/peerman_tests.cpp               |  17 ++-
 src/test/testnet4_miner_tests.cpp        |  16 +-
 src/test/util/mining.cpp                 |  35 ++---
 src/test/util/mining.h                   |  10 +-
 src/test/util/setup_common.cpp           |  80 +++++++---
 src/test/util/setup_common.h             |  29 ++--
 src/test/validation_block_tests.cpp      |  39 +++--
 src/test/validation_chainstate_tests.cpp |  15 +-
 32 files changed, 801 insertions(+), 438 deletions(-)
 create mode 100644 doc/release-notes-33966.md
 create mode 100644 src/node/mining_args.cpp
 create mode 100644 src/node/mining_args.h
 create mode 100644 src/node/mining_types.h

diff --git a/ci/test/03_test_script.sh b/ci/test/03_test_script.sh
index 9dfbbb0e5f5f..4824665c3ca5 100755
--- a/ci/test/03_test_script.sh
+++ b/ci/test/03_test_script.sh
@@ -203,7 +203,7 @@ fi
 
 if [[ "${RUN_IWYU}" == true ]]; then
   # TODO: Consider enforcing IWYU across the entire codebase.
-  FILES_WITH_ENFORCED_IWYU="/src/(((crypto|index|kernel|primitives|univalue/(lib|test)|util|zmq)/.*|common/license_info|node/blockstorage|node/utxo_snapshot|clientversion|core_io|signet)\\.cpp)"
+  FILES_WITH_ENFORCED_IWYU="/src/(((crypto|index|kernel|primitives|univalue/(lib|test)|util|zmq)/.*|bench/(block_assemble|connectblock)|common/license_info|node/(blockstorage|interfaces|miner|mining_args|utxo_snapshot)|rpc/mining|clientversion|core_io|signet|init)\\.cpp)"
   jq --arg patterns "$FILES_WITH_ENFORCED_IWYU" 'map(select(.file | test($patterns)))' "${BASE_BUILD_DIR}/compile_commands.json" > "${BASE_BUILD_DIR}/compile_commands_iwyu_errors.json"
   jq --arg patterns "$FILES_WITH_ENFORCED_IWYU" 'map(select(.file | test($patterns) | not))' "${BASE_BUILD_DIR}/compile_commands.json" > "${BASE_BUILD_DIR}/compile_commands_iwyu_warnings.json"
 
diff --git a/doc/release-notes-33966.md b/doc/release-notes-33966.md
new file mode 100644
index 000000000000..7251a13d52d1
--- /dev/null
+++ b/doc/release-notes-33966.md
@@ -0,0 +1,9 @@
+Mining
+------
+
+- The IPC mining interface now rejects out-of-range block template options
+  instead of silently clamping them, such as oversized reserved block weight or
+  coinbase sigops limits. (#33966)
+
+- The `-blockmaxweight` startup option is now rejected when it is lower than
+  `-blockreservedweight`, instead of being silently clamped. (#33966)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 1a7ea788851e..93ef5b3c9e5d 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -196,6 +196,7 @@ add_library(bitcoin_node STATIC EXCLUDE_FROM_ALL
   node/mempool_persist.cpp
   node/mempool_persist_args.cpp
   node/miner.cpp
+  node/mining_args.cpp
   node/mini_miner.cpp
   node/minisketchwrapper.cpp
   node/peerman_args.cpp
diff --git a/src/bench/block_assemble.cpp b/src/bench/block_assemble.cpp
index 84af166abf3a..87bf80d9b488 100644
--- a/src/bench/block_assemble.cpp
+++ b/src/bench/block_assemble.cpp
@@ -19,9 +19,10 @@
 #include <cassert>
 #include <cstddef>
 #include <memory>
+#include <string>
 #include <vector>
 
-using node::BlockAssembler;
+using node::BlockCreateOptions;
 
 static void AssembleBlock(benchmark::Bench& bench)
 {
@@ -29,8 +30,9 @@ static void AssembleBlock(benchmark::Bench& bench)
 
     CScriptWitness witness;
     witness.stack.push_back(WITNESS_STACK_ELEM_OP_TRUE);
-    BlockAssembler::Options options;
-    options.coinbase_output_script = P2WSH_OP_TRUE;
+    BlockCreateOptions options{
+        .coinbase_output_script = P2WSH_OP_TRUE,
+    };
 
     // Collect some loose transactions that spend the coinbases of our mined blocks
     constexpr size_t NUM_BLOCKS{200};
@@ -61,12 +63,12 @@ static void BlockAssemblerAddPackageTxns(benchmark::Bench& bench)
     FastRandomContext det_rand{true};
     auto testing_setup{MakeNoLogFileContext<TestChain100Setup>()};
     testing_setup->PopulateMempool(det_rand, /*num_transactions=*/1000, /*submit=*/true);
-    BlockAssembler::Options assembler_options;
-    assembler_options.test_block_validity = false;
-    assembler_options.coinbase_output_script = P2WSH_OP_TRUE;
 
     bench.run([&] {
-        PrepareBlock(testing_setup->m_node, assembler_options);
+        PrepareBlock(testing_setup->m_node, {
+            .coinbase_output_script = P2WSH_OP_TRUE,
+            .test_block_validity = false
+        });
     });
 }
 
diff --git a/src/bench/connectblock.cpp b/src/bench/connectblock.cpp
index 0757ba1c9249..6da4e6116f7d 100644
--- a/src/bench/connectblock.cpp
+++ b/src/bench/connectblock.cpp
@@ -13,6 +13,11 @@
 #include <chainstate.h>
 
 #include <cassert>
+#include <cstddef>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
 #include <vector>
 
 /*
@@ -40,7 +45,7 @@ CBlock CreateTestBlock(
         {COutPoint(coinbase_to_spend->GetHash(), 0)},
         chainstate.m_chain.Height() + 1, keys, outputs, {}, {})};
     const CScript coinbase_spk{GetScriptForDestination(coinbase_taproot)};
-    test_setup.CreateAndProcessBlock({first_tx}, coinbase_spk, &chainstate);
+    test_setup.CreateAndProcessBlock({first_tx}, coinbase_spk);
 
     std::vector<CMutableTransaction> txs;
     txs.reserve(num_txs);
@@ -60,7 +65,7 @@ CBlock CreateTestBlock(
     }
 
     // Coinbase output can use any output type as it is not spent and will not change the benchmark
-    return test_setup.CreateBlock(txs, coinbase_spk, chainstate);
+    return test_setup.CreateBlock(txs, coinbase_spk);
 }
 
 /*
diff --git a/src/init.cpp b/src/init.cpp
index 4415fc392e1c..aee117481243 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -9,6 +9,7 @@
 
 #include <kernel/checks.h>
 
+#include <addrdb.h>
 #include <addrman.h>
 #include <banman.h>
 #include <btcsignals.h>
@@ -30,14 +31,18 @@
 #include <interfaces/mining.h>
 #include <interfaces/node.h>
 #include <ipc/exception.h>
+#include <kernel/blockmanager_opts.h>
 #include <kernel/caches.h>
+#include <kernel/chainstatemanager_opts.h>
 #include <kernel/context.h>
+#include <kernel/notifications_interface.h>
 #include <key.h>
 #include <logging.h>
 #include <mapport.h>
 #include <net.h>
 #include <net_permissions.h>
 #include <net_processing.h>
+#include <netaddress.h>
 #include <netbase.h>
 #include <netgroup.h>
 #include <node/blockimport.h>
@@ -52,7 +57,8 @@
 #include <node/mempool_args.h>
 #include <node/mempool_persist.h>
 #include <node/mempool_persist_args.h>
-#include <node/miner.h>
+#include <node/mining_args.h>
+#include <node/mining_types.h>
 #include <node/peerman_args.h>
 #include <policy/feerate.h>
 #include <policy/fees/block_policy_estimator.h>
@@ -63,12 +69,13 @@
 #include <scheduler.h>
 #include <script/sigcache.h>
 #include <sync.h>
+#include <tinyformat.h>
 #include <torcontrol.h>
-#include <txdb.h>
+#include <txgraph.h>
 #include <txmempool.h>
+#include <uint256.h>
 #include <util/asmap.h>
 #include <util/batchpriority.h>
-#include <util/byte_units.h>
 #include <util/chaintype.h>
 #include <util/check.h>
 #include <util/fs.h>
@@ -87,21 +94,31 @@
 #include <validationinterface.h>
 
 #include <algorithm>
+#include <any>
 #include <cerrno>
 #include <condition_variable>
 #include <cstddef>
 #include <cstdint>
-#include <cstdio>
+#include <exception>
 #include <fstream>
 #include <functional>
+#include <initializer_list>
+#include <list>
+#include <memory>
+#include <new>
+#include <optional>
 #include <set>
+#include <span>
 #include <string>
+#include <system_error>
 #include <thread>
+#include <tuple>
+#include <utility>
+#include <variant>
 #include <vector>
 
 #ifndef WIN32
 #include <csignal>
-#include <sys/stat.h>
 #endif
 
 #ifdef ENABLE_ZMQ
@@ -113,7 +130,6 @@
 #include <node/data/ip_asn.dat.h>
 #endif
 
-using common::AmountErrMsg;
 using common::InvalidPortErrMsg;
 using common::ResolveErrMsg;
 
@@ -961,27 +977,9 @@ bool AppInitParameterInteraction(const ArgsManager& args)
         return InitError(Untranslated("peertimeout must be a positive integer."));
     }
 
-    if (const auto arg{args.GetArg("-blockmintxfee")}) {
-        if (!ParseMoney(*arg)) {
-            return InitError(AmountErrMsg("blockmintxfee", *arg));
-        }
-    }
-
-    {
-        const auto max_block_weight = args.GetIntArg("-blockmaxweight", DEFAULT_BLOCK_MAX_WEIGHT);
-        if (max_block_weight > MAX_BLOCK_WEIGHT) {
-            return InitError(strprintf(_("Specified -blockmaxweight (%d) exceeds consensus maximum block weight (%d)"), max_block_weight, MAX_BLOCK_WEIGHT));
-        }
-    }
-
-    {
-        const auto block_reserved_weight = args.GetIntArg("-blockreservedweight", DEFAULT_BLOCK_RESERVED_WEIGHT);
-        if (block_reserved_weight > MAX_BLOCK_WEIGHT) {
-            return InitError(strprintf(_("Specified -blockreservedweight (%d) exceeds consensus maximum block weight (%d)"), block_reserved_weight, MAX_BLOCK_WEIGHT));
-        }
-        if (block_reserved_weight < MINIMUM_BLOCK_RESERVED_WEIGHT) {
-            return InitError(strprintf(_("Specified -blockreservedweight (%d) is lower than minimum safety value of (%d)"), block_reserved_weight, MINIMUM_BLOCK_RESERVED_WEIGHT));
-        }
+    auto mining_result{node::ReadMiningArgs(args)};
+    if (!mining_result) {
+        return InitError(util::ErrorString(mining_result));
     }
 
     nBytesPerSigOp = args.GetIntArg("-bytespersigop", nBytesPerSigOp);
@@ -1213,6 +1211,9 @@ static ChainstateLoadResult InitAndLoadChainstate(
     if (!mempool_error.empty()) {
         return {ChainstateLoadStatus::FAILURE_FATAL, mempool_error};
     }
+    auto mining_args{node::ReadMiningArgs(args)};
+    Assert(mining_args); // no error can happen, already checked in AppInitParameterInteraction
+    node.mining_args = std::move(*mining_args);
     LogInfo("* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of unused mempool space)",
             cache_sizes.coins / double(1_MiB),
             mempool_opts.max_size_bytes / double(1_MiB));
diff --git a/src/interfaces/mining.h b/src/interfaces/mining.h
index 943d34e75d9b..a95bc220185c 100644
--- a/src/interfaces/mining.h
+++ b/src/interfaces/mining.h
@@ -7,7 +7,7 @@
 
 #include <consensus/amount.h>
 #include <interfaces/types.h>
-#include <node/types.h>
+#include <node/mining_types.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <uint256.h>
@@ -16,15 +16,13 @@
 #include <cstdint>
 #include <memory>
 #include <optional>
+#include <string>
 #include <vector>
 
 namespace node {
 struct NodeContext;
 } // namespace node
 
-class BlockValidationState;
-class CScript;
-
 namespace interfaces {
 
 //! Block template interface
@@ -161,7 +159,7 @@ class Mining
 
     //! Get internal node context. Useful for RPC and testing,
     //! but not accessible across processes.
-    virtual node::NodeContext* context() { return nullptr; }
+    virtual const node::NodeContext* context() { return nullptr; }
 };
 
 //! Return implementation of Mining interface.
@@ -169,7 +167,7 @@ class Mining
 //! @param[in] wait_loaded waits for chainstate data to be loaded before
 //!                        returning. Used to prevent external clients from
 //!                        being able to crash the node during startup.
-std::unique_ptr<Mining> MakeMining(node::NodeContext& node, bool wait_loaded=true);
+std::unique_ptr<Mining> MakeMining(const node::NodeContext& node, bool wait_loaded=true);
 
 } // namespace interfaces
 
diff --git a/src/node/context.h b/src/node/context.h
index 4c6564ef6ff6..7063bfcd83f0 100644
--- a/src/node/context.h
+++ b/src/node/context.h
@@ -5,7 +5,7 @@
 #ifndef BITCOIN_NODE_CONTEXT_H
 #define BITCOIN_NODE_CONTEXT_H
 
-#include <node/types.h>
+#include <node/mining_types.h>
 
 #include <atomic>
 #include <cstdlib>
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index f3e8e45d0610..50b70fafcb0f 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -2,38 +2,42 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <addrdb.h>
 #include <banman.h>
 #include <block_validation.h>
 #include <btcsignals.h>
 #include <chain.h>
 #include <chainparams.h>
+#include <chainstate.h>
+#include <coins.h>
 #include <common/args.h>
+#include <common/settings.h>
+#include <consensus/amount.h>
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
-#include <deploymentstatus.h>
 #include <init.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
 #include <interfaces/mining.h>
 #include <interfaces/node.h>
 #include <interfaces/types.h>
-#include <kernel/chain.h>
 #include <kernel/context.h>
-#include <kernel/mempool_entry.h>
+#include <key.h>
 #include <logging.h>
 #include <mapport.h>
 #include <net.h>
 #include <net_processing.h>
+#include <net_types.h>
 #include <netaddress.h>
 #include <netbase.h>
 #include <node/blockstorage.h>
 #include <node/coin.h>
 #include <node/context.h>
 #include <node/interface_ui.h>
-#include <node/mini_miner.h>
-#include <node/miner.h>
 #include <node/kernel_notifications.h>
+#include <node/miner.h>
+#include <node/mini_miner.h>
+#include <node/mining_args.h>
+#include <node/mining_types.h>
 #include <node/transaction.h>
 #include <node/types.h>
 #include <node/warnings.h>
@@ -41,10 +45,8 @@
 #include <policy/fees/block_policy_estimator.h>
 #include <policy/policy.h>
 #include <policy/rbf.h>
-#include <policy/settings.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
-#include <support/allocators/secure.h>
 #include <sync.h>
 #include <txmempool.h>
 #include <uint256.h>
@@ -53,15 +55,22 @@
 #include <util/result.h>
 #include <util/signalinterrupt.h>
 #include <util/string.h>
+#include <util/time.h>
 #include <util/translation.h>
-#include <chainstate.h>
 #include <validationinterface.h>
 
-#include <any>
+#include <atomic>
+#include <condition_variable>
+#include <cstdint>
+#include <cstdlib>
+#include <functional>
+#include <map>
 #include <memory>
 #include <optional>
-#include <stdexcept>
+#include <string>
+#include <tuple>
 #include <utility>
+#include <vector>
 
 using interfaces::BlockRef;
 using interfaces::BlockTemplate;
@@ -73,6 +82,7 @@ using interfaces::MakeSignalHandler;
 using interfaces::Mining;
 using interfaces::Node;
 using node::BlockAssembler;
+using node::BlockCreateOptions;
 using node::BlockWaitOptions;
 using node::CoinbaseTx;
 using util::Join;
@@ -746,11 +756,11 @@ class ChainImpl : public Chain
 class BlockTemplateImpl : public BlockTemplate
 {
 public:
-    explicit BlockTemplateImpl(BlockAssembler::Options assemble_options,
+    explicit BlockTemplateImpl(BlockCreateOptions create_options,
                                std::unique_ptr<CBlockTemplate> block_template,
-                               NodeContext& node) : m_assemble_options(std::move(assemble_options)),
-                                                    m_block_template(std::move(block_template)),
-                                                    m_node(node)
+                               const NodeContext& node) : m_create_options(std::move(create_options)),
+                                                          m_block_template(std::move(block_template)),
+                                                          m_node(node)
     {
         assert(m_block_template);
     }
@@ -793,8 +803,14 @@ class BlockTemplateImpl : public BlockTemplate
 
     std::unique_ptr<BlockTemplate> waitNext(BlockWaitOptions options) override
     {
-        auto new_template = WaitAndCreateNewBlock(chainman(), notifications(), m_node.mempool.get(), m_block_template, options, m_assemble_options, m_interrupt_wait);
-        if (new_template) return std::make_unique<BlockTemplateImpl>(m_assemble_options, std::move(new_template), m_node);
+        auto new_template = WaitAndCreateNewBlock(chainman(),
+                                                  notifications(),
+                                                  m_node.mempool.get(),
+                                                  m_block_template,
+                                                  /*wait_options=*/options,
+                                                  /*create_options=*/m_create_options,
+                                                  /*interrupt_wait=*/m_interrupt_wait);
+        if (new_template) return std::make_unique<BlockTemplateImpl>(m_create_options, std::move(new_template), m_node);
         return nullptr;
     }
 
@@ -803,20 +819,20 @@ class BlockTemplateImpl : public BlockTemplate
         InterruptWait(notifications(), m_interrupt_wait);
     }
 
-    const BlockAssembler::Options m_assemble_options;
+    const BlockCreateOptions m_create_options;
 
     const std::unique_ptr<CBlockTemplate> m_block_template;
 
     bool m_interrupt_wait{false};
     ChainstateManager& chainman() { return *Assert(m_node.chainman); }
     KernelNotifications& notifications() { return *Assert(m_node.notifications); }
-    NodeContext& m_node;
+    const NodeContext& m_node;
 };
 
 class MinerImpl : public Mining
 {
 public:
-    explicit MinerImpl(NodeContext& node) : m_node(node) {}
+    explicit MinerImpl(const NodeContext& node) : m_node(node) {}
 
     bool isTestChain() override
     {
@@ -840,16 +856,6 @@ class MinerImpl : public Mining
 
     std::unique_ptr<BlockTemplate> createNewBlock(const BlockCreateOptions& options, bool cooldown) override
     {
-        // Reject too-small values instead of clamping so callers don't silently
-        // end up mining with different options than requested. This matches the
-        // behavior of the `-blockreservedweight` startup option, which rejects
-        // values below MINIMUM_BLOCK_RESERVED_WEIGHT.
-        if (options.block_reserved_weight && options.block_reserved_weight < MINIMUM_BLOCK_RESERVED_WEIGHT) {
-            throw std::runtime_error(strprintf("block_reserved_weight (%zu) must be at least %u weight units",
-                                               *options.block_reserved_weight,
-                                               MINIMUM_BLOCK_RESERVED_WEIGHT));
-        }
-
         // Ensure m_tip_block is set so consumers of BlockTemplate can rely on that.
         std::optional<BlockRef> maybe_tip{waitTipChanged(uint256::ZERO, MillisecondsDouble::max())};
 
@@ -869,10 +875,14 @@ class MinerImpl : public Mining
             // Also wait during the final catch-up moments after IBD.
             if (!CooldownIfHeadersAhead(chainman(), notifications(), *maybe_tip, m_interrupt_mining)) return {};
         }
-
-        BlockAssembler::Options assemble_options{options};
-        ApplyArgsManOptions(*Assert(m_node.args), assemble_options);
-        return std::make_unique<BlockTemplateImpl>(assemble_options, BlockAssembler{chainman().ActiveChainstate(), context()->mempool.get(), assemble_options}.CreateNewBlock(), m_node);
+        const BlockCreateOptions create_options{MergeMiningOptions(options, m_node.mining_args)};
+        return std::make_unique<BlockTemplateImpl>(create_options,
+                                                   BlockAssembler{
+                                                       chainman().ActiveChainstate(),
+                                                       m_node.mempool.get(),
+                                                       create_options,
+                                                   }.CreateNewBlock(),
+                                                   m_node);
     }
 
     void interrupt() override
@@ -889,12 +899,12 @@ class MinerImpl : public Mining
         return state.IsValid();
     }
 
-    NodeContext* context() override { return &m_node; }
+    const NodeContext* context() override { return &m_node; }
     ChainstateManager& chainman() { return *Assert(m_node.chainman); }
     KernelNotifications& notifications() { return *Assert(m_node.notifications); }
     // Treat as if guarded by notifications().m_tip_block_mutex
     bool m_interrupt_mining{false};
-    NodeContext& m_node;
+    const NodeContext& m_node;
 };
 
 } // namespace
@@ -903,7 +913,7 @@ class MinerImpl : public Mining
 namespace interfaces {
 std::unique_ptr<Node> MakeNode(node::NodeContext& context) { return std::make_unique<node::NodeImpl>(context); }
 std::unique_ptr<Chain> MakeChain(node::NodeContext& context) { return std::make_unique<node::ChainImpl>(context); }
-std::unique_ptr<Mining> MakeMining(node::NodeContext& context, bool wait_loaded)
+std::unique_ptr<Mining> MakeMining(const node::NodeContext& context, bool wait_loaded)
 {
     if (wait_loaded) {
         node::KernelNotifications& kernel_notifications(*Assert(context.notifications));
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index e97e0c82665f..5069ac12f9de 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -7,31 +7,48 @@
 
 #include <block_validation.h>
 #include <chain.h>
-#include <interfaces/types.h>
 #include <chainparams.h>
-#include <coins.h>
+#include <chainstate.h>
 #include <common/args.h>
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
 #include <consensus/merkle.h>
+#include <consensus/params.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
-#include <deploymentstatus.h>
+#include <interfaces/types.h>
 #include <logging.h>
-#include <node/context.h>
+#include <node/blockstorage.h>
 #include <node/kernel_notifications.h>
+#include <node/mining_args.h>
+#include <node/mining_types.h>
 #include <policy/feerate.h>
 #include <policy/policy.h>
 #include <pow.h>
+#include <primitives/block.h>
 #include <primitives/transaction.h>
-#include <util/moneystr.h>
+#include <script/script.h>
+#include <sync.h>
+#include <tinyformat.h>
+#include <txgraph.h>
+#include <uint256.h>
+#include <util/check.h>
+#include <util/result.h>
 #include <util/signalinterrupt.h>
 #include <util/time.h>
-#include <chainstate.h>
+#include <util/translation.h>
+#include <versionbits.h>
 
 #include <algorithm>
-#include <utility>
+#include <compare>
+#include <condition_variable>
+#include <cstddef>
+#include <functional>
 #include <numeric>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <utility>
 
 namespace node {
 
@@ -78,38 +95,21 @@ void RegenerateCommitments(CBlock& block, ChainstateManager& chainman)
     block.hashMerkleRoot = BlockMerkleRoot(block);
 }
 
-static BlockAssembler::Options ClampOptions(BlockAssembler::Options options)
-{
-    // Apply DEFAULT_BLOCK_RESERVED_WEIGHT when the caller left it unset.
-    options.block_reserved_weight = std::clamp<size_t>(options.block_reserved_weight.value_or(DEFAULT_BLOCK_RESERVED_WEIGHT), MINIMUM_BLOCK_RESERVED_WEIGHT, MAX_BLOCK_WEIGHT);
-    options.coinbase_output_max_additional_sigops = std::clamp<size_t>(options.coinbase_output_max_additional_sigops, 0, MAX_BLOCK_SIGOPS_COST);
-    // Limit weight to between block_reserved_weight and MAX_BLOCK_WEIGHT for sanity:
-    // block_reserved_weight can safely exceed -blockmaxweight, but the rest of the block template will be empty.
-    options.nBlockMaxWeight = std::clamp<size_t>(options.nBlockMaxWeight, *options.block_reserved_weight, MAX_BLOCK_WEIGHT);
-    return options;
-}
-
-BlockAssembler::BlockAssembler(Chainstate& chainstate, const CTxMemPool* mempool, const Options& options)
+BlockAssembler::BlockAssembler(Chainstate& chainstate,
+                               const CTxMemPool* mempool,
+                               BlockCreateOptions options)
     : chainparams{chainstate.m_chainman.GetParams()},
       m_mempool{options.use_mempool ? mempool : nullptr},
       m_chainstate{chainstate},
-      m_options{ClampOptions(options)}
+      m_options{[&] {
+          if (auto result{CheckMiningOptions(options, /*use_argnames=*/false)}; !result) {
+              throw std::runtime_error(util::ErrorString(result).original);
+          }
+          return FlattenMiningOptions(std::move(options));
+      }()}
 {
 }
 
-void ApplyArgsManOptions(const ArgsManager& args, BlockAssembler::Options& options)
-{
-    // Block resource limits
-    options.nBlockMaxWeight = args.GetIntArg("-blockmaxweight", options.nBlockMaxWeight);
-    if (const auto blockmintxfee{args.GetArg("-blockmintxfee")}) {
-        if (const auto parsed{ParseMoney(*blockmintxfee)}) options.blockMinFeeRate = CFeeRate{*parsed};
-    }
-    options.print_modified_fee = args.GetBoolArg("-printpriority", options.print_modified_fee);
-    if (!options.block_reserved_weight) {
-        options.block_reserved_weight = args.GetIntArg("-blockreservedweight");
-    }
-}
-
 void BlockAssembler::resetBlock()
 {
     // Reserve space for fixed-size block header, txs count, and coinbase tx.
@@ -243,7 +243,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock()
 
 bool BlockAssembler::TestChunkBlockLimits(FeePerWeight chunk_feerate, int64_t chunk_sigops_cost) const
 {
-    if (nBlockWeight + chunk_feerate.size >= m_options.nBlockMaxWeight) {
+    if (nBlockWeight + chunk_feerate.size >= m_options.block_max_weight) {
         return false;
     }
     if (nBlockSigOpsCost + chunk_sigops_cost >= MAX_BLOCK_SIGOPS_COST) {
@@ -274,7 +274,7 @@ void BlockAssembler::AddToBlock(const CTxMemPoolEntry& entry)
     nBlockSigOpsCost += entry.GetSigOpCost();
     nFees += entry.GetFee();
 
-    if (m_options.print_modified_fee) {
+    if (*m_options.print_modified_fee) {
         LogInfo("fee rate %s txid %s\n",
                   CFeeRate(entry.GetModifiedFee(), entry.GetTxSize()).ToString(),
                   entry.GetTx().GetHash().ToString());
@@ -300,7 +300,7 @@ void BlockAssembler::addChunks()
 
     while (selected_transactions.size() > 0) {
         // Check to see if min fee rate is still respected.
-        if (ByRatio{chunk_feerate_vsize} < ByRatio{m_options.blockMinFeeRate.GetFeePerVSize()}) {
+        if (ByRatio{chunk_feerate_vsize} < ByRatio{m_options.block_min_fee_rate->GetFeePerVSize()}) {
             // Everything else we might consider has a lower feerate
             return;
         }
@@ -317,7 +317,7 @@ void BlockAssembler::addChunks()
             ++nConsecutiveFailed;
 
             if (nConsecutiveFailed > MAX_CONSECUTIVE_FAILURES && nBlockWeight +
-                    BLOCK_FULL_ENOUGH_WEIGHT_DELTA > m_options.nBlockMaxWeight) {
+                    BLOCK_FULL_ENOUGH_WEIGHT_DELTA > m_options.block_max_weight) {
                 // Give up if we're close to full and haven't succeeded in a while
                 return;
             }
@@ -367,8 +367,8 @@ std::unique_ptr<CBlockTemplate> WaitAndCreateNewBlock(ChainstateManager& chainma
                                                       KernelNotifications& kernel_notifications,
                                                       CTxMemPool* mempool,
                                                       const std::unique_ptr<CBlockTemplate>& block_template,
-                                                      const BlockWaitOptions& options,
-                                                      const BlockAssembler::Options& assemble_options,
+                                                      const BlockWaitOptions& wait_options,
+                                                      const BlockCreateOptions& create_options,
                                                       bool& interrupt_wait)
 {
     // Delay calculating the current template fees, just in case a new block
@@ -378,7 +378,7 @@ std::unique_ptr<CBlockTemplate> WaitAndCreateNewBlock(ChainstateManager& chainma
     // Alternate waiting for a new tip and checking if fees have risen.
     // The latter check is expensive so we only run it once per second.
     auto now{NodeClock::now()};
-    const auto deadline = now + options.timeout;
+    const auto deadline = now + wait_options.timeout;
     const MillisecondsDouble tick{1000};
     const bool allow_min_difficulty{chainman.GetParams().GetConsensus().fPowAllowMinDifficultyBlocks};
 
@@ -425,12 +425,12 @@ std::unique_ptr<CBlockTemplate> WaitAndCreateNewBlock(ChainstateManager& chainma
          *
          * We'll also create a new template if the tip changed during this iteration.
          */
-        if (options.fee_threshold < MAX_MONEY || tip_changed) {
+        if (wait_options.fee_threshold < MAX_MONEY || tip_changed) {
             auto new_tmpl{BlockAssembler{
                 chainman.ActiveChainstate(),
                 mempool,
-                assemble_options}
-                              .CreateNewBlock()};
+                create_options
+                }.CreateNewBlock()};
 
             // If the tip changed, return the new template regardless of its fees.
             if (tip_changed) return new_tmpl;
@@ -442,8 +442,8 @@ std::unique_ptr<CBlockTemplate> WaitAndCreateNewBlock(ChainstateManager& chainma
 
             // Check if fees increased enough to return the new template
             const CAmount new_fees = std::accumulate(new_tmpl->vTxFees.begin(), new_tmpl->vTxFees.end(), CAmount{0});
-            Assume(options.fee_threshold != MAX_MONEY);
-            if (new_fees >= current_fees + options.fee_threshold) return new_tmpl;
+            Assume(wait_options.fee_threshold != MAX_MONEY);
+            if (new_fees >= current_fees + wait_options.fee_threshold) return new_tmpl;
         }
 
         now = NodeClock::now();
diff --git a/src/node/miner.h b/src/node/miner.h
index 5c8668771f59..14780833c02b 100644
--- a/src/node/miner.h
+++ b/src/node/miner.h
@@ -6,39 +6,38 @@
 #ifndef BITCOIN_NODE_MINER_H
 #define BITCOIN_NODE_MINER_H
 
-#include <interfaces/types.h>
-#include <node/types.h>
-#include <policy/policy.h>
+#include <consensus/amount.h>
+#include <node/mining_types.h>
 #include <primitives/block.h>
+#include <primitives/transaction.h>
+#include <threadsafety.h>
 #include <txmempool.h>
 #include <util/feefrac.h>
+#include <util/time.h>
 
 #include <cstdint>
 #include <memory>
 #include <optional>
+#include <vector>
 
-#include <boost/multi_index/identity.hpp>
-#include <boost/multi_index/indexed_by.hpp>
-#include <boost/multi_index/ordered_index.hpp>
-#include <boost/multi_index/tag.hpp>
-#include <boost/multi_index_container.hpp>
-
-class ArgsManager;
 class CBlockIndex;
 class CChainParams;
-class CScript;
 class Chainstate;
 class ChainstateManager;
 
-namespace Consensus { struct Params; };
+namespace Consensus {
+struct Params;
+} // namespace Consensus
+class uint256;
+namespace interfaces {
+struct BlockRef;
+} // namespace interfaces
 
 using interfaces::BlockRef;
 
 namespace node {
 class KernelNotifications;
 
-static const bool DEFAULT_PRINT_MODIFIED_FEE = false;
-
 struct CBlockTemplate
 {
     CBlock block;
@@ -78,16 +77,9 @@ class BlockAssembler
     Chainstate& m_chainstate;
 
 public:
-    struct Options : BlockCreateOptions {
-        // Configuration parameters for the block size
-        size_t nBlockMaxWeight{DEFAULT_BLOCK_MAX_WEIGHT};
-        CFeeRate blockMinFeeRate{DEFAULT_BLOCK_MIN_TX_FEE};
-        // Whether to call TestBlockValidity() at the end of CreateNewBlock().
-        bool test_block_validity{true};
-        bool print_modified_fee{DEFAULT_PRINT_MODIFIED_FEE};
-    };
-
-    explicit BlockAssembler(Chainstate& chainstate, const CTxMemPool* mempool, const Options& options);
+    explicit BlockAssembler(Chainstate& chainstate,
+                            const CTxMemPool* mempool,
+                            BlockCreateOptions create_options);
 
     /** Construct a new block template */
     std::unique_ptr<CBlockTemplate> CreateNewBlock();
@@ -98,7 +90,7 @@ class BlockAssembler
     inline static std::optional<int64_t> m_last_block_weight{};
 
 private:
-    const Options m_options;
+    const BlockCreateOptions m_options;
 
     // utility functions
     /** Clear the block's state and prepare for assembling a new block */
@@ -134,9 +126,6 @@ int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParam
 /** Update an old GenerateCoinbaseCommitment from CreateNewBlock after the block txs have changed */
 void RegenerateCommitments(CBlock& block, ChainstateManager& chainman);
 
-/** Apply -blockmintxfee and -blockmaxweight options from ArgsManager to BlockAssembler options. */
-void ApplyArgsManOptions(const ArgsManager& gArgs, BlockAssembler::Options& options);
-
 /* Compute the block's merkle root, insert or replace the coinbase transaction and the merkle root into the block */
 void AddMerkleRootAndCoinbase(CBlock& block, CTransactionRef coinbase, uint32_t version, uint32_t timestamp, uint32_t nonce);
 
@@ -151,8 +140,8 @@ std::unique_ptr<CBlockTemplate> WaitAndCreateNewBlock(ChainstateManager& chainma
                                                       KernelNotifications& kernel_notifications,
                                                       CTxMemPool* mempool,
                                                       const std::unique_ptr<CBlockTemplate>& block_template,
-                                                      const BlockWaitOptions& options,
-                                                      const BlockAssembler::Options& assemble_options,
+                                                      const BlockWaitOptions& wait_options,
+                                                      const BlockCreateOptions& create_options,
                                                       bool& interrupt_wait);
 
 /* Locks cs_main and returns the block hash and block height of the active chain if it exists; otherwise, returns nullopt.*/
diff --git a/src/node/mini_miner.h b/src/node/mini_miner.h
index d07108cb1c26..0634c53eaf83 100644
--- a/src/node/mini_miner.h
+++ b/src/node/mini_miner.h
@@ -5,13 +5,12 @@
 #ifndef BITCOIN_NODE_MINI_MINER_H
 #define BITCOIN_NODE_MINI_MINER_H
 
+#include <attributes.h>
 #include <consensus/amount.h>
 #include <primitives/transaction.h>
-#include <uint256.h>
 
 #include <cstdint>
 #include <map>
-#include <memory>
 #include <optional>
 #include <set>
 #include <vector>
diff --git a/src/node/mining_args.cpp b/src/node/mining_args.cpp
new file mode 100644
index 000000000000..ec173464bb6a
--- /dev/null
+++ b/src/node/mining_args.cpp
@@ -0,0 +1,99 @@
+// Copyright (c) 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/mining_args.h>
+
+#include <common/args.h>
+#include <common/messages.h>
+#include <consensus/amount.h>
+#include <consensus/consensus.h>
+#include <node/mining_types.h>
+#include <policy/feerate.h>
+#include <policy/policy.h>
+#include <tinyformat.h>
+#include <util/moneystr.h>
+#include <util/result.h>
+#include <util/translation.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <utility>
+
+using common::AmountErrMsg;
+using util::Error;
+using util::Result;
+
+namespace node {
+
+Result<void> CheckMiningOptions(BlockCreateOptions options, bool use_argnames)
+{
+    options = FlattenMiningOptions(std::move(options));
+    if (*options.block_reserved_weight < MINIMUM_BLOCK_RESERVED_WEIGHT) {
+        return Error{Untranslated(strprintf("%s (%d) is lower than minimum safety value of (%d)",
+                                            use_argnames ? "-blockreservedweight" : "block_reserved_weight",
+                                            *options.block_reserved_weight, MINIMUM_BLOCK_RESERVED_WEIGHT))};
+    }
+    if (*options.block_reserved_weight > MAX_BLOCK_WEIGHT) {
+        return Error{Untranslated(strprintf("%s (%d) exceeds consensus maximum block weight (%d)",
+                                            use_argnames ? "-blockreservedweight" : "block_reserved_weight",
+                                            *options.block_reserved_weight, MAX_BLOCK_WEIGHT))};
+    }
+    if (*options.block_max_weight > MAX_BLOCK_WEIGHT) {
+        return Error{Untranslated(strprintf("%s (%d) exceeds consensus maximum block weight (%d)",
+                                            use_argnames ? "-blockmaxweight" : "block_max_weight",
+                                            *options.block_max_weight, MAX_BLOCK_WEIGHT))};
+    }
+    if (*options.block_reserved_weight > *options.block_max_weight) {
+        return Error{Untranslated(strprintf("%s (%d) exceeds %s (%d)",
+                                            use_argnames ? "-blockreservedweight" : "block_reserved_weight",
+                                            *options.block_reserved_weight,
+                                            use_argnames ? "-blockmaxweight" : "block_max_weight",
+                                            *options.block_max_weight))};
+    }
+    if (options.coinbase_output_max_additional_sigops > MAX_BLOCK_SIGOPS_COST) {
+        return Error{Untranslated(strprintf("%s (%zu) exceeds consensus maximum block sigops cost (%d)",
+                                            "coinbase_output_max_additional_sigops",
+                                            options.coinbase_output_max_additional_sigops, MAX_BLOCK_SIGOPS_COST))};
+    }
+    return {};
+}
+
+Result<BlockCreateOptions> ReadMiningArgs(const ArgsManager& args)
+{
+    BlockCreateOptions options;
+    if (const auto arg{args.GetArg("-blockmintxfee")}) {
+        std::optional<CAmount> block_min_tx_fee{ParseMoney(*arg)};
+        if (!block_min_tx_fee) return Error{AmountErrMsg("blockmintxfee", *arg)};
+        options.block_min_fee_rate = CFeeRate{*block_min_tx_fee};
+    }
+
+    if (const auto arg{args.GetBoolArg("-printpriority")}) options.print_modified_fee = *arg;
+
+    options.block_reserved_weight = args.GetArg<uint64_t>("-blockreservedweight");
+    options.block_max_weight = args.GetArg<uint64_t>("-blockmaxweight");
+
+    if (auto result{CheckMiningOptions(options, /*use_argnames=*/true)}; !result) return Error{util::ErrorString(result)};
+    return options;
+}
+
+BlockCreateOptions FlattenMiningOptions(BlockCreateOptions options)
+{
+    if (!options.block_min_fee_rate) options.block_min_fee_rate = CFeeRate{DEFAULT_BLOCK_MIN_TX_FEE};
+    if (!options.print_modified_fee) options.print_modified_fee = DEFAULT_PRINT_MODIFIED_FEE;
+    if (!options.block_reserved_weight) options.block_reserved_weight = DEFAULT_BLOCK_RESERVED_WEIGHT;
+    if (!options.block_max_weight) options.block_max_weight = DEFAULT_BLOCK_MAX_WEIGHT;
+    return options;
+}
+
+BlockCreateOptions MergeMiningOptions(BlockCreateOptions x, const BlockCreateOptions& y)
+{
+    if (!x.block_min_fee_rate) x.block_min_fee_rate = y.block_min_fee_rate;
+    if (!x.print_modified_fee) x.print_modified_fee = y.print_modified_fee;
+    if (!x.block_reserved_weight) x.block_reserved_weight = y.block_reserved_weight;
+    if (!x.block_max_weight) x.block_max_weight = y.block_max_weight;
+    return x;
+}
+
+} // namespace node
diff --git a/src/node/mining_args.h b/src/node/mining_args.h
new file mode 100644
index 000000000000..8baa73952851
--- /dev/null
+++ b/src/node/mining_args.h
@@ -0,0 +1,37 @@
+// Copyright (c) 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_MINING_ARGS_H
+#define BITCOIN_NODE_MINING_ARGS_H
+
+#include <node/mining_types.h>
+#include <util/result.h>
+
+class ArgsManager;
+
+namespace node {
+
+static const bool DEFAULT_PRINT_MODIFIED_FEE = false;
+
+/**
+ * Read the mining options set in \p args. Returns an error if one was
+ * encountered.
+ */
+[[nodiscard]] util::Result<BlockCreateOptions> ReadMiningArgs(const ArgsManager& args);
+
+/** Check option values for validity. Returns an error for invalid values. */
+[[nodiscard]] util::Result<void> CheckMiningOptions(BlockCreateOptions options, bool use_argnames);
+
+/** Replace null optional values with their hardcoded defaults. */
+[[nodiscard]] BlockCreateOptions FlattenMiningOptions(BlockCreateOptions options);
+
+/**
+ * Merge two BlockCreateOptions structs, replacing null values in \p x with
+ * non-null values from \p y.
+ */
+[[nodiscard]] BlockCreateOptions MergeMiningOptions(BlockCreateOptions x, const BlockCreateOptions& y);
+
+} // namespace node
+
+#endif // BITCOIN_NODE_MINING_ARGS_H
diff --git a/src/node/mining_types.h b/src/node/mining_types.h
new file mode 100644
index 000000000000..9c4fbcbbafeb
--- /dev/null
+++ b/src/node/mining_types.h
@@ -0,0 +1,178 @@
+// Copyright (c) The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+//! @file node/mining_types.h is used externally by mining IPC clients, so it should
+//! only declare simple data definitions.
+//!
+//! Avoid declaring functions or classes with methods here unless they are
+//! header-only or provided by the util library.
+
+#ifndef BITCOIN_NODE_MINING_TYPES_H
+#define BITCOIN_NODE_MINING_TYPES_H
+
+#include <consensus/amount.h>
+#include <policy/feerate.h>
+#include <policy/policy.h>
+#include <primitives/transaction.h>
+#include <script/script.h>
+#include <uint256.h>
+#include <util/time.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+namespace node {
+
+/**
+ * Block template creation options. These override node defaults, but can't
+ * exceed node limits (e.g. block_reserved_weight can't exceed max block weight).
+ */
+struct BlockCreateOptions {
+    /**
+     * Set false to omit mempool transactions
+     */
+    bool use_mempool{true};
+    /**
+     * Minimum fee rate for transactions to be included. Providing a value
+     * overrides the -blockmintxfee startup setting.
+     */
+    std::optional<CFeeRate> block_min_fee_rate{};
+    /**
+     * Whether to log the fee rate of each transaction when it is added to the
+     * block template. Providing a value overrides the -printpriority startup
+     * setting.
+     */
+    std::optional<bool> print_modified_fee{};
+    /**
+     * The default reserved weight for the fixed-size block header,
+     * transaction count and coinbase transaction. Minimum: 2000 weight units
+     * (MINIMUM_BLOCK_RESERVED_WEIGHT).
+     *
+     * Providing a value overrides the `-blockreservedweight` startup setting.
+     * Cap'n Proto IPC clients currently cannot leave this field unset, so they
+     * always provide a value.
+     */
+    std::optional<uint64_t> block_reserved_weight{};
+    /**
+     * Maximum block weight, defaults to -maxblockweight
+     *
+     * Must not be lower than block_reserved_weight. Setting this equal to
+     * block_reserved_weight leaves no room for non-coinbase transactions.
+     */
+    std::optional<uint64_t> block_max_weight{};
+    /**
+     * The maximum additional sigops which the pool will add in coinbase
+     * transaction outputs.
+     */
+    size_t coinbase_output_max_additional_sigops{DEFAULT_COINBASE_OUTPUT_MAX_ADDITIONAL_SIGOPS};
+    /**
+     * Script to put in the coinbase transaction. The default is an
+     * anyone-can-spend dummy.
+     *
+     * Should only be used for tests, when the default doesn't suffice.
+     *
+     * Note that higher level code like the getblocktemplate RPC may omit the
+     * coinbase transaction entirely. It's instead constructed by pool software
+     * using fields like coinbasevalue, coinbaseaux and default_witness_commitment.
+     * This software typically also controls the payout outputs, even for solo
+     * mining.
+     *
+     * The size and sigops are not checked against
+     * coinbase_max_additional_weight and coinbase_output_max_additional_sigops.
+     */
+    CScript coinbase_output_script{CScript() << OP_TRUE};
+    /**
+     * Whether to call TestBlockValidity() at the end of CreateNewBlock().
+     * Should only be used for tests / benchmarks.
+     */
+    bool test_block_validity{true};
+};
+
+struct BlockWaitOptions {
+    /**
+     * How long to wait before returning nullptr instead of a new template.
+     * Default is to wait forever.
+     */
+    MillisecondsDouble timeout{MillisecondsDouble::max()};
+
+    /**
+     * The wait method will not return a new template unless it has fees at
+     * least fee_threshold sats higher than the current template, or unless
+     * the chain tip changes and the previous template is no longer valid.
+     *
+     * A caller may not be interested in templates with higher fees, and
+     * determining whether fee_threshold is reached is also expensive. So as
+     * an optimization, when fee_threshold is set to MAX_MONEY (default), the
+     * implementation is able to be much more efficient, skipping expensive
+     * checks and only returning new templates when the chain tip changes.
+     */
+    CAmount fee_threshold{MAX_MONEY};
+};
+
+struct BlockCheckOptions {
+    /**
+     * Set false to omit the merkle root check
+     */
+    bool check_merkle_root{true};
+
+    /**
+     * Set false to omit the proof-of-work check
+     */
+    bool check_pow{true};
+};
+
+/**
+ * Template containing all coinbase transaction fields that are set by our
+ * miner code. Clients are expected to add their own outputs and typically
+ * also expand the scriptSig.
+ */
+struct CoinbaseTx {
+    /* nVersion */
+    uint32_t version;
+    /* nSequence for the only coinbase transaction input */
+    uint32_t sequence;
+    /**
+     * Prefix which needs to be placed at the beginning of the scriptSig.
+     * Clients may append extra data to this as long as the overall scriptSig
+     * size is 100 bytes or less, to avoid the block being rejected with
+     * "bad-cb-length" error. At heights <= 16 the BIP 34 height push is only
+     * one byte long, so clients must append at least one additional byte to
+     * meet the consensus minimum scriptSig length of two bytes.
+     *
+     * Currently with BIP 34, the prefix is guaranteed to be less than 8 bytes,
+     * but future soft forks could require longer prefixes.
+     */
+    CScript script_sig_prefix;
+    /**
+     * The first (and only) witness stack element of the coinbase input.
+     *
+     * Omitted for block templates without witness data.
+     *
+     * This is currently the BIP 141 witness reserved value, and can be chosen
+     * arbitrarily by the node, but future soft forks may constrain it.
+     */
+    std::optional<uint256> witness;
+    /**
+     * Block subsidy plus fees, minus any non-zero required_outputs.
+     *
+     * Currently there are no non-zero required_outputs, so block_reward_remaining
+     * is the entire block reward. See also required_outputs.
+     */
+    CAmount block_reward_remaining;
+    /*
+     * To be included as the last outputs in the coinbase transaction.
+     * Currently this is only the witness commitment OP_RETURN, but future
+     * softforks or a custom mining patch could add more.
+     *
+     * The dummy output that spends the full reward is excluded.
+     */
+    std::vector<CTxOut> required_outputs;
+    uint32_t lock_time;
+};
+
+} // namespace node
+
+#endif // BITCOIN_NODE_MINING_TYPES_H
diff --git a/src/node/types.h b/src/node/types.h
index d228fa41db6a..5124b9831127 100644
--- a/src/node/types.h
+++ b/src/node/types.h
@@ -13,16 +13,7 @@
 #ifndef BITCOIN_NODE_TYPES_H
 #define BITCOIN_NODE_TYPES_H
 
-#include <consensus/amount.h>
-#include <cstddef>
 #include <cstdint>
-#include <optional>
-#include <policy/policy.h>
-#include <primitives/transaction.h>
-#include <script/script.h>
-#include <uint256.h>
-#include <util/time.h>
-#include <vector>
 
 namespace node {
 enum class TransactionError {
@@ -36,126 +27,6 @@ enum class TransactionError {
     INVALID_PACKAGE,
 };
 
-struct BlockCreateOptions {
-    /**
-     * Set false to omit mempool transactions
-     */
-    bool use_mempool{true};
-    /**
-     * The default reserved weight for the fixed-size block header,
-     * transaction count and coinbase transaction. Minimum: 2000 weight units
-     * (MINIMUM_BLOCK_RESERVED_WEIGHT).
-     *
-     * Providing a value overrides the `-blockreservedweight` startup setting.
-     * Cap'n Proto IPC clients currently cannot leave this field unset, so they
-     * always provide a value.
-     */
-    std::optional<size_t> block_reserved_weight{};
-    /**
-     * The maximum additional sigops which the pool will add in coinbase
-     * transaction outputs.
-     */
-    size_t coinbase_output_max_additional_sigops{DEFAULT_COINBASE_OUTPUT_MAX_ADDITIONAL_SIGOPS};
-    /**
-     * Script to put in the coinbase transaction. The default is an
-     * anyone-can-spend dummy.
-     *
-     * Should only be used for tests, when the default doesn't suffice.
-     *
-     * Note that higher level code like the getblocktemplate RPC may omit the
-     * coinbase transaction entirely. It's instead constructed by pool software
-     * using fields like coinbasevalue, coinbaseaux and default_witness_commitment.
-     * This software typically also controls the payout outputs, even for solo
-     * mining.
-     *
-     * The size and sigops are not checked against
-     * coinbase_max_additional_weight and coinbase_output_max_additional_sigops.
-     */
-    CScript coinbase_output_script{CScript() << OP_TRUE};
-};
-
-struct BlockWaitOptions {
-    /**
-     * How long to wait before returning nullptr instead of a new template.
-     * Default is to wait forever.
-     */
-    MillisecondsDouble timeout{MillisecondsDouble::max()};
-
-    /**
-     * The wait method will not return a new template unless it has fees at
-     * least fee_threshold sats higher than the current template, or unless
-     * the chain tip changes and the previous template is no longer valid.
-     *
-     * A caller may not be interested in templates with higher fees, and
-     * determining whether fee_threshold is reached is also expensive. So as
-     * an optimization, when fee_threshold is set to MAX_MONEY (default), the
-     * implementation is able to be much more efficient, skipping expensive
-     * checks and only returning new templates when the chain tip changes.
-     */
-    CAmount fee_threshold{MAX_MONEY};
-};
-
-struct BlockCheckOptions {
-    /**
-     * Set false to omit the merkle root check
-     */
-    bool check_merkle_root{true};
-
-    /**
-     * Set false to omit the proof-of-work check
-     */
-    bool check_pow{true};
-};
-
-/**
- * Template containing all coinbase transaction fields that are set by our
- * miner code. Clients are expected to add their own outputs and typically
- * also expand the scriptSig.
- */
-struct CoinbaseTx {
-    /* nVersion */
-    uint32_t version;
-    /* nSequence for the only coinbase transaction input */
-    uint32_t sequence;
-    /**
-     * Prefix which needs to be placed at the beginning of the scriptSig.
-     * Clients may append extra data to this as long as the overall scriptSig
-     * size is 100 bytes or less, to avoid the block being rejected with
-     * "bad-cb-length" error. At heights <= 16 the BIP 34 height push is only
-     * one byte long, so clients must append at least one additional byte to
-     * meet the consensus minimum scriptSig length of two bytes.
-     *
-     * Currently with BIP 34, the prefix is guaranteed to be less than 8 bytes,
-     * but future soft forks could require longer prefixes.
-     */
-    CScript script_sig_prefix;
-    /**
-     * The first (and only) witness stack element of the coinbase input.
-     *
-     * Omitted for block templates without witness data.
-     *
-     * This is currently the BIP 141 witness reserved value, and can be chosen
-     * arbitrarily by the node, but future soft forks may constrain it.
-     */
-    std::optional<uint256> witness;
-    /**
-     * Block subsidy plus fees, minus any non-zero required_outputs.
-     *
-     * Currently there are no non-zero required_outputs, so block_reward_remaining
-     * is the entire block reward. See also required_outputs.
-     */
-    CAmount block_reward_remaining;
-    /*
-     * To be included as the last outputs in the coinbase transaction.
-     * Currently this is only the witness commitment OP_RETURN, but future
-     * softforks or a custom mining patch could add more.
-     *
-     * The dummy output that spends the full reward is excluded.
-     */
-    std::vector<CTxOut> required_outputs;
-    uint32_t lock_time;
-};
-
 /**
  * How to broadcast a local transaction.
  * Used to influence `BroadcastTransaction()` and its callers.
diff --git a/src/test/fuzz/cmpctblock.cpp b/src/test/fuzz/cmpctblock.cpp
index c5f320daf8bc..06666a5da5c6 100644
--- a/src/test/fuzz/cmpctblock.cpp
+++ b/src/test/fuzz/cmpctblock.cpp
@@ -15,12 +15,13 @@
 #include <net_processing.h>
 #include <netmessagemaker.h>
 #include <node/blockstorage.h>
-#include <node/miner.h>
+#include <node/mining_types.h>
 #include <policy/truc_policy.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <protocol.h>
 #include <script/script.h>
+#include <serialize.h>
 #include <sync.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
@@ -44,7 +45,6 @@
 #include <validationinterface.h>
 
 #include <boost/multi_index/detail/hash_index_iterator.hpp>
-#include <boost/operators.hpp>
 
 #include <cstddef>
 #include <cstdint>
@@ -53,7 +53,6 @@
 #include <memory>
 #include <optional>
 #include <string>
-#include <string_view>
 #include <thread>
 #include <utility>
 #include <vector>
@@ -122,7 +121,7 @@ void ResetChainmanAndMempool(TestingSetup& setup)
     setup.m_make_chainman();
     setup.LoadVerifyActivateChainstate();
 
-    node::BlockAssembler::Options options;
+    node::BlockCreateOptions options;
     options.coinbase_output_script = P2WSH_OP_TRUE;
 
     g_mature_coinbase.clear();
diff --git a/src/test/fuzz/mini_miner.cpp b/src/test/fuzz/mini_miner.cpp
index 77f9e682e7f9..daa3dae34112 100644
--- a/src/test/fuzz/mini_miner.cpp
+++ b/src/test/fuzz/mini_miner.cpp
@@ -2,27 +2,35 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <node/mini_miner.h>
+
+#include <consensus/amount.h>
+#include <kernel/cs_main.h>
+#include <policy/feerate.h>
+#include <primitives/transaction.h>
+#include <script/script.h>
+#include <sync.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
-#include <test/fuzz/util/mempool.h>
-#include <test/util/mining.h>
 #include <test/util/script.h>
+#include <test/util/random.h>
 #include <test/util/setup_common.h>
 #include <test/util/time.h>
 #include <test/util/txmempool.h>
-
-#include <node/miner.h>
-#include <node/mini_miner.h>
-#include <node/types.h>
-#include <primitives/transaction.h>
-#include <random.h>
 #include <txmempool.h>
+#include <uint256.h>
 #include <util/check.h>
-#include <util/time.h>
 #include <util/translation.h>
 
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
 #include <deque>
+#include <functional>
+#include <map>
+#include <optional>
+#include <utility>
 #include <vector>
 
 namespace {
diff --git a/src/test/fuzz/package_eval.cpp b/src/test/fuzz/package_eval.cpp
index cf4f861d46e5..3ffe7ec67eb2 100644
--- a/src/test/fuzz/package_eval.cpp
+++ b/src/test/fuzz/package_eval.cpp
@@ -2,27 +2,49 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <chain.h>
+#include <consensus/amount.h>
+#include <consensus/consensus.h>
 #include <consensus/validation.h>
 #include <mempool_validation.h>
 #include <node/context.h>
 #include <node/mempool_args.h>
 #include <node/miner.h>
 #include <policy/truc_policy.h>
+#include <primitives/transaction.h>
+#include <script/script.h>
+#include <sync.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 #include <test/fuzz/util/mempool.h>
 #include <test/util/mining.h>
+#include <test/util/random.h>
 #include <test/util/script.h>
 #include <test/util/setup_common.h>
 #include <test/util/txmempool.h>
+#include <txmempool.h>
 #include <util/check.h>
-#include <util/rbf.h>
+#include <util/hasher.h>
+#include <util/time.h>
 #include <util/translation.h>
 #include <chainstate.h>
 #include <validationinterface.h>
 
-using node::BlockAssembler;
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <memory>
+#include <optional>
+#include <set>
+#include <span>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
 using node::NodeContext;
 
 namespace {
@@ -45,11 +67,10 @@ void initialize_tx_pool()
     g_setup = testing_setup.get();
     SetMockTime(WITH_LOCK(g_setup->m_node.chainman->GetMutex(), return g_setup->m_node.chainman->ActiveTip()->Time()));
 
-    BlockAssembler::Options options;
-    options.coinbase_output_script = P2WSH_EMPTY;
-
     for (int i = 0; i < 2 * COINBASE_MATURITY; ++i) {
-        COutPoint prevout{MineBlock(g_setup->m_node, options)};
+        COutPoint prevout{MineBlock(g_setup->m_node, {
+            .coinbase_output_script = P2WSH_EMPTY,
+        })};
         if (i < COINBASE_MATURITY) {
             // Remember the txids to avoid expensive disk access later on
             g_outpoints_coinbase_init_mature.push_back(prevout);
diff --git a/src/test/fuzz/process_message.cpp b/src/test/fuzz/process_message.cpp
index d8a91d7f90a7..4fa4f4b16c40 100644
--- a/src/test/fuzz/process_message.cpp
+++ b/src/test/fuzz/process_message.cpp
@@ -2,14 +2,16 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <addrman.h>
 #include <banman.h>
 #include <consensus/consensus.h>
+#include <kernel/chainparams.h>
 #include <net.h>
 #include <net_processing.h>
-#include <node/warnings.h>
+#include <node/mining_types.h>
+#include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <protocol.h>
-#include <script/script.h>
 #include <sync.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
@@ -17,18 +19,25 @@
 #include <test/fuzz/util/net.h>
 #include <test/util/mining.h>
 #include <test/util/net.h>
+#include <test/util/random.h>
 #include <test/util/setup_common.h>
 #include <test/util/time.h>
 #include <test/util/validation.h>
 #include <util/check.h>
 #include <util/time.h>
+#include <chainstate.h>
 #include <validationinterface.h>
 
+#include <algorithm>
+#include <array>
 #include <cstdlib>
+#include <functional>
 #include <iostream>
 #include <memory>
+#include <optional>
 #include <string>
 #include <string_view>
+#include <utility>
 #include <vector>
 
 namespace {
@@ -42,7 +51,7 @@ void ResetChainman(TestingSetup& setup)
     setup.m_make_chainman();
     setup.LoadVerifyActivateChainstate();
     for (int i = 0; i < 2 * COINBASE_MATURITY; i++) {
-        node::BlockAssembler::Options options;
+        node::BlockCreateOptions options;
         MineBlock(setup.m_node, options);
     }
 }
diff --git a/src/test/fuzz/process_messages.cpp b/src/test/fuzz/process_messages.cpp
index 314388fac07e..bf301caa1fda 100644
--- a/src/test/fuzz/process_messages.cpp
+++ b/src/test/fuzz/process_messages.cpp
@@ -2,13 +2,16 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <addrman.h>
 #include <banman.h>
 #include <consensus/consensus.h>
+#include <kernel/chainparams.h>
 #include <net.h>
 #include <net_processing.h>
-#include <node/warnings.h>
+#include <node/mining_types.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
 #include <protocol.h>
-#include <script/script.h>
 #include <sync.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
@@ -16,13 +19,18 @@
 #include <test/fuzz/util/net.h>
 #include <test/util/mining.h>
 #include <test/util/net.h>
+#include <test/util/random.h>
 #include <test/util/setup_common.h>
 #include <test/util/time.h>
 #include <test/util/validation.h>
 #include <util/time.h>
+#include <chainstate.h>
 #include <validationinterface.h>
 
+#include <functional>
 #include <ios>
+#include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -36,7 +44,7 @@ void ResetChainman(TestingSetup& setup)
     setup.m_node.chainman.reset();
     setup.m_make_chainman();
     setup.LoadVerifyActivateChainstate();
-    node::BlockAssembler::Options options;
+    node::BlockCreateOptions options;
     for (int i = 0; i < 2 * COINBASE_MATURITY; i++) {
         MineBlock(setup.m_node, options);
     }
diff --git a/src/test/fuzz/tx_pool.cpp b/src/test/fuzz/tx_pool.cpp
index 72ce968d66f7..2963b60885cb 100644
--- a/src/test/fuzz/tx_pool.cpp
+++ b/src/test/fuzz/tx_pool.cpp
@@ -2,27 +2,56 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <chain.h>
+#include <coins.h>
+#include <consensus/amount.h>
+#include <consensus/consensus.h>
 #include <consensus/validation.h>
 #include <mempool_validation.h>
 #include <node/context.h>
 #include <node/mempool_args.h>
 #include <node/miner.h>
+#include <node/mining_types.h>
+#include <policy/feerate.h>
+#include <policy/packages.h>
+#include <policy/policy.h>
 #include <policy/truc_policy.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
+#include <script/script.h>
+#include <sync.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 #include <test/fuzz/util/mempool.h>
 #include <test/util/mining.h>
+#include <test/util/random.h>
 #include <test/util/script.h>
 #include <test/util/setup_common.h>
 #include <test/util/txmempool.h>
+#include <txmempool.h>
 #include <util/check.h>
-#include <util/rbf.h>
+#include <util/string.h>
+#include <util/time.h>
 #include <util/translation.h>
 #include <chainstate.h>
 #include <validationinterface.h>
 
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <memory>
+#include <optional>
+#include <set>
+#include <span>
+#include <string>
+#include <utility>
+#include <vector>
 using node::BlockAssembler;
+using node::BlockCreateOptions;
 using node::NodeContext;
 using util::ToString;
 
@@ -47,11 +76,10 @@ void initialize_tx_pool()
     g_setup = testing_setup.get();
     SetMockTime(WITH_LOCK(g_setup->m_node.chainman->GetMutex(), return g_setup->m_node.chainman->ActiveTip()->Time()));
 
-    BlockAssembler::Options options;
-    options.coinbase_output_script = P2WSH_OP_TRUE;
-
     for (int i = 0; i < 2 * COINBASE_MATURITY; ++i) {
-        COutPoint prevout{MineBlock(g_setup->m_node, options)};
+        COutPoint prevout{MineBlock(g_setup->m_node, {
+            .coinbase_output_script = P2WSH_OP_TRUE,
+        })};
         // Remember the txids to avoid expensive disk access later on
         auto& outpoints = i < COINBASE_MATURITY ?
                               g_outpoints_coinbase_init_mature :
@@ -93,9 +121,10 @@ void Finish(FuzzedDataProvider& fuzzed_data_provider, MockedTxPool& tx_pool, Cha
 {
     WITH_LOCK(::cs_main, tx_pool.check(chainstate.CoinsTip(), chainstate.m_chain.Height() + 1));
     {
-        BlockAssembler::Options options;
-        options.nBlockMaxWeight = fuzzed_data_provider.ConsumeIntegralInRange(0U, MAX_BLOCK_WEIGHT);
-        options.blockMinFeeRate = CFeeRate{ConsumeMoney(fuzzed_data_provider, /*max=*/COIN)};
+        BlockCreateOptions options{
+            .block_min_fee_rate = CFeeRate{ConsumeMoney(fuzzed_data_provider, /*max=*/COIN)},
+            .block_max_weight = fuzzed_data_provider.ConsumeIntegralInRange<uint64_t>(DEFAULT_BLOCK_RESERVED_WEIGHT, MAX_BLOCK_WEIGHT),
+        };
         auto assembler = BlockAssembler{chainstate, &tx_pool, options};
         auto block_template = assembler.CreateNewBlock();
         Assert(block_template->block.vtx.size() >= 1);
diff --git a/src/test/fuzz/utxo_total_supply.cpp b/src/test/fuzz/utxo_total_supply.cpp
index 8068232183ee..fba845326d64 100644
--- a/src/test/fuzz/utxo_total_supply.cpp
+++ b/src/test/fuzz/utxo_total_supply.cpp
@@ -3,23 +3,32 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
-#include <consensus/consensus.h>
+#include <consensus/amount.h>
 #include <consensus/merkle.h>
 #include <kernel/coinstats.h>
 #include <node/miner.h>
-#include <script/interpreter.h>
-#include <streams.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
+#include <script/script.h>
+#include <sync.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 #include <test/util/mining.h>
+#include <test/util/random.h>
 #include <test/util/setup_common.h>
 #include <test/util/time.h>
 #include <util/chaintype.h>
 #include <util/time.h>
 #include <chainstate.h>
 
-using node::BlockAssembler;
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <utility>
+#include <vector>
 
 FUZZ_TARGET(utxo_total_supply)
 {
@@ -44,11 +53,11 @@ FUZZ_TARGET(utxo_total_supply)
         LOCK(chainman.GetMutex());
         return chainman.ActiveHeight();
     };
-    BlockAssembler::Options options;
-    options.coinbase_output_script = CScript() << OP_FALSE;
     const auto PrepareNextBlock = [&]() {
         // Use OP_FALSE to avoid BIP30 check from hitting early
-        auto block = PrepareBlock(node, options);
+        auto block = PrepareBlock(node, {
+            .coinbase_output_script = CScript() << OP_FALSE,
+        });
         // Replace OP_FALSE with OP_TRUE
         {
             CMutableTransaction tx{*block->vtx.back()};
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index d55f9175722c..724be18d1c39 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -5,15 +5,25 @@
 #include <addresstype.h>
 #include <block_validation.h>
 #include <coins.h>
-#include <common/system.h>
+#include <consensus/amount.h>
 #include <consensus/consensus.h>
 #include <consensus/merkle.h>
 #include <consensus/tx_verify.h>
 #include <interfaces/mining.h>
 #include <mempool_validation.h>
 #include <node/miner.h>
+#include <node/mining_types.h>
+#include <policy/feerate.h>
 #include <policy/policy.h>
-#include <test/util/random.h>
+#include <pow.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
+#include <random.h>
+#include <script/script.h>
+#include <serialize.h>
+#include <sync.h>
+#include <test/util/common.h>
+#include <test/util/setup_common.h>
 #include <test/util/transaction_utils.h>
 #include <test/util/txmempool.h>
 #include <txmempool.h>
@@ -25,20 +35,24 @@
 #include <util/translation.h>
 #include <chainstate.h>
 #include <versionbits.h>
-#include <pow.h>
 
-#include <test/util/common.h>
-#include <test/util/setup_common.h>
+#include <boost/test/unit_test.hpp>
 
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
 #include <memory>
+#include <optional>
+#include <span>
+#include <stdexcept>
+#include <string>
 #include <vector>
 
-#include <boost/test/unit_test.hpp>
-
 using namespace util::hex_literals;
 using interfaces::BlockTemplate;
 using interfaces::Mining;
 using node::BlockAssembler;
+using node::BlockCreateOptions;
 
 namespace miner_tests {
 struct MinerTestingSetup : public TestingSetup {
@@ -117,8 +131,9 @@ void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const
 {
     CTxMemPool& tx_mempool{MakeMempool()};
     auto mining{MakeMining()};
-    BlockAssembler::Options options;
-    options.coinbase_output_script = scriptPubKey;
+    BlockCreateOptions options{
+        .coinbase_output_script = scriptPubKey,
+    };
 
     LOCK(tx_mempool.cs);
     BOOST_CHECK(tx_mempool.size() == 0);
@@ -177,7 +192,12 @@ void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const
     BOOST_CHECK(block.vtx[3]->GetHash() == hashMediumFeeTx);
 
     // Test the inclusion of package feerates in the block template and ensure they are sequential.
-    const auto block_package_feerates = BlockAssembler{m_node.chainman->ActiveChainstate(), &tx_mempool, options}.CreateNewBlock()->m_package_feerates;
+    // Can't use the Mining interface because it needs access to m_package_feerates.
+    const auto block_package_feerates = BlockAssembler{
+        m_node.chainman->ActiveChainstate(),
+        &tx_mempool,
+        m_node.mining_args,
+    }.CreateNewBlock()->m_package_feerates;
     BOOST_CHECK(block_package_feerates.size() == 2);
 
     // parent_tx and high_fee_tx are added to the block as a package.
@@ -335,8 +355,9 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
     auto mining{MakeMining()};
     BOOST_REQUIRE(mining);
 
-    BlockAssembler::Options options;
-    options.coinbase_output_script = scriptPubKey;
+    BlockCreateOptions options{
+        .coinbase_output_script = scriptPubKey,
+    };
 
     {
         CTxMemPool& tx_mempool{MakeMempool()};
@@ -661,8 +682,9 @@ void MinerTestingSetup::TestPrioritisedMining(const CScript& scriptPubKey, const
     auto mining{MakeMining()};
     BOOST_REQUIRE(mining);
 
-    BlockAssembler::Options options;
-    options.coinbase_output_script = scriptPubKey;
+    BlockCreateOptions options{
+        .coinbase_output_script = scriptPubKey,
+    };
 
     CTxMemPool& tx_mempool{MakeMempool()};
     LOCK(tx_mempool.cs);
@@ -750,12 +772,20 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
 
     // Note that by default, these tests run with size accounting enabled.
     CScript scriptPubKey = CScript() << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"_hex << OP_CHECKSIG;
-    BlockAssembler::Options options;
-    options.coinbase_output_script = scriptPubKey;
+    BlockCreateOptions options{
+        .coinbase_output_script = scriptPubKey,
+    };
 
     // Create and check a simple template
     std::unique_ptr<BlockTemplate> block_template = mining->createNewBlock(options, /*cooldown=*/false);
     BOOST_REQUIRE(block_template);
+
+    BlockCreateOptions invalid_options{options};
+    invalid_options.block_max_weight = DEFAULT_BLOCK_RESERVED_WEIGHT - 1;
+    BOOST_CHECK_EXCEPTION(mining->createNewBlock(invalid_options, /*cooldown=*/false),
+                          std::runtime_error,
+                          HasReason("block_reserved_weight (8000) exceeds block_max_weight (7999)"));
+
     {
         CBlock block{block_template->getBlock()};
         {
diff --git a/src/test/peerman_tests.cpp b/src/test/peerman_tests.cpp
index 88f33710095a..869945f48f0d 100644
--- a/src/test/peerman_tests.cpp
+++ b/src/test/peerman_tests.cpp
@@ -4,25 +4,34 @@
 
 #include <block_validation.h>
 #include <chainparams.h>
-#include <node/miner.h>
+#include <consensus/params.h>
+#include <interfaces/mining.h>
 #include <net_processing.h>
 #include <pow.h>
+#include <primitives/block.h>
+#include <protocol.h>
+#include <sync.h>
 #include <test/util/setup_common.h>
 #include <chainstate.h>
 
 #include <boost/test/unit_test.hpp>
 
+#include <cstdint>
+#include <memory>
+
 BOOST_FIXTURE_TEST_SUITE(peerman_tests, RegTestingSetup)
 
 /** Window, in blocks, for connecting to NODE_NETWORK_LIMITED peers */
 static constexpr int64_t NODE_NETWORK_LIMITED_ALLOW_CONN_BLOCKS = 144;
 
-static void mineBlock(const node::NodeContext& node, std::chrono::seconds block_time)
+static void mineBlock(node::NodeContext& node, std::chrono::seconds block_time)
 {
     auto curr_time = GetTime<std::chrono::seconds>();
-    node::BlockAssembler::Options options;
     SetMockTime(block_time); // update time so the block is created with it
-    CBlock block = node::BlockAssembler{node.chainman->ActiveChainstate(), nullptr, options}.CreateNewBlock()->block;
+    auto mining{interfaces::MakeMining(node)};
+    auto block_template{mining->createNewBlock({}, /*cooldown=*/false)};
+    BOOST_REQUIRE(block_template);
+    CBlock block{block_template->getBlock()};
     while (!CheckProofOfWork(block.GetHash(), block.nBits, node.chainman->GetConsensus())) ++block.nNonce;
     block.fChecked = true; // little speedup
     SetMockTime(curr_time); // process block at current time
diff --git a/src/test/testnet4_miner_tests.cpp b/src/test/testnet4_miner_tests.cpp
index 3375fa06362c..baf5a6320a2b 100644
--- a/src/test/testnet4_miner_tests.cpp
+++ b/src/test/testnet4_miner_tests.cpp
@@ -2,10 +2,11 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <common/system.h>
+#include <chain.h>
 #include <interfaces/mining.h>
-#include <node/miner.h>
-#include <test/util/common.h>
+#include <node/mining_types.h>
+#include <primitives/block.h>
+#include <sync.h>
 #include <test/util/setup_common.h>
 #include <test/util/time.h>
 #include <util/time.h>
@@ -13,9 +14,10 @@
 
 #include <boost/test/unit_test.hpp>
 
+#include <memory>
+
 using interfaces::BlockTemplate;
 using interfaces::Mining;
-using node::BlockAssembler;
 using node::BlockWaitOptions;
 
 namespace testnet4_miner_tests {
@@ -35,18 +37,18 @@ BOOST_AUTO_TEST_CASE(MiningInterface)
     auto mining{MakeMining()};
     BOOST_REQUIRE(mining);
 
-    BlockAssembler::Options options;
     std::unique_ptr<BlockTemplate> block_template;
 
     // Set node time a few minutes past the testnet4 genesis block
     const auto template_time{3min + WITH_LOCK(cs_main, return m_node.chainman->ActiveChain().Tip()->Time())};
     NodeClockContext clock_ctx{template_time};
 
-    block_template = mining->createNewBlock(options, /*cooldown=*/false);
+    block_template = mining->createNewBlock({}, /*cooldown=*/false);
     BOOST_REQUIRE(block_template);
 
     // The template should use the mocked system time
-    BOOST_REQUIRE_EQUAL(block_template->getBlockHeader().Time(), template_time);
+    BOOST_REQUIRE_EQUAL(TicksSinceEpoch<std::chrono::seconds>(block_template->getBlockHeader().Time()),
+                        TicksSinceEpoch<std::chrono::seconds>(template_time));
 
     const BlockWaitOptions wait_options{.timeout = MillisecondsDouble{0}, .fee_threshold = 1};
 
diff --git a/src/test/util/mining.cpp b/src/test/util/mining.cpp
index 38a3bad6cefb..0a72a08bd06a 100644
--- a/src/test/util/mining.cpp
+++ b/src/test/util/mining.cpp
@@ -8,30 +8,35 @@
 #include <chainparams.h>
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
+#include <interfaces/mining.h>
 #include <key_io.h>
 #include <node/context.h>
 #include <pow.h>
+#include <primitives/block.h>
 #include <primitives/transaction.h>
+#include <script/script.h>
+#include <sync.h>
 #include <test/util/script.h>
+#include <uint256.h>
 #include <util/check.h>
 #include <chainstate.h>
 #include <validationinterface.h>
 #include <versionbits.h>
 
-#include <algorithm>
+#include <cstdint>
 #include <memory>
+#include <optional>
+#include <utility>
 
-using node::BlockAssembler;
 using node::NodeContext;
 
 COutPoint generatetoaddress(const NodeContext& node, const std::string& address)
 {
     const auto dest = DecodeDestination(address);
     assert(IsValidDestination(dest));
-    BlockAssembler::Options assembler_options;
-    assembler_options.coinbase_output_script = GetScriptForDestination(dest);
-
-    return MineBlock(node, assembler_options);
+    return MineBlock(node, {
+        .coinbase_output_script = GetScriptForDestination(dest),
+    });
 }
 
 std::vector<std::shared_ptr<CBlock>> CreateBlockChain(size_t total_height, const CChainParams& params)
@@ -69,7 +74,7 @@ std::vector<std::shared_ptr<CBlock>> CreateBlockChain(size_t total_height, const
     return ret;
 }
 
-COutPoint MineBlock(const NodeContext& node, const node::BlockAssembler::Options& assembler_options)
+COutPoint MineBlock(const NodeContext& node, const node::BlockCreateOptions& assembler_options)
 {
     auto block = PrepareBlock(node, assembler_options);
     auto valid = MineBlock(node, block);
@@ -123,12 +128,11 @@ COutPoint ProcessBlock(const NodeContext& node, const std::shared_ptr<CBlock>& b
 }
 
 std::shared_ptr<CBlock> PrepareBlock(const NodeContext& node,
-                                     const BlockAssembler::Options& assembler_options)
+                                     const node::BlockCreateOptions& assembler_options)
 {
-    auto block = std::make_shared<CBlock>(
-        BlockAssembler{Assert(node.chainman)->ActiveChainstate(), Assert(node.mempool.get()), assembler_options}
-            .CreateNewBlock()
-            ->block);
+    auto mining = interfaces::MakeMining(node);
+    auto block_template = mining->createNewBlock(assembler_options, /*cooldown=*/false);
+    auto block = std::make_shared<CBlock>(Assert(block_template)->getBlock());
 
     LOCK(cs_main);
     block->nTime = Assert(node.chainman)->ActiveChain().Tip()->GetMedianTimePast() + 1;
@@ -136,10 +140,3 @@ std::shared_ptr<CBlock> PrepareBlock(const NodeContext& node,
 
     return block;
 }
-std::shared_ptr<CBlock> PrepareBlock(const NodeContext& node, const CScript& coinbase_scriptPubKey)
-{
-    BlockAssembler::Options assembler_options;
-    assembler_options.coinbase_output_script = coinbase_scriptPubKey;
-    ApplyArgsManOptions(*node.args, assembler_options);
-    return PrepareBlock(node, assembler_options);
-}
diff --git a/src/test/util/mining.h b/src/test/util/mining.h
index 9be01507d391..d1a071b3ee3a 100644
--- a/src/test/util/mining.h
+++ b/src/test/util/mining.h
@@ -5,8 +5,7 @@
 #ifndef BITCOIN_TEST_UTIL_MINING_H
 #define BITCOIN_TEST_UTIL_MINING_H
 
-#include <node/miner.h>
-
+#include <cstddef>
 #include <memory>
 #include <string>
 #include <vector>
@@ -14,8 +13,8 @@
 class CBlock;
 class CChainParams;
 class COutPoint;
-class CScript;
 namespace node {
+struct BlockCreateOptions;
 struct NodeContext;
 } // namespace node
 
@@ -24,7 +23,7 @@ std::vector<std::shared_ptr<CBlock>> CreateBlockChain(size_t total_height, const
 
 /** Returns the generated coin */
 COutPoint MineBlock(const node::NodeContext&,
-                    const node::BlockAssembler::Options& assembler_options);
+                    const node::BlockCreateOptions& assembler_options);
 
 /**
  * Returns the generated coin (or Null if the block was invalid).
@@ -38,9 +37,8 @@ COutPoint MineBlock(const node::NodeContext&, std::shared_ptr<CBlock>& block);
 COutPoint ProcessBlock(const node::NodeContext&, const std::shared_ptr<CBlock>& block);
 
 /** Prepare a block to be mined */
-std::shared_ptr<CBlock> PrepareBlock(const node::NodeContext&);
 std::shared_ptr<CBlock> PrepareBlock(const node::NodeContext& node,
-                                     const node::BlockAssembler::Options& assembler_options);
+                                     const node::BlockCreateOptions& assembler_options);
 
 /** RPC-like helper function, returns the generated coin */
 COutPoint generatetoaddress(const node::NodeContext&, const std::string& address);
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index f4a702bb015e..29e615e9e064 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -8,47 +8,66 @@
 #include <banman.h>
 #include <block_validation.h>
 #include <chainparams.h>
+#include <coins.h>
 #include <common/system.h>
+#include <consensus/amount.h>
 #include <consensus/consensus.h>
-#include <consensus/params.h>
 #include <consensus/validation.h>
-#include <crypto/sha256.h>
+#include <crypto/hex_base.h>
+#include <dbwrapper.h>
 #include <init.h>
 #include <init/common.h>
 #include <mempool_validation.h>
 #include <interfaces/chain.h>
-#include <kernel/mempool_entry.h>
+#include <interfaces/mining.h>
+#include <kernel/caches.h>
+#include <kernel/context.h>
+#include <key.h>
 #include <logging.h>
 #include <net.h>
 #include <net_processing.h>
+#include <netbase.h>
+#include <netgroup.h>
 #include <node/blockstorage.h>
 #include <node/chainstate_load.h>
 #include <node/context.h>
 #include <node/kernel_notifications.h>
-#include <node/mempool_args.h>
 #include <node/miner.h>
+#include <node/mining_args.h>
+#include <node/mining_types.h>
 #include <node/peerman_args.h>
 #include <node/warnings.h>
 #include <noui.h>
-#include <policy/fees/block_policy_estimator.h>
+#include <policy/feerate.h>
+#include <policy/policy.h>
 #include <pow.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
 #include <random.h>
 #include <scheduler.h>
-#include <script/sigcache.h>
+#include <script/interpreter.h>
+#include <script/script.h>
+#include <script/sign.h>
+#include <script/signingprovider.h>
+#include <serialize.h>
+#include <span.h>
 #include <streams.h>
+#include <sync.h>
 #include <test/util/coverage.h>
 #include <test/util/net.h>
 #include <test/util/random.h>
-#include <test/util/transaction_utils.h>
 #include <test/util/txmempool.h>
-#include <txdb.h>
+#include <tinyformat.h>
 #include <txmempool.h>
+#include <uint256.h>
 #include <util/chaintype.h>
 #include <util/check.h>
+#include <util/fs.h>
 #include <util/fs_helpers.h>
 #include <util/rbf.h>
+#include <util/result.h>
+#include <util/signalinterrupt.h>
 #include <util/strencodings.h>
-#include <util/string.h>
 #include <util/task_runner.h>
 #include <util/thread.h>
 #include <util/threadnames.h>
@@ -59,13 +78,25 @@
 #include <validationinterface.h>
 
 #include <algorithm>
-#include <future>
+#include <array>
+#include <atomic>
+#include <cstdlib>
+#include <deque>
 #include <functional>
+#include <future>
+#include <iostream>
+#include <iterator>
+#include <map>
+#include <numeric>
+#include <span>
 #include <stdexcept>
+#include <string_view>
+#include <thread>
+#include <tuple>
+#include <utility>
 
 using namespace util::hex_literals;
 using node::ApplyArgsManOptions;
-using node::BlockAssembler;
 using node::BlockManager;
 using node::KernelNotifications;
 using node::LoadChainstate;
@@ -327,6 +358,8 @@ void ChainTestingSetup::LoadVerifyActivateChainstate()
     std::tie(status, error) = VerifyLoadedChainstate(chainman, options);
     assert(status == node::ChainstateLoadStatus::SUCCESS);
 
+    m_node.notifications->setChainstateLoaded(true);
+
     BlockValidationState state;
     if (!chainman.ActiveChainstate().ActivateBestChain(state)) {
         throw std::runtime_error(strprintf("ActivateBestChain failed. (%s)", state.ToString()));
@@ -350,6 +383,9 @@ TestingSetup::TestingSetup(
                                                m_node.args->GetIntArg("-checkaddrman", 0));
     m_node.banman = std::make_unique<BanMan>(m_args.GetDataDirBase() / "banlist", nullptr, DEFAULT_MISBEHAVING_BANTIME);
     m_node.connman = std::make_unique<ConnmanTestMsg>(0x1337, 0x1337, *m_node.addrman, *m_node.netgroupman, Params()); // Deterministic randomness for tests.
+    auto mining_args{node::ReadMiningArgs(*m_node.args)};
+    Assert(mining_args);
+    m_node.mining_args = std::move(*mining_args);
     PeerManager::Options peerman_opts;
     ApplyArgsManOptions(*m_node.args, peerman_opts);
     peerman_opts.deterministic_rng = true;
@@ -399,12 +435,15 @@ void TestChain100Setup::mineBlocks(int num_blocks)
 
 CBlock TestChain100Setup::CreateBlock(
     const std::vector<CMutableTransaction>& txns,
-    const CScript& scriptPubKey,
-    Chainstate& chainstate)
+    const CScript& scriptPubKey)
 {
-    BlockAssembler::Options options;
-    options.coinbase_output_script = scriptPubKey;
-    CBlock block = BlockAssembler{chainstate, nullptr, options}.CreateNewBlock()->block;
+    auto mining{interfaces::MakeMining(m_node)};
+    auto block_template{mining->createNewBlock({
+        .use_mempool = false,
+        .coinbase_output_script = scriptPubKey,
+    }, /*cooldown=*/false)};
+    Assert(block_template);
+    CBlock block{block_template->getBlock()};
 
     Assert(block.vtx.size() == 1);
     for (const CMutableTransaction& tx : txns) {
@@ -419,14 +458,9 @@ CBlock TestChain100Setup::CreateBlock(
 
 CBlock TestChain100Setup::CreateAndProcessBlock(
     const std::vector<CMutableTransaction>& txns,
-    const CScript& scriptPubKey,
-    Chainstate* chainstate)
+    const CScript& scriptPubKey)
 {
-    if (!chainstate) {
-        chainstate = &Assert(m_node.chainman)->ActiveChainstate();
-    }
-
-    CBlock block = this->CreateBlock(txns, scriptPubKey, *chainstate);
+    CBlock block = this->CreateBlock(txns, scriptPubKey);
     std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(block);
     ProcessNewBlock(*Assert(m_node.chainman), shared_pblock, true, true, nullptr);
 
diff --git a/src/test/util/setup_common.h b/src/test/util/setup_common.h
index 8b1b0632185c..62bfaba9a970 100644
--- a/src/test/util/setup_common.h
+++ b/src/test/util/setup_common.h
@@ -6,34 +6,29 @@
 #define BITCOIN_TEST_UTIL_SETUP_COMMON_H
 
 #include <common/args.h> // IWYU pragma: export
+#include <consensus/amount.h>
 #include <kernel/caches.h>
-#include <kernel/context.h>
 #include <key.h>
 #include <node/caches.h>
 #include <node/context.h> // IWYU pragma: export
-#include <optional>
-#include <ostream>
 #include <primitives/transaction.h>
-#include <pubkey.h>
-#include <stdexcept>
+#include <random.h>
 #include <test/util/random.h>
 #include <util/chaintype.h> // IWYU pragma: export
-#include <util/check.h>
 #include <util/fs.h>
 #include <util/signalinterrupt.h>
-#include <util/string.h>
 #include <util/vector.h>
 
+#include <cstddef>
+#include <cstdint>
 #include <functional>
-#include <type_traits>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
 #include <vector>
 
-class arith_uint256;
 class CFeeRate;
-class Chainstate;
-class FastRandomContext;
-class uint160;
-class uint256;
 
 /** Retrieve the command line arguments. */
 extern const std::function<std::vector<const char*>()> G_TEST_COMMAND_LINE_ARGUMENTS;
@@ -134,7 +129,6 @@ struct Testnet4Setup : public TestingSetup {
 };
 
 class CBlock;
-struct CMutableTransaction;
 class CScript;
 
 /**
@@ -148,11 +142,9 @@ struct TestChain100Setup : public TestingSetup {
     /**
      * Create a new block with just given transactions, coinbase paying to
      * scriptPubKey, and try to add it to the current chain.
-     * If no chainstate is specified, default to the active.
      */
     CBlock CreateAndProcessBlock(const std::vector<CMutableTransaction>& txns,
-                                 const CScript& scriptPubKey,
-                                 Chainstate* chainstate = nullptr);
+                                 const CScript& scriptPubKey);
 
     /**
      * Create a new block with just given transactions, coinbase paying to
@@ -160,8 +152,7 @@ struct TestChain100Setup : public TestingSetup {
      */
     CBlock CreateBlock(
         const std::vector<CMutableTransaction>& txns,
-        const CScript& scriptPubKey,
-        Chainstate& chainstate);
+        const CScript& scriptPubKey);
 
     //! Mine a series of new blocks on the active chain.
     void mineBlocks(int num_blocks);
diff --git a/src/test/validation_block_tests.cpp b/src/test/validation_block_tests.cpp
index 6c7110c6caa7..f343bf38e8d5 100644
--- a/src/test/validation_block_tests.cpp
+++ b/src/test/validation_block_tests.cpp
@@ -6,23 +6,32 @@
 
 #include <block_validation.h>
 #include <chainparams.h>
+#include <consensus/consensus.h>
 #include <consensus/merkle.h>
 #include <mempool_validation.h>
 #include <consensus/validation.h>
-#include <node/miner.h>
+#include <interfaces/mining.h>
+#include <node/blockstorage.h>
 #include <pow.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
 #include <random.h>
-#include <test/util/common.h>
-#include <test/util/random.h>
+#include <script/script.h>
+#include <sync.h>
+#include <test/util/common.h> // IWYU pragma: keep
 #include <test/util/script.h>
 #include <test/util/setup_common.h>
 #include <util/time.h>
 #include <chainstate.h>
 #include <validationinterface.h>
 
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <span>
 #include <thread>
-
-using node::BlockAssembler;
+#include <utility>
+#include <vector>
 
 namespace validation_block_tests {
 struct MinerTestingSetup : public RegTestingSetup {
@@ -68,10 +77,12 @@ std::shared_ptr<CBlock> MinerTestingSetup::Block(const uint256& prev_hash)
     static int i = 0;
     static uint64_t time = Params().GenesisBlock().nTime;
 
-    BlockAssembler::Options options;
-    options.coinbase_output_script = CScript{} << i++ << OP_TRUE;
-    auto ptemplate = BlockAssembler{m_node.chainman->ActiveChainstate(), m_node.mempool.get(), options}.CreateNewBlock();
-    auto pblock = std::make_shared<CBlock>(ptemplate->block);
+    auto mining{interfaces::MakeMining(m_node)};
+    auto block_template{mining->createNewBlock({
+        .coinbase_output_script = CScript{} << i++ << OP_TRUE,
+    }, /*cooldown=*/false)};
+    BOOST_REQUIRE(block_template);
+    auto pblock = std::make_shared<CBlock>(block_template->getBlock());
     pblock->hashPrevBlock = prev_hash;
     pblock->nTime = ++time;
 
@@ -336,10 +347,12 @@ BOOST_AUTO_TEST_CASE(witness_commitment_index)
     LOCK(Assert(m_node.chainman)->GetMutex());
     CScript pubKey;
     pubKey << 1 << OP_TRUE;
-    BlockAssembler::Options options;
-    options.coinbase_output_script = pubKey;
-    auto ptemplate = BlockAssembler{m_node.chainman->ActiveChainstate(), m_node.mempool.get(), options}.CreateNewBlock();
-    CBlock pblock = ptemplate->block;
+    auto mining{interfaces::MakeMining(m_node)};
+    auto block_template{mining->createNewBlock({
+        .coinbase_output_script = pubKey,
+    }, /*cooldown=*/false)};
+    BOOST_REQUIRE(block_template);
+    CBlock pblock{block_template->getBlock()};
 
     CTxOut witness;
     witness.scriptPubKey.resize(MINIMUM_WITNESS_COMMITMENT);
diff --git a/src/test/validation_chainstate_tests.cpp b/src/test/validation_chainstate_tests.cpp
index 1b7aee03f5a6..c978949bb529 100644
--- a/src/test/validation_chainstate_tests.cpp
+++ b/src/test/validation_chainstate_tests.cpp
@@ -4,25 +4,32 @@
 //
 #include <block_validation.h>
 #include <chainparams.h>
+#include <coins.h>
 #include <consensus/amount.h>
 #include <consensus/validation.h>
+#include <node/blockstorage.h>
 #include <node/kernel_notifications.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
 #include <random.h>
 
 #include <script/script.h>
 #include <sync.h>
 #include <test/util/common.h>
 #include <test/util/coins.h>
-#include <test/util/random.h>
 #include <test/util/setup_common.h>
+#include <tinyformat.h>
 #include <uint256.h>
-#include <util/byte_units.h>
 #include <util/check.h>
 #include <chainstate.h>
 
+#include <boost/test/unit_test.hpp>
+
+#include <memory>
+#include <optional>
 #include <vector>
 
-#include <boost/test/unit_test.hpp>
+class CTxMemPool;
 
 BOOST_FIXTURE_TEST_SUITE(validation_chainstate_tests, ChainTestingSetup)
 
@@ -83,7 +90,7 @@ BOOST_FIXTURE_TEST_CASE(connect_tip_does_not_cache_inputs_on_failed_connect, Tes
     tx.vout.emplace_back(MAX_MONEY, CScript{} << OP_TRUE);
 
     const auto tip{WITH_LOCK(cs_main, return chainstate.m_chain.Tip()->GetBlockHash())};
-    const CBlock block{CreateBlock({tx}, CScript{} << OP_TRUE, chainstate)};
+    const CBlock block{CreateBlock({tx}, CScript{} << OP_TRUE)};
     BOOST_CHECK(ProcessNewBlock(*Assert(m_node.chainman), std::make_shared<CBlock>(block), true, true, nullptr));
 
     LOCK(cs_main);

From 55087c61ef81740eff27d6cd062f6692a0e52611 Mon Sep 17 00:00:00 2001
From: merge-script <seb.kung@gmail.com>
Date: Wed, 27 May 2026 12:06:53 +0200
Subject: [PATCH 08/10] Merge bitcoin/bitcoin#35372: refactor: Enhance type
 safety in overflow operations

0774eaaf0c221b3fed68e866130abafa2890880c util: Require integers for SaturatingAdd() and AdditionOverflow() (Hodlinator)
a815e3e2629fdcc1331a070a574fba595dac5c9e rpc: Correct type for tx_sigops (Hodlinator)

Pull request description:

  * Correct copy-paste error in RPC code
  * Require proper integers for `SaturatingAdd()` and `AdditionOverflow()` in src/util/overflow.h

  These changes increase the type safety of the code and were done while exploring increasing the type-safety of `CAmount` (currently just a `typedef` of `int64_t`).

  The first commit has nothing to do with overflow but is along for the ride if reviewers agree.

ACKs for top commit:
  maflcko:
    lgtm ACK 0774eaaf0c221b3fed68e866130abafa2890880c
  winterrdog:
    ACK 0774eaaf0c221b3fed68e866130abafa2890880c
  sedited:
    ACK 0774eaaf0c221b3fed68e866130abafa2890880c

Tree-SHA512: a245ad52cfd1c257151aea1a1ed4b6769415c1dddc7c405d8bbe71b9f3abc512a6d890a45cbc8381718be16274e337cc876e6e6da11dc35de71bea83bece6634
(cherry picked from commit 0687438e94d756d323865eebde0cb00c8dc7d4cf)
---
 src/util/overflow.h | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/util/overflow.h b/src/util/overflow.h
index 274ba0454e3a..48732838ac8a 100644
--- a/src/util/overflow.h
+++ b/src/util/overflow.h
@@ -13,10 +13,9 @@
 #include <optional>
 #include <type_traits>
 
-template <class T>
+template <std::integral T>
 [[nodiscard]] bool AdditionOverflow(const T i, const T j) noexcept
 {
-    static_assert(std::is_integral_v<T>, "Integral required.");
     if constexpr (std::numeric_limits<T>::is_signed) {
         return (i > 0 && j > std::numeric_limits<T>::max() - i) ||
                (i < 0 && j < std::numeric_limits<T>::min() - i);
@@ -41,7 +40,7 @@ template <std::unsigned_integral T, std::unsigned_integral U>
     return true;
 }
 
-template <class T>
+template <std::integral T>
 [[nodiscard]] T SaturatingAdd(const T i, const T j) noexcept
 {
     if constexpr (std::numeric_limits<T>::is_signed) {

From a9d8f7bdb1d3b7719a845b98ebdb7a37de5b44ae Mon Sep 17 00:00:00 2001
From: merge-script <fanquake@gmail.com>
Date: Wed, 27 May 2026 15:48:32 +0100
Subject: [PATCH 09/10] Merge bitcoin/bitcoin#35206: doc: fix doxygen links to
 threads in developer-notes.md

d5adb9d09b858d2ab61be52a4b8359cef7c65a0b doc: fix doxygen links to threads in developer-notes.md (Matthew Zipkin)

Pull request description:

  The "threads" section of `developer-notes.md` has links to anchor tags in the code generated by doxygen. As far as I can tell this was introduced in #18645 and changes to this section of this document have continued the pattern. The problem is, the content at `https://doxygen.bitcoincore.org` gets re-rendered daily and those anchor tags are generated internally by doxygen, so they are all broken now.

  This PR adds doxygen syntax `\anchor XXXX` comments in the code where functions that run in these threads are defined, and then those stable, human-readable anchor tags are applied to the links in the doc.

  I have generated the doxygen output from this branch, hosted it on my own web server, and created a modified `developer-notes.md` with these anchor tags and my server as host for demonstration:

  https://gist.github.com/pinheadmz/ed3dda7d3c8d589e3989040519190b84#threads

  Just note when looking at this:
  - `main` is at the bottom of the html page so it might not look right at first
  - `initload` is a lambda inside `AppInitMain` so thats where doxygen renders the anchor

ACKs for top commit:
  fanquake:
    ACK d5adb9d09b858d2ab61be52a4b8359cef7c65a0b
  rkrux:
    lgtm ACK d5adb9d

Tree-SHA512: c5517823a2d668b01318b3dae3d76fdd9db8a74d8c721aeb748e4f4a6cb56cb4d24e34b2590a41f8553992005cab368fca4ce322a4f204cec16ce338337ae9ee
(cherry picked from commit 00af5620f01dbd1d2e696487303fad0382b67591)
---
 doc/developer-notes.md | 22 +++++++++++-----------
 src/bitcoind.cpp       |  1 +
 src/checkqueue.h       |  1 +
 src/init.cpp           |  1 +
 src/mapport.cpp        |  1 +
 src/net.h              |  6 ++++++
 src/scheduler.h        |  1 +
 src/torcontrol.h       |  3 ++-
 8 files changed, 24 insertions(+), 12 deletions(-)

diff --git a/doc/developer-notes.md b/doc/developer-notes.md
index 80301ec01c41..3df109bf5865 100644
--- a/doc/developer-notes.md
+++ b/doc/developer-notes.md
@@ -703,21 +703,21 @@ done by the components.
 
 ## Threads
 
-- [Main thread (`bitcoind`)](https://doxygen.bitcoincore.org/bitcoind_8cpp.html#a0ddf1224851353fc92bfbff6f499fa97)
+- [Main thread (`bitcoind`)](https://doxygen.bitcoincore.org/bitcoind_8cpp.html#main)
   : Started from `main()` in `bitcoind.cpp`. Responsible for starting up and
   shutting down the application.
 
-- [Init load (`b-initload`)](https://doxygen.bitcoincore.org/namespacenode.html#ab4305679079866f0f420f7dbf278381d)
+- [Init load (`b-initload`)](https://doxygen.bitcoincore.org/init_8cpp.html#initload)
   : Performs various loading tasks that are part of init but shouldn't block the node from being started: external block import,
    reindex, reindex-chainstate, main chain activation, spawn indexes background sync threads and mempool load.
 
-- [CCheckQueue::Loop (`b-scriptch.x`)](https://doxygen.bitcoincore.org/class_c_check_queue.html#a6e7fa51d3a25e7cb65446d4b50e6a987)
+- [CCheckQueue::Loop (`b-scriptch.x`)](https://doxygen.bitcoincore.org/class_c_check_queue.html#checkqueue)
   : Parallel script validation threads for transactions in blocks.
 
 - [ThreadHTTP (`b-http`)](https://doxygen.bitcoincore.org/httpserver_8cpp.html#abb9f6ea8819672bd9a62d3695070709c)
   : Thread to listen for RPC and REST connections.
 
-- [HTTP worker threads (`b-http_pool_x`)](https://doxygen.bitcoincore.org/httpserver_8cpp.html#a2ad0a49dc9b5e8117c0dee98c24187d8)
+- [HTTP worker threads (`b-http_pool_x`)](https://doxygen.bitcoincore.org/httpserver_8cpp.html#http_pool)
   : Threads to service RPC and REST requests.
 
 - [SchedulerThread (`b-scheduler`)](https://doxygen.bitcoincore.org/class_c_scheduler.html#a14d2800815da93577858ea078aed1fba)
@@ -729,26 +729,26 @@ done by the components.
 
 - Net threads:
 
-  - [ThreadMessageHandler (`b-msghand`)](https://doxygen.bitcoincore.org/class_c_connman.html#aacdbb7148575a31bb33bc345e2bf22a9)
+  - [ThreadMessageHandler (`b-msghand`)](https://doxygen.bitcoincore.org/class_c_connman.html#msghand)
     : Application level message handling (sending and receiving). Almost
     all net_processing and validation logic runs on this thread.
 
-  - [ThreadDNSAddressSeed (`b-dnsseed`)](https://doxygen.bitcoincore.org/class_c_connman.html#aa7c6970ed98a4a7bafbc071d24897d13)
+  - [ThreadDNSAddressSeed (`b-dnsseed`)](https://doxygen.bitcoincore.org/class_c_connman.html#dnsseed)
     : Loads addresses of peers from the DNS.
 
-  - ThreadMapPort (`b-mapport`)
+  - [ThreadMapPort (`b-mapport`)](https://doxygen.bitcoincore.org/mapport_8cpp.html#mapport)
     : Universal plug-and-play startup/shutdown.
 
-  - [ThreadSocketHandler (`b-net`)](https://doxygen.bitcoincore.org/class_c_connman.html#a765597cbfe99c083d8fa3d61bb464e34)
+  - [ThreadSocketHandler (`b-net`)](https://doxygen.bitcoincore.org/class_c_connman.html#net)
     : Sends/Receives data from peers on port 8333.
 
-  - [ThreadOpenAddedConnections (`b-addcon`)](https://doxygen.bitcoincore.org/class_c_connman.html#a0b787caf95e52a346a2b31a580d60a62)
+  - [ThreadOpenAddedConnections (`b-addcon`)](https://doxygen.bitcoincore.org/class_c_connman.html#addcon)
     : Opens network connections to added nodes.
 
-  - [ThreadOpenConnections (`b-opencon`)](https://doxygen.bitcoincore.org/class_c_connman.html#a55e9feafc3bab78e5c9d408c207faa45)
+  - [ThreadOpenConnections (`b-opencon`)](https://doxygen.bitcoincore.org/class_c_connman.html#opencon)
     : Initiates new connections to peers.
 
-  - [ThreadI2PAcceptIncoming (`b-i2paccept`)](https://doxygen.bitcoincore.org/class_c_connman.html#a57787b4f9ac847d24065fbb0dd6e70f8)
+  - [ThreadI2PAcceptIncoming (`b-i2paccept`)](https://doxygen.bitcoincore.org/class_c_connman.html#i2paccept)
     : Listens for and accepts incoming I2P connections through the I2P SAM proxy.
 
 ## General Bitcoin Core
diff --git a/src/bitcoind.cpp b/src/bitcoind.cpp
index ac7315876830..472ff381a82f 100644
--- a/src/bitcoind.cpp
+++ b/src/bitcoind.cpp
@@ -258,6 +258,7 @@ static bool AppInit(NodeContext& node)
     return fRet;
 }
 
+/// \anchor main
 MAIN_FUNCTION
 {
     NodeContext node;
diff --git a/src/checkqueue.h b/src/checkqueue.h
index 5258d7113e65..1e265525df8d 100644
--- a/src/checkqueue.h
+++ b/src/checkqueue.h
@@ -68,6 +68,7 @@ class CCheckQueue
     std::vector<std::thread> m_worker_threads;
     bool m_request_stop GUARDED_BY(m_mutex){false};
 
+    /// \anchor checkqueue
     /** Internal function that does bulk of the verification work. If fMaster, return the final result. */
     std::optional<R> Loop(bool fMaster) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
     {
diff --git a/src/init.cpp b/src/init.cpp
index aee117481243..beee32d6254f 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1821,6 +1821,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         vImportFiles.push_back(fs::PathFromString(strFile));
     }
 
+    /// \anchor initload
     node.background_init_thread = std::thread(&util::TraceThread, "initload", [=, &chainman, &args, &node] {
         ScheduleBatchPriority();
         // Import blocks and ActivateBestChain()
diff --git a/src/mapport.cpp b/src/mapport.cpp
index 43918ebf1019..1b079fafea2b 100644
--- a/src/mapport.cpp
+++ b/src/mapport.cpp
@@ -119,6 +119,7 @@ static void ProcessPCP()
     // we rather just choose a fairly short expiry time.
 }
 
+/// \anchor mapport
 static void ThreadMapPort()
 {
     do {
diff --git a/src/net.h b/src/net.h
index 9bc1f7da35a2..37e50207bca0 100644
--- a/src/net.h
+++ b/src/net.h
@@ -1425,6 +1425,7 @@ class CConnman
     bool Bind(const CService& addr, unsigned int flags, NetPermissionFlags permissions);
     bool InitBinds(const Options& options);
 
+    /// \anchor addcon
     void ThreadOpenAddedConnections() EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex,
                                                                !m_nodes_mutex,
                                                                !m_reconnections_mutex,
@@ -1436,6 +1437,7 @@ class CConnman
                                                      !m_nodes_mutex,
                                                      !m_unused_i2p_sessions_mutex);
 
+    /// \anchor opencon
     void ThreadOpenConnections(std::vector<std::string> connect, std::span<const std::string> seed_nodes)
         EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex,
                                  !m_addr_fetches_mutex,
@@ -1443,7 +1445,9 @@ class CConnman
                                  !m_reconnections_mutex,
                                  !m_unused_i2p_sessions_mutex);
 
+    /// \anchor msghand
     void ThreadMessageHandler() EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !mutexMsgProc);
+    /// \anchor i2paccept
     void ThreadI2PAcceptIncoming() EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
     void ThreadPrivateBroadcast() EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex, !m_unused_i2p_sessions_mutex);
     void AcceptConnection(const ListenSocket& hListenSocket) EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
@@ -1495,7 +1499,9 @@ class CConnman
     void SocketHandlerListening(const Sock::EventsPerSock& events_per_sock)
         EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex);
 
+    /// \anchor net
     void ThreadSocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex, !mutexMsgProc, !m_nodes_mutex, !m_reconnections_mutex);
+    /// \anchor dnsseed
     void ThreadDNSAddressSeed() EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex, !m_nodes_mutex);
 
     uint64_t CalculateKeyedNetGroup(const CNetAddr& ad) const;
diff --git a/src/scheduler.h b/src/scheduler.h
index 5d4affb0ab8b..0a05f6cb71ff 100644
--- a/src/scheduler.h
+++ b/src/scheduler.h
@@ -70,6 +70,7 @@ class CScheduler
     void MockForward(std::chrono::seconds delta_seconds) EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex);
 
     /**
+     * \anchor scheduler
      * Services the queue 'forever'. Should be run in a thread.
      */
     void serviceQueue() EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex);
diff --git a/src/torcontrol.h b/src/torcontrol.h
index 75b81b87b2d9..410cb0b368c3 100644
--- a/src/torcontrol.h
+++ b/src/torcontrol.h
@@ -151,7 +151,8 @@ class TorController
     std::vector<uint8_t> m_cookie;
     /** ClientNonce for SAFECOOKIE auth */
     std::vector<uint8_t> m_client_nonce;
-    /** Main control thread */
+
+    /// \anchor torcontrol
     void ThreadControl();
 
 public:

From 19655b5ea4c0508f3f19f140cecc56bd50d7d202 Mon Sep 17 00:00:00 2001
From: rustaceanrob <rob.netzke@gmail.com>
Date: Thu, 28 May 2026 17:28:12 +0100
Subject: [PATCH 10/10] Fix IWYU

---
 src/bench/block_assemble.cpp |  4 ++--
 src/bench/connectblock.cpp   | 16 ++++++++++++----
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/src/bench/block_assemble.cpp b/src/bench/block_assemble.cpp
index 87bf80d9b488..191357fa6621 100644
--- a/src/bench/block_assemble.cpp
+++ b/src/bench/block_assemble.cpp
@@ -3,9 +3,10 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <bench/bench.h>
+#include <chainstate.h>
 #include <consensus/consensus.h>
 #include <mempool_validation.h>
-#include <node/miner.h>
+#include <node/mining_types.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <script/script.h>
@@ -13,7 +14,6 @@
 #include <test/util/mining.h>
 #include <test/util/script.h>
 #include <test/util/setup_common.h>
-#include <chainstate.h>
 
 #include <array>
 #include <cassert>
diff --git a/src/bench/connectblock.cpp b/src/bench/connectblock.cpp
index 6da4e6116f7d..eaeaf675d915 100644
--- a/src/bench/connectblock.cpp
+++ b/src/bench/connectblock.cpp
@@ -5,12 +5,20 @@
 #include <addresstype.h>
 #include <bench/bench.h>
 #include <block_validation.h>
-#include <interfaces/chain.h>
-#include <kernel/cs_main.h>
-#include <script/interpreter.h>
+#include <chain.h>
+#include <chainstate.h>
+#include <coins.h>
+#include <consensus/amount.h>
+#include <consensus/validation.h>
+#include <key.h>
+#include <node/blockstorage.h>
+#include <policy/feerate.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
+#include <pubkey.h>
+#include <script/script.h>
 #include <sync.h>
 #include <test/util/setup_common.h>
-#include <chainstate.h>
 
 #include <cassert>
 #include <cstddef>