From c548d6f0e8ecc0da6e29256c7085d48d10e10216 Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Fri, 21 Nov 2025 16:28:19 +0100
Subject: [PATCH 1/5] test: destroy templates more carefully

Prepare template destruction handling for a later commit that checks
memory management:

- add destroy_template helper which awaits the result and avoids
  calling destroy() if we never received a template
- reverse order and prevent template override. This ensures template
  and template2 (which don't have transactions) are destroyed last.

Additionally, expand the test to demonstrate how setting feeThreshold
to MAX_MONEY ignores new mempool transactions. This extra transaction
is needed in a later commit (to add coverage for reference counting).
---
 test/functional/interface_ipc.py | 59 ++++++++++++++++++++++----------
 1 file changed, 40 insertions(+), 19 deletions(-)

diff --git a/test/functional/interface_ipc.py b/test/functional/interface_ipc.py
index 75d340d5838e3..b9342ad62d869 100755
--- a/test/functional/interface_ipc.py
+++ b/test/functional/interface_ipc.py
@@ -7,7 +7,13 @@
 from io import BytesIO
 from pathlib import Path
 import shutil
-from test_framework.messages import (CBlock, CTransaction, ser_uint256, COIN)
+from test_framework.messages import (
+    CBlock,
+    COIN,
+    CTransaction,
+    MAX_MONEY,
+    ser_uint256,
+)
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
@@ -88,6 +94,12 @@ async def parse_and_deserialize_coinbase_tx(self, block_template, ctx):
         tx.deserialize(coinbase_data)
         return tx
 
+    async def destroy_template(self, template_obj, ctx):
+        """Destroy template if we received one."""
+        if template_obj is None or template_obj.to_dict() == {}:
+            return
+        await template_obj.result.destroy(ctx)
+
     def run_echo_test(self):
         self.log.info("Running echo test")
         async def async_routine():
@@ -154,12 +166,18 @@ async def async_routine():
             coinbase = CTransaction()
             coinbase.deserialize(coinbase_data)
             assert_equal(coinbase.vin[0].prevout.hash, 0)
-            self.log.debug("Wait for a new template")
+            self.log.debug("Wait for a new template, get one after the tip updates")
             waitoptions = self.capnp_modules['mining'].BlockWaitOptions()
             waitoptions.timeout = timeout
-            waitoptions.feeThreshold = 1
+            # Ignore fee increases, wait only for the tip update
+            waitoptions.feeThreshold = MAX_MONEY
+            miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0])
             waitnext = template.result.waitNext(ctx, waitoptions)
-            self.generate(self.nodes[0], 1)
+            template2 = await waitnext
+            assert_equal(template2.to_dict(), {})
+            waitnext = template.result.waitNext(ctx, waitoptions)
+            # This mines the transaction, so it won't be in the next template
+            self.generate(self.nodes[0], 1, sync_fun=self.no_op)
             template2 = await waitnext
             block2 = await self.parse_and_deserialize_block(template2, ctx)
             assert_equal(len(block2.vtx), 1)
@@ -167,6 +185,7 @@ async def async_routine():
             template3 = await template2.result.waitNext(ctx, waitoptions)
             assert_equal(template3.to_dict(), {})
             self.log.debug("Wait for another, get one after increase in fees in the mempool")
+            waitoptions.feeThreshold = 1
             waitnext = template2.result.waitNext(ctx, waitoptions)
             miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0])
             template4 = await waitnext
@@ -212,9 +231,9 @@ async def interrupt_wait():
 
             current_block_height = self.nodes[0].getchaintips()[0]["height"]
             check_opts = self.capnp_modules['mining'].BlockCheckOptions()
-            template = await mining.result.createNewBlock(opts)
-            block = await self.parse_and_deserialize_block(template, ctx)
-            coinbase = await self.parse_and_deserialize_coinbase_tx(template, ctx)
+            template8 = await mining.result.createNewBlock(opts)
+            block = await self.parse_and_deserialize_block(template8, ctx)
+            coinbase = await self.parse_and_deserialize_coinbase_tx(template8, ctx)
             balance = miniwallet.get_balance()
             coinbase.vout[0].scriptPubKey = miniwallet.get_output_script()
             coinbase.vout[0].nValue = COIN
