From 63ee9cd15b628abe3f1ce1427938c945fe1534d6 Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Thu, 12 Feb 2026 12:14:12 +0100
Subject: [PATCH 01/15] test: misc interface_ipc_mining.py improvements

- clarify run_ipc_option_override_test description: https://github.com/bitcoin/bitcoin/pull/33965#discussion_r2784515535
- trailing comma after includes: https://github.com/bitcoin/bitcoin/pull/34452#discussion_r2775183035
- include order: https://github.com/bitcoin/bitcoin/pull/34452#discussion_r2774730966
- reuse the shared miniwallet in the low block height test: https://github.com/bitcoin/bitcoin/pull/34860#discussion_r3255163123
---
 test/functional/interface_ipc_mining.py | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/test/functional/interface_ipc_mining.py b/test/functional/interface_ipc_mining.py
index 2740662f1c0..389b7f13d6d 100755
--- a/test/functional/interface_ipc_mining.py
+++ b/test/functional/interface_ipc_mining.py
@@ -9,35 +9,35 @@ from contextlib import AsyncExitStack
 from io import BytesIO
 from test_framework.blocktools import NULL_OUTPOINT, script_BIP34_coinbase_height
 from test_framework.messages import (
-    MAX_BLOCK_WEIGHT,
     CBlockHeader,
+    COIN,
     CTransaction,
     CTxIn,
-    CTxOut,
     CTxInWitness,
-    ser_uint256,
-    COIN,
+    CTxOut,
+    MAX_BLOCK_WEIGHT,
     from_hex,
     msg_headers,
+    ser_uint256,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_greater_than_or_equal,
-    assert_not_equal
+    assert_not_equal,
 )
 from test_framework.wallet import MiniWallet
 from test_framework.p2p import P2PInterface
 from test_framework.ipc_util import (
+    assert_capnp_failed,
     destroying,
-    mining_create_block_template,
     load_capnp_modules,
+    make_mining_ctx,
+    mining_create_block_template,
     mining_get_block,
     mining_get_coinbase_tx,
     mining_wait_next_template,
     wait_and_do,
-    make_mining_ctx,
-    assert_capnp_failed
 )
 
 # Test may be skipped and not have capnp installed
@@ -291,8 +291,9 @@ class IPCMiningTest(BitcoinTestFramework):
 
     def run_ipc_option_override_test(self):
         self.log.info("Running IPC option override test")
-        # Set an absurd reserved weight. `-blockreservedweight` is RPC-only, so
-        # with this setting RPC templates would be empty. IPC clients set
+        # Confirm that BlockCreateOptions.blockReservedWeight takes precedence
+        # over -blockreservedweight. Set an absurdly high -blockreservedweight
+        # value that would result in empty blocks to verify this. IPC clients set
         # blockReservedWeight per template request and are unaffected; later in
         # the test the IPC template includes a mempool transaction.
         self.restart_node(0, extra_args=[f"-blockreservedweight={MAX_BLOCK_WEIGHT}"])
@@ -421,8 +422,6 @@ class IPCMiningTest(BitcoinTestFramework):
         node.wait_for_rpc_connection()
         assert_equal(node.getblockcount(), 0)
 
-        miniwallet = MiniWallet(node)
-
         async def async_routine():
             ctx, mining = await make_mining_ctx(self)
             opts = self.capnp_modules['mining'].BlockCreateOptions()
@@ -437,7 +436,7 @@ class IPCMiningTest(BitcoinTestFramework):
                     block = await mining_get_block(template, ctx)
                     # Heights <= 16 need extra nonce padding.
                     extra_nonce = b'\xaa\xbb\xcc\xdd' if height <= 16 else b""
-                    coinbase = await self.build_coinbase_test(template, ctx, miniwallet, extra_nonce=extra_nonce)
+                    coinbase = await self.build_coinbase_test(template, ctx, self.miniwallet, extra_nonce=extra_nonce)
                     block.vtx[0] = coinbase
                     block.hashMerkleRoot = block.calc_merkle_root()
                     block.solve()

From 24750f8b31a42c468e49baa2c584ebddb4bc15fb Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Wed, 25 Mar 2026 18:10:10 +0100
Subject: [PATCH 02/15] test: add createNewBlock failure helper