@@ -227,7 +246,7 @@ async def interrupt_wait():
             res = await mining.result.checkBlock(block.serialize(), check_opts)
             assert_equal(res.result, False)
             assert_equal(res.reason, "bad-version(0x00000000)")
-            res = await template.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())
+            res = await template8.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())
             assert_equal(res.result, False)
             self.log.debug("Submit a valid block")
             block.nVersion = original_version
@@ -238,21 +257,21 @@ async def interrupt_wait():
             assert_equal(res.result, True)
 
             # The remote template block will be mutated, capture the original:
-            remote_block_before = await self.parse_and_deserialize_block(template, ctx)
+            remote_block_before = await self.parse_and_deserialize_block(template8, ctx)
 
             self.log.debug("Submitted coinbase must include witness")
             assert_not_equal(coinbase.serialize_without_witness().hex(), coinbase.serialize().hex())
-            res = await template.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize_without_witness())
+            res = await template8.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize_without_witness())
             assert_equal(res.result, False)
 
             self.log.debug("Even a rejected submitBlock() mutates the template's block")
             # Can be used by clients to download and inspect the (rejected)
             # reconstructed block.
-            remote_block_after = await self.parse_and_deserialize_block(template, ctx)
+            remote_block_after = await self.parse_and_deserialize_block(template8, ctx)
             assert_not_equal(remote_block_before.serialize().hex(), remote_block_after.serialize().hex())
 
             self.log.debug("Submit again, with the witness")
-            res = await template.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())
+            res = await template8.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())
             assert_equal(res.result, True)
 
             self.log.debug("Block should propagate")
@@ -271,13 +290,15 @@ async def interrupt_wait():
             assert_equal(res.reason, "inconclusive-not-best-prevblk")
 
             self.log.debug("Destroy template objects")
-            template.result.destroy(ctx)
-            template2.result.destroy(ctx)
-            template3.result.destroy(ctx)
-            template4.result.destroy(ctx)
-            template5.result.destroy(ctx)
-            template6.result.destroy(ctx)
-            template7.result.destroy(ctx)
+            await self.destroy_template(template8, ctx)
+            await self.destroy_template(template7, ctx)
+            await self.destroy_template(template6, ctx)
+            await self.destroy_template(template5, ctx)
+            await self.destroy_template(template4, ctx)
+            await self.destroy_template(template3, ctx)
+            await self.destroy_template(template2, ctx)
+            await self.destroy_template(template, ctx)
+
         asyncio.run(capnp.run(async_routine()))
 
     def run_test(self):

From a5eee29fd7d177f57c78da9773cb656a129de839 Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Tue, 25 Nov 2025 18:16:43 +0100
Subject: [PATCH 2/5] rpc: move static block_template to node context

The getblocktemplate RPC uses a static BlockTemplate, which goes out
of scope only after the node completed its shutdown sequence.

This becomes a problem when a later commit implements a destructor
that uses m_node.
---
 src/node/context.h | 3 +++
 src/rpc/mining.cpp | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/node/context.h b/src/node/context.h
index debc12212064c..cc88180b33cf8 100644
--- a/src/node/context.h
+++ b/src/node/context.h
@@ -26,6 +26,7 @@ class ECC_Context;
 class NetGroupManager;
 class PeerManager;
 namespace interfaces {
+class BlockTemplate;
 class Chain;
 class ChainClient;
 class Mining;
@@ -66,6 +67,8 @@ struct NodeContext {
     std::unique_ptr<AddrMan> addrman;
     std::unique_ptr<CConnman> connman;
     std::unique_ptr<CTxMemPool> mempool;
+    //! Cache latest getblocktemplate result for BIP 22 long polling
+    std::unique_ptr<interfaces::BlockTemplate> gbt_template;
     std::unique_ptr<const NetGroupManager> netgroupman;
     std::unique_ptr<CBlockPolicyEstimator> fee_estimator;
     std::unique_ptr<PeerManager> peerman;
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 2639b9161298c..bd497a852f5bd 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -858,7 +858,7 @@ static RPCHelpMan getblocktemplate()
     // Update block
     static CBlockIndex* pindexPrev;
     static int64_t time_start;
-    static std::unique_ptr<BlockTemplate> block_template;
+    std::unique_ptr<BlockTemplate>& block_template{node.gbt_template};
     if (!pindexPrev || pindexPrev->GetBlockHash() != tip ||
         (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast && GetTime() - time_start > 5))
     {

From f90ab4ed715d87e7df93e01de55c7f15e9f20023 Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Fri, 21 Nov 2025 16:12:27 +0100
Subject: [PATCH 3/5] mining: track non-mempool memory usage

IPC clients can hold on to block templates indefinately, which has the
same impact as when the node holds a shared pointer to the
CBlockTemplate. Because each template in turn tracks CTransactionRefs,
transactions that are removed from the mempool will have not have
their memory cleared.

This commit adds bookkeeping to the block template constructor and
destructor that will let us track the resulting memory footprint.
---
 src/node/context.h      | 10 +++++++++-
 src/node/interfaces.cpp | 20 +++++++++++++++++++-
 src/node/types.h        |  7 +++++++
 3 files changed, 35 insertions(+), 2 deletions(-)

diff --git a/src/node/context.h b/src/node/context.h
index cc88180b33cf8..613a6579735e3 100644
--- a/src/node/context.h
+++ b/src/node/context.h
@@ -5,10 +5,13 @@
 #ifndef BITCOIN_NODE_CONTEXT_H
 #define BITCOIN_NODE_CONTEXT_H
 
+#include <node/types.h>
+
 #include <atomic>
 #include <cstdlib>
 #include <functional>
 #include <memory>
+#include <sync.h>
 #include <thread>
 #include <vector>
 
@@ -67,7 +70,12 @@ struct NodeContext {
     std::unique_ptr<AddrMan> addrman;
     std::unique_ptr<CConnman> connman;
     std::unique_ptr<CTxMemPool> mempool;
-    //! Cache latest getblocktemplate result for BIP 22 long polling
+    Mutex template_state_mutex;
+    //! Track how many templates (which we hold on to on behalf of connected IPC
+    //! clients) are referencing each transaction.
+    TxTemplateMap template_tx_refs GUARDED_BY(template_state_mutex);
+    //! Cache latest getblocktemplate result for BIP 22 long polling. Must be cleared
+    //! before template_tx_refs.
     std::unique_ptr<interfaces::BlockTemplate> gbt_template;
     std::unique_ptr<const NetGroupManager> netgroupman;
     std::unique_ptr<CBlockPolicyEstimator> fee_estimator;
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index ac817e01b157c..1c887df81ab6c 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -67,6 +67,7 @@
 #include <any>
 #include <memory>
 #include <optional>
+#include <ranges>
 #include <utility>
 
 #include <boost/signals2/signal.hpp>
@@ -862,7 +863,24 @@ class BlockTemplateImpl : public BlockTemplate
                                                     m_block_template(std::move(block_template)),
                                                     m_node(node)
     {
-        assert(m_block_template);
+        // Don't track the dummy coinbase, because it can be modified in-place
+        // by submitSolution()
+        LOCK(m_node.template_state_mutex);
+        for (const CTransactionRef& tx : Assert(m_block_template)->block.vtx | std::views::drop(1)) {
+            m_node.template_tx_refs[tx]++;
+        }
+    }
+
+    ~BlockTemplateImpl()
+    {
+        LOCK(m_node.template_state_mutex);
+        for (const CTransactionRef& tx : m_block_template->block.vtx | std::views::drop(1)) {
+            auto ref_count{m_node.template_tx_refs.find(tx)};
+            if (!Assume(ref_count != m_node.template_tx_refs.end())) break;
+            if (--ref_count->second == 0) {
+                m_node.template_tx_refs.erase(ref_count);
+            }
+        }
     }
 
     CBlockHeader getBlockHeader() override
diff --git a/src/node/types.h b/src/node/types.h
index 6c2687626c98c..437e5df87b89c 100644
--- a/src/node/types.h
+++ b/src/node/types.h
@@ -16,7 +16,9 @@
 #include <consensus/amount.h>
 #include <cstddef>
 #include <cstdint>
+#include <map>
 #include <policy/policy.h>
+#include <primitives/transaction.h>
 #include <script/script.h>
 #include <uint256.h>
 #include <util/time.h>
@@ -110,6 +112,11 @@ enum class TxBroadcast : uint8_t {
     MEMPOOL_NO_BROADCAST,
 };
 
+/*
+ * Map how many templates refer to each transaction reference.
+ */
+using TxTemplateMap = std::map<CTransactionRef, size_t>;
+
 } // namespace node
 
 #endif // BITCOIN_NODE_TYPES_H

From a63d2e1c920a966dc73837589357156e921e496a Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Tue, 25 Nov 2025 16:26:16 +0100
Subject: [PATCH 4/5] mining: add GetTemplateMemoryUsage()

Calculate the non-mempool memory footprint for template transaction
references.

Add bench logging to collect data on whether caching or simplified
heuristics are needed, such as not checking for mempool presence.
---
 src/node/miner.cpp | 24 ++++++++++++++++++++++++
 src/node/miner.h   | 10 ++++++++++
 2 files changed, 34 insertions(+)

diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index 8ea538e7b4fda..2c4edc14d520b 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -16,12 +16,15 @@
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
 #include <logging.h>
+#include <logging/timer.h>
+#include <memusage.h>
 #include <node/context.h>
 #include <node/kernel_notifications.h>
 #include <policy/feerate.h>
 #include <policy/policy.h>
 #include <pow.h>
 #include <primitives/transaction.h>
+#include <util/check.h>
 #include <util/moneystr.h>
 #include <util/signalinterrupt.h>
 #include <util/time.h>
@@ -440,4 +443,25 @@ std::optional<BlockRef> WaitTipChanged(ChainstateManager& chainman, KernelNotifi
     // avoid deadlocks.
     return GetTip(chainman);
 }
+
+size_t GetTemplateMemoryUsage(const CTxMemPool& mempool, const TxTemplateMap& tx_refs)
+{
+    size_t usage_bytes{0};
+    {
+        LOG_TIME_MILLIS_WITH_CATEGORY("Calculate template transaction reference memory footprint", BCLog::BENCH);
+        for (const auto& [tx_ref, _] : tx_refs) {
+            if (!Assume(tx_ref)) continue;
+            // mempool.exists() locks mempool.cs each time, which slows down
+            // our calculation. This is preferable to potentially blocking
+            // the node from processing new transactions while this
+            // (non-urgent) calculation is in progress.
+            //
+            // As a side-effect the result is not an accurate snapshot, because
+            // the mempool may change during the loop.
+            if (mempool.exists(tx_ref->GetWitnessHash())) continue;
+            usage_bytes += RecursiveDynamicUsage(*tx_ref);
+        }
+    }
+    return usage_bytes;
+}
 } // namespace node
diff --git a/src/node/miner.h b/src/node/miner.h
index 02272242b419a..822c2ad43ce94 100644
--- a/src/node/miner.h
+++ b/src/node/miner.h
@@ -14,6 +14,7 @@
 #include <util/feefrac.h>
 
 #include <cstdint>
+#include <map>
 #include <memory>
 #include <optional>
 
@@ -157,6 +158,15 @@ std::optional<BlockRef> GetTip(ChainstateManager& chainman);
 /* Waits for the connected tip to change until timeout has elapsed. During node initialization, this will wait until the tip is connected (regardless of `timeout`).
  * Returns the current tip, or nullopt if the node is shutting down. */
 std::optional<BlockRef> WaitTipChanged(ChainstateManager& chainman, KernelNotifications& kernel_notifications, const uint256& current_tip, MillisecondsDouble& timeout);
+
+/**
+ * Estimate non-mempool memory footprint of transaction data referenced by block
+ * templates.
+ *
+ * Result is not guaranteed to be an accurate snapshot, because it does not
+ * lock mempool.cs while iterating over transaction references.
+ */
+size_t GetTemplateMemoryUsage(const CTxMemPool& mempool, const TxTemplateMap& tx_refs);
 } // namespace node
 
 #endif // BITCOIN_NODE_MINER_H

From 7f4249b0d0a126cfaddba48bc1bd4966c14fbd0d Mon Sep 17 00:00:00 2001
From: Sjors Provoost <sjors@sprovoost.nl>
Date: Fri, 5 Dec 2025 12:16:26 +0100
Subject: [PATCH 5/5] ipc: add getMemoryLoad()

Allow IPC clients to inspect the amount of memory consumed by
non-mempool transactions in blocks.

Returns a MemoryLoad struct which can later be expand to e.g.
include a limit.

Expand the interface_ipc.py test to demonstrate the behavior and
to illustrate how clients can call destroy() to reduce memory
pressure.
---
 src/interfaces/mining.h          | 12 +++++++++++
 src/ipc/capnp/mining.capnp       |  5 +++++
 src/node/interfaces.cpp          |  8 +++++++
 test/functional/interface_ipc.py | 36 ++++++++++++++++++++++++++------
 4 files changed, 55 insertions(+), 6 deletions(-)

diff --git a/src/interfaces/mining.h b/src/interfaces/mining.h
index 6e0376915d8ad..c84768bd57213 100644
--- a/src/interfaces/mining.h
+++ b/src/interfaces/mining.h
@@ -92,6 +92,12 @@ class BlockTemplate
     virtual void interruptWait() = 0;
 };
 