Move the IPC createNewBlock failure assertion into ipc_util.py so
later invalid mining option tests can share the same remote exception check.
---
 test/functional/interface_ipc_mining.py    | 8 +++-----
 test/functional/test_framework/ipc_util.py | 9 +++++++++
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/test/functional/interface_ipc_mining.py b/test/functional/interface_ipc_mining.py
index 389b7f13d6d..e78a21f7c02 100755
--- a/test/functional/interface_ipc_mining.py
+++ b/test/functional/interface_ipc_mining.py
@@ -30,6 +30,7 @@ from test_framework.wallet import MiniWallet
 from test_framework.p2p import P2PInterface
 from test_framework.ipc_util import (
     assert_capnp_failed,
+    assert_create_new_block_fails,
     destroying,
     load_capnp_modules,
     make_mining_ctx,
@@ -318,11 +319,8 @@ class IPCMiningTest(BitcoinTestFramework):
 
             self.log.debug("Enforce minimum reserved weight for IPC clients too")
             opts.blockReservedWeight = 0
-            try:
-                await mining.createNewBlock(ctx, opts)
-                raise AssertionError("createNewBlock unexpectedly succeeded")
-            except capnp.lib.capnp.KjException as e:
-                assert_capnp_failed(e, "remote exception: std::exception: block_reserved_weight (0) must be at least 2000 weight units")
+            await assert_create_new_block_fails(ctx, mining, opts,
+                "block_reserved_weight (0) must be at least 2000 weight units")
 
         asyncio.run(capnp.run(async_routine()))
 
diff --git a/test/functional/test_framework/ipc_util.py b/test/functional/test_framework/ipc_util.py
index 340cd15c618..5ce582372f8 100644
--- a/test/functional/test_framework/ipc_util.py
+++ b/test/functional/test_framework/ipc_util.py
@@ -162,3 +162,12 @@ async def make_mining_ctx(self):
 def assert_capnp_failed(e, description_prefix):
     assert e.description.startswith(description_prefix), f"Expected description starting with '{description_prefix}', got '{e.description}'"
     assert_equal(e.type, "FAILED")
+
+
+async def assert_create_new_block_fails(ctx, mining, opts, expected_msg):
+    """Assert that mining.createNewBlock fails with the expected remote exception."""
+    try:
+        await mining.createNewBlock(ctx, opts)
+        raise AssertionError("createNewBlock unexpectedly succeeded")
+    except capnp.lib.capnp.KjException as e:
+        assert_capnp_failed(e, f"remote exception: std::exception: {expected_msg}")

From 63b23ea1e94f8f1f74e24abbadf2e5de3148f396 Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Tue, 12 May 2026 15:56:56 +0200
Subject: [PATCH 03/15] test: regression test for waitNext mining policy

Demonstrates that BlockTemplateImpl::waitNext() must respect the
mining policy supplied via -blockmintxfee, not silently fall back
to defaults.

Co-authored-by: Enoch Azariah <enirox001@gmail.com>
---
 test/functional/interface_ipc_mining.py | 56 +++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/test/functional/interface_ipc_mining.py b/test/functional/interface_ipc_mining.py
index e78a21f7c02..d09bc538819 100755
--- a/test/functional/interface_ipc_mining.py
+++ b/test/functional/interface_ipc_mining.py
@@ -6,6 +6,7 @@
 import asyncio
 import time
 from contextlib import AsyncExitStack
+from decimal import Decimal
 from io import BytesIO
 from test_framework.blocktools import NULL_OUTPOINT, script_BIP34_coinbase_height
 from test_framework.messages import (
@@ -324,6 +325,57 @@ class IPCMiningTest(BitcoinTestFramework):
 
         asyncio.run(capnp.run(async_routine()))
 
+    def run_waitnext_mining_policy_test(self):
+        """Verify that waitNext() preserves the mining policy from -blockmintxfee
+        instead of falling back to defaults."""
+        self.log.info("Running waitNext mining policy test")
+        block_min_tx_fee = Decimal("0.00002000")
+        below_block_min_tx_fee = Decimal("0.00001000")
+        above_block_min_tx_fee = Decimal("0.00003000")
+
+        self.restart_node(0, extra_args=[
+            f"-blockmintxfee={block_min_tx_fee:.8f}",
+            "-minrelaytxfee=0",
+            "-persistmempool=0",
+        ])
+
+        async def async_routine():
+            ctx, mining = await make_mining_ctx(self)
+
+            self.log.debug("Create a below -blockmintxfee transaction")
+            low_fee_tx = self.miniwallet.send_self_transfer(
+                fee_rate=below_block_min_tx_fee,
+                from_node=self.nodes[0],
+                confirmed_only=True,
+            )
+            assert low_fee_tx["txid"] in self.nodes[0].getrawmempool()
+
+            async with AsyncExitStack() as stack:
+                self.log.debug("createNewBlock should respect -blockmintxfee")
+                template = await mining_create_block_template(mining, stack, ctx, self.default_block_create_options)
+                assert template is not None
+                block = await mining_get_block(template, ctx)
+                assert low_fee_tx["txid"] not in {tx.txid_hex for tx in block.vtx[1:]}
+
+                self.log.debug("waitNext should preserve the same mining policy")
+                high_fee_tx = self.miniwallet.send_self_transfer(
+                    fee_rate=above_block_min_tx_fee,
+                    from_node=self.nodes[0],
+                    confirmed_only=True,
+                )
+                mempool_txids = self.nodes[0].getrawmempool()
+                assert high_fee_tx["txid"] in mempool_txids
+                assert low_fee_tx["txid"] in mempool_txids
+                template_next = await mining_wait_next_template(template, stack, ctx, self.default_block_wait_options)
+                assert template_next is not None
+
+                block_next = await mining_get_block(template_next, ctx)
+                block_next_txids = {tx.txid_hex for tx in block_next.vtx[1:]}
+                assert high_fee_tx["txid"] in block_next_txids
+                assert low_fee_tx["txid"] not in block_next_txids
+
+        asyncio.run(capnp.run(async_routine()))
+
     def run_coinbase_and_submission_test(self):
         """Test coinbase construction (getCoinbaseTx) and block submission (submitSolution)."""
         self.log.info("Running coinbase construction and submission test")
@@ -447,10 +499,14 @@ class IPCMiningTest(BitcoinTestFramework):
     def run_test(self):
         self.miniwallet = MiniWallet(self.nodes[0])
         self.default_block_create_options = self.capnp_modules['mining'].BlockCreateOptions()
+        self.default_block_wait_options = self.capnp_modules['mining'].BlockWaitOptions()
+        self.default_block_wait_options.timeout = 1000.0 * self.options.timeout_factor
+        self.default_block_wait_options.feeThreshold = 1
         self.run_mining_interface_test()
         self.run_early_startup_test()
         self.run_block_template_test()
         self.run_coinbase_and_submission_test()
+        self.run_waitnext_mining_policy_test()
         self.run_ipc_option_override_test()
 
         # Needs to run last because it resets the chain.

From 6aeb1fbea2399bf28b00d128126cd28409e9b0c0 Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Thu, 14 May 2026 08:25:35 +0200
Subject: [PATCH 04/15] test: cover IPC blockmaxweight policy

Verify that -blockmaxweight is honored both when an IPC block template is first created and after waitNext() refreshes the template.

Co-authored-by: w0xlt <94266259+w0xlt@users.noreply.github.com>
---
 test/functional/interface_ipc_mining.py | 61 +++++++++++++++++++++++++
 1 file changed, 61 insertions(+)

diff --git a/test/functional/interface_ipc_mining.py b/test/functional/interface_ipc_mining.py
index d09bc538819..710a9a2d82c 100755
--- a/test/functional/interface_ipc_mining.py
+++ b/test/functional/interface_ipc_mining.py
@@ -16,6 +16,7 @@ from test_framework.messages import (
     CTxIn,
     CTxInWitness,
     CTxOut,
+    DEFAULT_BLOCK_RESERVED_WEIGHT,
     MAX_BLOCK_WEIGHT,
     from_hex,
     msg_headers,
@@ -376,6 +377,65 @@ class IPCMiningTest(BitcoinTestFramework):
 
         asyncio.run(capnp.run(async_routine()))
 
+    def run_block_max_weight_test(self):
+        """Verify IPC createNewBlock() and waitNext() preserve the -blockmaxweight policy."""
+        self.log.info("Running block_max_weight test")
+
+        # Cap that leaves room for only a handful of mempool transactions
+        # above DEFAULT_BLOCK_RESERVED_WEIGHT (8000). Well below MAX_BLOCK_WEIGHT
+        # (4_000_000), so any truncation observed here is attributable to the
+        # cap, not to consensus limits or wallet chain limits.
+        small_cap = DEFAULT_BLOCK_RESERVED_WEIGHT + 4000
+        NUM_TXS = 20
+
+        self.restart_node(0, extra_args=[
+            f"-blockmaxweight={small_cap}",
+            "-minrelaytxfee=0",
+            "-persistmempool=0",
+        ])
+        # Refresh miniwallet's UTXO view from the chain after restart.
+        self.miniwallet.rescan_utxos()
+
+        # Fill the mempool enough that the configured block weight cap forces
+        # template truncation.
+        for _ in range(NUM_TXS):
+            self.miniwallet.send_self_transfer(from_node=self.nodes[0], confirmed_only=True)
+        assert_equal(self.nodes[0].getmempoolinfo()["size"], NUM_TXS)
+
+        async def async_routine():
+            ctx, mining = await make_mining_ctx(self)
+            async with AsyncExitStack() as stack:
+                template = await mining_create_block_template(mining, stack, ctx, self.default_block_create_options)
+                assert template is not None
+                block = await mining_get_block(template, ctx)
+                assert_greater_than_or_equal(small_cap, block.get_weight())
+                # Exclude the coinbase; the cap must have forced truncation.
+                initial_included = len(block.vtx) - 1
+                assert initial_included < NUM_TXS, (
+                    f"Expected -blockmaxweight={small_cap} to truncate; "
+                    f"included {initial_included}/{NUM_TXS} mempool txs"
+                )
+
+                self.log.debug("waitNext should preserve -blockmaxweight")
+                high_fee_tx = self.miniwallet.send_self_transfer(
+                    from_node=self.nodes[0],
+                    confirmed_only=True,
+                    fee_rate=10,
+                )
+                template_next = await mining_wait_next_template(template, stack, ctx, self.default_block_wait_options)
+                assert template_next is not None
+
+                block_next = await mining_get_block(template_next, ctx)
+                assert_greater_than_or_equal(small_cap, block_next.get_weight())
+                assert high_fee_tx["txid"] in {tx.txid_hex for tx in block_next.vtx[1:]}
+                next_included = len(block_next.vtx) - 1
+                assert next_included < NUM_TXS + 1, (
+                    f"Expected -blockmaxweight={small_cap} to remain capped after waitNext; "
+                    f"included {next_included}/{NUM_TXS + 1} mempool txs"
+                )
+
+        asyncio.run(capnp.run(async_routine()))
+
     def run_coinbase_and_submission_test(self):
         """Test coinbase construction (getCoinbaseTx) and block submission (submitSolution)."""
         self.log.info("Running coinbase construction and submission test")
@@ -507,6 +567,7 @@ class IPCMiningTest(BitcoinTestFramework):
         self.run_block_template_test()
         self.run_coinbase_and_submission_test()
         self.run_waitnext_mining_policy_test()
+        self.run_block_max_weight_test()
         self.run_ipc_option_override_test()
 
         # Needs to run last because it resets the chain.

From d4368e059cfe09d973a238d08cbe6812511366d3 Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Thu, 4 Dec 2025 14:10:20 +0100
Subject: [PATCH 05/15] move-only: add node/mining_types.h

Move mining related structs there.

This simplifies includes in later commits and makes the code easier to
understand for Mining IPC client developers.
---
 src/interfaces/mining.h |   4 +-
 src/node/miner.h        |   1 +
 src/node/mining_types.h | 151 ++++++++++++++++++++++++++++++++++++++++
 src/node/types.h        | 129 ----------------------------------
 src/test/util/mining.h  |   2 +-
 5 files changed, 154 insertions(+), 133 deletions(-)
 create mode 100644 src/node/mining_types.h

diff --git a/src/interfaces/mining.h b/src/interfaces/mining.h
index 943d34e75d9..ca4f73813b9 100644
--- a/src/interfaces/mining.h
+++ b/src/interfaces/mining.h
@@ -8,6 +8,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>
@@ -22,9 +23,6 @@ namespace node {
 struct NodeContext;
 } // namespace node
 
-class BlockValidationState;
-class CScript;
-
 namespace interfaces {
 
 //! Block template interface
diff --git a/src/node/miner.h b/src/node/miner.h
index 5c8668771f5..c5d21cfc322 100644
--- a/src/node/miner.h
+++ b/src/node/miner.h
@@ -8,6 +8,7 @@
 
 #include <interfaces/types.h>
 #include <node/types.h>
+#include <node/mining_types.h>
 #include <policy/policy.h>
 #include <primitives/block.h>
 #include <txmempool.h>
diff --git a/src/node/mining_types.h b/src/node/mining_types.h
new file mode 100644
index 00000000000..69088bb7187
--- /dev/null
+++ b/src/node/mining_types.h
@@ -0,0 +1,151 @@
+// 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 <consensus/consensus.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 {
+
+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;
+};
+
+} // namespace node
+
+#endif // BITCOIN_NODE_MINING_TYPES_H
diff --git a/src/node/types.h b/src/node/types.h
index d228fa41db6..5124b983112 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/util/mining.h b/src/test/util/mining.h
index 9be01507d39..2bd539379b8 100644
--- a/src/test/util/mining.h
+++ b/src/test/util/mining.h
@@ -14,8 +14,8 @@
 class CBlock;
 class CChainParams;
 class COutPoint;
-class CScript;
 namespace node {
+struct BlockCreateOptions;
 struct NodeContext;
 } // namespace node
 

From 44082bea47942072992cbde4d6f96253c7f79284 Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Mon, 18 May 2026 12:18:20 +0200
Subject: [PATCH 06/15] interfaces: make Mining use const NodeContext

The next commit switches test helpers that take a const NodeContext& to
create blocks through the Mining interface, so MakeMining needs to
accept a const NodeContext too.
---
 src/interfaces/mining.h |  4 ++--
 src/node/interfaces.cpp | 18 +++++++++---------
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/interfaces/mining.h b/src/interfaces/mining.h
index ca4f73813b9..30dade3e05f 100644
--- a/src/interfaces/mining.h
+++ b/src/interfaces/mining.h
@@ -159,7 +159,7 @@ public:
 
     //! 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.
@@ -167,7 +167,7 @@ public:
 //! @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/interfaces.cpp b/src/node/interfaces.cpp
index 16db8692a15..7abd4b75b2c 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -869,9 +869,9 @@ class BlockTemplateImpl : public BlockTemplate
 public:
     explicit BlockTemplateImpl(BlockAssembler::Options assemble_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_assemble_options(std::move(assemble_options)),
+                                                          m_block_template(std::move(block_template)),
+                                                          m_node(node)
     {
         assert(m_block_template);
     }
@@ -931,13 +931,13 @@ public:
     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
     {
@@ -993,7 +993,7 @@ public:
 
         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);
+        return std::make_unique<BlockTemplateImpl>(assemble_options, BlockAssembler{chainman().ActiveChainstate(), m_node.mempool.get(), assemble_options}.CreateNewBlock(), m_node);
     }
 
     void interrupt() override
@@ -1010,12 +1010,12 @@ public:
         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;
 };
 
 class RpcImpl : public Rpc
@@ -1041,7 +1041,7 @@ public:
 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));

From 020166080cf57e6eb869abc56d603eb1d6e5e45b Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Thu, 4 Dec 2025 13:47:08 +0100
Subject: [PATCH 07/15] mining: use interface for tests, bench and fuzzers

Have most tests, benchmarks and fuzzers go through the mining interface.
This is a refactor: it does not change what blocks are created, just how
the creation calls are made. This avoids most direct test, benchmark and
fuzzer use of node::BlockAssembler::Options, making it easier to drop in a
later commit.

Two exceptions which use BlockAssembler directly:
- one check in test/miner_tests.cpp needs m_package_feerates
- fuzz/tx_pool.cpp Finish() doesn't have access to a NodeContext

Move test_block_validity from BlockAssembler::Options to
BlockCreateOptions so bench/block_assemble.cpp can continue to set it.
Just like coinbase_output_script, this is not exposed to IPC clients.

Inline options variable in places where it's only needed once.

We also drop one unused PrepareBlock declaration and one unused
implementation.

TestChain100Setup::CreateBlock no longer needs a chainstate argument,
which in turn means it can be dropped from CreateAndProcessBlock. Using
the Mining interface here also requires marking the test
KernelNotifications chainstate as loaded after LoadVerifyActivateChainstate().
---
 src/bench/block_assemble.cpp             | 15 +++++++------
 src/bench/connectblock.cpp               |  4 ++--
 src/node/miner.h                         |  2 --
 src/node/mining_types.h                  |  5 +++++
 src/test/blockfilter_index_tests.cpp     | 13 ++++++-----
 src/test/coinstatsindex_tests.cpp        |  2 +-
 src/test/fuzz/package_eval.cpp           |  8 +++----
 src/test/fuzz/process_message.cpp        |  2 +-
 src/test/fuzz/process_messages.cpp       |  2 +-
 src/test/fuzz/tx_pool.cpp                |  7 +++---
 src/test/fuzz/utxo_total_supply.cpp      |  8 +++----
 src/test/miner_tests.cpp                 | 28 ++++++++++++++++--------
 src/test/peerman_tests.cpp               |  9 +++++---
 src/test/testnet4_miner_tests.cpp        |  7 +++---
 src/test/util/mining.cpp                 | 27 ++++++++---------------
 src/test/util/mining.h                   |  5 ++---
 src/test/util/setup_common.cpp           | 26 +++++++++++-----------
 src/test/util/setup_common.h             | 13 ++---------
 src/test/validation_block_tests.cpp      | 22 +++++++++++--------
 src/test/validation_chainstate_tests.cpp |  4 +++-
 20 files changed, 104 insertions(+), 105 deletions(-)

diff --git a/src/bench/block_assemble.cpp b/src/bench/block_assemble.cpp
index 297465be80f..9bc159229ee 100644
--- a/src/bench/block_assemble.cpp
+++ b/src/bench/block_assemble.cpp
@@ -20,7 +20,7 @@
 #include <memory>
 #include <vector>
 
-using node::BlockAssembler;
+using node::BlockCreateOptions;
 
 static void AssembleBlock(benchmark::Bench& bench)
 {
@@ -28,8 +28,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};
@@ -60,12 +61,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 434bcdcbfe2..ba2d9048770 100644
--- a/src/bench/connectblock.cpp
+++ b/src/bench/connectblock.cpp
@@ -39,7 +39,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);
@@ -59,7 +59,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/node/miner.h b/src/node/miner.h
index c5d21cfc322..73003d18c31 100644
--- a/src/node/miner.h
+++ b/src/node/miner.h
@@ -83,8 +83,6 @@ public:
         // 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};
     };
 
diff --git a/src/node/mining_types.h b/src/node/mining_types.h
index 69088bb7187..4a2ef0527d3 100644
--- a/src/node/mining_types.h
+++ b/src/node/mining_types.h
@@ -62,6 +62,11 @@ struct BlockCreateOptions {
      * 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 {
diff --git a/src/test/blockfilter_index_tests.cpp b/src/test/blockfilter_index_tests.cpp
index b77942f741d..a26f34112de 100644
--- a/src/test/blockfilter_index_tests.cpp
+++ b/src/test/blockfilter_index_tests.cpp
@@ -8,6 +8,7 @@
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
 #include <index/blockfilterindex.h>
+#include <interfaces/mining.h>
 #include <interfaces/chain.h>
 #include <node/miner.h>
 #include <pow.h>
@@ -20,9 +21,7 @@
 #include <boost/test/unit_test.hpp>
 #include <future>
 
-using node::BlockAssembler;
 using node::BlockManager;
-using node::CBlockTemplate;
 
 BOOST_AUTO_TEST_SUITE(blockfilter_index_tests)
 
@@ -69,10 +68,12 @@ CBlock BuildChainTestingSetup::CreateBlock(const CBlockIndex* prev,
     const std::vector<CMutableTransaction>& txns,
     const CScript& scriptPubKey)
 {
-    BlockAssembler::Options options;
-    options.coinbase_output_script = scriptPubKey;
-    std::unique_ptr<CBlockTemplate> pblocktemplate = BlockAssembler{m_node.chainman->ActiveChainstate(), m_node.mempool.get(), options}.CreateNewBlock();
-    CBlock& block = pblocktemplate->block;
+    auto mining{interfaces::MakeMining(m_node)};
+    auto block_template{mining->createNewBlock({
+        .coinbase_output_script = scriptPubKey,
+    }, /*cooldown=*/false)};
+    BOOST_REQUIRE(block_template);
+    CBlock block{block_template->getBlock()};
     block.hashPrevBlock = prev->GetBlockHash();
     block.nTime = prev->nTime + 1;
 
diff --git a/src/test/coinstatsindex_tests.cpp b/src/test/coinstatsindex_tests.cpp
index f7f97c9b371..e4755ed6271 100644
--- a/src/test/coinstatsindex_tests.cpp
+++ b/src/test/coinstatsindex_tests.cpp
@@ -83,7 +83,7 @@ BOOST_FIXTURE_TEST_CASE(coinstatsindex_unclean_shutdown, TestChain100Setup)
         CBlockIndex* new_block_index = nullptr;
         {
             const CScript script_pub_key{CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG};
-            const CBlock block = this->CreateBlock({}, script_pub_key, chainstate);
+            const CBlock block = this->CreateBlock({}, script_pub_key);
 
             new_block = std::make_shared<CBlock>(block);
 
diff --git a/src/test/fuzz/package_eval.cpp b/src/test/fuzz/package_eval.cpp
index 1cc2caa396e..c87a36517f6 100644
--- a/src/test/fuzz/package_eval.cpp
+++ b/src/test/fuzz/package_eval.cpp
@@ -21,7 +21,6 @@
 #include <validation.h>
 #include <validationinterface.h>
 
-using node::BlockAssembler;
 using node::NodeContext;
 
 namespace {
@@ -44,11 +43,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 d8a91d7f90a..dd95a5fc0fd 100644
--- a/src/test/fuzz/process_message.cpp
+++ b/src/test/fuzz/process_message.cpp
@@ -42,7 +42,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 314388fac07..d3a3ccb6fc3 100644
--- a/src/test/fuzz/process_messages.cpp
+++ b/src/test/fuzz/process_messages.cpp
@@ -36,7 +36,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 f70dd710b35..7daed7237ec 100644
--- a/src/test/fuzz/tx_pool.cpp
+++ b/src/test/fuzz/tx_pool.cpp
@@ -46,11 +46,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 :
diff --git a/src/test/fuzz/utxo_total_supply.cpp b/src/test/fuzz/utxo_total_supply.cpp
index b281f20028e..9e227234e35 100644
--- a/src/test/fuzz/utxo_total_supply.cpp
+++ b/src/test/fuzz/utxo_total_supply.cpp
@@ -19,8 +19,6 @@
 #include <util/time.h>
 #include <validation.h>
 
-using node::BlockAssembler;
-
 FUZZ_TARGET(utxo_total_supply)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
@@ -44,11 +42,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 124ef08500c..5b5b6c3aded 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -37,6 +37,7 @@ using namespace util::hex_literals;
 using interfaces::BlockTemplate;
 using interfaces::Mining;
 using node::BlockAssembler;
+using node::BlockCreateOptions;
 
 namespace miner_tests {
 struct MinerTestingSetup : public TestingSetup {
@@ -115,8 +116,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);
@@ -175,7 +177,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,
+        {}
+    }.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.
@@ -333,8 +340,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()};
@@ -659,8 +667,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);
@@ -748,8 +757,9 @@ 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);
diff --git a/src/test/peerman_tests.cpp b/src/test/peerman_tests.cpp
index 36a66b14eb5..1681b8760e4 100644
--- a/src/test/peerman_tests.cpp
+++ b/src/test/peerman_tests.cpp
@@ -3,6 +3,7 @@
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
+#include <interfaces/mining.h>
 #include <node/miner.h>
 #include <net_processing.h>
 #include <pow.h>
@@ -16,12 +17,14 @@ 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 c501b4eb086..c5b144d44ae 100644
--- a/src/test/testnet4_miner_tests.cpp
+++ b/src/test/testnet4_miner_tests.cpp
@@ -15,7 +15,6 @@
 
 using interfaces::BlockTemplate;
 using interfaces::Mining;
-using node::BlockAssembler;
 using node::BlockWaitOptions;
 
 namespace testnet4_miner_tests {
@@ -35,18 +34,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 05f1be77ee2..6191f91b8f1 100644
--- a/src/test/util/mining.cpp
+++ b/src/test/util/mining.cpp
@@ -7,6 +7,7 @@
 #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>
@@ -20,17 +21,15 @@
 #include <algorithm>
 #include <memory>
 
-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)
@@ -68,7 +67,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);
@@ -122,12 +121,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;
@@ -135,10 +133,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 2bd539379b8..e15b8a0bada 100644
--- a/src/test/util/mining.h
+++ b/src/test/util/mining.h
@@ -24,7 +24,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 +38,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 8f2f70a3576..09b6c9c7ddc 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -13,6 +13,7 @@
 #include <consensus/validation.h>
 #include <crypto/sha256.h>
 #include <init.h>
+#include <interfaces/mining.h>
 #include <init/common.h>
 #include <interfaces/chain.h>
 #include <kernel/mempool_entry.h>
@@ -67,7 +68,6 @@
 
 using namespace util::hex_literals;
 using node::ApplyArgsManOptions;
-using node::BlockAssembler;
 using node::BlockManager;
 using node::KernelNotifications;
 using node::LoadChainstate;
@@ -335,6 +335,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()));
@@ -411,12 +413,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) {
@@ -431,14 +436,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);
     Assert(m_node.chainman)->ProcessNewBlock(shared_pblock, true, true, nullptr);
 
diff --git a/src/test/util/setup_common.h b/src/test/util/setup_common.h
index 8b1b0632185..6ab63ec9322 100644
--- a/src/test/util/setup_common.h
+++ b/src/test/util/setup_common.h
@@ -28,12 +28,7 @@
 #include <type_traits>
 #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 e1f90477fc4..2d3d5d65c20 100644
--- a/src/test/validation_block_tests.cpp
+++ b/src/test/validation_block_tests.cpp
@@ -7,6 +7,7 @@
 #include <chainparams.h>
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
+#include <interfaces/mining.h>
 #include <node/miner.h>
 #include <pow.h>
 #include <random.h>
@@ -21,7 +22,6 @@
 #include <thread>
 
 using kernel::ChainstateRole;