+//! Tracks memory usage for template-bound transactions.
+struct MemoryLoad
+{
+    uint64_t usage{0};
+};
+
 //! Interface giving clients (RPC, Stratum v2 Template Provider in the future)
 //! ability to create block templates.
 class Mining
@@ -147,6 +153,12 @@ class Mining
      */
     virtual bool checkBlock(const CBlock& block, const node::BlockCheckOptions& options, std::string& reason, std::string& debug) = 0;
 
+    /**
+     * Returns the current memory load for template transactions outside the
+     * mempool.
+     */
+    virtual MemoryLoad getMemoryLoad() = 0;
+
     //! Get internal node context. Useful for RPC and testing,
     //! but not accessible across processes.
     virtual node::NodeContext* context() { return nullptr; }
diff --git a/src/ipc/capnp/mining.capnp b/src/ipc/capnp/mining.capnp
index ed01e44a32aa0..74a71f7dbd2e5 100644
--- a/src/ipc/capnp/mining.capnp
+++ b/src/ipc/capnp/mining.capnp
@@ -19,6 +19,7 @@ interface Mining $Proxy.wrap("interfaces::Mining") {
     waitTipChanged @3 (context :Proxy.Context, currentTip: Data, timeout: Float64) -> (result: Common.BlockRef);
     createNewBlock @4 (options: BlockCreateOptions) -> (result: BlockTemplate);
     checkBlock @5 (block: Data, options: BlockCheckOptions) -> (reason: Text, debug: Text, result: Bool);
+    getMemoryLoad @6 (context :Proxy.Context) -> (result: MemoryLoad);
 }
 
 interface BlockTemplate $Proxy.wrap("interfaces::BlockTemplate") {
@@ -42,6 +43,10 @@ struct BlockCreateOptions $Proxy.wrap("node::BlockCreateOptions") {
     coinbaseOutputMaxAdditionalSigops @2 :UInt64 $Proxy.name("coinbase_output_max_additional_sigops");
 }
 
+struct MemoryLoad $Proxy.wrap("interfaces::MemoryLoad") {
+    usage @0 :UInt64;
+}
+
 struct BlockWaitOptions $Proxy.wrap("node::BlockWaitOptions") {
     timeout @0 : Float64 $Proxy.name("timeout");
     feeThreshold @1 : Int64 $Proxy.name("fee_threshold");
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 1c887df81ab6c..86fb1041049f9 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -79,6 +79,7 @@ using interfaces::Chain;
 using interfaces::FoundBlock;
 using interfaces::Handler;
 using interfaces::MakeSignalHandler;
+using interfaces::MemoryLoad;
 using interfaces::Mining;
 using interfaces::Node;
 using interfaces::WalletLoader;
@@ -995,6 +996,13 @@ class MinerImpl : public Mining
         return state.IsValid();
     }
 
+    MemoryLoad getMemoryLoad() override
+    {
+        LOCK(m_node.template_state_mutex);
+        CTxMemPool& mempool{*Assert(m_node.mempool)};
+        return {.usage = GetTemplateMemoryUsage(mempool, m_node.template_tx_refs)};
+    }
+
     NodeContext* context() override { return &m_node; }
     ChainstateManager& chainman() { return *Assert(m_node.chainman); }
     KernelNotifications& notifications() { return *Assert(m_node.notifications); }
diff --git a/test/functional/interface_ipc.py b/test/functional/interface_ipc.py
index b9342ad62d869..553c6fcc5d96c 100755
--- a/test/functional/interface_ipc.py
+++ b/test/functional/interface_ipc.py
@@ -17,6 +17,7 @@
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
+    assert_greater_than,
     assert_not_equal
 )
 from test_framework.wallet import MiniWallet
@@ -171,16 +172,22 @@ async def async_routine():
             waitoptions.timeout = timeout
             # Ignore fee increases, wait only for the tip update
             waitoptions.feeThreshold = MAX_MONEY
+            # In order to test ~BlockTemplateImpl reference counting, template2
+            # will contain a transaction that's also included in later templates.
+            # To keep it in the mempool for these later templates, we temporarily
+            # disconnect so node 1 will mine a block without it.
+            self.disconnect_nodes(0, 1)
             miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0])
             waitnext = template.result.waitNext(ctx, waitoptions)
             template2 = await waitnext
             assert_equal(template2.to_dict(), {})
             waitnext = template.result.waitNext(ctx, waitoptions)
-            # This mines the transaction, so it won't be in the next template
-            self.generate(self.nodes[0], 1, sync_fun=self.no_op)
+            self.generate(self.nodes[1], 1, sync_fun=self.no_op)
+            self.connect_nodes(0, 1)
+            self.sync_blocks()
             template2 = await waitnext
             block2 = await self.parse_and_deserialize_block(template2, ctx)
-            assert_equal(len(block2.vtx), 1)
+            assert_equal(len(block2.vtx), 2)
             self.log.debug("Wait for another, but time out")
             template3 = await template2.result.waitNext(ctx, waitoptions)
             assert_equal(template3.to_dict(), {})