-using node::BlockAssembler;
 
 namespace validation_block_tests {
 struct MinerTestingSetup : public RegTestingSetup {
@@ -67,10 +67,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;
 
@@ -335,10 +337,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 38a04d8e46c..4d7c8334a2d 100644
--- a/src/test/validation_chainstate_tests.cpp
+++ b/src/test/validation_chainstate_tests.cpp
@@ -24,6 +24,8 @@
 
 #include <boost/test/unit_test.hpp>
 
+class CTxMemPool;
+
 BOOST_FIXTURE_TEST_SUITE(validation_chainstate_tests, ChainTestingSetup)
 
 //! Test resizing coins-related Chainstate caches during runtime.
@@ -83,7 +85,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(Assert(m_node.chainman)->ProcessNewBlock(std::make_shared<CBlock>(block), true, true, nullptr));
 
     LOCK(cs_main);

From fa81e51eaeeabb5e3e1b1419fad912af4cde40a4 Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Thu, 12 Feb 2026 19:25:26 +0100
Subject: [PATCH 08/15] mining: parse block creation args in mining_args

Move the argument parsing for -blockmaxweight, -blockreservedweight,
-blockmintxfee out of init.cpp to a dedicated mining_args.cpp.

This is mostly a refactor and keeps the existing validation checks. It
does switch the weight arguments to GetArg<uint64_t>, introduced in
bitcoin/bitcoin#34582, so very large or negative weight values can be
reported differently in error messages.
---
 src/CMakeLists.txt       |  1 +
 src/init.cpp             | 26 ++++------------------
 src/node/mining_args.cpp | 47 ++++++++++++++++++++++++++++++++++++++++
 src/node/mining_args.h   | 18 +++++++++++++++
 4 files changed, 70 insertions(+), 22 deletions(-)
 create mode 100644 src/node/mining_args.cpp
 create mode 100644 src/node/mining_args.h

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 439239962ab..b5f8cd1f4e7 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -232,6 +232,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/init.cpp b/src/init.cpp
index c53e5ed634c..adf94665f59 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -58,6 +58,7 @@
 #include <node/mempool_persist.h>
 #include <node/mempool_persist_args.h>
 #include <node/miner.h>
+#include <node/mining_args.h>
 #include <node/peerman_args.h>
 #include <policy/feerate.h>
 #include <policy/fees/block_policy_estimator.h>
@@ -124,7 +125,6 @@
 #include <node/data/ip_asn.dat.h>
 #endif
 
-using common::AmountErrMsg;
 using common::InvalidPortErrMsg;
 using common::ResolveErrMsg;
 
@@ -1074,27 +1074,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);
diff --git a/src/node/mining_args.cpp b/src/node/mining_args.cpp
new file mode 100644
index 00000000000..ece422a808e
--- /dev/null
+++ b/src/node/mining_args.cpp
@@ -0,0 +1,47 @@
+// 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/consensus.h>
+#include <node/mining_types.h>
+#include <tinyformat.h>
+#include <util/moneystr.h>
+#include <util/translation.h>
+
+#include <cstdint>
+
+using common::AmountErrMsg;
+using util::Error;
+using util::Result;
+
+namespace node {
+
+Result<void> ReadMiningArgs(const ArgsManager& args)
+{
+    if (const auto arg{args.GetArg("-blockmintxfee")}) {
+        if (!ParseMoney(*arg)) {
+            return Error{AmountErrMsg("blockmintxfee", *arg)};
+        }
+    }
+
+    const uint64_t max_block_weight{args.GetArg<uint64_t>("-blockmaxweight", DEFAULT_BLOCK_MAX_WEIGHT)};
+    if (max_block_weight > MAX_BLOCK_WEIGHT) {
+        return Error{strprintf(_("Specified -blockmaxweight (%d) exceeds consensus maximum block weight (%d)"), max_block_weight, MAX_BLOCK_WEIGHT)};
+    }
+
+    const uint64_t block_reserved_weight{args.GetArg<uint64_t>("-blockreservedweight", DEFAULT_BLOCK_RESERVED_WEIGHT)};
+    if (block_reserved_weight > MAX_BLOCK_WEIGHT) {
+        return Error{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 Error{strprintf(_("Specified -blockreservedweight (%d) is lower than minimum safety value of (%d)"), block_reserved_weight, MINIMUM_BLOCK_RESERVED_WEIGHT)};
+    }
+
+    return {};
+}
+
+} // namespace node
diff --git a/src/node/mining_args.h b/src/node/mining_args.h
new file mode 100644
index 00000000000..01e695ee82c
--- /dev/null
+++ b/src/node/mining_args.h
@@ -0,0 +1,18 @@
+// 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 <util/result.h>
+
+class ArgsManager;
+
+namespace node {
+
+[[nodiscard]] util::Result<void> ReadMiningArgs(const ArgsManager& args);
+
+} // namespace node
+
+#endif // BITCOIN_NODE_MINING_ARGS_H

From 128da7c3ff8071b0f2decddfbe50797c5134e41a Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Thu, 4 Dec 2025 13:51:43 +0100
Subject: [PATCH 09/15] miner: add block_max_weight to BlockCreateOptions

This new optional replaces nBlockMaxWeight.

Use uint64_t for the block weight options to match BlockAssembler's
nBlockWeight accounting and the IPC schema's blockReservedWeight type.

A negative -blockmaxweight value is now parsed as 0 instead of an
overflowed signed value before validation rejects it.

The new block_max_weight option is not exposed to IPC clients.
---
 src/node/miner.cpp        | 16 +++++++++-------
 src/node/miner.h          |  2 --
 src/node/mining_types.h   |  9 ++++++++-
 src/test/fuzz/tx_pool.cpp |  2 +-
 4 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index c9a491ef23c..41c1d997128 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -78,12 +78,12 @@ void RegenerateCommitments(CBlock& block, ChainstateManager& chainman)
 
 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);
+    // Apply DEFAULT_BLOCK_RESERVED_WEIGHT and DEFAULT_BLOCK_MAX_WEIGHT when the caller left it unset.
+    options.block_reserved_weight = std::clamp<uint64_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);
+    options.block_max_weight = std::clamp<uint64_t>(options.block_max_weight.value_or(DEFAULT_BLOCK_MAX_WEIGHT), *options.block_reserved_weight, MAX_BLOCK_WEIGHT);
     return options;
 }
 
@@ -98,13 +98,15 @@ BlockAssembler::BlockAssembler(Chainstate& chainstate, const CTxMemPool* mempool
 void ApplyArgsManOptions(const ArgsManager& args, BlockAssembler::Options& options)
 {
     // Block resource limits
-    options.nBlockMaxWeight = args.GetIntArg("-blockmaxweight", options.nBlockMaxWeight);
+    if (!options.block_max_weight) {
+        options.block_max_weight = args.GetArg<uint64_t>("-blockmaxweight");
+    }
     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");
+        options.block_reserved_weight = args.GetArg<uint64_t>("-blockreservedweight");
     }
 }
 
@@ -241,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) {
@@ -315,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;
             }
diff --git a/src/node/miner.h b/src/node/miner.h
index 73003d18c31..b579dc68893 100644
--- a/src/node/miner.h
+++ b/src/node/miner.h
@@ -80,8 +80,6 @@ private:
 
 public:
     struct Options : BlockCreateOptions {
-        // Configuration parameters for the block size
-        size_t nBlockMaxWeight{DEFAULT_BLOCK_MAX_WEIGHT};
         CFeeRate blockMinFeeRate{DEFAULT_BLOCK_MIN_TX_FEE};
         bool print_modified_fee{DEFAULT_PRINT_MODIFIED_FEE};
     };
diff --git a/src/node/mining_types.h b/src/node/mining_types.h
index 4a2ef0527d3..30206c2e87c 100644
--- a/src/node/mining_types.h
+++ b/src/node/mining_types.h
@@ -40,7 +40,14 @@ struct BlockCreateOptions {
      * Cap'n Proto IPC clients currently cannot leave this field unset, so they
      * always provide a value.
      */
-    std::optional<size_t> block_reserved_weight{};
+    std::optional<uint64_t> block_reserved_weight{};
+    /**
+     * Maximum block weight, defaults to -maxblockweight
+     *
+     * block_reserved_weight can safely exceed block_max_weight, but the rest of
+     * the block template will be empty.
+     */
+    std::optional<uint64_t> block_max_weight{};
     /**
      * The maximum additional sigops which the pool will add in coinbase
      * transaction outputs.
diff --git a/src/test/fuzz/tx_pool.cpp b/src/test/fuzz/tx_pool.cpp
index 7daed7237ec..9cada5df5b3 100644
--- a/src/test/fuzz/tx_pool.cpp
+++ b/src/test/fuzz/tx_pool.cpp
@@ -94,7 +94,7 @@ 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.block_max_weight = fuzzed_data_provider.ConsumeIntegralInRange(0U, MAX_BLOCK_WEIGHT);
         options.blockMinFeeRate = CFeeRate{ConsumeMoney(fuzzed_data_provider, /*max=*/COIN)};
         auto assembler = BlockAssembler{chainstate, &tx_pool, options};
         auto block_template = assembler.CreateNewBlock();

From 8daac1d6eba79991a1d2758ec24d314f3874cf66 Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Mon, 18 May 2026 15:58:39 +0200
Subject: [PATCH 10/15] mining: add block create option helpers

Move block template defaulting into helper functions for
BlockCreateOptions. FlattenMiningOptions() fills hardcoded defaults and
MergeMiningOptions() overlays defaults without replacing caller-provided
values.

Use the shared option type in BlockAssembler so IPC callers and internal
callers can pass through the same options path. This commit does not
change behavior, except for dropping the "Specified " prefix from startup
option error messages.

Keep the -blockmintxfee ParseMoney check in ReadMiningArgs() instead of
CheckMiningOptions(), because CheckMiningOptions() only sees the parsed
CFeeRate value and not the original string.

Co-authored-by: Ryan Ofsky <ryan@ofsky.org>
---
 src/node/interfaces.cpp         | 31 ++++++++++-----
 src/node/miner.cpp              | 50 +++++++++--------------
 src/node/miner.h                | 20 +++-------
 src/node/mining_args.cpp        | 70 +++++++++++++++++++++++++--------
 src/node/mining_args.h          | 21 +++++++++-
 src/node/mining_types.h         | 17 +++++++-
 src/rpc/mining.cpp              |  9 +++--
 src/test/fuzz/cmpctblock.cpp    |  2 +-
 src/test/fuzz/tx_pool.cpp       |  8 ++--
 src/test/miner_tests.cpp        |  2 +-
 test/functional/mining_basic.py |  6 +--
 11 files changed, 151 insertions(+), 85 deletions(-)

diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 7abd4b75b2c..7a078c81cb2 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -38,6 +38,7 @@
 #include <node/interface_ui.h>
 #include <node/mini_miner.h>
 #include <node/miner.h>
+#include <node/mining_args.h>
 #include <node/kernel_notifications.h>
 #include <node/transaction.h>
 #include <node/types.h>
@@ -86,6 +87,7 @@ using interfaces::Rpc;
 using interfaces::WalletLoader;
 using kernel::ChainstateRole;
 using node::BlockAssembler;
+using node::BlockCreateOptions;
 using node::BlockWaitOptions;
 using node::CoinbaseTx;
 using util::Join;
@@ -867,9 +869,9 @@ public:
 class BlockTemplateImpl : public BlockTemplate
 {
 public:
-    explicit BlockTemplateImpl(BlockAssembler::Options assemble_options,
+    explicit BlockTemplateImpl(BlockCreateOptions create_options,
                                std::unique_ptr<CBlockTemplate> block_template,
-                               const NodeContext& node) : m_assemble_options(std::move(assemble_options)),
+                               const NodeContext& node) : m_create_options(std::move(create_options)),
                                                           m_block_template(std::move(block_template)),
                                                           m_node(node)
     {
@@ -914,8 +916,14 @@ public:
 
     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;
     }
 
@@ -924,7 +932,7 @@ public:
         InterruptWait(notifications(), m_interrupt_wait);
     }
 
-    const BlockAssembler::Options m_assemble_options;
+    const BlockCreateOptions m_create_options;
 
     const std::unique_ptr<CBlockTemplate> m_block_template;
 
@@ -990,10 +998,15 @@ public:
             // 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(), m_node.mempool.get(), assemble_options}.CreateNewBlock(), m_node);
+        const auto args_options{*Assert(ReadMiningArgs(*Assert(m_node.args)))};
+        const BlockCreateOptions create_options{MergeMiningOptions(options, args_options)};
+        return std::make_unique<BlockTemplateImpl>(create_options,
+                                                   BlockAssembler{
+                                                       chainman().ActiveChainstate(),
+                                                       m_node.mempool.get(),
+                                                       create_options,
+                                                   }.CreateNewBlock(),
+                                                   m_node);
     }
 
     void interrupt() override
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index 41c1d997128..e1b6a480fbd 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -17,6 +17,7 @@
 #include <deploymentstatus.h>
 #include <node/context.h>
 #include <node/kernel_notifications.h>
+#include <node/mining_args.h>
 #include <policy/feerate.h>
 #include <policy/policy.h>
 #include <pow.h>
@@ -76,40 +77,27 @@ void RegenerateCommitments(CBlock& block, ChainstateManager& chainman)
     block.hashMerkleRoot = BlockMerkleRoot(block);
 }
 