@@ -190,23 +197,28 @@ async def async_routine():
             miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0])
             template4 = await waitnext
             block3 = await self.parse_and_deserialize_block(template4, ctx)
-            assert_equal(len(block3.vtx), 2)
+            assert_equal(len(block3.vtx), 3)
             self.log.debug("Wait again, this should return the same template, since the fee threshold is zero")
             waitoptions.feeThreshold = 0
             template5 = await template4.result.waitNext(ctx, waitoptions)
             block4 = await self.parse_and_deserialize_block(template5, ctx)
-            assert_equal(len(block4.vtx), 2)
+            assert_equal(len(block4.vtx), 3)
             waitoptions.feeThreshold = 1
             self.log.debug("Wait for another, get one after increase in fees in the mempool")
             waitnext = template5.result.waitNext(ctx, waitoptions)
             miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0])
             template6 = await waitnext
             block4 = await self.parse_and_deserialize_block(template6, ctx)
-            assert_equal(len(block4.vtx), 3)
+            assert_equal(len(block4.vtx), 4)
             self.log.debug("Wait for another, but time out, since the fee threshold is set now")
             template7 = await template6.result.waitNext(ctx, waitoptions)
             assert_equal(template7.to_dict(), {})
 
+            self.log.debug("Memory load should be zero because there was no mempool churn")
+            with self.nodes[0].assert_debug_log(["Calculate template transaction reference memory footprint"]):
+                memory_load = await mining.result.getMemoryLoad(ctx)
+            assert_equal(memory_load.result.usage, 0)
+
             self.log.debug("interruptWait should abort the current wait")
             wait_started = asyncio.Event()
             async def wait_for_block():
@@ -289,6 +301,13 @@ async def interrupt_wait():
             assert_equal(res.result, False)
             assert_equal(res.reason, "inconclusive-not-best-prevblk")
 
+            self.log.debug("Reported memory load should be > 0")
+            # Clients are expected to drop references to stale block templates
+            # briefly after the tip updates. In practice we mainly care about
+            # the memory footprint caused by mempool churn, but this scenario
+            # is easier to test.
+            assert_greater_than((await mining.result.getMemoryLoad(ctx)).result.usage, 0)
+
             self.log.debug("Destroy template objects")
             await self.destroy_template(template8, ctx)
             await self.destroy_template(template7, ctx)
@@ -297,6 +316,11 @@ async def interrupt_wait():
             await self.destroy_template(template4, ctx)
             await self.destroy_template(template3, ctx)
             await self.destroy_template(template2, ctx)
+
+            # All templates with transactions have been released
+            self.log.debug("Reported memory load should be 0")
+            assert_equal((await mining.result.getMemoryLoad(ctx)).result.usage, 0)
+
             await self.destroy_template(template, ctx)
 
         asyncio.run(capnp.run(async_routine()))