-static BlockAssembler::Options ClampOptions(BlockAssembler::Options options)
+static BlockCreateOptions ClampOptions(BlockCreateOptions options)
 {
-    // Apply DEFAULT_BLOCK_RESERVED_WEIGHT and DEFAULT_BLOCK_MAX_WEIGHT when the caller left it unset.
-    options.block_reserved_weight = std::clamp<uint64_t>(options.block_reserved_weight.value_or(DEFAULT_BLOCK_RESERVED_WEIGHT), MINIMUM_BLOCK_RESERVED_WEIGHT, MAX_BLOCK_WEIGHT);
+    options = FlattenMiningOptions(std::move(options));
+    options.block_reserved_weight = std::clamp<uint64_t>(*options.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.block_max_weight = std::clamp<uint64_t>(options.block_max_weight.value_or(DEFAULT_BLOCK_MAX_WEIGHT), *options.block_reserved_weight, MAX_BLOCK_WEIGHT);
+    options.block_max_weight = std::clamp<uint64_t>(*options.block_max_weight, *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{ClampOptions(std::move(options))}
 {
 }
 
-void ApplyArgsManOptions(const ArgsManager& args, BlockAssembler::Options& options)
-{
-    // Block resource limits
-    if (!options.block_max_weight) {
-        options.block_max_weight = args.GetArg<uint64_t>("-blockmaxweight");
-    }
-    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.GetArg<uint64_t>("-blockreservedweight");
-    }
-}
-
 void BlockAssembler::resetBlock()
 {
     // Reserve space for fixed-size block header, txs count, and coinbase tx.
@@ -274,7 +262,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 +288,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;
         }
@@ -367,8 +355,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 +366,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 +413,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 +430,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 b579dc68893..fcb5649f63a 100644
--- a/src/node/miner.h
+++ b/src/node/miner.h
@@ -38,8 +38,6 @@ using interfaces::BlockRef;
 namespace node {
 class KernelNotifications;
 
-static const bool DEFAULT_PRINT_MODIFIED_FEE = false;
-
 struct CBlockTemplate
 {
     CBlock block;
@@ -79,12 +77,9 @@ private:
     Chainstate& m_chainstate;
 
 public:
-    struct Options : BlockCreateOptions {
-        CFeeRate blockMinFeeRate{DEFAULT_BLOCK_MIN_TX_FEE};
-        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();
@@ -95,7 +90,7 @@ public:
     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 */
@@ -131,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);
 
@@ -148,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/mining_args.cpp b/src/node/mining_args.cpp
index ece422a808e..ef859655cae 100644
--- a/src/node/mining_args.cpp
+++ b/src/node/mining_args.cpp
@@ -6,13 +6,17 @@
 
 #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/translation.h>
 
 #include <cstdint>
+#include <optional>
 
 using common::AmountErrMsg;
 using util::Error;
@@ -20,28 +24,60 @@ using util::Result;
 
 namespace node {
 
-Result<void> ReadMiningArgs(const ArgsManager& args)
+Result<void> CheckMiningOptions(const BlockCreateOptions& options, bool use_argnames)
 {
-    if (const auto arg{args.GetArg("-blockmintxfee")}) {
-        if (!ParseMoney(*arg)) {
-            return Error{AmountErrMsg("blockmintxfee", *arg)};
-        }
+    if (options.block_max_weight && *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))};
     }
-
-    const uint64_t max_block_weight{args.GetArg<uint64_t>("-blockmaxweight", DEFAULT_BLOCK_MAX_WEIGHT)};
-    if (max_block_weight > MAX_BLOCK_WEIGHT) {
-        return Error{strprintf(_("Specified -blockmaxweight (%d) exceeds consensus maximum block weight (%d)"), max_block_weight, MAX_BLOCK_WEIGHT)};
+    if (options.block_reserved_weight && *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))};
     }
-
-    const uint64_t block_reserved_weight{args.GetArg<uint64_t>("-blockreservedweight", DEFAULT_BLOCK_RESERVED_WEIGHT)};
-    if (block_reserved_weight > MAX_BLOCK_WEIGHT) {
-        return Error{strprintf(_("Specified -blockreservedweight (%d) exceeds consensus maximum block weight (%d)"), block_reserved_weight, MAX_BLOCK_WEIGHT)};
+    if (options.block_reserved_weight && *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 (block_reserved_weight < MINIMUM_BLOCK_RESERVED_WEIGHT) {
-        return Error{strprintf(_("Specified -blockreservedweight (%d) is lower than minimum safety value of (%d)"), block_reserved_weight, MINIMUM_BLOCK_RESERVED_WEIGHT)};
-    }
-
     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
index 01e695ee82c..e3ebf959c0e 100644
--- a/src/node/mining_args.h
+++ b/src/node/mining_args.h
@@ -5,13 +5,32 @@
 #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 {
 
-[[nodiscard]] util::Result<void> ReadMiningArgs(const ArgsManager& args);
+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(const 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
 
diff --git a/src/node/mining_types.h b/src/node/mining_types.h
index 30206c2e87c..6e3ee0f4afb 100644
--- a/src/node/mining_types.h
+++ b/src/node/mining_types.h
@@ -12,7 +12,7 @@
 #define BITCOIN_NODE_MINING_TYPES_H
 
 #include <consensus/amount.h>
-#include <consensus/consensus.h>
+#include <policy/feerate.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
@@ -26,11 +26,26 @@
 
 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
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 223569fdafe..62e64a5427c 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -22,6 +22,8 @@
 #include <net.h>
 #include <node/context.h>
 #include <node/miner.h>
+#include <node/mining_args.h>
+#include <node/mining_types.h>
 #include <node/warnings.h>
 #include <policy/ephemeral_policy.h>
 #include <pow.h>
@@ -463,7 +465,7 @@ static RPCMethod getmininginfo()
     CBlockIndex& tip{*CHECK_NONFATAL(active_chain.Tip())};
 
     UniValue obj(UniValue::VOBJ);
-    obj.pushKV("blocks",           active_chain.Height());
+    obj.pushKV("blocks", active_chain.Height());
     if (BlockAssembler::m_last_block_weight) obj.pushKV("currentblockweight", *BlockAssembler::m_last_block_weight);
     if (BlockAssembler::m_last_block_num_txs) obj.pushKV("currentblocktx", *BlockAssembler::m_last_block_num_txs);
     obj.pushKV("bits", strprintf("%08x", tip.nBits));
@@ -471,9 +473,8 @@ static RPCMethod getmininginfo()
     obj.pushKV("target", GetTarget(tip, chainman.GetConsensus().powLimit).GetHex());
     obj.pushKV("networkhashps",    getnetworkhashps().HandleRequest(request));
     obj.pushKV("pooledtx", mempool.size());
-    BlockAssembler::Options assembler_options;
-    ApplyArgsManOptions(*node.args, assembler_options);
-    obj.pushKV("blockmintxfee", ValueFromAmount(assembler_options.blockMinFeeRate.GetFeePerK()));
+    const auto options{node::FlattenMiningOptions(*Assert(node::ReadMiningArgs(*node.args)))};
+    obj.pushKV("blockmintxfee", ValueFromAmount(CHECK_NONFATAL(options.block_min_fee_rate)->GetFeePerK()));
     obj.pushKV("chain", chainman.GetParams().GetChainTypeString());
 
     UniValue next(UniValue::VOBJ);
diff --git a/src/test/fuzz/cmpctblock.cpp b/src/test/fuzz/cmpctblock.cpp
index 85e3bedfe92..7808acba980 100644
--- a/src/test/fuzz/cmpctblock.cpp
+++ b/src/test/fuzz/cmpctblock.cpp
@@ -121,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/tx_pool.cpp b/src/test/fuzz/tx_pool.cpp
index 9cada5df5b3..b7279990a1d 100644
--- a/src/test/fuzz/tx_pool.cpp
+++ b/src/test/fuzz/tx_pool.cpp
@@ -22,6 +22,7 @@
 #include <validationinterface.h>
 
 using node::BlockAssembler;
+using node::BlockCreateOptions;
 using node::NodeContext;
 using util::ToString;
 
@@ -93,9 +94,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.block_max_weight = 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(0U, 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/miner_tests.cpp b/src/test/miner_tests.cpp
index 5b5b6c3aded..6f2855c819a 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -181,7 +181,7 @@ void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const
     const auto block_package_feerates = BlockAssembler{
         m_node.chainman->ActiveChainstate(),
         &tx_mempool,
-        {}
+        BlockCreateOptions{},
     }.CreateNewBlock()->m_package_feerates;
     BOOST_CHECK(block_package_feerates.size() == 2);
 
diff --git a/test/functional/mining_basic.py b/test/functional/mining_basic.py
index bb53f736a44..2f6f1146c19 100755
--- a/test/functional/mining_basic.py
+++ b/test/functional/mining_basic.py
@@ -357,21 +357,21 @@ class MiningTest(BitcoinTestFramework):
         self.stop_node(0)
         self.nodes[0].assert_start_raises_init_error(
             extra_args=[f"-blockreservedweight={MAX_BLOCK_WEIGHT + 1}"],
-            expected_msg=f"Error: Specified -blockreservedweight ({MAX_BLOCK_WEIGHT + 1}) exceeds consensus maximum block weight ({MAX_BLOCK_WEIGHT})",
+            expected_msg=f"Error: -blockreservedweight ({MAX_BLOCK_WEIGHT + 1}) exceeds consensus maximum block weight ({MAX_BLOCK_WEIGHT})",
         )
 
         self.log.info(f"Test that node will fail to start when user provide -blockreservedweight below {MINIMUM_BLOCK_RESERVED_WEIGHT}")
         self.stop_node(0)
         self.nodes[0].assert_start_raises_init_error(
             extra_args=[f"-blockreservedweight={MINIMUM_BLOCK_RESERVED_WEIGHT - 1}"],
-            expected_msg=f"Error: Specified -blockreservedweight ({MINIMUM_BLOCK_RESERVED_WEIGHT - 1}) is lower than minimum safety value of ({MINIMUM_BLOCK_RESERVED_WEIGHT})",
+            expected_msg=f"Error: -blockreservedweight ({MINIMUM_BLOCK_RESERVED_WEIGHT - 1}) is lower than minimum safety value of ({MINIMUM_BLOCK_RESERVED_WEIGHT})",
         )
 
         self.log.info("Test that node will fail to start when user provide invalid -blockmaxweight")
         self.stop_node(0)
         self.nodes[0].assert_start_raises_init_error(
             extra_args=[f"-blockmaxweight={MAX_BLOCK_WEIGHT + 1}"],
-            expected_msg=f"Error: Specified -blockmaxweight ({MAX_BLOCK_WEIGHT + 1}) exceeds consensus maximum block weight ({MAX_BLOCK_WEIGHT})",
+            expected_msg=f"Error: -blockmaxweight ({MAX_BLOCK_WEIGHT + 1}) exceeds consensus maximum block weight ({MAX_BLOCK_WEIGHT})",
         )
 
     def test_height_in_locktime(self):

From 4637cd157da836ef377fb35e40956a0226d0baac Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Mon, 18 May 2026 15:59:57 +0200
Subject: [PATCH 11/15] mining: reject invalid block create options

Check BlockCreateOptions before block template creation instead of
clamping runtime values. This makes invalid runtime block creation
options, including those passed by IPC mining clients, fail explicitly
instead of silently mining with different values than the caller
requested.

Runtime option validation now uses the same error wording as startup
option validation. Startup validation also rejects -blockmaxweight
values lower than -blockreservedweight instead of allowing them to be
clamped later.

Co-authored-by: Ryan Ofsky <ryan@ofsky.org>
---
 src/node/interfaces.cpp                    | 10 -------
 src/node/miner.cpp                         | 21 ++++++--------
 src/node/mining_args.cpp                   | 32 ++++++++++++++++------
 src/node/mining_args.h                     |  2 +-
 src/node/mining_types.h                    |  4 +--
 src/test/fuzz/tx_pool.cpp                  |  3 +-
 src/test/miner_tests.cpp                   |  7 +++++
 test/functional/interface_ipc_mining.py    | 21 +++++++++++++-
 test/functional/mining_basic.py            |  7 +++++
 test/functional/test_framework/messages.py |  1 +
 10 files changed, 71 insertions(+), 37 deletions(-)

diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 7a078c81cb2..5317af9ff97 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -969,16 +969,6 @@ public:
 
     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())};
 
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index e1b6a480fbd..97a316ce217 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -29,8 +29,9 @@
 #include <validation.h>
 
 #include <algorithm>
-#include <utility>
 #include <numeric>
+#include <stdexcept>
+#include <utility>
 
 namespace node {
 
@@ -77,24 +78,18 @@ void RegenerateCommitments(CBlock& block, ChainstateManager& chainman)
     block.hashMerkleRoot = BlockMerkleRoot(block);
 }
 
-static BlockCreateOptions ClampOptions(BlockCreateOptions options)
-{
-    options = FlattenMiningOptions(std::move(options));
-    options.block_reserved_weight = std::clamp<uint64_t>(*options.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.block_max_weight = std::clamp<uint64_t>(*options.block_max_weight, *options.block_reserved_weight, MAX_BLOCK_WEIGHT);
-    return 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(std::move(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));
+      }()}
 {
 }
 
diff --git a/src/node/mining_args.cpp b/src/node/mining_args.cpp
index ef859655cae..33e623a14be 100644
--- a/src/node/mining_args.cpp
+++ b/src/node/mining_args.cpp
@@ -17,6 +17,7 @@
 
 #include <cstdint>
 #include <optional>
+#include <utility>
 
 using common::AmountErrMsg;
 using util::Error;
@@ -24,22 +25,35 @@ using util::Result;
 
 namespace node {
 
-Result<void> CheckMiningOptions(const BlockCreateOptions& options, bool use_argnames)
+Result<void> CheckMiningOptions(BlockCreateOptions options, bool use_argnames)
 {
-    if (options.block_max_weight && *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))};
+    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 && *options.block_reserved_weight > MAX_BLOCK_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_reserved_weight && *options.block_reserved_weight < MINIMUM_BLOCK_RESERVED_WEIGHT) {
-        return Error{Untranslated(strprintf("%s (%d) is lower than minimum safety value of (%d)",
+    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, MINIMUM_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 {};
 }
diff --git a/src/node/mining_args.h b/src/node/mining_args.h
index e3ebf959c0e..8baa7395285 100644
--- a/src/node/mining_args.h
+++ b/src/node/mining_args.h
@@ -21,7 +21,7 @@ static const bool DEFAULT_PRINT_MODIFIED_FEE = false;
 [[nodiscard]] util::Result<BlockCreateOptions> ReadMiningArgs(const ArgsManager& args);
 
 /** Check option values for validity. Returns an error for invalid values. */
-[[nodiscard]] util::Result<void> CheckMiningOptions(const BlockCreateOptions& options, bool use_argnames);
+[[nodiscard]] util::Result<void> CheckMiningOptions(BlockCreateOptions options, bool use_argnames);
 
 /** Replace null optional values with their hardcoded defaults. */
 [[nodiscard]] BlockCreateOptions FlattenMiningOptions(BlockCreateOptions options);
diff --git a/src/node/mining_types.h b/src/node/mining_types.h
index 6e3ee0f4afb..9c4fbcbbafe 100644
--- a/src/node/mining_types.h
+++ b/src/node/mining_types.h
@@ -59,8 +59,8 @@ struct BlockCreateOptions {
     /**
      * Maximum block weight, defaults to -maxblockweight
      *
-     * block_reserved_weight can safely exceed block_max_weight, but the rest of
-     * the block template will be empty.
+     * 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{};
     /**
diff --git a/src/test/fuzz/tx_pool.cpp b/src/test/fuzz/tx_pool.cpp
index b7279990a1d..825b32bc0c2 100644
--- a/src/test/fuzz/tx_pool.cpp
+++ b/src/test/fuzz/tx_pool.cpp
@@ -6,6 +6,7 @@
 #include <node/context.h>
 #include <node/mempool_args.h>
 #include <node/miner.h>
+#include <policy/policy.h>
 #include <policy/truc_policy.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
@@ -96,7 +97,7 @@ void Finish(FuzzedDataProvider& fuzzed_data_provider, MockedTxPool& tx_pool, Cha
     {
         BlockCreateOptions options{
             .block_min_fee_rate = CFeeRate{ConsumeMoney(fuzzed_data_provider, /*max=*/COIN)},
-            .block_max_weight = fuzzed_data_provider.ConsumeIntegralInRange(0U, MAX_BLOCK_WEIGHT),
+            .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();
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index 6f2855c819a..be2b5e60f6a 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -764,6 +764,13 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
     // 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/test/functional/interface_ipc_mining.py b/test/functional/interface_ipc_mining.py
index 710a9a2d82c..b59ffaab653 100755
--- a/test/functional/interface_ipc_mining.py
+++ b/test/functional/interface_ipc_mining.py
@@ -17,6 +17,7 @@ from test_framework.messages import (
     CTxInWitness,
     CTxOut,
     DEFAULT_BLOCK_RESERVED_WEIGHT,
+    MAX_BLOCK_SIGOPS_COST,
     MAX_BLOCK_WEIGHT,
     from_hex,
     msg_headers,
@@ -322,9 +323,27 @@ class IPCMiningTest(BitcoinTestFramework):
             self.log.debug("Enforce minimum reserved weight for IPC clients too")
             opts.blockReservedWeight = 0
             await assert_create_new_block_fails(ctx, mining, opts,
-                "block_reserved_weight (0) must be at least 2000 weight units")
+                "block_reserved_weight (0) is lower than minimum safety value of (2000)")
+
+        async def async_routine_check_max_reserved_weight():
+            self.log.debug("Enforce maximum reserved weight for IPC clients too")
+            ctx, mining = await make_mining_ctx(self)
+            opts = self.capnp_modules['mining'].BlockCreateOptions()
+            opts.blockReservedWeight = MAX_BLOCK_WEIGHT + 1
+            await assert_create_new_block_fails(ctx, mining, opts,
+                f"block_reserved_weight ({MAX_BLOCK_WEIGHT + 1}) exceeds consensus maximum block weight ({MAX_BLOCK_WEIGHT})")
+
+        async def async_routine_check_sigops_limit():
+            self.log.debug("Enforce sigops limit for IPC clients too")
+            ctx, mining = await make_mining_ctx(self)
+            opts = self.capnp_modules['mining'].BlockCreateOptions()
+            opts.coinbaseOutputMaxAdditionalSigops = MAX_BLOCK_SIGOPS_COST + 1
+            await assert_create_new_block_fails(ctx, mining, opts,
+                f"coinbase_output_max_additional_sigops ({MAX_BLOCK_SIGOPS_COST + 1}) exceeds consensus maximum block sigops cost ({MAX_BLOCK_SIGOPS_COST})")
 
         asyncio.run(capnp.run(async_routine()))
+        asyncio.run(capnp.run(async_routine_check_max_reserved_weight()))
+        asyncio.run(capnp.run(async_routine_check_sigops_limit()))
 
     def run_waitnext_mining_policy_test(self):
         """Verify that waitNext() preserves the mining policy from -blockmintxfee
diff --git a/test/functional/mining_basic.py b/test/functional/mining_basic.py
index 2f6f1146c19..7060a3cba62 100755
--- a/test/functional/mining_basic.py
+++ b/test/functional/mining_basic.py
@@ -374,6 +374,13 @@ class MiningTest(BitcoinTestFramework):
             expected_msg=f"Error: -blockmaxweight ({MAX_BLOCK_WEIGHT + 1}) exceeds consensus maximum block weight ({MAX_BLOCK_WEIGHT})",
         )
 
+        self.log.info("Test that node will fail to start when -blockmaxweight is lower than -blockreservedweight")
+        self.stop_node(0)
+        self.nodes[0].assert_start_raises_init_error(
+            extra_args=[f"-blockmaxweight={DEFAULT_BLOCK_RESERVED_WEIGHT - 1}"],
+            expected_msg=f"Error: -blockreservedweight ({DEFAULT_BLOCK_RESERVED_WEIGHT}) exceeds -blockmaxweight ({DEFAULT_BLOCK_RESERVED_WEIGHT - 1})",
+        )
+
     def test_height_in_locktime(self):
         self.log.info("Sanity check generated blocks have their coinbase timelocked to their height.")
         self.generate(self.nodes[0], 1, sync_fun=self.no_op)
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index 012049c257c..a0f2a174023 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -36,6 +36,7 @@ from test_framework.util import (
 
 MAX_LOCATOR_SZ = 101
 MAX_BLOCK_WEIGHT = 4000000
+MAX_BLOCK_SIGOPS_COST = 80000
 DEFAULT_BLOCK_RESERVED_WEIGHT = 8000
 MINIMUM_BLOCK_RESERVED_WEIGHT = 2000
 MAX_BLOOM_FILTER_SIZE = 36000

From 3bb6498fb0f6ac611ba4093ef774a3152b93a2c6 Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Mon, 18 May 2026 14:17:29 +0200
Subject: [PATCH 12/15] mining: store block create options in NodeContext

Read configured mining options once during startup instead of parsing
options like -blockmaxweight each time a block template is generated.

Store the parsed startup options as BlockCreateOptions. Members left unset
keep representing unset options; hardcoded defaults are applied by
FlattenMiningOptions() before the options are used. IPC overrides and node
defaults can then be merged with the same option type used by
BlockAssembler.

Co-authored-by: Ryan Ofsky <ryan@ofsky.org>
---
 src/init.cpp                   |  3 +++
 src/node/context.h             |  7 ++++++
 src/node/interfaces.cpp        |  3 +--
 src/node/mining_args.cpp       |  2 ++
 src/rpc/mining.cpp             | 45 ++++++++++++++++++++++++++++------
 src/test/miner_tests.cpp       |  2 +-
 src/test/util/setup_common.cpp |  5 ++++
 7 files changed, 56 insertions(+), 11 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index adf94665f59..aab7a52ebea 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1310,6 +1310,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/node/context.h b/src/node/context.h
index 848c872fd4a..b8b3274f090 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/mining_types.h>
+
 #include <atomic>
 #include <cstdlib>
 #include <functional>
@@ -81,6 +83,11 @@ struct NodeContext {
     //! Reference to chain client that should used to load or create wallets
     //! opened by the gui.
     std::unique_ptr<interfaces::Mining> mining;
+    //! Mining options used to create block templates. This value member is an
+    //! exception to the dependency guidance above because BlockCreateOptions is
+    //! a minimal dependency. It could be moved to the BlockTemplateCache
+    //! proposed in bitcoin/bitcoin#33421.
+    BlockCreateOptions mining_args;
     interfaces::WalletLoader* wallet_loader{nullptr};
     std::unique_ptr<CScheduler> scheduler;
     std::function<void()> rpc_interruption_point = [] {};
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 5317af9ff97..5aa6e27155d 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -988,8 +988,7 @@ public:
             // Also wait during the final catch-up moments after IBD.
             if (!CooldownIfHeadersAhead(chainman(), notifications(), *maybe_tip, m_interrupt_mining)) return {};
         }
-        const auto args_options{*Assert(ReadMiningArgs(*Assert(m_node.args)))};
-        const BlockCreateOptions create_options{MergeMiningOptions(options, args_options)};
+        const BlockCreateOptions create_options{MergeMiningOptions(options, m_node.mining_args)};
         return std::make_unique<BlockTemplateImpl>(create_options,
                                                    BlockAssembler{
                                                        chainman().ActiveChainstate(),
diff --git a/src/node/mining_args.cpp b/src/node/mining_args.cpp
index 33e623a14be..ec173464bb6 100644
--- a/src/node/mining_args.cpp
+++ b/src/node/mining_args.cpp
@@ -13,10 +13,12 @@
 #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;
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 62e64a5427c..e89a0e61ee1 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -5,48 +5,77 @@
 
 #include <bitcoin-build-config.h> // IWYU pragma: keep
 
+#include <interfaces/mining.h>
+
+#include <addresstype.h>
+#include <arith_uint256.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <chainparamsbase.h>
-#include <common/system.h>
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
 #include <consensus/merkle.h>
 #include <consensus/params.h>
 #include <consensus/validation.h>
 #include <core_io.h>
-#include <deploymentinfo.h>
-#include <deploymentstatus.h>
-#include <interfaces/mining.h>
+#include <crypto/hex_base.h>
+#include <interfaces/types.h>
 #include <key_io.h>
 #include <net.h>
+#include <netbase.h>
+#include <node/blockstorage.h>
 #include <node/context.h>
 #include <node/miner.h>
 #include <node/mining_args.h>
 #include <node/mining_types.h>
 #include <node/warnings.h>
-#include <policy/ephemeral_policy.h>
+#include <policy/feerate.h>
+#include <policy/policy.h>
 #include <pow.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
 #include <rpc/blockchain.h>
 #include <rpc/mining.h>
+#include <rpc/protocol.h>
+#include <rpc/request.h>
 #include <rpc/server.h>
 #include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/signingprovider.h>
+#include <serialize.h>
+#include <streams.h>
+#include <sync.h>
+#include <tinyformat.h>
 #include <txmempool.h>
+#include <uint256.h>
 #include <univalue.h>
+#include <util/chaintype.h>
+#include <util/check.h>
 #include <util/signalinterrupt.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/time.h>
-#include <util/translation.h>
 #include <validation.h>
 #include <validationinterface.h>
+#include <versionbits.h>
 
+#include <algorithm>
+#include <cstddef>
 #include <cstdint>
+#include <functional>
+#include <initializer_list>
+#include <limits>
+#include <map>
 #include <memory>
+#include <optional>
+#include <set>
+#include <span>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
 
 using interfaces::BlockRef;
 using interfaces::BlockTemplate;
@@ -473,8 +502,8 @@ static RPCMethod getmininginfo()
     obj.pushKV("target", GetTarget(tip, chainman.GetConsensus().powLimit).GetHex());
     obj.pushKV("networkhashps",    getnetworkhashps().HandleRequest(request));
     obj.pushKV("pooledtx", mempool.size());
-    const auto options{node::FlattenMiningOptions(*Assert(node::ReadMiningArgs(*node.args)))};
-    obj.pushKV("blockmintxfee", ValueFromAmount(CHECK_NONFATAL(options.block_min_fee_rate)->GetFeePerK()));
+    const auto mining_options{node::FlattenMiningOptions(node.mining_args)};
+    obj.pushKV("blockmintxfee", ValueFromAmount(CHECK_NONFATAL(mining_options.block_min_fee_rate)->GetFeePerK()));
     obj.pushKV("chain", chainman.GetParams().GetChainTypeString());
 
     UniValue next(UniValue::VOBJ);
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index be2b5e60f6a..4d1c305311f 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -181,7 +181,7 @@ void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const
     const auto block_package_feerates = BlockAssembler{
         m_node.chainman->ActiveChainstate(),
         &tx_mempool,
-        BlockCreateOptions{},
+        m_node.mining_args,
     }.CreateNewBlock()->m_package_feerates;
     BOOST_CHECK(block_package_feerates.size() == 2);
 
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 09b6c9c7ddc..25d71f38550 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -26,6 +26,7 @@
 #include <node/kernel_notifications.h>
 #include <node/mempool_args.h>
 #include <node/miner.h>
+#include <node/mining_args.h>
 #include <node/peerman_args.h>
 #include <node/warnings.h>
 #include <noui.h>
@@ -65,6 +66,7 @@
 #include <future>
 #include <functional>
 #include <stdexcept>
+#include <utility>
 
 using namespace util::hex_literals;
 using node::ApplyArgsManOptions;
@@ -364,6 +366,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;

From 8c58f63578a44c8b4ebdda4637d1b198d8a67d08 Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Mon, 18 May 2026 14:34:12 +0200
Subject: [PATCH 13/15] refactor: have mining files include what they use

---
 src/bench/block_assemble.cpp             |  3 +-
 src/bench/connectblock.cpp               | 19 ++++++--
 src/init.cpp                             | 38 +++++++++++-----
 src/interfaces/mining.h                  |  2 +-
 src/node/interfaces.cpp                  | 35 +++++++++------
 src/node/miner.cpp                       | 26 +++++++++--
 src/node/miner.h                         | 24 +++++------
 src/node/mini_miner.h                    |  3 +-
 src/rpc/mining.h                         |  2 +
 src/test/blockfilter_index_tests.cpp     | 31 ++++++++++---
 src/test/coinstatsindex_tests.cpp        | 15 ++++++-
 src/test/fuzz/cmpctblock.cpp             |  5 +--
 src/test/fuzz/mini_miner.cpp             | 26 +++++++----
 src/test/fuzz/package_eval.cpp           | 33 ++++++++++++--
 src/test/fuzz/process_message.cpp        | 13 +++++-
 src/test/fuzz/process_messages.cpp       | 12 +++++-
 src/test/fuzz/tx_pool.cpp                | 31 +++++++++++--
 src/test/fuzz/utxo_total_supply.cpp      | 22 +++++++---
 src/test/miner_tests.cpp                 | 34 +++++++++++----
 src/test/peerman_tests.cpp               | 12 +++++-
 src/test/testnet4_miner_tests.cpp        |  9 ++--
 src/test/util/mining.cpp                 | 10 ++++-
 src/test/util/mining.h                   |  3 +-
 src/test/util/setup_common.cpp           | 55 ++++++++++++++++++------
 src/test/util/setup_common.h             | 16 +++----
 src/test/validation_block_tests.cpp      | 25 ++++++++---
 src/test/validation_chainstate_tests.cpp | 17 +++++---
 27 files changed, 391 insertions(+), 130 deletions(-)

diff --git a/src/bench/block_assemble.cpp b/src/bench/block_assemble.cpp
index 9bc159229ee..be03917417e 100644
--- a/src/bench/block_assemble.cpp
+++ b/src/bench/block_assemble.cpp
@@ -4,7 +4,7 @@
 
 #include <bench/bench.h>
 #include <consensus/consensus.h>
-#include <node/miner.h>
+#include <node/mining_types.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <script/script.h>
@@ -18,6 +18,7 @@
 #include <cassert>
 #include <cstddef>
 #include <memory>
+#include <string>
 #include <vector>
 
 using node::BlockCreateOptions;
diff --git a/src/bench/connectblock.cpp b/src/bench/connectblock.cpp
index ba2d9048770..0c7470b56c8 100644
--- a/src/bench/connectblock.cpp
+++ b/src/bench/connectblock.cpp
@@ -4,14 +4,27 @@
 
 #include <addresstype.h>
 #include <bench/bench.h>
-#include <interfaces/chain.h>
-#include <kernel/cs_main.h>
-#include <script/interpreter.h>
+#include <chain.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 <validation.h>
 
 #include <cassert>
+#include <cstddef>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
 #include <vector>
 
 /*
diff --git a/src/init.cpp b/src/init.cpp
index aab7a52ebea..ec270ffd61c 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 <blockfilter.h>
@@ -18,13 +19,15 @@
 #include <chainparamsbase.h>
 #include <clientversion.h>
 #include <common/args.h>
+#include <common/messages.h>
 #include <common/system.h>
-#include <consensus/amount.h>
-#include <consensus/consensus.h>
-#include <deploymentstatus.h>
-#include <hash.h>
+#include <compat/compat.h>
+#include <consensus/params.h>
+#include <crypto/hex_base.h>
+#include <dbwrapper.h>
 #include <httprpc.h>
 #include <httpserver.h>
+#include <index/base.h>
 #include <index/blockfilterindex.h>
 #include <index/coinstatsindex.h>
 #include <index/txindex.h>
@@ -36,14 +39,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/blockmanager_args.h>
@@ -57,8 +64,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>
@@ -66,19 +73,20 @@
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <protocol.h>
-#include <rpc/blockchain.h>
+#include <random.h>
 #include <rpc/register.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #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>
@@ -98,21 +106,31 @@
 #include <walletinitinterface.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
diff --git a/src/interfaces/mining.h b/src/interfaces/mining.h
index 30dade3e05f..a95bc220185 100644
--- a/src/interfaces/mining.h
+++ b/src/interfaces/mining.h
@@ -7,7 +7,6 @@
 
 #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>
@@ -17,6 +16,7 @@
 #include <cstdint>
 #include <memory>
 #include <optional>
+#include <string>
 #include <vector>
 
 namespace node {
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 5aa6e27155d..edb73628484 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -2,16 +2,19 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <addrdb.h>
+#include <bitcoin-build-config.h> // IWYU pragma: keep
+
 #include <banman.h>
 #include <blockfilter.h>
 #include <btcsignals.h>
 #include <chain.h>
 #include <chainparams.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 <external_signer.h>
 #include <httprpc.h>
 #include <index/blockfilterindex.h>
@@ -22,24 +25,24 @@
 #include <interfaces/node.h>
 #include <interfaces/rpc.h>
 #include <interfaces/types.h>
-#include <interfaces/wallet.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/mining_args.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>
@@ -47,13 +50,12 @@
 #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 <rpc/blockchain.h>
 #include <rpc/protocol.h>
+#include <rpc/request.h>
 #include <rpc/server.h>
-#include <support/allocators/secure.h>
 #include <sync.h>
 #include <txmempool.h>
 #include <uint256.h>
@@ -62,17 +64,24 @@
 #include <util/result.h>
 #include <util/signalinterrupt.h>
 #include <util/string.h>
+#include <util/time.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <validationinterface.h>
 
-#include <bitcoin-build-config.h> // IWYU pragma: keep
-
 #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;
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index 97a316ce217..5c0df502e83 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -7,30 +7,48 @@
 
 #include <chain.h>
 #include <chainparams.h>
-#include <coins.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 <node/context.h>
+#include <interfaces/types.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 <script/script.h>
+#include <sync.h>
+#include <tinyformat.h>
+#include <txgraph.h>
+#include <txmempool.h>
+#include <uint256.h>
+#include <util/check.h>
+#include <util/feefrac.h>
 #include <util/log.h>
-#include <util/moneystr.h>
+#include <util/result.h>
 #include <util/signalinterrupt.h>
 #include <util/time.h>
+#include <util/translation.h>
 #include <validation.h>
+#include <versionbits.h>
 
 #include <algorithm>
+#include <compare>
+#include <condition_variable>
+#include <cstddef>
+#include <functional>
 #include <numeric>
+#include <span>
 #include <stdexcept>
+#include <string>
 #include <utility>
 
 namespace node {
diff --git a/src/node/miner.h b/src/node/miner.h
index fcb5649f63a..14780833c02 100644
--- a/src/node/miner.h
+++ b/src/node/miner.h
@@ -6,32 +6,32 @@
 #ifndef BITCOIN_NODE_MINER_H
 #define BITCOIN_NODE_MINER_H
 
-#include <interfaces/types.h>
-#include <node/types.h>
+#include <consensus/amount.h>
 #include <node/mining_types.h>
-#include <policy/policy.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;
 
diff --git a/src/node/mini_miner.h b/src/node/mini_miner.h
index d07108cb1c2..0634c53eaf8 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/rpc/mining.h b/src/rpc/mining.h
index 136272271a3..a6c243c22c5 100644
--- a/src/rpc/mining.h
+++ b/src/rpc/mining.h
@@ -5,6 +5,8 @@
 #ifndef BITCOIN_RPC_MINING_H
 #define BITCOIN_RPC_MINING_H
 
+#include <cstdint>
+
 /** Default max iterations to try in RPC generatetodescriptor, generatetoaddress, and generateblock. */
 static const uint64_t DEFAULT_MAX_TRIES{1000000};
 
diff --git a/src/test/blockfilter_index_tests.cpp b/src/test/blockfilter_index_tests.cpp
index a26f34112de..3fb273dfd32 100644
--- a/src/test/blockfilter_index_tests.cpp
+++ b/src/test/blockfilter_index_tests.cpp
@@ -4,22 +4,43 @@
 
 #include <addresstype.h>
 #include <blockfilter.h>
-#include <chainparams.h>
+#include <chain.h>
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
+#include <index/base.h>
 #include <index/blockfilterindex.h>
-#include <interfaces/mining.h>
 #include <interfaces/chain.h>
-#include <node/miner.h>
+#include <interfaces/mining.h>
+#include <key.h>
+#include <node/blockstorage.h>
 #include <pow.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
+#include <script/script.h>
+#include <sync.h>
 #include <test/util/blockfilter.h>
-#include <test/util/common.h>
+#include <test/util/common.h> // IWYU pragma: keep
 #include <test/util/setup_common.h>
-#include <util/byte_units.h>
+#include <tinyformat.h>
+#include <uint256.h>
+#include <util/check.h>
+#include <util/fs.h>
+#include <util/time.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
+
+#include <compare>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
 #include <future>
+#include <memory>
+#include <span>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
 
 using node::BlockManager;
 
diff --git a/src/test/coinstatsindex_tests.cpp b/src/test/coinstatsindex_tests.cpp
index e4755ed6271..42c01ca5b8f 100644
--- a/src/test/coinstatsindex_tests.cpp
+++ b/src/test/coinstatsindex_tests.cpp
@@ -2,18 +2,31 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <chain.h>
 #include <chainparams.h>
+#include <coins.h>
+#include <consensus/validation.h>
 #include <index/coinstatsindex.h>
 #include <interfaces/chain.h>
 #include <kernel/coinstats.h>
 #include <kernel/types.h>
+#include <key.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
+#include <script/script.h>
+#include <sync.h>
 #include <test/util/setup_common.h>
 #include <test/util/validation.h>
-#include <util/byte_units.h>
+#include <util/check.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
 
+#include <memory>
+#include <optional>
+#include <span>
+#include <vector>
+
 using kernel::ChainstateRole;
 
 BOOST_AUTO_TEST_SUITE(coinstatsindex_tests)
diff --git a/src/test/fuzz/cmpctblock.cpp b/src/test/fuzz/cmpctblock.cpp
index 7808acba980..882169c93a3 100644
--- a/src/test/fuzz/cmpctblock.cpp
+++ b/src/test/fuzz/cmpctblock.cpp
@@ -14,12 +14,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>
@@ -43,7 +44,6 @@
 #include <validationinterface.h>
 
 #include <boost/multi_index/detail/hash_index_iterator.hpp>
-#include <boost/operators.hpp>
 
 #include <cstddef>
 #include <cstdint>
@@ -52,7 +52,6 @@
 #include <memory>
 #include <optional>
 #include <string>
-#include <string_view>
 #include <thread>
 #include <utility>
 #include <vector>
diff --git a/src/test/fuzz/mini_miner.cpp b/src/test/fuzz/mini_miner.cpp
index 77f9e682e7f..daa3dae3411 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 c87a36517f6..9cb51c7d59e 100644
--- a/src/test/fuzz/package_eval.cpp
+++ b/src/test/fuzz/package_eval.cpp
@@ -2,25 +2,50 @@
 // 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 <node/context.h>
-#include <node/mempool_args.h>
-#include <node/miner.h>
+#include <node/mining_types.h> // IWYU pragma: keep
+#include <policy/feerate.h>
+#include <policy/packages.h>
+#include <policy/policy.h>
+#include <policy/settings.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 <validation.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 <unordered_map>
+#include <utility>
+#include <vector>
 using node::NodeContext;
 
 namespace {
diff --git a/src/test/fuzz/process_message.cpp b/src/test/fuzz/process_message.cpp
index dd95a5fc0fd..3ebedd919a2 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 <validation.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 {
diff --git a/src/test/fuzz/process_messages.cpp b/src/test/fuzz/process_messages.cpp
index d3a3ccb6fc3..21b44515187 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 <validation.h>
 #include <validationinterface.h>
 
+#include <functional>
 #include <ios>
+#include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
diff --git a/src/test/fuzz/tx_pool.cpp b/src/test/fuzz/tx_pool.cpp
index 825b32bc0c2..23c40c9fc44 100644
--- a/src/test/fuzz/tx_pool.cpp
+++ b/src/test/fuzz/tx_pool.cpp
@@ -2,26 +2,51 @@
 // 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 <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 <validation.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;
diff --git a/src/test/fuzz/utxo_total_supply.cpp b/src/test/fuzz/utxo_total_supply.cpp
index 9e227234e35..b59cbf997db 100644
--- a/src/test/fuzz/utxo_total_supply.cpp
+++ b/src/test/fuzz/utxo_total_supply.cpp
@@ -3,22 +3,34 @@
 // 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 <txdb.h>
+#include <uint256.h>
+#include <util/check.h>
 #include <validation.h>
 
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <utility>
+#include <vector>
+
 FUZZ_TARGET(utxo_total_supply)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index 4d1c305311f..2ddc1307cba 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -3,15 +3,28 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <addresstype.h>
+#include <chain.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 <interfaces/types.h>
+#include <kernel/chainparams.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>
@@ -23,16 +36,19 @@
 #include <util/translation.h>
 #include <validation.h>
 #include <versionbits.h>
-#include <pow.h>
-
-#include <test/util/common.h>
-#include <test/util/setup_common.h>
-
-#include <memory>
-#include <vector>
 
 #include <boost/test/unit_test.hpp>
 
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <memory>
+#include <optional>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
 using namespace util::hex_literals;
 using interfaces::BlockTemplate;
 using interfaces::Mining;
diff --git a/src/test/peerman_tests.cpp b/src/test/peerman_tests.cpp
index 1681b8760e4..9044e9c2e1a 100644
--- a/src/test/peerman_tests.cpp
+++ b/src/test/peerman_tests.cpp
@@ -2,16 +2,26 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
+#include <chain.h>
 #include <chainparams.h>
+#include <consensus/params.h>
 #include <interfaces/mining.h>
-#include <node/miner.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 <util/check.h>
+#include <util/time.h>
 #include <validation.h>
+#include <validationinterface.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 */
diff --git a/src/test/testnet4_miner_tests.cpp b/src/test/testnet4_miner_tests.cpp
index c5b144d44ae..5998b5e6723 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,6 +14,8 @@
 
 #include <boost/test/unit_test.hpp>
 
+#include <memory>
+
 using interfaces::BlockTemplate;
 using interfaces::Mining;
 using node::BlockWaitOptions;
diff --git a/src/test/util/mining.cpp b/src/test/util/mining.cpp
index 6191f91b8f1..9df682f5261 100644
--- a/src/test/util/mining.cpp
+++ b/src/test/util/mining.cpp
@@ -4,6 +4,8 @@
 
 #include <test/util/mining.h>
 
+#include <addresstype.h>
+#include <chain.h>
 #include <chainparams.h>
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
@@ -11,15 +13,21 @@
 #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 <validation.h>
 #include <validationinterface.h>
 #include <versionbits.h>
 
-#include <algorithm>
+#include <cstdint>
 #include <memory>
+#include <optional>
+#include <utility>
 
 using node::NodeContext;
 
diff --git a/src/test/util/mining.h b/src/test/util/mining.h
index e15b8a0bada..d1a071b3ee3 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>
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 25d71f38550..d7b7b29d584 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -6,52 +6,68 @@
 
 #include <addrman.h>
 #include <banman.h>
+#include <chain.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 <interfaces/mining.h>
-#include <init/common.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.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 <rpc/blockchain.h>
 #include <rpc/register.h>
 #include <rpc/server.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>
@@ -60,12 +76,23 @@
 #include <util/vector.h>
 #include <validation.h>
 #include <validationinterface.h>
-#include <walletinitinterface.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;
diff --git a/src/test/util/setup_common.h b/src/test/util/setup_common.h
index 6ab63ec9322..62bfaba9a97 100644
--- a/src/test/util/setup_common.h
+++ b/src/test/util/setup_common.h
@@ -6,26 +6,26 @@
 #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 CFeeRate;
diff --git a/src/test/validation_block_tests.cpp b/src/test/validation_block_tests.cpp
index 2d3d5d65c20..51aecd60725 100644
--- a/src/test/validation_block_tests.cpp
+++ b/src/test/validation_block_tests.cpp
@@ -2,24 +2,37 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <boost/test/unit_test.hpp>
-
+#include <chain.h>
 #include <chainparams.h>
+#include <consensus/consensus.h>
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
 #include <interfaces/mining.h>
-#include <node/miner.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 <txmempool.h>
+#include <uint256.h>
+#include <util/check.h>
 #include <validation.h>
 #include <validationinterface.h>
 
+#include <boost/test/unit_test.hpp>
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <span>
 #include <thread>
+#include <utility>
+#include <vector>
 
 using kernel::ChainstateRole;
 
diff --git a/src/test/validation_chainstate_tests.cpp b/src/test/validation_chainstate_tests.cpp
index 4d7c8334a2d..c9110655de1 100644
--- a/src/test/validation_chainstate_tests.cpp
+++ b/src/test/validation_chainstate_tests.cpp
@@ -2,28 +2,33 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 //
+#include <chain.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 <rpc/blockchain.h>
 #include <script/script.h>
 #include <sync.h>
 #include <test/util/chainstate.h>
-#include <test/util/common.h>
+#include <test/util/common.h> // IWYU pragma: keep
 #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 <validation.h>
 
-#include <vector>
-
 #include <boost/test/unit_test.hpp>
 
+#include <memory>
+#include <optional>
+#include <vector>
+
 class CTxMemPool;
 
 BOOST_FIXTURE_TEST_SUITE(validation_chainstate_tests, ChainTestingSetup)

From 0317f52022cd34a2fb6647f0a85ad6537d7cc820 Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Mon, 18 May 2026 14:34:25 +0200
Subject: [PATCH 14/15] ci: enforce iwyu for touched files

Except tests, fuzz and util which are left to a followup.
---
 ci/test/03_test_script.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ci/test/03_test_script.sh b/ci/test/03_test_script.sh
index 4e4d975778d..fdd3a2c08a9 100755
--- a/ci/test/03_test_script.sh
+++ b/ci/test/03_test_script.sh
@@ -209,7 +209,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"
 

From 1e5d3b4f0da41d38305b8c8ff654396ed451cc2c Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Thu, 14 May 2026 09:08:01 +0200
Subject: [PATCH 15/15] doc: add release note for mining option validation

---
 doc/release-notes-33966.md | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 doc/release-notes-33966.md

diff --git a/doc/release-notes-33966.md b/doc/release-notes-33966.md
new file mode 100644
index 00000000000..7251a13d52d
--- /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)