From 5a69d9457b1d351d64d3c8a12378bffbffb1a7ee Mon Sep 17 00:00:00 2001
From: josibake <josibake@protonmail.com>
Date: Thu, 11 Jun 2026 06:05:40 +0100
Subject: [PATCH 1/3] ipc: replace libmultiprocess runtime with native capnp

---
 CMakeLists.txt                      |    8 +-
 ci/test/03_test_script.sh           |    8 +
 src/CMakeLists.txt                  |    4 -
 src/bench/block_assemble.cpp        |    2 +-
 src/bitcoin.cpp                     |   34 +-
 src/init.cpp                        |   16 +-
 src/interfaces/ipc.h                |   14 -
 src/interfaces/mining.h             |   97 +-
 src/ipc/CMakeLists.txt              |   49 +-
 src/ipc/capnp/common-types.h        |  106 +-
 src/ipc/capnp/common.capnp          |    5 +-
 src/ipc/capnp/echo-types.h          |   12 -
 src/ipc/capnp/echo.capnp            |    9 +-
 src/ipc/capnp/init-types.h          |   11 -
 src/ipc/capnp/init.capnp            |   15 +-
 src/ipc/capnp/mining-types.h        |   20 -
 src/ipc/capnp/mining.capnp          |   99 +-
 src/ipc/capnp/mining.cpp            |   11 -
 src/ipc/capnp/protocol.cpp          | 1530 +++++++++++++++++++++++++--
 src/ipc/interfaces.cpp              |   45 +-
 src/ipc/process.cpp                 |   94 +-
 src/ipc/protocol.h                  |    5 -
 src/ipc/test/CMakeLists.txt         |    4 +-
 src/ipc/test/ipc_test.capnp         |   23 -
 src/ipc/test/ipc_test.cpp           |  465 ++++++--
 src/ipc/test/ipc_test.h             |   18 +-
 src/ipc/test/ipc_test_types.h       |   12 -
 src/ipc/test/ipc_tests.cpp          |    4 +-
 src/node/interfaces.cpp             |  448 ++++++--
 src/node/miner.cpp                  |  117 +-
 src/node/miner.h                    |   19 +-
 src/test/fuzz/package_eval.cpp      |    4 +-
 src/test/fuzz/tx_pool.cpp           |    4 +-
 src/test/miner_tests.cpp            |  409 ++++---
 src/test/peerman_tests.cpp          |    3 +-
 src/test/testnet4_miner_tests.cpp   |    9 +-
 src/test/util/mining.cpp            |   87 +-
 src/test/util/mining.h              |   43 +-
 src/test/util/setup_common.cpp      |    3 +-
 src/test/validation_block_tests.cpp |    6 +-
 40 files changed, 2858 insertions(+), 1014 deletions(-)
 delete mode 100644 src/ipc/capnp/echo-types.h
 delete mode 100644 src/ipc/capnp/init-types.h
 delete mode 100644 src/ipc/capnp/mining-types.h
 delete mode 100644 src/ipc/capnp/mining.cpp
 delete mode 100644 src/ipc/test/ipc_test.capnp
 delete mode 100644 src/ipc/test/ipc_test_types.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a56a4db40547..ba7dd35f1989 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -121,13 +121,7 @@ if(WITH_USDT)
   find_package(USDT MODULE REQUIRED)
 endif()
 
-option(WITH_EXTERNAL_LIBMULTIPROCESS "Build with external libmultiprocess library instead of with local git subtree. This is not normally recommended, but can be useful for developing libmultiprocess itself." OFF)
-if(WITH_EXTERNAL_LIBMULTIPROCESS)
-  find_package(Libmultiprocess REQUIRED COMPONENTS Lib)
-  find_package(LibmultiprocessNative REQUIRED COMPONENTS Bin
-    NAMES Libmultiprocess
-  )
-endif()
+find_package(CapnProto REQUIRED)
 
 option(BUILD_BENCH "Build bench_bitcoin executable." OFF)
 option(BUILD_FUZZ_BINARY "Build fuzz binary." OFF)
diff --git a/ci/test/03_test_script.sh b/ci/test/03_test_script.sh
index 837e661a9cc9..3774674a049e 100755
--- a/ci/test/03_test_script.sh
+++ b/ci/test/03_test_script.sh
@@ -196,6 +196,14 @@ if [ "${RUN_TIDY}" = "true" ]; then
 fi
 
 if [[ "${RUN_IWYU}" == true ]]; then
+  mkdir -p "${BASE_BUILD_DIR}/src/node/data"
+  cmake -DRAW_SOURCE_PATH="${BASE_ROOT_DIR}/src/node/data/ip_asn.dat" \
+        -DHEADER_PATH="${BASE_BUILD_DIR}/src/node/data/ip_asn.dat.h" \
+        -DRAW_NAMESPACE=node::data \
+        -P "${BASE_ROOT_DIR}/cmake/script/GenerateHeaderFromRaw.cmake"
+  # shellcheck disable=SC2086
+  cmake --build "${BASE_BUILD_DIR}" "$MAKEJOBS" --target bitcoin_ipc
+
   # TODO: Consider enforcing IWYU across the entire codebase.
   FILES_WITH_ENFORCED_IWYU="/src/(((crypto|index|kernel|primitives|script|univalue/(lib|test)|util)/.*|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"
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index f5feb9959341..c1bdab596d77 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -19,10 +19,6 @@ include(../cmake/crc32c.cmake)
 include(../cmake/leveldb.cmake)
 include(../cmake/minisketch.cmake)
 add_subdirectory(univalue)
-if (NOT WITH_EXTERNAL_LIBMULTIPROCESS)
-  include(../cmake/libmultiprocess.cmake)
-  add_libmultiprocess(ipc/libmultiprocess)
-endif()
 include(../cmake/secp256k1.cmake)
 add_secp256k1(secp256k1)
 
diff --git a/src/bench/block_assemble.cpp b/src/bench/block_assemble.cpp
index 191357fa6621..13113833345e 100644
--- a/src/bench/block_assemble.cpp
+++ b/src/bench/block_assemble.cpp
@@ -26,7 +26,7 @@ using node::BlockCreateOptions;
 
 static void AssembleBlock(benchmark::Bench& bench)
 {
-    const auto test_setup = MakeNoLogFileContext<const TestingSetup>();
+    auto test_setup = MakeNoLogFileContext<TestingSetup>();
 
     CScriptWitness witness;
     witness.stack.push_back(WITNESS_STACK_ELEM_OP_TRUE);
diff --git a/src/bitcoin.cpp b/src/bitcoin.cpp
index 4b36a03a1406..4da4f35dd748 100644
--- a/src/bitcoin.cpp
+++ b/src/bitcoin.cpp
@@ -8,14 +8,14 @@
 #include <common/args.h>
 #include <common/license_info.h>
 #include <common/system.h>
-#include <util/fs.h>
+#include <tinyformat.h>
 #include <util/exec.h>
+#include <util/fs.h>
 #include <util/strencodings.h>
 #include <util/translation.h>
 
 #include <iostream>
 #include <string>
-#include <tinyformat.h>
 #include <vector>
 
 const TranslateFn G_TRANSLATION_FUN{nullptr};
@@ -23,7 +23,7 @@ const TranslateFn G_TRANSLATION_FUN{nullptr};
 static constexpr auto HELP_USAGE = R"(Usage: %s [OPTIONS] COMMAND...
 
 Options:
-  -m, --multiprocess     Run multiprocess binary bitcoin-node.
+  -m, --ipc-server       Run IPC server binary bitcoin-node.
   -M, --monolithic       Run monolithic binary bitcoind. (Default behavior)
   -v, --version          Show version information
   -h, --help             Show full help message
@@ -47,7 +47,7 @@ Run '%s help' to see additional commands (e.g. for testing and debugging).
 )";
 
 struct CommandLine {
-    std::optional<bool> use_multiprocess;
+    std::optional<bool> use_ipc_server;
     bool show_version{false};
     bool show_help{false};
     std::string_view command;
@@ -118,10 +118,10 @@ CommandLine ParseCommandLine(int argc, char* argv[])
         std::string_view arg = argv[i];
         if (!cmd.command.empty()) {
             cmd.args.emplace_back(argv[i]);
-        } else if (arg == "-m" || arg == "--multiprocess") {
-            cmd.use_multiprocess = true;
+        } else if (arg == "-m" || arg == "--ipc-server") {
+            cmd.use_ipc_server = true;
         } else if (arg == "-M" || arg == "--monolithic") {
-            cmd.use_multiprocess = false;
+            cmd.use_ipc_server = false;
         } else if (arg == "-v" || arg == "--version") {
             cmd.show_version = true;
         } else if (arg == "-h" || arg == "--help" || arg == "help") {
@@ -139,7 +139,7 @@ bool UseMultiprocess(const CommandLine& cmd)
 {
     // If -m or -M options were explicitly specified, there is no need to
     // further parse arguments to determine which to use.
-    if (cmd.use_multiprocess) return *cmd.use_multiprocess;
+    if (cmd.use_ipc_server) return *cmd.use_ipc_server;
 
     ArgsManager args;
     args.SetDefaultFlags(ArgsManager::ALLOW_ANY);
@@ -154,8 +154,8 @@ bool UseMultiprocess(const CommandLine& cmd)
     }
     args.SelectConfigNetwork(args.GetChainTypeString());
 
-    // If any -ipc* options are set these need to be processed by a
-    // multiprocess-capable binary.
+    // If any -ipc* options are set these need to be processed by the
+    // IPC-capable server binary.
     return args.IsArgSet("-ipcbind") || args.IsArgSet("-ipcconnect") || args.IsArgSet("-ipcfd");
 }
 
@@ -187,7 +187,7 @@ static void ExecCommand(const std::vector<const char*>& args, std::string_view w
     auto try_exec = [&](fs::path exe_path, bool allow_notfound = true) {
         std::string exe_path_str{fs::PathToString(exe_path)};
         exec_args[0] = exe_path_str.c_str();
-        if (util::ExecVp(exec_args[0], (char*const*)exec_args.data()) == -1) {
+        if (util::ExecVp(exec_args[0], (char* const*)exec_args.data()) == -1) {
             if (allow_notfound && errno == ENOENT) return false;
             throw std::system_error(errno, std::system_category(), strprintf("execvp failed to execute '%s'", exec_args[0]));
         }
@@ -217,11 +217,11 @@ static void ExecCommand(const std::vector<const char*>& args, std::string_view w
     // in libexec/
     (wrapper_dir.filename() == "bin" && try_exec(wrapper_dir.parent_path() / "libexec" / arg0.filename())) ||
 #ifdef WIN32
-    // Otherwise check the "daemon" subdirectory in a windows install.
-    (!wrapper_dir.empty() && try_exec(wrapper_dir / "daemon" / arg0.filename())) ||
+        // Otherwise check the "daemon" subdirectory in a windows install.
+        (!wrapper_dir.empty() && try_exec(wrapper_dir / "daemon" / arg0.filename())) ||
 #endif
-    // Otherwise look for target executable next to current wrapper
-    (!wrapper_dir.empty() && try_exec(wrapper_dir / arg0.filename(), fallback_os_search)) ||
-    // Otherwise just look on the system path.
-    (fallback_os_search && try_exec(arg0.filename(), false));
+        // Otherwise look for target executable next to current wrapper
+        (!wrapper_dir.empty() && try_exec(wrapper_dir / arg0.filename(), fallback_os_search)) ||
+        // Otherwise just look on the system path.
+        (fallback_os_search && try_exec(arg0.filename(), false));
 }
diff --git a/src/init.cpp b/src/init.cpp
index 19cbc46c53ef..67dbd06d0d77 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -7,8 +7,6 @@
 
 #include <init.h>
 
-#include <kernel/checks.h>
-
 #include <addrdb.h>
 #include <addrman.h>
 #include <banman.h>
@@ -16,24 +14,25 @@
 #include <chain.h>
 #include <chainparams.h>
 #include <chainparamsbase.h>
+#include <chainstate.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 <init/common.h>
 #include <interfaces/chain.h>
 #include <interfaces/init.h>
 #include <interfaces/ipc.h>
 #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/checks.h>
 #include <kernel/context.h>
 #include <kernel/notifications_interface.h>
 #include <key.h>
@@ -66,6 +65,7 @@
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <protocol.h>
+#include <random.h>
 #include <scheduler.h>
 #include <script/sigcache.h>
 #include <sync.h>
@@ -90,11 +90,9 @@
 #include <util/threadnames.h>
 #include <util/time.h>
 #include <util/translation.h>
-#include <chainstate.h>
 #include <validationinterface.h>
 
 #include <algorithm>
-#include <any>
 #include <cerrno>
 #include <condition_variable>
 #include <cstddef>
diff --git a/src/interfaces/ipc.h b/src/interfaces/ipc.h
index 23b46fb68266..b3adf66403c2 100644
--- a/src/interfaces/ipc.h
+++ b/src/interfaces/ipc.h
@@ -8,7 +8,6 @@
 #include <functional>
 #include <memory>
 #include <string>
-#include <typeindex>
 
 namespace ipc {
 struct Context;
@@ -74,21 +73,8 @@ class Ipc
     //! Disconnect any incoming connections that are still connected.
     virtual void disconnectIncoming() = 0;
 
-    //! Add cleanup callback to remote interface that will run when the
-    //! interface is deleted.
-    template<typename Interface>
-    void addCleanup(Interface& iface, std::function<void()> cleanup)
-    {
-        addCleanup(typeid(Interface), &iface, std::move(cleanup));
-    }
-
     //! IPC context struct accessor (see struct definition for more description).
     virtual ipc::Context& context() = 0;
-
-protected:
-    //! Internal implementation of public addCleanup method (above) as a
-    //! type-erased virtual function, since template functions can't be virtual.
-    virtual void addCleanup(std::type_index type, void* iface, std::function<void()> cleanup) = 0;
 };
 
 //! Return implementation of Ipc interface.
diff --git a/src/interfaces/mining.h b/src/interfaces/mining.h
index ff4f87109f92..02be9bf8e74f 100644
--- a/src/interfaces/mining.h
+++ b/src/interfaces/mining.h
@@ -6,14 +6,17 @@
 #define BITCOIN_INTERFACES_MINING_H
 
 #include <consensus/amount.h>
+#include <interfaces/handler.h>
 #include <interfaces/types.h>
 #include <node/mining_types.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <uint256.h>
+#include <util/result.h>
 #include <util/time.h>
 
 #include <cstdint>
+#include <functional>
 #include <memory>
 #include <optional>
 #include <string>
@@ -29,6 +32,9 @@ namespace interfaces {
 class BlockTemplate
 {
 public:
+    using NextTemplateFn = std::function<void(std::unique_ptr<BlockTemplate>)>;
+    using SubmitSolutionFn = std::function<void(bool)>;
+
     virtual ~BlockTemplate() = default;
 
     virtual CBlockHeader getBlockHeader() = 0;
@@ -75,25 +81,26 @@ class BlockTemplate
      *       the solved block is constructed and broadcast by multiple nodes
      *       (e.g. both the miner who constructed the template and the pool).
      */
-    virtual bool submitSolution(uint32_t version, uint32_t timestamp, uint32_t nonce, CTransactionRef coinbase) = 0;
+    /**
+     * Construct and broadcast the block asynchronously. The returned handler
+     * cancels the submission before the callback runs.
+     */
+    virtual std::unique_ptr<Handler> submitSolutionAsync(uint32_t version, uint32_t timestamp, uint32_t nonce, CTransactionRef coinbase, SubmitSolutionFn fn) = 0;
 
     /**
-     * Waits for fees in the next block to rise, a new tip or the timeout.
+     * Watches for fees in the next block to rise, a new tip or the timeout.
      *
      * @param[in] options   Control the timeout (default forever) and by how much total fees
      *                      for the next block should rise (default infinite).
+     * @param[in] fn        Called with a new block template, or nullptr on
+     *                      timeout or cancellation.
      *
-     * @returns a new BlockTemplate or nothing if the timeout occurs.
+     * @returns a handler that cancels the watch before the callback runs.
      *
      * On testnet this will additionally return a template with difficulty 1 if
      * the tip is more than 20 minutes old.
      */
-    virtual std::unique_ptr<BlockTemplate> waitNext(node::BlockWaitOptions options = {}) = 0;
-
-    /**
-     * Interrupts the current wait for the next block template.
-    */
-    virtual void interruptWait() = 0;
+    virtual std::unique_ptr<Handler> watchNext(node::BlockWaitOptions options, NextTemplateFn fn) = 0;
 };
 
 //! Interface giving clients (RPC, Stratum v2 Template Provider in the future)
@@ -101,6 +108,12 @@ class BlockTemplate
 class Mining
 {
 public:
+    using TipChangedFn = std::function<void(std::optional<BlockRef>)>;
+    using CreateBlockResult = util::Result<std::unique_ptr<BlockTemplate>>;
+    using CreateBlockFn = std::function<void(CreateBlockResult)>;
+    using CheckBlockFn = std::function<void(bool, std::string, std::string)>;
+    using SubmitBlockFn = std::function<void(bool, std::string, std::string)>;
+
     virtual ~Mining() = default;
 
     //! If this chain is exclusively used for testing
@@ -112,21 +125,12 @@ class Mining
     //! Returns the hash and height for the tip of this chain
     virtual std::optional<BlockRef> getTip() = 0;
 
-    /**
-     * Waits for the connected tip to change. During node initialization, this will
-     * wait until the tip is connected (regardless of `timeout`).
-     *
-     * @param[in] current_tip block hash of the current chain tip. Function waits
-     *                        for the chain tip to differ from this.
-     * @param[in] timeout     how long to wait for a new tip (default is forever)
-     *
-     * @retval BlockRef hash and height of the current chain tip after this call.
-     * @retval std::nullopt if the node is shut down or interrupt() is called.
-     */
-    virtual std::optional<BlockRef> waitTipChanged(uint256 current_tip, MillisecondsDouble timeout = MillisecondsDouble::max()) = 0;
+    //! Watches for the connected tip to differ from current_tip. The returned
+    //! handler cancels the watch before the callback runs.
+    virtual std::unique_ptr<Handler> watchTip(uint256 current_tip, MillisecondsDouble timeout, TipChangedFn fn) = 0;
 
-   /**
-     * Construct a new block template.
+    /**
+     * Construct a new block template asynchronously.
      *
      * @param[in] options options for creating the block
      * @param[in] cooldown wait for tip to be connected and IBD to complete.
@@ -134,55 +138,50 @@ class Mining
      *                     tip to catch up. It's recommended to disable this on
      *                     regtest and signets with only one miner, as these
      *                     could stall.
-     * @retval BlockTemplate a block template.
-     * @retval std::nullptr if the node is shut down or interrupt() is called.
-     */
-    virtual std::unique_ptr<BlockTemplate> createNewBlock(const node::BlockCreateOptions& options = {}, bool cooldown = true) = 0;
-
-    /**
-     * Interrupts createNewBlock and waitTipChanged.
+     * @param[in] fn called with a block template result. A successful result
+     *               may contain nullptr when the operation is cancelled or the
+     *               node is shutting down.
+     *
+     * @returns a handler that cancels the operation before the callback runs.
      */
-    virtual void interrupt() = 0;
+    virtual std::unique_ptr<Handler> createNewBlockAsync(const node::BlockCreateOptions& options, bool cooldown, CreateBlockFn fn) = 0;
 
     /**
-     * Checks if a given block is valid.
+     * Checks if a given block is valid asynchronously.
      *
      * @param[in] block       the block to check
      * @param[in] options     verification options: the proof-of-work check can be
      *                        skipped in order to verify a template generated by
      *                        external software.
-     * @param[out] reason     failure reason (BIP22)
-     * @param[out] debug      more detailed rejection reason
-     * @returns               whether the block is valid
+     * @param[in] fn          called with validity, failure reason (BIP22), and
+     *                        more detailed rejection reason.
      *
      * For signets the challenge verification is skipped when check_pow is false.
      */
-    virtual bool checkBlock(const CBlock& block, const node::BlockCheckOptions& options, std::string& reason, std::string& debug) = 0;
+    virtual std::unique_ptr<Handler> checkBlockAsync(CBlock block, node::BlockCheckOptions options, CheckBlockFn fn) = 0;
 
     /**
-     * Process a fully assembled block.
+     * Process a fully assembled block asynchronously.
      *
-     * Similar to the submitblock RPC. Accepts a complete block, validates
-     * it, and if accepted as new, processes it into chainstate. Accepted
-     * blocks may then be announced to peers through normal validation signals.
+     * Similar to the submitblock RPC. Accepts a complete block, validates it,
+     * and if accepted as new, processes it into chainstate. Accepted blocks may
+     * then be announced to peers through normal validation signals.
      *
-     * @param[in]  block  the complete block to submit
-     * @param[out] reason failure reason (BIP22)
-     * @param[out] debug  more detailed rejection reason
-     * @returns           true if the block was accepted as a new block. Returns
-     *                    false and sets reason if the block is a duplicate or
-     *                    the validation result is inconclusive.
+     * @param[in] block the complete block to submit
+     * @param[in] fn called with accepted, failure reason (BIP22), and more
+     *               detailed rejection reason. Accepted is false for duplicate
+     *               or inconclusive validation results.
      *
      * @note Unlike the submitblock RPC, this method does not call
      *       UpdateUncommittedBlockStructures to add a missing coinbase witness
      *       reserved value. Callers must submit a fully formed block, including
      *       the coinbase witness when a witness commitment is present.
      */
-    virtual bool submitBlock(const CBlock& block, std::string& reason, std::string& debug) = 0;
+    virtual std::unique_ptr<Handler> submitBlockAsync(CBlock block, SubmitBlockFn fn) = 0;
 
     //! Get internal node context. Useful for RPC and testing,
     //! but not accessible across processes.
-    virtual const node::NodeContext* context() { return nullptr; }
+    virtual node::NodeContext* context() { return nullptr; }
 };
 
 //! Return implementation of Mining interface.
@@ -190,7 +189,7 @@ class Mining
 //! @param[in] wait_loaded waits for chainstate data to be loaded before
 //!                        returning. Used to prevent external clients from
 //!                        being able to crash the node during startup.
-std::unique_ptr<Mining> MakeMining(const node::NodeContext& node, bool wait_loaded=true);
+std::unique_ptr<Mining> MakeMining(node::NodeContext& node, bool wait_loaded = true);
 
 } // namespace interfaces
 
diff --git a/src/ipc/CMakeLists.txt b/src/ipc/CMakeLists.txt
index 5378ef1924bf..068412f11ea6 100644
--- a/src/ipc/CMakeLists.txt
+++ b/src/ipc/CMakeLists.txt
@@ -2,48 +2,33 @@
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or https://opensource.org/license/mit/.
 
-add_library(bitcoin_ipc STATIC EXCLUDE_FROM_ALL
-  capnp/mining.cpp
-  capnp/protocol.cpp
-  interfaces.cpp
-  process.cpp
-)
-
-target_capnp_sources(bitcoin_ipc ${CMAKE_CURRENT_SOURCE_DIR}
+set(CAPNPC_SRC_PREFIX ${CMAKE_CURRENT_SOURCE_DIR})
+set(CAPNPC_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
+capnp_generate_cpp(IPC_CAPNP_SRCS IPC_CAPNP_HDRS
   capnp/common.capnp
   capnp/echo.capnp
   capnp/init.capnp
   capnp/mining.capnp
 )
 
+add_library(bitcoin_ipc STATIC EXCLUDE_FROM_ALL
+  ${IPC_CAPNP_SRCS}
+  ${IPC_CAPNP_HDRS}
+  capnp/protocol.cpp
+  interfaces.cpp
+  process.cpp
+)
+
 target_link_libraries(bitcoin_ipc
   PRIVATE
+    bitcoin_common
     core_interface
     univalue
-    Boost::headers
+    CapnProto::capnp-rpc
+)
+target_include_directories(bitcoin_ipc
+  PUBLIC
+    ${CMAKE_CURRENT_BINARY_DIR}
 )
-
-if(BUILD_TESTS)
-  # bitcoin_ipc_test library target is defined here in src/ipc/CMakeLists.txt
-  # instead of src/ipc/test/CMakeLists.txt so capnp files in src/ipc/test/ are able to
-  # reference capnp files in src/ipc/capnp/ by relative path. The Cap'n Proto
-  # compiler only allows importing by relative path when the importing and
-  # imported files are underneath the same compilation source prefix, so the
-  # source prefix must be src/ipc, not src/ipc/test/
-  add_library(bitcoin_ipc_test STATIC EXCLUDE_FROM_ALL
-    test/ipc_test.cpp
-  )
-  target_capnp_sources(bitcoin_ipc_test ${CMAKE_CURRENT_SOURCE_DIR}
-    test/ipc_test.capnp
-  )
-  add_dependencies(bitcoin_ipc_test bitcoin_ipc_headers)
-
-  target_link_libraries(bitcoin_ipc_test
-    PRIVATE
-      core_interface
-      univalue
-      Boost::headers
-  )
-endif()
 
 configure_file(.clang-tidy.in .clang-tidy USE_SOURCE_PERMISSIONS COPYONLY)
diff --git a/src/ipc/capnp/common-types.h b/src/ipc/capnp/common-types.h
index 309799b8afff..5512e8a9d2dd 100644
--- a/src/ipc/capnp/common-types.h
+++ b/src/ipc/capnp/common-types.h
@@ -5,30 +5,16 @@
 #ifndef BITCOIN_IPC_CAPNP_COMMON_TYPES_H
 #define BITCOIN_IPC_CAPNP_COMMON_TYPES_H
 
-#include <clientversion.h>
-#include <interfaces/types.h>
-#include <primitives/transaction.h>
+#include <capnp/blob.h>
 #include <serialize.h>
 #include <streams.h>
-#include <univalue.h>
 
 #include <cstddef>
-#include <mp/proxy-types.h>
-#include <mp/type-chrono.h>
-#include <mp/type-context.h>
-#include <mp/type-data.h>
-#include <mp/type-decay.h>
-#include <mp/type-interface.h>
-#include <mp/type-message.h>
-#include <mp/type-number.h>
-#include <mp/type-optional.h>
-#include <mp/type-pointer.h>
-#include <mp/type-string.h>
-#include <mp/type-struct.h>
-#include <mp/type-threadmap.h>
-#include <mp/type-vector.h>
+#include <cstring>
+#include <span>
 #include <type_traits>
 #include <utility>
+#include <vector>
 
 namespace ipc {
 namespace capnp {
@@ -50,83 +36,45 @@ auto Wrap(S& s)
 //! existing objects because they are immutable.
 template <typename T>
 concept Deserializable = std::is_constructible_v<T, ::deserialize_type, ::DataStream&>;
-} // namespace capnp
-} // namespace ipc
 
-//! Functions to serialize / deserialize common bitcoin types.
-namespace mp {
-//! Overload multiprocess library's CustomBuildField hook to allow any
-//! serializable object to be stored in a capnproto Data field or passed to a
-//! capnproto interface. Use Priority<1> so this hook has medium priority, and
-//! higher priority hooks could take precedence over this one.
-template <typename LocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<LocalType>, Priority<1>, InvokeContext& invoke_context, Value&& value, Output&& output)
-// Enable if serializeable and if LocalType is not cv or reference qualified. If
-// LocalType is cv or reference qualified, it is important to fall back to
-// lower-priority Priority<0> implementation of this function that strips cv
-// references, to prevent this CustomBuildField overload from taking precedence
-// over more narrow overloads for specific LocalTypes.
-requires Serializable<LocalType, DataStream> && std::is_same_v<LocalType, std::remove_cv_t<std::remove_reference_t<LocalType>>>
+template <typename T>
+std::vector<unsigned char> SerializeBytes(const T& value)
+    requires Serializable<T, DataStream>
 {
     DataStream stream;
     auto wrapper{ipc::capnp::Wrap(stream)};
-    value.Serialize(wrapper);
-    auto result = output.init(stream.size());
-    memcpy(result.begin(), stream.data(), stream.size());
-}
-
-//! Overload multiprocess library's CustomReadField hook to allow any object
-//! with an Unserialize method to be read from a capnproto Data field or
-//! returned from capnproto interface. Use Priority<1> so this hook has medium
-//! priority, and higher priority hooks could take precedence over this one.
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<LocalType>, Priority<1>, InvokeContext& invoke_context, Input&& input, ReadDest&& read_dest)
-requires Unserializable<LocalType, DataStream> && (!ipc::capnp::Deserializable<LocalType>)
-{
-    return read_dest.update([&](auto& value) {
-        if (!input.has()) return;
-        auto data = input.get();
-        SpanReader stream({data.begin(), data.end()});
-        auto wrapper{ipc::capnp::Wrap(stream)};
-        value.Unserialize(wrapper);
-    });
+    wrapper << value;
+    std::vector<unsigned char> bytes(stream.size());
+    std::memcpy(bytes.data(), stream.data(), stream.size());
+    return bytes;
 }
 
-//! Overload multiprocess library's CustomReadField hook to allow any object
-//! with a deserialize constructor to be read from a capnproto Data field or
-//! returned from capnproto interface. Use Priority<1> so this hook has medium
-//! priority, and higher priority hooks could take precedence over this one.
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<LocalType>, Priority<1>, InvokeContext& invoke_context, Input&& input, ReadDest&& read_dest)
-requires ipc::capnp::Deserializable<LocalType>
+template <typename T>
+T DeserializeBytes(::capnp::Data::Reader data)
+    requires Deserializable<T>
 {
-    assert(input.has());
-    auto data = input.get();
     SpanReader stream({data.begin(), data.end()});
     auto wrapper{ipc::capnp::Wrap(stream)};
-    return read_dest.construct(::deserialize, wrapper);
+    return T{::deserialize, wrapper};
 }
 
-//! Overload CustomBuildField and CustomReadField to serialize UniValue
-//! parameters and return values as JSON strings.
-template <typename Value, typename Output>
-void CustomBuildField(TypeList<UniValue>, Priority<1>, InvokeContext& invoke_context, Value&& value, Output&& output)
+template <typename T>
+T DeserializeBytes(::capnp::Data::Reader data)
+    requires Unserializable<T, DataStream> && (!Deserializable<T>)
 {
-    std::string str = value.write();
-    auto result = output.init(str.size());
-    memcpy(result.begin(), str.data(), str.size());
+    T value;
+    SpanReader stream({data.begin(), data.end()});
+    auto wrapper{ipc::capnp::Wrap(stream)};
+    wrapper >> value;
+    return value;
 }
 
-template <typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<UniValue>, Priority<1>, InvokeContext& invoke_context, Input&& input,
-                               ReadDest&& read_dest)
+inline void SetData(::capnp::Data::Builder output, std::span<const unsigned char> bytes)
 {
-    return read_dest.update([&](auto& value) {
-        auto data = input.get();
-        value.read(std::string_view{data.begin(), data.size()});
-    });
+    std::memcpy(output.begin(), bytes.data(), bytes.size());
 }
 
-} // namespace mp
+} // namespace capnp
+} // namespace ipc
 
 #endif // BITCOIN_IPC_CAPNP_COMMON_TYPES_H
diff --git a/src/ipc/capnp/common.capnp b/src/ipc/capnp/common.capnp
index cae6603d80ce..de2414cdf1b0 100644
--- a/src/ipc/capnp/common.capnp
+++ b/src/ipc/capnp/common.capnp
@@ -7,10 +7,7 @@
 using Cxx = import "/capnp/c++.capnp";
 $Cxx.namespace("ipc::capnp::messages");
 
-using Proxy = import "/mp/proxy.capnp";
-$Proxy.includeTypes("ipc/capnp/common-types.h");
-
-struct BlockRef $Proxy.wrap("interfaces::BlockRef") {
+struct BlockRef {
     hash @0 :Data;
     height @1 :Int32;
 }
diff --git a/src/ipc/capnp/echo-types.h b/src/ipc/capnp/echo-types.h
deleted file mode 100644
index 47eadce10c32..000000000000
--- a/src/ipc/capnp/echo-types.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) 2025-present The Bitcoin Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef BITCOIN_IPC_CAPNP_ECHO_TYPES_H
-#define BITCOIN_IPC_CAPNP_ECHO_TYPES_H
-
-#include <mp/type-context.h>
-#include <mp/type-decay.h>
-#include <mp/type-string.h>
-
-#endif // BITCOIN_IPC_CAPNP_ECHO_TYPES_H
diff --git a/src/ipc/capnp/echo.capnp b/src/ipc/capnp/echo.capnp
index ce7ea3f65625..64f69d13f3fd 100644
--- a/src/ipc/capnp/echo.capnp
+++ b/src/ipc/capnp/echo.capnp
@@ -7,11 +7,6 @@
 using Cxx = import "/capnp/c++.capnp";
 $Cxx.namespace("ipc::capnp::messages");
 
-using Proxy = import "/mp/proxy.capnp";
-$Proxy.include("interfaces/echo.h");
-$Proxy.includeTypes("ipc/capnp/echo-types.h");
-
-interface Echo $Proxy.wrap("interfaces::Echo") {
-    destroy @0 (context :Proxy.Context) -> ();
-    echo @1 (context :Proxy.Context, echo: Text) -> (result :Text);
+interface Echo {
+    echo @0 (message :Text) -> (message :Text);
 }
diff --git a/src/ipc/capnp/init-types.h b/src/ipc/capnp/init-types.h
deleted file mode 100644
index 2abd7b211e17..000000000000
--- a/src/ipc/capnp/init-types.h
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright (c) 2021-present The Bitcoin Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef BITCOIN_IPC_CAPNP_INIT_TYPES_H
-#define BITCOIN_IPC_CAPNP_INIT_TYPES_H
-
-#include <ipc/capnp/echo.capnp.proxy-types.h>
-#include <ipc/capnp/mining.capnp.proxy-types.h>
-
-#endif // BITCOIN_IPC_CAPNP_INIT_TYPES_H
diff --git a/src/ipc/capnp/init.capnp b/src/ipc/capnp/init.capnp
index 094305b44341..6ba046123049 100644
--- a/src/ipc/capnp/init.capnp
+++ b/src/ipc/capnp/init.capnp
@@ -7,18 +7,11 @@
 using Cxx = import "/capnp/c++.capnp";
 $Cxx.namespace("ipc::capnp::messages");
 
-using Proxy = import "/mp/proxy.capnp";
-$Proxy.include("interfaces/echo.h");
-$Proxy.include("interfaces/init.h");
-$Proxy.include("interfaces/mining.h");
-$Proxy.includeTypes("ipc/capnp/init-types.h");
-
 using Echo = import "echo.capnp";
 using Mining = import "mining.capnp";
 
-interface Init $Proxy.wrap("interfaces::Init") {
-    construct @0 (threadMap: Proxy.ThreadMap) -> (threadMap :Proxy.ThreadMap);
-    makeEcho @1 (context :Proxy.Context) -> (result :Echo.Echo);
-    makeMining @2 (context :Proxy.Context) -> (result :Mining.Mining);
-    stop @3 (context :Proxy.Context) -> ();
+interface Init {
+    makeEcho @0 () -> (result :Echo.Echo);
+    makeMining @1 () -> (result :Mining.Mining);
+    stop @2 () -> ();
 }
diff --git a/src/ipc/capnp/mining-types.h b/src/ipc/capnp/mining-types.h
deleted file mode 100644
index 8e3286f1304f..000000000000
--- a/src/ipc/capnp/mining-types.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) 2024-present The Bitcoin Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef BITCOIN_IPC_CAPNP_MINING_TYPES_H
-#define BITCOIN_IPC_CAPNP_MINING_TYPES_H
-
-#include <interfaces/mining.h>
-#include <ipc/capnp/common.capnp.proxy-types.h>
-#include <ipc/capnp/common-types.h>
-#include <ipc/capnp/mining.capnp.proxy.h>
-#include <node/miner.h>
-#include <node/types.h>
-#include <chainstate.h>
-
-namespace mp {
-// Custom serializations
-} // namespace mp
-
-#endif // BITCOIN_IPC_CAPNP_MINING_TYPES_H
diff --git a/src/ipc/capnp/mining.capnp b/src/ipc/capnp/mining.capnp
index a6dd8d71f315..3acde7912401 100644
--- a/src/ipc/capnp/mining.capnp
+++ b/src/ipc/capnp/mining.capnp
@@ -8,61 +8,78 @@ using Cxx = import "/capnp/c++.capnp";
 $Cxx.namespace("ipc::capnp::messages");
 
 using Common = import "common.capnp";
-using Proxy = import "/mp/proxy.capnp";
-$Proxy.include("interfaces/mining.h");
-$Proxy.includeTypes("ipc/capnp/mining-types.h");
 
 const maxMoney :Int64 = 2100000000000000;
 const maxDouble :Float64 = 1.7976931348623157e308;
 const defaultBlockReservedWeight :UInt32 = 8000;
 const defaultCoinbaseOutputMaxAdditionalSigops :UInt32 = 400;
 
-interface Mining $Proxy.wrap("interfaces::Mining") {
-    isTestChain @0 (context :Proxy.Context) -> (result: Bool);
-    isInitialBlockDownload @1 (context :Proxy.Context) -> (result: Bool);
-    getTip @2 (context :Proxy.Context) -> (result: Common.BlockRef, hasResult: Bool);
-    waitTipChanged @3 (context :Proxy.Context, currentTip: Data, timeout: Float64 = .maxDouble) -> (result: Common.BlockRef);
-    createNewBlock @4 (context :Proxy.Context, options: BlockCreateOptions, cooldown: Bool = true) -> (result: BlockTemplate);
-    checkBlock @5 (context :Proxy.Context, block: Data, options: BlockCheckOptions) -> (reason: Text, debug: Text, result: Bool);
-    interrupt @6 () -> ();
-    submitBlock @7 (context :Proxy.Context, block: Data) -> (reason: Text, debug: Text, result: Bool);
+interface Mining {
+    isTestChain @0 () -> (result: Bool);
+    isInitialBlockDownload @1 () -> (result: Bool);
+    getTip @2 () -> (result: Common.BlockRef, found: Bool);
+    createNewBlock @3 (options: BlockCreateOptions, cooldown: Bool = true) -> (result: BlockTemplate, found: Bool);
+    checkBlock @4 (block: Data, options: BlockCheckOptions) -> (reason: Text, debug: Text, result: Bool);
+    watchTip @5 (currentTip: Data, timeout: Float64 = .maxDouble, listener: TipListener) -> (watch: Watch);
+    submitBlock @6 (block: Data) -> (reason: Text, debug: Text, result: Bool);
 }
 
-interface BlockTemplate $Proxy.wrap("interfaces::BlockTemplate") {
-    destroy @0 (context :Proxy.Context) -> ();
-    getBlockHeader @1 (context: Proxy.Context) -> (result: Data);
-    getBlock @2 (context: Proxy.Context) -> (result: Data);
-    getTxFees @3 (context: Proxy.Context) -> (result: List(Int64));
-    getTxSigops @4 (context: Proxy.Context) -> (result: List(Int64));
-    getCoinbaseTx @5 (context: Proxy.Context) -> (result: CoinbaseTx);
-    getCoinbaseMerklePath @6 (context: Proxy.Context) -> (result: List(Data));
-    submitSolution @7 (context: Proxy.Context, version: UInt32, timestamp: UInt32, nonce: UInt32, coinbase :Data) -> (result: Bool);
-    waitNext @8 (context: Proxy.Context, options: BlockWaitOptions) -> (result: BlockTemplate);
-    interruptWait @9() -> ();
+interface BlockTemplate {
+    getBlockHeader @0 () -> (result: Data);
+    getBlock @1 () -> (result: Data);
+    getTxFees @2 () -> (result: List(Int64));
+    getTxSigops @3 () -> (result: List(Int64));
+    getCoinbaseTx @4 () -> (result: CoinbaseTx);
+    getCoinbaseMerklePath @5 () -> (result: List(Data));
+    submitSolution @6 (version: UInt32, timestamp: UInt32, nonce: UInt32, coinbase: Data) -> (result: Bool);
+    watchNext @7 (options: BlockWaitOptions, listener: BlockTemplateListener) -> (watch: Watch);
 }
 
-struct BlockCreateOptions $Proxy.wrap("node::BlockCreateOptions") {
-    useMempool @0 :Bool = true $Proxy.name("use_mempool");
-    blockReservedWeight @1 :UInt64 = .defaultBlockReservedWeight $Proxy.name("block_reserved_weight");
-    coinbaseOutputMaxAdditionalSigops @2 :UInt64 = .defaultCoinbaseOutputMaxAdditionalSigops $Proxy.name("coinbase_output_max_additional_sigops");
+interface TipListener {
+    tipChanged @0 (tip: Common.BlockRef) -> ();
+    stopped @1 () -> ();
 }
 
-struct BlockWaitOptions $Proxy.wrap("node::BlockWaitOptions") {
-    timeout @0 : Float64 = .maxDouble $Proxy.name("timeout");
-    feeThreshold @1 : Int64 = .maxMoney $Proxy.name("fee_threshold");
+interface BlockTemplateListener {
+    templateReady @0 (result: BlockTemplate) -> ();
+    stopped @1 () -> ();
 }
 
-struct BlockCheckOptions $Proxy.wrap("node::BlockCheckOptions") {
-    checkMerkleRoot @0 :Bool = true $Proxy.name("check_merkle_root");
-    checkPow @1 :Bool = true $Proxy.name("check_pow");
+interface Watch {
+    cancel @0 () -> ();
 }
 
-struct CoinbaseTx $Proxy.wrap("node::CoinbaseTx") {
-    version @0 :UInt32 $Proxy.name("version");
-    sequence @1 :UInt32 $Proxy.name("sequence");
-    scriptSigPrefix @2 :Data $Proxy.name("script_sig_prefix");
-    witness @3 :Data $Proxy.name("witness");
-    blockRewardRemaining @4 :Int64 $Proxy.name("block_reward_remaining");
-    requiredOutputs @5 :List(Data) $Proxy.name("required_outputs");
-    lockTime @6 :UInt32 $Proxy.name("lock_time");
+struct BlockCreateOptions {
+    useMempool @0 :Bool = true;
+    hasBlockMinFeeRate @1 :Bool = false;
+    blockMinFeeRate @2 :Data;
+    hasPrintModifiedFee @3 :Bool = false;
+    printModifiedFee @4 :Bool = false;
+    hasBlockReservedWeight @5 :Bool = false;
+    blockReservedWeight @6 :UInt64 = .defaultBlockReservedWeight;
+    hasBlockMaxWeight @7 :Bool = false;
+    blockMaxWeight @8 :UInt64 = 0;
+    coinbaseOutputMaxAdditionalSigops @9 :UInt64 = .defaultCoinbaseOutputMaxAdditionalSigops;
+    coinbaseOutputScript @10 :Data;
+    testBlockValidity @11 :Bool = true;
+}
+
+struct BlockWaitOptions {
+    timeout @0 : Float64 = .maxDouble;
+    feeThreshold @1 : Int64 = .maxMoney;
+}
+
+struct BlockCheckOptions {
+    checkMerkleRoot @0 :Bool = true;
+    checkPow @1 :Bool = true;
+}
+
+struct CoinbaseTx {
+    version @0 :UInt32;
+    sequence @1 :UInt32;
+    scriptSigPrefix @2 :Data;
+    witness @3 :Data;
+    blockRewardRemaining @4 :Int64;
+    requiredOutputs @5 :List(Data);
+    lockTime @6 :UInt32;
 }
diff --git a/src/ipc/capnp/mining.cpp b/src/ipc/capnp/mining.cpp
deleted file mode 100644
index 706fd1546880..000000000000
--- a/src/ipc/capnp/mining.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright (c) 2024-present The Bitcoin Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include <ipc/capnp/mining-types.h>
-#include <ipc/capnp/mining.capnp.proxy-types.h>
-
-#include <mp/proxy-types.h>
-
-namespace mp {
-} // namespace mp
diff --git a/src/ipc/capnp/protocol.cpp b/src/ipc/capnp/protocol.cpp
index 2645e46f70f2..ceed755575c7 100644
--- a/src/ipc/capnp/protocol.cpp
+++ b/src/ipc/capnp/protocol.cpp
@@ -2,152 +2,1488 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <ipc/capnp/protocol.h>
+
+#include <capnp/rpc-twoparty.h>
+#include <capnp/rpc.h>
+#include <interfaces/echo.h>
 #include <interfaces/init.h>
+#include <interfaces/mining.h>
+#include <ipc/capnp/common-types.h>
 #include <ipc/capnp/context.h>
+#include <ipc/capnp/echo.capnp.h>
 #include <ipc/capnp/init.capnp.h>
-#include <ipc/capnp/init.capnp.proxy.h>
-#include <ipc/capnp/protocol.h>
+#include <ipc/capnp/mining.capnp.h>
 #include <ipc/exception.h>
 #include <ipc/protocol.h>
-#include <kj/async.h>
+#include <kj/async-io.h>
+#include <kj/debug.h>
 #include <logging.h>
-#include <mp/proxy-io.h>
-#include <mp/proxy-types.h>
-#include <mp/util.h>
+#include <node/mining_types.h>
+#include <policy/feerate.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
+#include <script/script.h>
+#include <sys/socket.h>
+#include <uint256.h>
+#include <unistd.h>
+#include <util/result.h>
+#include <util/syserror.h>
 #include <util/threadnames.h>
 
-#include <cassert>
+#include <algorithm>
+#include <atomic>
 #include <cerrno>
+#include <condition_variable>
+#include <cstring>
+#include <deque>
+#include <functional>
 #include <future>
 #include <memory>
 #include <mutex>
 #include <optional>
+#include <span>
 #include <string>
-#include <sys/socket.h>
 #include <system_error>
 #include <thread>
+#include <utility>
+#include <vector>
 
 namespace ipc {
 namespace capnp {
 namespace {
 
-mp::Log GetRequestedIPCLogLevel()
+namespace messages = ipc::capnp::messages;
+
+::capnp::rpc::twoparty::VatId::Reader ServerVatId(::capnp::MallocMessageBuilder& message)
+{
+    auto vat_id{message.getRoot<::capnp::rpc::twoparty::VatId>()};
+    vat_id.setSide(::capnp::rpc::twoparty::Side::SERVER);
+    return vat_id.asReader();
+}
+
+uint256 ReadUint256(::capnp::Data::Reader data)
+{
+    if (data.size() != uint256::size()) {
+        throw Exception{"invalid uint256 byte length"};
+    }
+    uint256 value;
+    std::copy(data.begin(), data.end(), value.begin());
+    return value;
+}
+
+void SetBytes(::capnp::Data::Builder output, std::span<const unsigned char> bytes)
+{
+    std::memcpy(output.begin(), bytes.data(), bytes.size());
+}
+
+void SetBlockRef(messages::BlockRef::Builder builder, const interfaces::BlockRef& block)
 {
-    if (LogAcceptCategory(BCLog::IPC, BCLog::Level::Trace)) return mp::Log::Trace;
-    if (LogAcceptCategory(BCLog::IPC, BCLog::Level::Debug)) return mp::Log::Debug;
+    SetBytes(builder.initHash(uint256::size()), {block.hash.data(), block.hash.size()});
+    builder.setHeight(block.height);
+}
 
-    // Info, Warning, and Error are logged unconditionally
-    return mp::Log::Info;
+interfaces::BlockRef ReadBlockRef(messages::BlockRef::Reader reader)
+{
+    return {.hash = ReadUint256(reader.getHash()), .height = reader.getHeight()};
+}
+
+CScript ReadScript(::capnp::Data::Reader data)
+{
+    return {data.begin(), data.end()};
 }
 
-void IpcLogFn(mp::LogMessage message)
+node::BlockCreateOptions ReadBlockCreateOptions(messages::BlockCreateOptions::Reader reader)
 {
-    switch (message.level) {
-    case mp::Log::Trace:
-        LogTrace(BCLog::IPC, "%s", message.message);
-        return;
-    case mp::Log::Debug:
-        LogDebug(BCLog::IPC, "%s", message.message);
-        return;
-    case mp::Log::Info:
-        LogInfo("ipc: %s", message.message);
-        return;
-    case mp::Log::Warning:
-        LogWarning("ipc: %s", message.message);
-        return;
-    case mp::Log::Error:
-        LogError("ipc: %s", message.message);
-        return;
-    case mp::Log::Raise:
-        LogError("ipc: %s", message.message);
-        throw Exception(message.message);
-    } // no default case, so the compiler can warn about missing cases
+    node::BlockCreateOptions options;
+    options.use_mempool = reader.getUseMempool();
+    if (reader.getHasBlockMinFeeRate()) options.block_min_fee_rate = ipc::capnp::DeserializeBytes<CFeeRate>(reader.getBlockMinFeeRate());
+    if (reader.getHasPrintModifiedFee()) options.print_modified_fee = reader.getPrintModifiedFee();
+    if (reader.getHasBlockReservedWeight()) options.block_reserved_weight = reader.getBlockReservedWeight();
+    if (reader.getHasBlockMaxWeight()) options.block_max_weight = reader.getBlockMaxWeight();
+    options.coinbase_output_max_additional_sigops = reader.getCoinbaseOutputMaxAdditionalSigops();
+    options.test_block_validity = reader.getTestBlockValidity();
+    if (reader.getCoinbaseOutputScript().size() > 0) {
+        options.coinbase_output_script = ReadScript(reader.getCoinbaseOutputScript());
+    }
+    return options;
+}
 
-    // Be conservative and assume that if MP ever adds a new log level, it
-    // should only be shown at our most verbose level.
-    LogTrace(BCLog::IPC, "%s", message.message);
+void SetBlockCreateOptions(messages::BlockCreateOptions::Builder builder, const node::BlockCreateOptions& options)
+{
+    builder.setUseMempool(options.use_mempool);
+    builder.setHasBlockMinFeeRate(options.block_min_fee_rate.has_value());
+    if (options.block_min_fee_rate) {
+        const auto fee_rate_bytes{ipc::capnp::SerializeBytes(*options.block_min_fee_rate)};
+        SetBytes(builder.initBlockMinFeeRate(fee_rate_bytes.size()), fee_rate_bytes);
+    }
+    builder.setHasPrintModifiedFee(options.print_modified_fee.has_value());
+    if (options.print_modified_fee) builder.setPrintModifiedFee(*options.print_modified_fee);
+    builder.setHasBlockReservedWeight(options.block_reserved_weight.has_value());
+    if (options.block_reserved_weight) builder.setBlockReservedWeight(*options.block_reserved_weight);
+    builder.setHasBlockMaxWeight(options.block_max_weight.has_value());
+    if (options.block_max_weight) builder.setBlockMaxWeight(*options.block_max_weight);
+    builder.setCoinbaseOutputMaxAdditionalSigops(options.coinbase_output_max_additional_sigops);
+    SetBytes(builder.initCoinbaseOutputScript(options.coinbase_output_script.size()), {options.coinbase_output_script.data(), options.coinbase_output_script.size()});
+    builder.setTestBlockValidity(options.test_block_validity);
 }
 
-class CapnpProtocol : public Protocol
+node::BlockWaitOptions ReadBlockWaitOptions(messages::BlockWaitOptions::Reader reader)
+{
+    return {
+        .timeout = MillisecondsDouble{reader.getTimeout()},
+        .fee_threshold = reader.getFeeThreshold(),
+    };
+}
+
+void SetBlockWaitOptions(messages::BlockWaitOptions::Builder builder, const node::BlockWaitOptions& options)
+{
+    builder.setTimeout(options.timeout.count());
+    builder.setFeeThreshold(options.fee_threshold);
+}
+
+node::BlockCheckOptions ReadBlockCheckOptions(messages::BlockCheckOptions::Reader reader)
+{
+    return {
+        .check_merkle_root = reader.getCheckMerkleRoot(),
+        .check_pow = reader.getCheckPow(),
+    };
+}
+
+void SetBlockCheckOptions(messages::BlockCheckOptions::Builder builder, const node::BlockCheckOptions& options)
+{
+    builder.setCheckMerkleRoot(options.check_merkle_root);
+    builder.setCheckPow(options.check_pow);
+}
+
+void SetCoinbaseTx(messages::CoinbaseTx::Builder builder, const node::CoinbaseTx& tx)
+{
+    builder.setVersion(tx.version);
+    builder.setSequence(tx.sequence);
+    SetBytes(builder.initScriptSigPrefix(tx.script_sig_prefix.size()), {tx.script_sig_prefix.data(), tx.script_sig_prefix.size()});
+    if (tx.witness) {
+        SetBytes(builder.initWitness(uint256::size()), {tx.witness->data(), tx.witness->size()});
+    }
+    builder.setBlockRewardRemaining(tx.block_reward_remaining);
+    auto outputs{builder.initRequiredOutputs(tx.required_outputs.size())};
+    for (size_t i{0}; i < tx.required_outputs.size(); ++i) {
+        const auto bytes{ipc::capnp::SerializeBytes(tx.required_outputs[i])};
+        SetBytes(outputs.init(i, bytes.size()), bytes);
+    }
+    builder.setLockTime(tx.lock_time);
+}
+
+node::CoinbaseTx ReadCoinbaseTx(messages::CoinbaseTx::Reader reader)
+{
+    std::vector<CTxOut> outputs;
+    outputs.reserve(reader.getRequiredOutputs().size());
+    for (auto output : reader.getRequiredOutputs()) {
+        outputs.push_back(ipc::capnp::DeserializeBytes<CTxOut>(output));
+    }
+    std::optional<uint256> witness;
+    if (reader.getWitness().size() > 0) {
+        witness = ReadUint256(reader.getWitness());
+    }
+    return {
+        .version = reader.getVersion(),
+        .sequence = reader.getSequence(),
+        .script_sig_prefix = ReadScript(reader.getScriptSigPrefix()),
+        .witness = witness,
+        .block_reward_remaining = reader.getBlockRewardRemaining(),
+        .required_outputs = std::move(outputs),
+        .lock_time = reader.getLockTime(),
+    };
+}
+
+template <typename T, typename Start>
+kj::Promise<T> NodePromise(Start&& start)
+{
+    auto pair{kj::newPromiseAndCrossThreadFulfiller<T>()};
+    auto fulfiller{std::make_shared<kj::Own<kj::CrossThreadPromiseFulfiller<T>>>(kj::mv(pair.fulfiller))};
+    auto complete{[fulfiller](T result) mutable {
+        if (*fulfiller) {
+            (*fulfiller)->fulfill(std::move(result));
+            *fulfiller = nullptr;
+        }
+    }};
+    auto handler{start(std::move(complete))};
+    return kj::mv(pair.promise).attach(std::move(handler), std::move(fulfiller));
+}
+
+class TaskErrorLogger final : public kj::TaskSet::ErrorHandler
 {
 public:
-    ~CapnpProtocol() noexcept(true)
+    void taskFailed(kj::Exception&& exception) override
     {
-        m_loop_ref.reset();
-        if (m_loop_thread.joinable()) m_loop_thread.join();
-        assert(!m_loop);
+        LogDebug(BCLog::IPC, "IPC background task failed: %s\n", exception.getDescription().cStr());
+    }
+};
+
+class CallbackExecutor
+{
+public:
+    CallbackExecutor()
+        : m_thread([this] {
+              util::ThreadRename("ipc-callback");
+              Run();
+          })
+    {
+    }
+
+    ~CallbackExecutor() noexcept { Stop(); }
+
+    void Post(std::function<void()> task)
+    {
+        {
+            std::lock_guard lock{m_mutex};
+            if (m_stopped) return;
+            m_tasks.push_back(std::move(task));
+        }
+        m_cv.notify_one();
+    }
+
+    void Stop() noexcept
+    {
+        {
+            std::lock_guard lock{m_mutex};
+            if (m_stopped) return;
+            m_stopped = true;
+        }
+        m_cv.notify_one();
+        if (m_thread.joinable()) {
+            m_thread.join();
+        }
+    }
+
+private:
+    void Run() noexcept
+    {
+        while (true) {
+            std::function<void()> task;
+            {
+                std::unique_lock lock{m_mutex};
+                m_cv.wait(lock, [this] { return m_stopped || !m_tasks.empty(); });
+                if (m_stopped && m_tasks.empty()) return;
+                task = std::move(m_tasks.front());
+                m_tasks.pop_front();
+            }
+
+            try {
+                task();
+            } catch (const std::exception& e) {
+                LogDebug(BCLog::IPC, "IPC callback failed: %s\n", e.what());
+            } catch (...) {
+                LogDebug(BCLog::IPC, "IPC callback failed\n");
+            }
+        }
+    }
+
+    std::mutex m_mutex;
+    std::condition_variable m_cv;
+    std::deque<std::function<void()>> m_tasks;
+    std::thread m_thread;
+    bool m_stopped{false};
+};
+
+// Cap'n Proto clients are thread-affine. Remote client slots may be held by
+// ordinary C++ interface objects, but the contained capability is created,
+// used, and destroyed on the client event-loop thread.
+template <typename Client>
+struct RemoteClient {
+    std::optional<Client> client;
+};
+
+struct ClientThreadContext {
+    explicit ClientThreadContext(int fd)
+        : io(kj::setupAsyncIo()),
+          stream(io.lowLevelProvider->wrapSocketFd(fd, kj::LowLevelAsyncIoProvider::TAKE_OWNERSHIP)),
+          network(*stream, ::capnp::rpc::twoparty::Side::CLIENT, ::capnp::ReaderOptions{}),
+          rpc_system(::capnp::makeRpcClient(network)),
+          tasks(task_errors)
+    {
+    }
+
+    kj::AsyncIoContext io;
+    kj::Own<kj::AsyncIoStream> stream;
+    ::capnp::TwoPartyVatNetwork network;
+    ::capnp::RpcSystem<::capnp::rpc::twoparty::VatId> rpc_system;
+    TaskErrorLogger task_errors;
+    kj::TaskSet tasks;
+};
+
+class ClientConnection
+{
+public:
+    explicit ClientConnection(int fd)
+    {
+        m_init = MakeClient<messages::Init::Client>();
+
+        std::promise<void> ready;
+        auto ready_future{ready.get_future()};
+        auto state{m_state};
+        auto init{m_init};
+        m_thread = std::thread{[fd, state, init, ready = std::move(ready)]() mutable {
+            util::ThreadRename("capnp-client");
+            bool ready_sent{false};
+            try {
+                ClientThreadContext context{fd};
+                ::capnp::MallocMessageBuilder vat_message;
+                init->client.emplace(context.rpc_system.bootstrap(ServerVatId(vat_message)).castAs<messages::Init>());
+
+                auto shutdown_pair{kj::newPromiseAndFulfiller<void>()};
+                {
+                    std::lock_guard lock{state->mutex};
+                    state->context = &context;
+                    state->executor = kj::getCurrentThreadExecutor().addRef();
+                    state->shutdown_fulfiller = std::make_shared<kj::Own<kj::PromiseFulfiller<void>>>(kj::mv(shutdown_pair.fulfiller));
+                    state->thread_id = std::this_thread::get_id();
+                }
+                ready.set_value();
+                ready_sent = true;
+
+                try {
+                    kj::mv(shutdown_pair.promise).exclusiveJoin(context.network.onDisconnect()).wait(context.io.waitScope);
+                } catch (kj::Exception& exception) {
+                    LogDebug(BCLog::IPC, "IPC client connection closed: %s\n", exception.getDescription().cStr());
+                }
+                context.tasks.clear();
+                init->client.reset();
+            } catch (...) {
+                if (!ready_sent) ready.set_exception(std::current_exception());
+            }
+            {
+                std::lock_guard lock{state->mutex};
+                state->context = nullptr;
+                state->executor = nullptr;
+                state->shutdown_fulfiller.reset();
+                state->stopped = true;
+            }
+        }};
+        try {
+            ready_future.get();
+        } catch (...) {
+            if (m_thread.joinable()) m_thread.join();
+            throw;
+        }
+    }
+
+    ~ClientConnection() noexcept
+    {
+        Stop();
+        m_callbacks->Stop();
+    }
+
+    template <typename Client>
+    using ClientPtr = std::shared_ptr<RemoteClient<Client>>;
+
+    template <typename Client>
+    ClientPtr<Client> MakeClient()
+    {
+        std::weak_ptr<State> state{m_state};
+        return ClientPtr<Client>{new RemoteClient<Client>{}, [state](RemoteClient<Client>* client) noexcept {
+            DestroyClient(state, client);
+        }};
+    }
+
+    ClientPtr<messages::Init::Client> init() { return m_init; }
+
+    void PostCallback(std::function<void()> task)
+    {
+        m_callbacks->Post(std::move(task));
+    }
+
+    template <typename Fn>
+    decltype(auto) Call(Fn&& fn)
+    {
+        ClientThreadContext* context{nullptr};
+        kj::Maybe<kj::Own<const kj::Executor>> executor;
+        bool on_thread{false};
+        {
+            std::lock_guard lock{m_state->mutex};
+            if (m_state->stopped || !m_state->context) {
+                throw Exception{"IPC client connection closed"};
+            }
+            context = m_state->context;
+            on_thread = std::this_thread::get_id() == m_state->thread_id;
+            if (!on_thread) {
+                KJ_IF_MAYBE(e, m_state->executor) {
+                    executor = (*e)->addRef();
+                } else {
+                    throw Exception{"IPC client connection closed"};
+                }
+            }
+        }
+
+        if (on_thread) {
+            throw Exception{"synchronous IPC client call from IPC event loop"};
+        }
+        KJ_IF_MAYBE(e, executor) {
+            // Compatibility path for synchronous interface methods. If fn
+            // returns a KJ promise, executeSync drives it on the event loop.
+            return (*e)->executeSync([context, fn = std::forward<Fn>(fn)]() mutable -> decltype(auto) {
+                return fn(*context);
+            });
+        }
+        throw Exception{"IPC client connection closed"};
+    }
+
+    template <typename Fn>
+    void AddTaskSync(Fn&& fn)
+    {
+        ClientThreadContext* context{nullptr};
+        kj::Maybe<kj::Own<const kj::Executor>> executor;
+        bool on_thread{false};
+        {
+            std::lock_guard lock{m_state->mutex};
+            if (m_state->stopped || !m_state->context) {
+                throw Exception{"IPC client connection closed"};
+            }
+            context = m_state->context;
+            on_thread = std::this_thread::get_id() == m_state->thread_id;
+            if (!on_thread) {
+                KJ_IF_MAYBE(e, m_state->executor) {
+                    executor = (*e)->addRef();
+                } else {
+                    throw Exception{"IPC client connection closed"};
+                }
+            }
+        }
+
+        // Preserve the async interface contract even when the RPC promise is
+        // ready immediately: callers must receive the handler before callbacks
+        // can run.
+        if (on_thread) {
+            context->tasks.add(kj::evalLater([context, fn = std::forward<Fn>(fn)]() mutable {
+                return fn(*context);
+            }));
+            return;
+        }
+        KJ_IF_MAYBE(e, executor) {
+            // Async interface methods schedule the RPC and return immediately;
+            // completion callbacks run from the Cap'n Proto event loop.
+            (*e)->executeSync([context, fn = std::forward<Fn>(fn)]() mutable {
+                context->tasks.add(kj::evalLater([context, fn = std::move(fn)]() mutable {
+                    return fn(*context);
+                }));
+            });
+            return;
+        }
+        throw Exception{"IPC client connection closed"};
+    }
+
+private:
+    struct State {
+        std::mutex mutex;
+        ClientThreadContext* context{nullptr};
+        kj::Maybe<kj::Own<const kj::Executor>> executor;
+        std::shared_ptr<kj::Own<kj::PromiseFulfiller<void>>> shutdown_fulfiller;
+        std::thread::id thread_id;
+        bool stopped{false};
     };
-    std::unique_ptr<interfaces::Init> connect(int fd, const char* exe_name) override
+
+    template <typename Client>
+    static void DestroyClient(std::weak_ptr<State> weak_state, RemoteClient<Client>* client) noexcept
+    {
+        if (auto state{weak_state.lock()}) {
+            kj::Maybe<kj::Own<const kj::Executor>> executor;
+            bool on_thread{false};
+            {
+                std::lock_guard lock{state->mutex};
+                on_thread = std::this_thread::get_id() == state->thread_id;
+                if (!on_thread && !state->stopped) {
+                    KJ_IF_MAYBE(e, state->executor) {
+                        executor = (*e)->addRef();
+                    }
+                }
+            }
+
+            if (on_thread) {
+                delete client;
+                return;
+            }
+            KJ_IF_MAYBE(e, executor) {
+                try {
+                    (*e)->executeSync([client] {
+                        delete client;
+                    });
+                    return;
+                } catch (...) {
+                }
+            }
+        }
+        delete client;
+    }
+
+    void Stop() noexcept
+    {
+        std::shared_ptr<kj::Own<kj::PromiseFulfiller<void>>> shutdown_fulfiller;
+        kj::Maybe<kj::Own<const kj::Executor>> executor;
+        bool on_thread{false};
+        {
+            std::lock_guard lock{m_state->mutex};
+            on_thread = std::this_thread::get_id() == m_state->thread_id;
+            shutdown_fulfiller = m_state->shutdown_fulfiller;
+            if (!on_thread && !m_state->stopped) {
+                KJ_IF_MAYBE(e, m_state->executor) {
+                    executor = (*e)->addRef();
+                }
+            }
+        }
+
+        auto stop{[shutdown_fulfiller] {
+            if (shutdown_fulfiller && *shutdown_fulfiller) {
+                (*shutdown_fulfiller)->fulfill();
+                *shutdown_fulfiller = nullptr;
+            }
+        }};
+
+        try {
+            if (on_thread) {
+                stop();
+            } else {
+                KJ_IF_MAYBE(e, executor) {
+                    (*e)->executeSync(std::move(stop));
+                }
+            }
+        } catch (...) {
+        }
+
+        if (m_thread.joinable()) {
+            if (std::this_thread::get_id() == m_thread.get_id()) {
+                m_thread.detach();
+            } else {
+                m_thread.join();
+            }
+        }
+    }
+
+    std::shared_ptr<State> m_state{std::make_shared<State>()};
+    std::shared_ptr<CallbackExecutor> m_callbacks{std::make_shared<CallbackExecutor>()};
+    std::thread m_thread;
+    ClientPtr<messages::Init::Client> m_init;
+};
+
+struct RemoteWatchState {
+    explicit RemoteWatchState(ClientConnection::ClientPtr<messages::Watch::Client> watch_client)
+        : watch(std::move(watch_client))
+    {
+    }
+
+    std::atomic<bool> active{true};
+    ClientConnection::ClientPtr<messages::Watch::Client> watch;
+};
+
+kj::Promise<void> CancelRemoteWatch(const std::shared_ptr<RemoteWatchState>& state)
+{
+    if (!state->watch->client) return kj::READY_NOW;
+    return state->watch->client->cancelRequest().send().ignoreResult();
+}
+
+std::unique_ptr<interfaces::BlockTemplate> MakeRemoteBlockTemplate(std::shared_ptr<ClientConnection> connection, ClientConnection::ClientPtr<messages::BlockTemplate::Client> client);
+
+class RemoteTipListener final : public messages::TipListener::Server
+{
+public:
+    RemoteTipListener(std::shared_ptr<ClientConnection> connection, std::shared_ptr<RemoteWatchState> state, interfaces::Mining::TipChangedFn fn)
+        : m_connection(std::move(connection)), m_state(std::move(state)), m_fn(std::move(fn))
+    {
+    }
+
+    kj::Promise<void> tipChanged(TipChangedContext context) override
+    {
+        const auto tip{ReadBlockRef(context.getParams().getTip())};
+        m_connection->PostCallback([state = m_state, fn = m_fn, tip] {
+            if (state->active.exchange(false, std::memory_order_acq_rel)) {
+                fn(tip);
+            }
+        });
+        return CancelRemoteWatch(m_state);
+    }
+
+    kj::Promise<void> stopped(StoppedContext) override
+    {
+        m_connection->PostCallback([state = m_state, fn = m_fn] {
+            if (state->active.exchange(false, std::memory_order_acq_rel)) {
+                fn(std::nullopt);
+            }
+        });
+        return CancelRemoteWatch(m_state);
+    }
+
+private:
+    std::shared_ptr<ClientConnection> m_connection;
+    std::shared_ptr<RemoteWatchState> m_state;
+    interfaces::Mining::TipChangedFn m_fn;
+};
+
+class RemoteTemplateListener final : public messages::BlockTemplateListener::Server
+{
+public:
+    RemoteTemplateListener(std::shared_ptr<ClientConnection> connection, std::shared_ptr<RemoteWatchState> state, interfaces::BlockTemplate::NextTemplateFn fn)
+        : m_connection(std::move(connection)), m_state(std::move(state)), m_fn(std::move(fn))
     {
-        startLoop(exe_name);
-        return mp::ConnectStream<messages::Init>(*m_loop, fd);
     }
+
+    kj::Promise<void> templateReady(TemplateReadyContext context) override
+    {
+        auto block_template{m_connection->MakeClient<messages::BlockTemplate::Client>()};
+        block_template->client.emplace(context.getParams().getResult());
+        auto result{std::make_shared<std::unique_ptr<interfaces::BlockTemplate>>(MakeRemoteBlockTemplate(m_connection, std::move(block_template)))};
+        m_connection->PostCallback([state = m_state, fn = m_fn, result]() mutable {
+            if (state->active.exchange(false, std::memory_order_acq_rel)) {
+                fn(std::move(*result));
+            }
+        });
+        return CancelRemoteWatch(m_state);
+    }
+
+    kj::Promise<void> stopped(StoppedContext) override
+    {
+        m_connection->PostCallback([state = m_state, fn = m_fn] {
+            if (state->active.exchange(false, std::memory_order_acq_rel)) {
+                fn(nullptr);
+            }
+        });
+        return CancelRemoteWatch(m_state);
+    }
+
+private:
+    std::shared_ptr<ClientConnection> m_connection;
+    std::shared_ptr<RemoteWatchState> m_state;
+    interfaces::BlockTemplate::NextTemplateFn m_fn;
+};
+
+class RemoteBlockTemplate final : public interfaces::BlockTemplate
+{
+public:
+    RemoteBlockTemplate(std::shared_ptr<ClientConnection> connection, ClientConnection::ClientPtr<messages::BlockTemplate::Client> client)
+        : m_connection(std::move(connection)), m_client(std::move(client))
+    {
+    }
+    ~RemoteBlockTemplate() noexcept override {}
+
+    CBlockHeader getBlockHeader() override
+    {
+        return m_connection->Call([client = m_client](ClientThreadContext& context) {
+            return client->client->getBlockHeaderRequest().send().then([](auto response) {
+                return ipc::capnp::DeserializeBytes<CBlockHeader>(response.getResult());
+            });
+        });
+    }
+
+    CBlock getBlock() override
+    {
+        return m_connection->Call([client = m_client](ClientThreadContext& context) {
+            return client->client->getBlockRequest().send().then([](auto response) {
+                return ipc::capnp::DeserializeBytes<CBlock>(response.getResult());
+            });
+        });
+    }
+
+    std::vector<CAmount> getTxFees() override
+    {
+        return m_connection->Call([client = m_client](ClientThreadContext& context) {
+            return client->client->getTxFeesRequest().send().then([](auto response) {
+                std::vector<CAmount> fees;
+                fees.reserve(response.getResult().size());
+                for (const int64_t fee : response.getResult()) {
+                    fees.push_back(fee);
+                }
+                return fees;
+            });
+        });
+    }
+
+    std::vector<int64_t> getTxSigops() override
+    {
+        return m_connection->Call([client = m_client](ClientThreadContext& context) {
+            return client->client->getTxSigopsRequest().send().then([](auto response) {
+                std::vector<int64_t> sigops;
+                sigops.reserve(response.getResult().size());
+                for (const int64_t value : response.getResult()) {
+                    sigops.push_back(value);
+                }
+                return sigops;
+            });
+        });
+    }
+
+    node::CoinbaseTx getCoinbaseTx() override
+    {
+        return m_connection->Call([client = m_client](ClientThreadContext& context) {
+            return client->client->getCoinbaseTxRequest().send().then([](auto response) {
+                return ReadCoinbaseTx(response.getResult());
+            });
+        });
+    }
+
+    std::vector<uint256> getCoinbaseMerklePath() override
+    {
+        return m_connection->Call([client = m_client](ClientThreadContext& context) {
+            return client->client->getCoinbaseMerklePathRequest().send().then([](auto response) {
+                std::vector<uint256> path;
+                path.reserve(response.getResult().size());
+                for (auto hash : response.getResult()) {
+                    path.push_back(ReadUint256(hash));
+                }
+                return path;
+            });
+        });
+    }
+
+    std::unique_ptr<interfaces::Handler> submitSolutionAsync(uint32_t version, uint32_t timestamp, uint32_t nonce, CTransactionRef coinbase, SubmitSolutionFn fn) override
+    {
+        auto active{std::make_shared<std::atomic<bool>>(true)};
+        auto client{m_client};
+        auto connection{m_connection};
+        connection->AddTaskSync([connection, client, active, version, timestamp, nonce, coinbase = std::move(coinbase), fn = std::move(fn)](ClientThreadContext&) mutable -> kj::Promise<void> {
+            if (!active->load(std::memory_order_acquire)) return kj::READY_NOW;
+            auto request{client->client->submitSolutionRequest()};
+            request.setVersion(version);
+            request.setTimestamp(timestamp);
+            request.setNonce(nonce);
+            const auto coinbase_bytes{ipc::capnp::SerializeBytes(*coinbase)};
+            SetBytes(request.initCoinbase(coinbase_bytes.size()), coinbase_bytes);
+            return request.send().then([connection, active, fn = std::move(fn)](auto response) mutable {
+                const bool accepted{response.getResult()};
+                connection->PostCallback([active, fn = std::move(fn), accepted]() mutable {
+                    if (active->exchange(false, std::memory_order_acq_rel)) {
+                        fn(accepted);
+                    }
+                });
+            });
+        });
+        return interfaces::MakeCleanupHandler([connection = std::move(connection), active] {
+            active->store(false, std::memory_order_release);
+        });
+    }
+
+    std::unique_ptr<interfaces::Handler> watchNext(node::BlockWaitOptions options, NextTemplateFn fn) override
+    {
+        auto client{m_client};
+        auto connection{m_connection};
+        auto state{std::make_shared<RemoteWatchState>(connection->MakeClient<messages::Watch::Client>())};
+        connection->AddTaskSync([connection, client, state, options, fn = std::move(fn)](ClientThreadContext&) mutable -> kj::Promise<void> {
+            if (!state->active.load(std::memory_order_acquire)) return kj::READY_NOW;
+            auto request{client->client->watchNextRequest()};
+            SetBlockWaitOptions(request.getOptions(), options);
+            request.setListener(messages::BlockTemplateListener::Client(kj::heap<RemoteTemplateListener>(connection, state, std::move(fn))));
+            return request.send().then([state](auto response) mutable -> kj::Promise<void> {
+                state->watch->client.emplace(response.getWatch());
+                if (!state->active.load(std::memory_order_acquire)) {
+                    return CancelRemoteWatch(state);
+                }
+                return kj::READY_NOW;
+            });
+        });
+        return interfaces::MakeCleanupHandler([connection = std::move(connection), state] {
+            if (!state->active.exchange(false, std::memory_order_acq_rel)) return;
+            try {
+                connection->AddTaskSync([state](ClientThreadContext&) -> kj::Promise<void> {
+                    return CancelRemoteWatch(state);
+                });
+            } catch (...) {
+            }
+        });
+    }
+
+private:
+    std::shared_ptr<ClientConnection> m_connection;
+    ClientConnection::ClientPtr<messages::BlockTemplate::Client> m_client;
+};
+
+std::unique_ptr<interfaces::BlockTemplate> MakeRemoteBlockTemplate(std::shared_ptr<ClientConnection> connection, ClientConnection::ClientPtr<messages::BlockTemplate::Client> client)
+{
+    return std::make_unique<RemoteBlockTemplate>(std::move(connection), std::move(client));
+}
+
+class RemoteMining final : public interfaces::Mining
+{
+public:
+    RemoteMining(std::shared_ptr<ClientConnection> connection, ClientConnection::ClientPtr<messages::Mining::Client> client)
+        : m_connection(std::move(connection)), m_client(std::move(client))
+    {
+    }
+    ~RemoteMining() noexcept override {}
+
+    bool isTestChain() override
+    {
+        return m_connection->Call([client = m_client](ClientThreadContext& context) {
+            return client->client->isTestChainRequest().send().then([](auto response) {
+                return response.getResult();
+            });
+        });
+    }
+
+    bool isInitialBlockDownload() override
+    {
+        return m_connection->Call([client = m_client](ClientThreadContext& context) {
+            return client->client->isInitialBlockDownloadRequest().send().then([](auto response) {
+                return response.getResult();
+            });
+        });
+    }
+
+    std::optional<interfaces::BlockRef> getTip() override
+    {
+        return m_connection->Call([client = m_client](ClientThreadContext& context) {
+            return client->client->getTipRequest().send().then([](auto response) -> std::optional<interfaces::BlockRef> {
+                if (!response.getFound()) return std::nullopt;
+                return ReadBlockRef(response.getResult());
+            });
+        });
+    }
+
+    std::unique_ptr<interfaces::Handler> watchTip(uint256 current_tip, MillisecondsDouble timeout, TipChangedFn fn) override
+    {
+        auto client{m_client};
+        auto connection{m_connection};
+        auto state{std::make_shared<RemoteWatchState>(connection->MakeClient<messages::Watch::Client>())};
+        connection->AddTaskSync([connection, client, state, current_tip, timeout, fn = std::move(fn)](ClientThreadContext&) mutable -> kj::Promise<void> {
+            if (!state->active.load(std::memory_order_acquire)) return kj::READY_NOW;
+            auto request{client->client->watchTipRequest()};
+            SetBytes(request.initCurrentTip(uint256::size()), {current_tip.data(), current_tip.size()});
+            request.setTimeout(timeout.count());
+            request.setListener(messages::TipListener::Client(kj::heap<RemoteTipListener>(connection, state, std::move(fn))));
+            return request.send().then([state](auto response) mutable -> kj::Promise<void> {
+                state->watch->client.emplace(response.getWatch());
+                if (!state->active.load(std::memory_order_acquire)) {
+                    return CancelRemoteWatch(state);
+                }
+                return kj::READY_NOW;
+            });
+        });
+        return interfaces::MakeCleanupHandler([connection = std::move(connection), state] {
+            if (!state->active.exchange(false, std::memory_order_acq_rel)) return;
+            try {
+                connection->AddTaskSync([state](ClientThreadContext&) -> kj::Promise<void> {
+                    return CancelRemoteWatch(state);
+                });
+            } catch (...) {
+            }
+        });
+    }
+
+    std::unique_ptr<interfaces::Handler> createNewBlockAsync(const node::BlockCreateOptions& options, bool cooldown, CreateBlockFn fn) override
+    {
+        auto active{std::make_shared<std::atomic<bool>>(true)};
+        auto client{m_client};
+        auto connection{m_connection};
+        connection->AddTaskSync([connection, client, active, options, cooldown, fn = std::move(fn)](ClientThreadContext&) mutable -> kj::Promise<void> {
+            if (!active->load(std::memory_order_acquire)) return kj::READY_NOW;
+            auto request{client->client->createNewBlockRequest()};
+            SetBlockCreateOptions(request.getOptions(), options);
+            request.setCooldown(cooldown);
+            return request.send().then([connection, active, fn = std::move(fn)](auto response) mutable {
+                if (!response.getFound()) {
+                    connection->PostCallback([active, fn = std::move(fn)]() mutable {
+                        if (active->exchange(false, std::memory_order_acq_rel)) {
+                            fn(CreateBlockResult{nullptr});
+                        }
+                    });
+                    return;
+                }
+                auto block_template{connection->MakeClient<messages::BlockTemplate::Client>()};
+                block_template->client.emplace(response.getResult());
+                auto result{std::make_shared<std::unique_ptr<interfaces::BlockTemplate>>(MakeRemoteBlockTemplate(connection, std::move(block_template)))};
+                connection->PostCallback([active, fn = std::move(fn), result]() mutable {
+                    if (active->exchange(false, std::memory_order_acq_rel)) {
+                        fn(CreateBlockResult{std::move(*result)});
+                    }
+                });
+            });
+        });
+        return interfaces::MakeCleanupHandler([connection = std::move(connection), active] {
+            active->store(false, std::memory_order_release);
+        });
+    }
+
+    std::unique_ptr<interfaces::Handler> checkBlockAsync(CBlock block, node::BlockCheckOptions options, CheckBlockFn fn) override
+    {
+        auto active{std::make_shared<std::atomic<bool>>(true)};
+        auto client{m_client};
+        auto connection{m_connection};
+        connection->AddTaskSync([connection, client, active, block = std::move(block), options, fn = std::move(fn)](ClientThreadContext&) mutable -> kj::Promise<void> {
+            if (!active->load(std::memory_order_acquire)) return kj::READY_NOW;
+            auto request{client->client->checkBlockRequest()};
+            const auto block_bytes{ipc::capnp::SerializeBytes(block)};
+            SetBytes(request.initBlock(block_bytes.size()), block_bytes);
+            SetBlockCheckOptions(request.getOptions(), options);
+            return request.send().then([connection, active, fn = std::move(fn)](auto response) mutable {
+                const bool valid{response.getResult()};
+                const std::string reason{response.getReason().cStr()};
+                const std::string debug{response.getDebug().cStr()};
+                connection->PostCallback([active, fn = std::move(fn), valid, reason = std::move(reason), debug = std::move(debug)]() mutable {
+                    if (active->exchange(false, std::memory_order_acq_rel)) {
+                        fn(valid, std::move(reason), std::move(debug));
+                    }
+                });
+            });
+        });
+        return interfaces::MakeCleanupHandler([connection = std::move(connection), active] {
+            active->store(false, std::memory_order_release);
+        });
+    }
+
+    std::unique_ptr<interfaces::Handler> submitBlockAsync(CBlock block, SubmitBlockFn fn) override
+    {
+        auto active{std::make_shared<std::atomic<bool>>(true)};
+        auto client{m_client};
+        auto connection{m_connection};
+        connection->AddTaskSync([connection, client, active, block = std::move(block), fn = std::move(fn)](ClientThreadContext&) mutable -> kj::Promise<void> {
+            if (!active->load(std::memory_order_acquire)) return kj::READY_NOW;
+            auto request{client->client->submitBlockRequest()};
+            const auto block_bytes{ipc::capnp::SerializeBytes(block)};
+            SetBytes(request.initBlock(block_bytes.size()), block_bytes);
+            return request.send().then([connection, active, fn = std::move(fn)](auto response) mutable {
+                const bool accepted{response.getResult()};
+                const std::string reason{response.getReason().cStr()};
+                const std::string debug{response.getDebug().cStr()};
+                connection->PostCallback([active, fn = std::move(fn), accepted, reason = std::move(reason), debug = std::move(debug)]() mutable {
+                    if (active->exchange(false, std::memory_order_acq_rel)) {
+                        fn(accepted, std::move(reason), std::move(debug));
+                    }
+                });
+            });
+        });
+        return interfaces::MakeCleanupHandler([connection = std::move(connection), active] {
+            active->store(false, std::memory_order_release);
+        });
+    }
+
+private:
+    std::shared_ptr<ClientConnection> m_connection;
+    ClientConnection::ClientPtr<messages::Mining::Client> m_client;
+};
+
+class RemoteEcho final : public interfaces::Echo
+{
+public:
+    RemoteEcho(std::shared_ptr<ClientConnection> connection, ClientConnection::ClientPtr<messages::Echo::Client> client)
+        : m_connection(std::move(connection)), m_client(std::move(client))
+    {
+    }
+    ~RemoteEcho() noexcept override {}
+
+    std::string echo(const std::string& echo) override
+    {
+        return m_connection->Call([client = m_client, echo](ClientThreadContext& context) {
+            auto request{client->client->echoRequest()};
+            request.setMessage(echo);
+            return request.send().then([](auto response) {
+                return std::string{response.getMessage().cStr()};
+            });
+        });
+    }
+
+private:
+    std::shared_ptr<ClientConnection> m_connection;
+    ClientConnection::ClientPtr<messages::Echo::Client> m_client;
+};
+
+class RemoteInit final : public interfaces::Init
+{
+public:
+    RemoteInit(std::shared_ptr<ClientConnection> connection, ClientConnection::ClientPtr<messages::Init::Client> client)
+        : m_connection(std::move(connection)), m_client(std::move(client))
+    {
+    }
+    ~RemoteInit() noexcept override {}
+
+    std::unique_ptr<interfaces::Mining> makeMining() override
+    {
+        auto mining{m_connection->MakeClient<messages::Mining::Client>()};
+        m_connection->Call([init = m_client, mining](ClientThreadContext& context) {
+            return init->client->makeMiningRequest().send().then([mining](auto response) {
+                mining->client.emplace(response.getResult());
+            });
+        });
+        return std::make_unique<RemoteMining>(m_connection, std::move(mining));
+    }
+
+    std::unique_ptr<interfaces::Echo> makeEcho() override
+    {
+        auto echo{m_connection->MakeClient<messages::Echo::Client>()};
+        m_connection->Call([init = m_client, echo](ClientThreadContext& context) {
+            return init->client->makeEchoRequest().send().then([echo](auto response) {
+                echo->client.emplace(response.getResult());
+            });
+        });
+        return std::make_unique<RemoteEcho>(m_connection, std::move(echo));
+    }
+
+    void stop() override
+    {
+        m_connection->Call([client = m_client](ClientThreadContext& context) {
+            return client->client->stopRequest().send().ignoreResult();
+        });
+    }
+
+private:
+    std::shared_ptr<ClientConnection> m_connection;
+    ClientConnection::ClientPtr<messages::Init::Client> m_client;
+};
+
+struct BlockCheckResult {
+    bool valid{false};
+    std::string reason;
+    std::string debug;
+};
+
+struct SubmitBlockResult {
+    bool accepted{false};
+    std::string reason;
+    std::string debug;
+};
+
+class WatchServer final : public messages::Watch::Server
+{
+public:
+    WatchServer(std::shared_ptr<std::atomic<bool>> active, std::function<void()> cancel) : m_active(std::move(active)), m_cancel(std::move(cancel)) {}
+    ~WatchServer() noexcept { Cancel(); }
+
+    kj::Promise<void> cancel(CancelContext) override
+    {
+        Cancel();
+        return kj::READY_NOW;
+    }
+
+private:
+    void Cancel() noexcept
+    {
+        if (m_active->exchange(false, std::memory_order_acq_rel)) {
+            m_cancel();
+        }
+    }
+
+    std::shared_ptr<std::atomic<bool>> m_active;
+    std::function<void()> m_cancel;
+};
+
+kj::Promise<void> NotifyTipChanged(messages::TipListener::Client listener, const interfaces::BlockRef& tip)
+{
+    auto request{listener.tipChangedRequest()};
+    SetBlockRef(request.getTip(), tip);
+    return request.send().ignoreResult();
+}
+
+kj::Promise<void> NotifyTipStopped(messages::TipListener::Client listener)
+{
+    return listener.stoppedRequest().send().ignoreResult();
+}
+
+class BlockTemplateServer final : public messages::BlockTemplate::Server
+{
+public:
+    explicit BlockTemplateServer(std::unique_ptr<interfaces::BlockTemplate> block_template)
+        : m_block_template(std::move(block_template))
+    {
+    }
+
+    kj::Promise<void> getBlockHeader(GetBlockHeaderContext context) override
+    {
+        const auto block_header_bytes{ipc::capnp::SerializeBytes(m_block_template->getBlockHeader())};
+        SetBytes(context.getResults().initResult(block_header_bytes.size()), block_header_bytes);
+        return kj::READY_NOW;
+    }
+
+    kj::Promise<void> getBlock(GetBlockContext context) override
+    {
+        const auto block_bytes{ipc::capnp::SerializeBytes(m_block_template->getBlock())};
+        SetBytes(context.getResults().initResult(block_bytes.size()), block_bytes);
+        return kj::READY_NOW;
+    }
+
+    kj::Promise<void> getTxFees(GetTxFeesContext context) override
+    {
+        const auto fees{m_block_template->getTxFees()};
+        auto result{context.getResults().initResult(fees.size())};
+        for (size_t i{0}; i < fees.size(); ++i)
+            result.set(i, fees[i]);
+        return kj::READY_NOW;
+    }
+
+    kj::Promise<void> getTxSigops(GetTxSigopsContext context) override
+    {
+        const auto sigops{m_block_template->getTxSigops()};
+        auto result{context.getResults().initResult(sigops.size())};
+        for (size_t i{0}; i < sigops.size(); ++i)
+            result.set(i, sigops[i]);
+        return kj::READY_NOW;
+    }
+
+    kj::Promise<void> getCoinbaseTx(GetCoinbaseTxContext context) override
+    {
+        SetCoinbaseTx(context.getResults().getResult(), m_block_template->getCoinbaseTx());
+        return kj::READY_NOW;
+    }
+
+    kj::Promise<void> getCoinbaseMerklePath(GetCoinbaseMerklePathContext context) override
+    {
+        const auto path{m_block_template->getCoinbaseMerklePath()};
+        auto result{context.getResults().initResult(path.size())};
+        for (size_t i{0}; i < path.size(); ++i) {
+            SetBytes(result.init(i, uint256::size()), {path[i].data(), path[i].size()});
+        }
+        return kj::READY_NOW;
+    }
+
+    kj::Promise<void> submitSolution(SubmitSolutionContext context) override
+    {
+        const auto params{context.getParams()};
+        const uint32_t version{params.getVersion()};
+        const uint32_t timestamp{params.getTimestamp()};
+        const uint32_t nonce{params.getNonce()};
+        CTransactionRef coinbase{MakeTransactionRef(ipc::capnp::DeserializeBytes<CTransaction>(params.getCoinbase()))};
+        auto result{NodePromise<bool>([block_template = m_block_template, version, timestamp, nonce, coinbase = std::move(coinbase)](std::function<void(bool)> done) mutable {
+            return block_template->submitSolutionAsync(version, timestamp, nonce, std::move(coinbase), std::move(done));
+        })};
+        return kj::mv(result).then([KJ_CPCAP(context)](bool result) mutable {
+            context.getResults().setResult(result);
+        });
+    }
+
+    kj::Promise<void> watchNext(WatchNextContext context) override
+    {
+        auto active{std::make_shared<std::atomic<bool>>(true)};
+        auto options{ReadBlockWaitOptions(context.getParams().getOptions())};
+        auto listener{context.getParams().getListener()};
+        auto handler{std::make_shared<std::unique_ptr<interfaces::Handler>>()};
+
+        context.getResults().setWatch(kj::heap<WatchServer>(active, [handler] {
+            if (*handler) (*handler)->disconnect();
+        }));
+
+        auto next_template{std::make_shared<std::unique_ptr<interfaces::BlockTemplate>>()};
+        auto pair{kj::newPromiseAndCrossThreadFulfiller<bool>()};
+        auto fulfiller{std::make_shared<kj::Own<kj::CrossThreadPromiseFulfiller<bool>>>(kj::mv(pair.fulfiller))};
+        *handler = m_block_template->watchNext(options, [next_template, fulfiller](std::unique_ptr<interfaces::BlockTemplate> block_template) mutable {
+            if (*fulfiller) {
+                *next_template = std::move(block_template);
+                (*fulfiller)->fulfill(static_cast<bool>(*next_template));
+                *fulfiller = nullptr;
+            }
+        });
+        auto next_template_keepalive{next_template};
+        auto next{kj::mv(pair.promise).attach(std::move(handler), std::move(fulfiller), std::move(next_template_keepalive))};
+        m_tasks.add(kj::mv(next).then([active, listener, next_template](bool found) mutable -> kj::Promise<void> {
+            if (!active->exchange(false, std::memory_order_acq_rel)) return kj::READY_NOW;
+            if (!found) return listener.stoppedRequest().send().ignoreResult();
+            auto request{listener.templateReadyRequest()};
+            request.setResult(kj::heap<BlockTemplateServer>(std::move(*next_template)));
+            return request.send().ignoreResult();
+        }));
+        return kj::READY_NOW;
+    }
+
+private:
+    std::shared_ptr<interfaces::BlockTemplate> m_block_template;
+    TaskErrorLogger m_task_errors;
+    kj::TaskSet m_tasks{m_task_errors};
+};
+
+class MiningServer final : public messages::Mining::Server
+{
+public:
+    explicit MiningServer(std::unique_ptr<interfaces::Mining> mining) : m_mining(std::move(mining)) {}
+
+    kj::Promise<void> isTestChain(IsTestChainContext context) override
+    {
+        context.getResults().setResult(m_mining->isTestChain());
+        return kj::READY_NOW;
+    }
+
+    kj::Promise<void> isInitialBlockDownload(IsInitialBlockDownloadContext context) override
+    {
+        context.getResults().setResult(m_mining->isInitialBlockDownload());
+        return kj::READY_NOW;
+    }
+
+    kj::Promise<void> getTip(GetTipContext context) override
+    {
+        const auto tip{m_mining->getTip()};
+        context.getResults().setFound(tip.has_value());
+        if (tip) SetBlockRef(context.getResults().getResult(), *tip);
+        return kj::READY_NOW;
+    }
+
+    kj::Promise<void> createNewBlock(CreateNewBlockContext context) override
+    {
+        const auto params{context.getParams()};
+        auto options{ReadBlockCreateOptions(params.getOptions())};
+        const bool cooldown{params.getCooldown()};
+        auto block_template{std::make_shared<std::unique_ptr<interfaces::BlockTemplate>>()};
+        auto pair{kj::newPromiseAndCrossThreadFulfiller<bool>()};
+        auto fulfiller{std::make_shared<kj::Own<kj::CrossThreadPromiseFulfiller<bool>>>(kj::mv(pair.fulfiller))};
+        auto handler{m_mining->createNewBlockAsync(options, cooldown, [block_template, fulfiller](interfaces::Mining::CreateBlockResult result) mutable {
+            if (!*fulfiller) return;
+            if (result) {
+                *block_template = std::move(*result);
+                (*fulfiller)->fulfill(static_cast<bool>(*block_template));
+            } else {
+                (*fulfiller)->reject(KJ_EXCEPTION(FAILED, util::ErrorString(result).original));
+            }
+            *fulfiller = nullptr;
+        })};
+        auto block_template_keepalive{block_template};
+        auto found{kj::mv(pair.promise).attach(std::move(handler), std::move(fulfiller), std::move(block_template_keepalive))};
+        return kj::mv(found).then([KJ_CPCAP(context), block_template](bool found) mutable {
+            context.getResults().setFound(found);
+            if (found) {
+                context.getResults().setResult(kj::heap<BlockTemplateServer>(std::move(*block_template)));
+            }
+        });
+    }
+
+    kj::Promise<void> checkBlock(CheckBlockContext context) override
+    {
+        const auto params{context.getParams()};
+        auto block{ipc::capnp::DeserializeBytes<CBlock>(params.getBlock())};
+        auto options{ReadBlockCheckOptions(params.getOptions())};
+        auto result{NodePromise<BlockCheckResult>([mining = m_mining, block = std::move(block), options](std::function<void(BlockCheckResult)> done) mutable {
+            return mining->checkBlockAsync(std::move(block), options, [done = std::move(done)](bool valid, std::string reason, std::string debug) mutable {
+                done({valid, std::move(reason), std::move(debug)});
+            });
+        })};
+        return kj::mv(result).then([KJ_CPCAP(context)](BlockCheckResult result) mutable {
+            context.getResults().setReason(result.reason);
+            context.getResults().setDebug(result.debug);
+            context.getResults().setResult(result.valid);
+        });
+    }
+
+    kj::Promise<void> submitBlock(SubmitBlockContext context) override
+    {
+        const auto params{context.getParams()};
+        auto block{ipc::capnp::DeserializeBytes<CBlock>(params.getBlock())};
+        auto result{NodePromise<SubmitBlockResult>([mining = m_mining, block = std::move(block)](std::function<void(SubmitBlockResult)> done) mutable {
+            return mining->submitBlockAsync(std::move(block), [done = std::move(done)](bool accepted, std::string reason, std::string debug) mutable {
+                done({accepted, std::move(reason), std::move(debug)});
+            });
+        })};
+        return kj::mv(result).then([KJ_CPCAP(context)](SubmitBlockResult result) mutable {
+            context.getResults().setReason(result.reason);
+            context.getResults().setDebug(result.debug);
+            context.getResults().setResult(result.accepted);
+        });
+    }
+
+    kj::Promise<void> watchTip(WatchTipContext context) override
+    {
+        const auto params{context.getParams()};
+        auto active{std::make_shared<std::atomic<bool>>(true)};
+        auto listener{params.getListener()};
+        const auto current_tip{ReadUint256(params.getCurrentTip())};
+        const MillisecondsDouble timeout{params.getTimeout()};
+        auto handler{std::make_shared<std::unique_ptr<interfaces::Handler>>()};
+
+        context.getResults().setWatch(kj::heap<WatchServer>(active, [handler] {
+            if (*handler) (*handler)->disconnect();
+        }));
+
+        auto pair{kj::newPromiseAndCrossThreadFulfiller<std::optional<interfaces::BlockRef>>()};
+        auto fulfiller{std::make_shared<kj::Own<kj::CrossThreadPromiseFulfiller<std::optional<interfaces::BlockRef>>>>(kj::mv(pair.fulfiller))};
+        *handler = m_mining->watchTip(current_tip, timeout, [fulfiller](std::optional<interfaces::BlockRef> tip) mutable {
+            if (*fulfiller) {
+                (*fulfiller)->fulfill(std::move(tip));
+                *fulfiller = nullptr;
+            }
+        });
+        auto tip{kj::mv(pair.promise).attach(std::move(handler), std::move(fulfiller))};
+        m_tasks.add(kj::mv(tip).then([active, listener](std::optional<interfaces::BlockRef> tip) mutable -> kj::Promise<void> {
+            if (!active->exchange(false, std::memory_order_acq_rel)) return kj::READY_NOW;
+            if (!tip) return NotifyTipStopped(listener);
+            return NotifyTipChanged(listener, *tip);
+        }));
+        return kj::READY_NOW;
+    }
+
+private:
+    std::shared_ptr<interfaces::Mining> m_mining;
+    TaskErrorLogger m_task_errors;
+    kj::TaskSet m_tasks{m_task_errors};
+};
+
+class EchoServer final : public messages::Echo::Server
+{
+public:
+    explicit EchoServer(std::unique_ptr<interfaces::Echo> echo) : m_echo(std::move(echo)) {}
+
+    kj::Promise<void> echo(EchoContext context) override
+    {
+        context.getResults().setMessage(m_echo->echo(context.getParams().getMessage().cStr()));
+        return kj::READY_NOW;
+    }
+
+private:
+    std::unique_ptr<interfaces::Echo> m_echo;
+};
+
+class InitServer final : public messages::Init::Server
+{
+public:
+    explicit InitServer(interfaces::Init& init) : m_init(init) {}
+
+    kj::Promise<void> makeEcho(MakeEchoContext context) override
+    {
+        if (auto echo{m_init.makeEcho()}) {
+            context.getResults().setResult(kj::heap<EchoServer>(std::move(echo)));
+        }
+        return kj::READY_NOW;
+    }
+
+    kj::Promise<void> makeMining(MakeMiningContext context) override
+    {
+        if (auto mining{m_init.makeMining()}) {
+            context.getResults().setResult(kj::heap<MiningServer>(std::move(mining)));
+        }
+        return kj::READY_NOW;
+    }
+
+    kj::Promise<void> stop(StopContext) override
+    {
+        m_init.stop();
+        return kj::READY_NOW;
+    }
+
+private:
+    interfaces::Init& m_init;
+};
+
+void ServeConnection(int fd, const char* exe_name, interfaces::Init& init, const std::function<void()>& ready_fn = {})
+{
+    auto io{kj::setupAsyncIo()};
+    auto stream{io.lowLevelProvider->wrapSocketFd(fd, kj::LowLevelAsyncIoProvider::TAKE_OWNERSHIP)};
+    ::capnp::TwoPartyVatNetwork network{*stream, ::capnp::rpc::twoparty::Side::SERVER, ::capnp::ReaderOptions{}};
+    auto rpc_system{::capnp::makeRpcServer(network, messages::Init::Client(kj::heap<InitServer>(init)))};
+    if (ready_fn) ready_fn();
+    network.onDisconnect().wait(io.waitScope);
+}
+
+class CapnpProtocol final : public Protocol
+{
+    class SharedFd
+    {
+    public:
+        explicit SharedFd(int fd) : m_fd(fd) {}
+        ~SharedFd() { Close(); }
+
+        int fd() const { return m_fd.load(); }
+        void Shutdown() const
+        {
+            const int fd{m_fd.load()};
+            if (fd >= 0) (void)::shutdown(fd, SHUT_RDWR);
+        }
+        void Close() const
+        {
+            const int fd{m_fd.exchange(-1)};
+            if (fd >= 0) (void)::close(fd);
+        }
+
+    private:
+        mutable std::atomic<int> m_fd;
+    };
+    struct Listener {
+        int fd{-1};
+        std::thread thread;
+    };
+    struct ConnectionThread {
+        std::shared_ptr<SharedFd> shutdown_fd;
+        std::thread thread;
+    };
+
+public:
+    ~CapnpProtocol() noexcept override { disconnectIncoming(); }
+
+    std::unique_ptr<interfaces::Init> connect(int fd, const char*) override
+    {
+        auto connection{std::make_shared<ClientConnection>(fd)};
+        return std::make_unique<RemoteInit>(connection, connection->init());
+    }
+
     void listen(int listen_fd, const char* exe_name, interfaces::Init& init) override
     {
-        startLoop(exe_name);
         if (::listen(listen_fd, /*backlog=*/5) != 0) {
             throw std::system_error(errno, std::system_category());
         }
-        mp::ListenConnections<messages::Init>(*m_loop, listen_fd, init);
+        std::thread accept_thread{[this, listen_fd, exe_name, &init] {
+            util::ThreadRename("capnp-accept");
+            while (!m_stop.load()) {
+                const int fd{::accept(listen_fd, nullptr, nullptr)};
+                if (fd < 0) {
+                    if (m_stop.load() || errno == EBADF || errno == EINVAL) return;
+                    LogWarning("ipc: accept failed: %s\n", SysErrorString(errno));
+                    continue;
+                }
+                auto shutdown_fd{std::make_shared<SharedFd>(::dup(fd))};
+                if (shutdown_fd->fd() < 0) {
+                    (void)::close(fd);
+                    LogWarning("ipc: dup failed: %s\n", SysErrorString(errno));
+                    continue;
+                }
+                std::lock_guard lock{m_mutex};
+                m_connection_threads.push_back({.shutdown_fd = shutdown_fd,
+                                                .thread = std::thread([fd, shutdown_fd, exe_name, &init] {
+                                                    util::ThreadRename("capnp-serve");
+                                                    try {
+                                                        ServeConnection(fd, exe_name, init);
+                                                    } catch (const kj::Exception& e) {
+                                                        LogDebug(BCLog::IPC, "IPC connection closed: %s\n", e.getDescription().cStr());
+                                                    } catch (const std::exception& e) {
+                                                        LogWarning("ipc: connection failed: %s\n", e.what());
+                                                    }
+                                                    shutdown_fd->Close();
+                                                })});
+            }
+        }};
+        std::lock_guard lock{m_mutex};
+        m_listeners.push_back({.fd = listen_fd, .thread = std::move(accept_thread)});
     }
+
     void serve(int fd, const char* exe_name, interfaces::Init& init, const std::function<void()>& ready_fn = {}) override
     {
-        assert(!m_loop);
-        mp::g_thread_context.thread_name = mp::ThreadName(exe_name);
-        mp::LogOptions opts = {
-            .log_fn = IpcLogFn,
-            .log_level = GetRequestedIPCLogLevel()
-        };
-        m_loop.emplace(exe_name, std::move(opts), &m_context);
-        if (ready_fn) ready_fn();
-        mp::ServeStream<messages::Init>(*m_loop, fd, init);
-        m_parent_connection = &m_loop->m_incoming_connections.back();
-        m_loop->loop();
-        m_loop.reset();
+        util::ThreadRename(exe_name);
+        ServeConnection(fd, exe_name, init, ready_fn);
     }
+
     void disconnectIncoming() override
     {
-        if (!m_loop) return;
-        // Delete incoming connections, except the connection to a parent
-        // process (if there is one), since a parent process should be able to
-        // monitor and control this process, even during shutdown.
-        m_loop->sync([&] {
-            m_loop->m_incoming_connections.remove_if([this](mp::Connection& c) { return &c != m_parent_connection; });
-        });
-    }
-    void addCleanup(std::type_index type, void* iface, std::function<void()> cleanup) override
-    {
-        mp::ProxyTypeRegister::types().at(type)(iface).cleanup_fns.emplace_back(std::move(cleanup));
+        const bool was_stopped{m_stop.exchange(true)};
+        if (was_stopped) return;
+        std::vector<Listener> listeners;
+        {
+            std::lock_guard lock{m_mutex};
+            listeners.swap(m_listeners);
+        }
+        for (auto& listener : listeners) {
+            (void)::shutdown(listener.fd, SHUT_RDWR);
+            (void)::close(listener.fd);
+        }
+        for (auto& listener : listeners) {
+            if (listener.thread.joinable()) listener.thread.join();
+        }
+        std::vector<ConnectionThread> threads;
+        {
+            std::lock_guard lock{m_mutex};
+            threads.swap(m_connection_threads);
+        }
+        for (auto& thread : threads) {
+            thread.shutdown_fd->Shutdown();
+            thread.shutdown_fd->Close();
+        }
+        for (auto& thread : threads) {
+            if (thread.thread.joinable()) thread.thread.join();
+        }
     }
+
     Context& context() override { return m_context; }
-    void startLoop(const char* exe_name)
-    {
-        if (m_loop) return;
-        std::promise<void> promise;
-        m_loop_thread = std::thread([&] {
-            util::ThreadRename("capnp-loop");
-            mp::LogOptions opts = {
-                .log_fn = IpcLogFn,
-                .log_level = GetRequestedIPCLogLevel()
-            };
-            m_loop.emplace(exe_name, std::move(opts), &m_context);
-            m_loop_ref.emplace(*m_loop);
-            promise.set_value();
-            m_loop->loop();
-            m_loop.reset();
-        });
-        promise.get_future().wait();
-    }
+
+private:
     Context m_context;
-    std::thread m_loop_thread;
-    //! EventLoop object which manages I/O events for all connections.
-    std::optional<mp::EventLoop> m_loop;
-    //! Reference to the same EventLoop. Increments the loop’s refcount on
-    //! creation, decrements on destruction. The loop thread exits when the
-    //! refcount reaches 0. Other IPC objects also hold their own EventLoopRef.
-    std::optional<mp::EventLoopRef> m_loop_ref;
-    //! Connection to parent, if this is a child process spawned by a parent process.
-    mp::Connection* m_parent_connection{nullptr};
+    std::atomic<bool> m_stop{false};
+    std::mutex m_mutex;
+    std::vector<Listener> m_listeners;
+    std::vector<ConnectionThread> m_connection_threads;
 };
 } // namespace
 
diff --git a/src/ipc/interfaces.cpp b/src/ipc/interfaces.cpp
index 1171f7064871..6317127bb1ea 100644
--- a/src/ipc/interfaces.cpp
+++ b/src/ipc/interfaces.cpp
@@ -11,6 +11,7 @@
 #include <ipc/protocol.h>
 #include <logging.h>
 #include <tinyformat.h>
+#include <unistd.h>
 #include <util/fs.h>
 
 #include <csignal>
@@ -21,7 +22,6 @@
 #include <memory>
 #include <stdexcept>
 #include <string>
-#include <unistd.h>
 #include <utility>
 #include <vector>
 
@@ -49,12 +49,39 @@ void IgnoreCtrlC(std::string message)
 #endif
 }
 
+class SpawnedInit final : public interfaces::Init
+{
+public:
+    SpawnedInit(std::unique_ptr<interfaces::Init> init, std::function<void()> cleanup)
+        : m_init(std::move(init)), m_cleanup(std::move(cleanup))
+    {
+    }
+
+    ~SpawnedInit() override
+    {
+        m_init.reset();
+        if (m_cleanup) m_cleanup();
+    }
+
+    std::unique_ptr<interfaces::Node> makeNode() override { return m_init->makeNode(); }
+    std::unique_ptr<interfaces::Chain> makeChain() override { return m_init->makeChain(); }
+    std::unique_ptr<interfaces::Mining> makeMining() override { return m_init->makeMining(); }
+    std::unique_ptr<interfaces::Echo> makeEcho() override { return m_init->makeEcho(); }
+    void stop() override { m_init->stop(); }
+    interfaces::Ipc* ipc() override { return m_init->ipc(); }
+    bool canListenIpc() override { return m_init->canListenIpc(); }
+    const char* exeName() override { return m_init->exeName(); }
+
+private:
+    std::unique_ptr<interfaces::Init> m_init;
+    std::function<void()> m_cleanup;
+};
+
 class IpcImpl : public interfaces::Ipc
 {
 public:
     IpcImpl(const char* exe_name, const char* process_argv0, interfaces::Init& init)
-        : m_exe_name(exe_name), m_process_argv0(process_argv0), m_init(init),
-          m_protocol(ipc::capnp::MakeCapnpProtocol()), m_process(ipc::MakeProcess())
+        : m_exe_name(exe_name), m_process_argv0(process_argv0), m_init(init), m_protocol(ipc::capnp::MakeCapnpProtocol()), m_process(ipc::MakeProcess())
     {
     }
     std::unique_ptr<interfaces::Init> spawnProcess(const char* new_exe_name) override
@@ -62,12 +89,10 @@ class IpcImpl : public interfaces::Ipc
         int pid;
         int fd = m_process->spawn(new_exe_name, m_process_argv0, pid);
         LogDebug(::BCLog::IPC, "Process %s pid %i launched\n", new_exe_name, pid);
-        auto init = m_protocol->connect(fd, m_exe_name);
-        Ipc::addCleanup(*init, [this, new_exe_name, pid] {
+        return std::make_unique<SpawnedInit>(m_protocol->connect(fd, m_exe_name), [this, new_exe_name, pid] {
             int status = m_process->waitSpawned(pid);
             LogDebug(::BCLog::IPC, "Process %s pid %i exited with status %i\n", new_exe_name, pid, status);
         });
-        return init;
     }
     bool startSpawnedProcess(int argc, char* argv[], int& exit_status) override
     {
@@ -100,8 +125,8 @@ class IpcImpl : public interfaces::Ipc
                 }
                 throw;
             } catch (const std::invalid_argument&) {
-               // Catch 'Unix address path "..." exceeded maximum socket path length' error
-               return nullptr;
+                // Catch 'Unix address path "..." exceeded maximum socket path length' error
+                return nullptr;
             }
         } else {
             fd = m_process->connect(gArgs.GetDataDirNet(), "bitcoin-node", address);
@@ -117,10 +142,6 @@ class IpcImpl : public interfaces::Ipc
     {
         m_protocol->disconnectIncoming();
     }
-    void addCleanup(std::type_index type, void* iface, std::function<void()> cleanup) override
-    {
-        m_protocol->addCleanup(type, iface, std::move(cleanup));
-    }
     Context& context() override { return m_protocol->context(); }
     const char* m_exe_name;
     const char* m_process_argv0;
diff --git a/src/ipc/process.cpp b/src/ipc/process.cpp
index e89414be8e9b..11902dbf95d7 100644
--- a/src/ipc/process.cpp
+++ b/src/ipc/process.cpp
@@ -3,24 +3,25 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <ipc/process.h>
+
 #include <ipc/protocol.h>
 #include <logging.h>
-#include <mp/util.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/wait.h>
 #include <tinyformat.h>
+#include <unistd.h>
 #include <util/fs.h>
 #include <util/strencodings.h>
 #include <util/syserror.h>
 
+#include <cerrno>
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
-#include <cerrno>
 #include <exception>
 #include <iostream>
 #include <stdexcept>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <unistd.h>
 #include <utility>
 #include <vector>
 
@@ -28,19 +29,76 @@ using util::RemovePrefixView;
 
 namespace ipc {
 namespace {
+
+std::vector<char*> MakeArgv(const std::vector<std::string>& args)
+{
+    std::vector<char*> argv;
+    argv.reserve(args.size() + 1);
+    for (const auto& arg : args) {
+        argv.push_back(const_cast<char*>(arg.c_str()));
+    }
+    argv.push_back(nullptr);
+    return argv;
+}
+
+int MaxFd()
+{
+    const long max_fd{sysconf(_SC_OPEN_MAX)};
+    return max_fd > 0 ? max_fd : 1024;
+}
+
+int SpawnProcess(int& pid, const fs::path& path)
+{
+    int fds[2];
+    if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) != 0) {
+        throw std::system_error(errno, std::system_category(), "socketpair");
+    }
+    const std::vector<std::string> args{fs::PathToString(path), "-ipcfd", strprintf("%i", fds[0])};
+    const std::vector<char*> argv{MakeArgv(args)};
+
+    pid = fork();
+    if (pid == -1) {
+        throw std::system_error(errno, std::system_category(), "fork");
+    }
+    if (close(fds[pid ? 0 : 1]) != 0) {
+        if (pid) {
+            (void)close(fds[1]);
+            throw std::system_error(errno, std::system_category(), "close");
+        }
+        static constexpr char msg[] = "SpawnProcess(child): close(fds[1]) failed\n";
+        (void)!::write(STDERR_FILENO, msg, sizeof(msg) - 1);
+        _exit(126);
+    }
+
+    if (!pid) {
+        for (int fd = 3; fd < MaxFd(); ++fd) {
+            if (fd != fds[0]) close(fd);
+        }
+        execvp(argv[0], argv.data());
+        perror("execvp failed");
+        _exit(127);
+    }
+    return fds[1];
+}
+
 class ProcessImpl : public Process
 {
 public:
     int spawn(const std::string& new_exe_name, const fs::path& argv0_path, int& pid) override
     {
-        return mp::SpawnProcess(pid, [&](int fd) {
-            fs::path path = argv0_path;
-            path.remove_filename();
-            path /= fs::PathFromString(new_exe_name);
-            return std::vector<std::string>{fs::PathToString(path), "-ipcfd", strprintf("%i", fd)};
-        });
-    }
-    int waitSpawned(int pid) override { return mp::WaitProcess(pid); }
+        fs::path path = argv0_path;
+        path.remove_filename();
+        path /= fs::PathFromString(new_exe_name);
+        return SpawnProcess(pid, path);
+    }
+    int waitSpawned(int pid) override
+    {
+        int status;
+        if (::waitpid(pid, &status, /*options=*/0) != pid) {
+            throw std::system_error(errno, std::system_category(), "waitpid");
+        }
+        return status;
+    }
     bool checkSpawned(int argc, char* argv[], int& fd) override
     {
         // If this process was not started with a single -ipcfd argument, it is
@@ -69,10 +127,10 @@ class ProcessImpl : public Process
 };
 
 static bool ParseAddress(std::string& address,
-                  const fs::path& data_dir,
-                  const std::string& dest_exe_name,
-                  struct sockaddr_un& addr,
-                  std::string& error)
+                         const fs::path& data_dir,
+                         const std::string& dest_exe_name,
+                         struct sockaddr_un& addr,
+                         std::string& error)
 {
     if (address == "unix" || address.starts_with("unix:")) {
         fs::path path;
@@ -89,7 +147,7 @@ static bool ParseAddress(std::string& address,
         }
         memset(&addr, 0, sizeof(addr));
         addr.sun_family = AF_UNIX;
-        strncpy(addr.sun_path, path_str.c_str(), sizeof(addr.sun_path)-1);
+        strncpy(addr.sun_path, path_str.c_str(), sizeof(addr.sun_path) - 1);
         return true;
     }
 
diff --git a/src/ipc/protocol.h b/src/ipc/protocol.h
index e7d66887a1ae..bc3066fe9360 100644
--- a/src/ipc/protocol.h
+++ b/src/ipc/protocol.h
@@ -9,7 +9,6 @@
 
 #include <functional>
 #include <memory>
-#include <typeindex>
 
 namespace ipc {
 struct Context;
@@ -61,10 +60,6 @@ class Protocol
     //! Disconnect any incoming connections that are still connected.
     virtual void disconnectIncoming() = 0;
 
-    //! Add cleanup callback to interface that will run when the interface is
-    //! deleted.
-    virtual void addCleanup(std::type_index type, void* iface, std::function<void()> cleanup) = 0;
-
     //! Context accessor.
     virtual Context& context() = 0;
 };
diff --git a/src/ipc/test/CMakeLists.txt b/src/ipc/test/CMakeLists.txt
index e71bc2bc6a19..25b37f76d949 100644
--- a/src/ipc/test/CMakeLists.txt
+++ b/src/ipc/test/CMakeLists.txt
@@ -6,7 +6,9 @@
 # SOURCES property is processed to gather test suite macros.
 target_sources(test_bitcoin
   PRIVATE
+    ipc_test.cpp
     ipc_tests.cpp
 )
 
-target_link_libraries(test_bitcoin bitcoin_ipc_test bitcoin_ipc)
+target_link_libraries(test_bitcoin bitcoin_ipc CapnProto::capnp-rpc)
+target_include_directories(test_bitcoin SYSTEM PRIVATE ${CAPNP_INCLUDE_DIRS})
diff --git a/src/ipc/test/ipc_test.capnp b/src/ipc/test/ipc_test.capnp
deleted file mode 100644
index adb928251169..000000000000
--- a/src/ipc/test/ipc_test.capnp
+++ /dev/null
@@ -1,23 +0,0 @@
-# Copyright (c) 2023-present The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-@0xd71b0fc8727fdf83;
-
-using Cxx = import "/capnp/c++.capnp";
-$Cxx.namespace("gen");
-
-using Proxy = import "/mp/proxy.capnp";
-$Proxy.include("ipc/test/ipc_test.h");
-$Proxy.includeTypes("ipc/test/ipc_test_types.h");
-
-using Mining = import "../capnp/mining.capnp";
-
-interface FooInterface $Proxy.wrap("FooImplementation") {
-    add @0 (a :Int32, b :Int32) -> (result :Int32);
-    passOutPoint @1 (arg :Data) -> (result :Data);
-    passUniValue @2 (arg :Text) -> (result :Text);
-    passTransaction @3 (arg :Data) -> (result :Data);
-    passVectorChar @4 (arg :Data) -> (result :Data);
-    passScript @5 (arg :Data) -> (result :Data);
-}
diff --git a/src/ipc/test/ipc_test.cpp b/src/ipc/test/ipc_test.cpp
index 4ff854e9a21c..6b92a1b7191d 100644
--- a/src/ipc/test/ipc_test.cpp
+++ b/src/ipc/test/ipc_test.cpp
@@ -2,45 +2,227 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <ipc/test/ipc_test.h>
+
+#include <capnp/rpc-twoparty.h>
+#include <capnp/rpc.h>
 #include <interfaces/init.h>
+#include <interfaces/mining.h>
+#include <ipc/capnp/common-types.h>
+#include <ipc/capnp/init.capnp.h>
+#include <ipc/capnp/mining.capnp.h>
 #include <ipc/capnp/protocol.h>
 #include <ipc/process.h>
 #include <ipc/protocol.h>
-#include <logging.h>
-#include <mp/proxy-types.h>
-#include <ipc/capnp/mining.capnp.h>
-#include <ipc/test/ipc_test.capnp.h>
-#include <ipc/test/ipc_test.capnp.proxy.h>
-#include <ipc/test/ipc_test.h>
+#include <kj/async-io.h>
+#include <kj/debug.h>
 #include <tinyformat.h>
-#include <chainstate.h>
+
+#include <boost/test/unit_test.hpp>
 
 #include <atomic>
+#include <chrono>
+#include <condition_variable>
 #include <future>
-#include <thread>
-#include <kj/common.h>
-#include <kj/memory.h>
-#include <kj/test.h>
+#include <mutex>
+#include <span>
 #include <stdexcept>
-
-#include <boost/test/unit_test.hpp>
+#include <thread>
 
 static_assert(ipc::capnp::messages::MAX_MONEY == MAX_MONEY);
 static_assert(ipc::capnp::messages::MAX_DOUBLE == std::numeric_limits<double>::max());
 static_assert(ipc::capnp::messages::DEFAULT_BLOCK_RESERVED_WEIGHT == DEFAULT_BLOCK_RESERVED_WEIGHT);
 static_assert(ipc::capnp::messages::DEFAULT_COINBASE_OUTPUT_MAX_ADDITIONAL_SIGOPS == DEFAULT_COINBASE_OUTPUT_MAX_ADDITIONAL_SIGOPS);
 
+namespace {
+
+namespace messages = ipc::capnp::messages;
+
+::capnp::rpc::twoparty::VatId::Reader ServerVatId(::capnp::MallocMessageBuilder& message)
+{
+    auto vat_id{message.getRoot<::capnp::rpc::twoparty::VatId>()};
+    vat_id.setSide(::capnp::rpc::twoparty::Side::SERVER);
+    return vat_id.asReader();
+}
+
+void SetData(::capnp::Data::Builder output, std::span<const unsigned char> bytes)
+{
+    std::copy(bytes.begin(), bytes.end(), output.begin());
+}
+
+uint256 ReadUint256(::capnp::Data::Reader data)
+{
+    BOOST_REQUIRE_EQUAL(data.size(), uint256::size());
+    uint256 value;
+    std::copy(data.begin(), data.end(), value.begin());
+    return value;
+}
+
+interfaces::BlockRef ReadBlockRef(messages::BlockRef::Reader reader)
+{
+    return {.hash = ReadUint256(reader.getHash()), .height = reader.getHeight()};
+}
+
+struct TestMiningState {
+    std::mutex mutex;
+    std::condition_variable cv;
+    int cancellations{0};
+};
+
+class TestBlockTemplate final : public interfaces::BlockTemplate
+{
+public:
+    CBlockHeader getBlockHeader() override { return {}; }
+    CBlock getBlock() override { return {}; }
+    std::vector<CAmount> getTxFees() override { return {12, 34}; }
+    std::vector<int64_t> getTxSigops() override { return {1, 2}; }
+    node::CoinbaseTx getCoinbaseTx() override
+    {
+        return {
+            .version = 1,
+            .sequence = CTxIn::SEQUENCE_FINAL,
+            .script_sig_prefix = {},
+            .witness = std::nullopt,
+            .block_reward_remaining = 0,
+            .required_outputs = {},
+            .lock_time = 0,
+        };
+    }
+    std::vector<uint256> getCoinbaseMerklePath() override { return {}; }
+    std::unique_ptr<interfaces::Handler> submitSolutionAsync(uint32_t, uint32_t, uint32_t, CTransactionRef, SubmitSolutionFn fn) override
+    {
+        fn(true);
+        return interfaces::MakeCleanupHandler([] {});
+    }
+    std::unique_ptr<interfaces::Handler> watchNext(node::BlockWaitOptions, NextTemplateFn fn) override
+    {
+        fn(std::make_unique<TestBlockTemplate>());
+        return interfaces::MakeCleanupHandler([] {});
+    }
+};
+
+class TestMining final : public interfaces::Mining
+{
+public:
+    explicit TestMining(std::shared_ptr<TestMiningState> state) : m_state(std::move(state)) {}
+
+    bool isTestChain() override { return true; }
+    bool isInitialBlockDownload() override { return false; }
+
+    std::optional<interfaces::BlockRef> getTip() override
+    {
+        return interfaces::BlockRef{.hash = uint256::ONE, .height = 7};
+    }
+
+    std::unique_ptr<interfaces::Handler> watchTip(uint256 current_tip, MillisecondsDouble, TipChangedFn fn) override
+    {
+        if (current_tip != uint256::ONE) fn(getTip());
+        return interfaces::MakeCleanupHandler([state = m_state] {
+            {
+                std::lock_guard lock{state->mutex};
+                ++state->cancellations;
+            }
+            state->cv.notify_all();
+        });
+    }
+
+    std::unique_ptr<interfaces::Handler> createNewBlockAsync(const node::BlockCreateOptions&, bool, CreateBlockFn fn) override
+    {
+        fn(CreateBlockResult{std::make_unique<TestBlockTemplate>()});
+        return interfaces::MakeCleanupHandler([] {});
+    }
+
+    std::unique_ptr<interfaces::Handler> checkBlockAsync(CBlock, node::BlockCheckOptions, CheckBlockFn fn) override
+    {
+        fn(true, "accepted", "checked");
+        return interfaces::MakeCleanupHandler([] {});
+    }
+
+    std::unique_ptr<interfaces::Handler> submitBlockAsync(CBlock, SubmitBlockFn fn) override
+    {
+        fn(true, "submitted", "processed");
+        return interfaces::MakeCleanupHandler([] {});
+    }
+
+private:
+    std::shared_ptr<TestMiningState> m_state;
+};
+
 //! Remote init class.
 namespace {
 class TestInit : public interfaces::Init
 {
 public:
     std::atomic<bool> stop_called{false};
+    std::shared_ptr<TestMiningState> mining_state{std::make_shared<TestMiningState>()};
     std::unique_ptr<interfaces::Echo> makeEcho() override { return interfaces::MakeEcho(); }
+    std::unique_ptr<interfaces::Mining> makeMining() override { return std::make_unique<TestMining>(mining_state); }
     void stop() override { stop_called.store(true); }
 };
 } // namespace
 
+class TestTipListener final : public messages::TipListener::Server
+{
+public:
+    explicit TestTipListener(kj::Own<kj::PromiseFulfiller<interfaces::BlockRef>> fulfiller)
+    {
+        m_fulfiller.emplace(kj::mv(fulfiller));
+    }
+
+    kj::Promise<void> tipChanged(TipChangedContext context) override
+    {
+        if (m_fulfiller) {
+            (*m_fulfiller)->fulfill(ReadBlockRef(context.getParams().getTip()));
+            m_fulfiller.reset();
+        }
+        return kj::READY_NOW;
+    }
+
+    kj::Promise<void> stopped(StoppedContext) override
+    {
+        if (m_fulfiller) {
+            (*m_fulfiller)->reject(KJ_EXCEPTION(FAILED, "tip watch stopped"));
+            m_fulfiller.reset();
+        }
+        return kj::READY_NOW;
+    }
+
+private:
+    std::optional<kj::Own<kj::PromiseFulfiller<interfaces::BlockRef>>> m_fulfiller;
+};
+
+class TestTemplateListener final : public messages::BlockTemplateListener::Server
+{
+public:
+    explicit TestTemplateListener(kj::Own<kj::PromiseFulfiller<messages::BlockTemplate::Client>> fulfiller)
+    {
+        m_fulfiller.emplace(kj::mv(fulfiller));
+    }
+
+    kj::Promise<void> templateReady(TemplateReadyContext context) override
+    {
+        if (m_fulfiller) {
+            (*m_fulfiller)->fulfill(context.getParams().getResult());
+            m_fulfiller.reset();
+        }
+        return kj::READY_NOW;
+    }
+
+    kj::Promise<void> stopped(StoppedContext) override
+    {
+        if (m_fulfiller) {
+            (*m_fulfiller)->reject(KJ_EXCEPTION(FAILED, "template watch stopped"));
+            m_fulfiller.reset();
+        }
+        return kj::READY_NOW;
+    }
+
+private:
+    std::optional<kj::Own<kj::PromiseFulfiller<messages::BlockTemplate::Client>>> m_fulfiller;
+};
+
+} // namespace
+
 //! Generate a temporary path with temp_directory_path and mkstemp
 static std::string TempPath(std::string_view pattern)
 {
@@ -54,73 +236,6 @@ static std::string TempPath(std::string_view pattern)
     return temp;
 }
 
-//! Unit test that tests execution of IPC calls without actually creating a
-//! separate process. This test is primarily intended to verify behavior of type
-//! conversion code that converts C++ objects to Cap'n Proto messages and vice
-//! versa.
-//!
-//! The test creates a thread which creates a FooImplementation object (defined
-//! in ipc_test.h) and a two-way pipe accepting IPC requests which call methods
-//! on the object through FooInterface (defined in ipc_test.capnp).
-void IpcPipeTest()
-{
-    // Setup: create FooImplementation object and listen for FooInterface requests
-    std::promise<std::unique_ptr<mp::ProxyClient<gen::FooInterface>>> foo_promise;
-    std::thread thread([&]() {
-        mp::EventLoop loop("IpcPipeTest", [](bool raise, const std::string& log) { LogInfo("LOG%i: %s", raise, log); });
-        auto pipe = loop.m_io_context.provider->newTwoWayPipe();
-
-        auto connection_client = std::make_unique<mp::Connection>(loop, kj::mv(pipe.ends[0]));
-        auto foo_client = std::make_unique<mp::ProxyClient<gen::FooInterface>>(
-            connection_client->m_rpc_system->bootstrap(mp::ServerVatId().vat_id).castAs<gen::FooInterface>(),
-            connection_client.get(), /* destroy_connection= */ true);
-        (void)connection_client.release();
-        foo_promise.set_value(std::move(foo_client));
-
-        auto connection_server = std::make_unique<mp::Connection>(loop, kj::mv(pipe.ends[1]), [&](mp::Connection& connection) {
-            auto foo_server = kj::heap<mp::ProxyServer<gen::FooInterface>>(std::make_shared<FooImplementation>(), connection);
-            return capnp::Capability::Client(kj::mv(foo_server));
-        });
-        connection_server->onDisconnect([&] { connection_server.reset(); });
-        loop.loop();
-    });
-    std::unique_ptr<mp::ProxyClient<gen::FooInterface>> foo{foo_promise.get_future().get()};
-
-    // Test: make sure arguments were sent and return value is received
-    BOOST_CHECK_EQUAL(foo->add(1, 2), 3);
-
-    COutPoint txout1{Txid::FromUint256(uint256{100}), 200};
-    COutPoint txout2{foo->passOutPoint(txout1)};
-    BOOST_CHECK(txout1 == txout2);
-
-    UniValue uni1{UniValue::VOBJ};
-    uni1.pushKV("i", 1);
-    uni1.pushKV("s", "two");
-    UniValue uni2{foo->passUniValue(uni1)};
-    BOOST_CHECK_EQUAL(uni1.write(), uni2.write());
-
-    CMutableTransaction mtx;
-    mtx.version = 2;
-    mtx.nLockTime = 3;
-    mtx.vin.emplace_back(txout1);
-    mtx.vout.emplace_back(COIN, CScript());
-    CTransactionRef tx1{MakeTransactionRef(mtx)};
-    CTransactionRef tx2{foo->passTransaction(tx1)};
-    BOOST_CHECK(*Assert(tx1) == *Assert(tx2));
-
-    std::vector<char> vec1{'H', 'e', 'l', 'l', 'o'};
-    std::vector<char> vec2{foo->passVectorChar(vec1)};
-    BOOST_CHECK_EQUAL(std::string_view(vec1.begin(), vec1.end()), std::string_view(vec2.begin(), vec2.end()));
-
-    auto script1{CScript() << OP_11};
-    auto script2{foo->passScript(script1)};
-    BOOST_CHECK_EQUAL(HexStr(script1), HexStr(script2));
-
-    // Test cleanup: disconnect and join thread
-    foo.reset();
-    thread.join();
-}
-
 //! Test ipc::Protocol connect() and serve() methods connecting over a socketpair.
 void IpcSocketPairTest()
 {
@@ -137,12 +252,202 @@ void IpcSocketPairTest()
     std::unique_ptr<interfaces::Echo> remote_echo{remote_init->makeEcho()};
     BOOST_CHECK_EQUAL(remote_echo->echo("echo test"), "echo test");
     remote_echo.reset();
+    std::unique_ptr<interfaces::Mining> remote_mining{remote_init->makeMining()};
+    BOOST_REQUIRE(remote_mining);
+    BOOST_CHECK(remote_mining->isTestChain());
+    BOOST_CHECK(!remote_mining->isInitialBlockDownload());
+    const auto tip{remote_mining->getTip()};
+    BOOST_REQUIRE(tip);
+    BOOST_CHECK_EQUAL(tip->hash.ToString(), uint256::ONE.ToString());
+    BOOST_CHECK_EQUAL(tip->height, 7);
+    const auto test_thread{std::this_thread::get_id()};
+
+    struct TipResult {
+        std::thread::id callback_thread;
+        std::optional<interfaces::BlockRef> tip;
+    };
+    std::promise<TipResult> async_tip_promise;
+    auto tip_handler{remote_mining->watchTip(uint256::ZERO, MillisecondsDouble{0}, [&async_tip_promise](std::optional<interfaces::BlockRef> tip) {
+        async_tip_promise.set_value({std::this_thread::get_id(), std::move(tip)});
+    })};
+    (void)tip_handler;
+    const auto tip_result{async_tip_promise.get_future().get()};
+    BOOST_CHECK(tip_result.callback_thread != test_thread);
+    const auto& changed_tip{tip_result.tip};
+    BOOST_REQUIRE(changed_tip);
+    BOOST_CHECK_EQUAL(changed_tip->height, 7);
+
+    struct CreateResult {
+        std::thread::id callback_thread;
+        std::unique_ptr<interfaces::BlockTemplate> block_template;
+    };
+    std::promise<CreateResult> create_promise;
+    auto create_handler{remote_mining->createNewBlockAsync(node::BlockCreateOptions{}, false, [&create_promise](interfaces::Mining::CreateBlockResult result) {
+        std::unique_ptr<interfaces::BlockTemplate> block_template;
+        if (result) block_template = std::move(*result);
+        create_promise.set_value({std::this_thread::get_id(), std::move(block_template)});
+    })};
+    (void)create_handler;
+    auto create_result{create_promise.get_future().get()};
+    BOOST_CHECK(create_result.callback_thread != test_thread);
+    BOOST_REQUIRE(create_result.block_template);
+    const auto fees{create_result.block_template->getTxFees()};
+    BOOST_REQUIRE_EQUAL(fees.size(), 2);
+    BOOST_CHECK_EQUAL(fees[0], 12);
+    BOOST_CHECK_EQUAL(fees[1], 34);
+
+    struct NextResult {
+        std::thread::id callback_thread;
+        std::unique_ptr<interfaces::BlockTemplate> block_template;
+    };
+    std::promise<NextResult> next_promise;
+    auto next_handler{create_result.block_template->watchNext(node::BlockWaitOptions{}, [&next_promise](std::unique_ptr<interfaces::BlockTemplate> block_template) {
+        next_promise.set_value({std::this_thread::get_id(), std::move(block_template)});
+    })};
+    (void)next_handler;
+    auto next_result{next_promise.get_future().get()};
+    BOOST_CHECK(next_result.callback_thread != test_thread);
+    BOOST_REQUIRE(next_result.block_template);
+
+    struct SubmitResult {
+        std::thread::id callback_thread;
+        bool accepted{false};
+    };
+    std::promise<SubmitResult> submit_promise;
+    auto submit_handler{next_result.block_template->submitSolutionAsync(0, 0, 0, MakeTransactionRef(CMutableTransaction{}), [&submit_promise](bool accepted) {
+        submit_promise.set_value({std::this_thread::get_id(), accepted});
+    })};
+    (void)submit_handler;
+    const auto submit_result{submit_promise.get_future().get()};
+    BOOST_CHECK(submit_result.callback_thread != test_thread);
+    BOOST_CHECK(submit_result.accepted);
+
+    struct CheckResult {
+        std::thread::id callback_thread;
+        bool valid{false};
+        std::string reason;
+        std::string debug;
+    };
+    std::promise<CheckResult> check_promise;
+    auto check_handler{remote_mining->checkBlockAsync(CBlock{}, node::BlockCheckOptions{}, [&check_promise](bool valid, std::string reason, std::string debug) {
+        check_promise.set_value({std::this_thread::get_id(), valid, std::move(reason), std::move(debug)});
+    })};
+    (void)check_handler;
+    const auto check_result{check_promise.get_future().get()};
+    BOOST_CHECK(check_result.callback_thread != test_thread);
+    BOOST_CHECK(check_result.valid);
+    BOOST_CHECK_EQUAL(check_result.reason, "accepted");
+    BOOST_CHECK_EQUAL(check_result.debug, "checked");
+
+    struct SubmitBlockResult {
+        std::thread::id callback_thread;
+        bool accepted{false};
+        std::string reason;
+        std::string debug;
+    };
+    std::promise<SubmitBlockResult> submit_block_promise;
+    auto submit_block_handler{remote_mining->submitBlockAsync(CBlock{}, [&submit_block_promise](bool accepted, std::string reason, std::string debug) {
+        submit_block_promise.set_value({std::this_thread::get_id(), accepted, std::move(reason), std::move(debug)});
+    })};
+    (void)submit_block_handler;
+    const auto submit_block_result{submit_block_promise.get_future().get()};
+    BOOST_CHECK(submit_block_result.callback_thread != test_thread);
+    BOOST_CHECK(submit_block_result.accepted);
+    BOOST_CHECK_EQUAL(submit_block_result.reason, "submitted");
+    BOOST_CHECK_EQUAL(submit_block_result.debug, "processed");
+
+    remote_mining.reset();
     remote_init->stop();
     BOOST_CHECK(static_cast<TestInit*>(init.get())->stop_called.load());
+    submit_block_handler.reset();
+    check_handler.reset();
+    submit_handler.reset();
+    next_handler.reset();
+    create_handler.reset();
+    tip_handler.reset();
+    next_result.block_template.reset();
+    create_result.block_template.reset();
     remote_init.reset();
     thread.join();
 }
 
+//! Test the native Cap'n Proto mining watch/cancel API without going through
+//! the synchronous C++ compatibility wrapper.
+void IpcNativeMiningWatchTest()
+{
+    int fds[2];
+    BOOST_CHECK_EQUAL(socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0);
+    auto init{std::make_unique<TestInit>()};
+    auto* test_init{init.get()};
+    std::unique_ptr<ipc::Protocol> protocol{ipc::capnp::MakeCapnpProtocol()};
+    std::promise<void> promise;
+    std::thread thread([&] {
+        protocol->serve(fds[0], "test-serve", *init, [&] { promise.set_value(); });
+    });
+    promise.get_future().wait();
+
+    {
+        auto io{kj::setupAsyncIo()};
+        auto stream{io.lowLevelProvider->wrapSocketFd(fds[1], kj::LowLevelAsyncIoProvider::TAKE_OWNERSHIP)};
+        ::capnp::TwoPartyVatNetwork network{*stream, ::capnp::rpc::twoparty::Side::CLIENT, ::capnp::ReaderOptions{}};
+        auto rpc_system{::capnp::makeRpcClient(network)};
+        ::capnp::MallocMessageBuilder vat_message;
+        auto init_client{rpc_system.bootstrap(ServerVatId(vat_message)).castAs<messages::Init>()};
+        auto mining{init_client.makeMiningRequest().send().wait(io.waitScope).getResult()};
+
+        auto tip_pair{kj::newPromiseAndFulfiller<interfaces::BlockRef>()};
+        auto watch_tip{mining.watchTipRequest()};
+        SetData(watch_tip.initCurrentTip(uint256::size()), {uint256::ZERO.data(), uint256::ZERO.size()});
+        watch_tip.setListener(messages::TipListener::Client(kj::heap<TestTipListener>(kj::mv(tip_pair.fulfiller))));
+        auto watch_response{watch_tip.send().wait(io.waitScope)};
+        const auto tip{tip_pair.promise.wait(io.waitScope)};
+        BOOST_CHECK_EQUAL(tip.hash.ToString(), uint256::ONE.ToString());
+        BOOST_CHECK_EQUAL(tip.height, 7);
+
+        auto cancel_watch{mining.watchTipRequest()};
+        SetData(cancel_watch.initCurrentTip(uint256::size()), {uint256::ONE.data(), uint256::ONE.size()});
+        auto cancel_pair{kj::newPromiseAndFulfiller<interfaces::BlockRef>()};
+        cancel_watch.setListener(messages::TipListener::Client(kj::heap<TestTipListener>(kj::mv(cancel_pair.fulfiller))));
+        auto cancel_response{cancel_watch.send().wait(io.waitScope)};
+        cancel_response.getWatch().cancelRequest().send().wait(io.waitScope);
+        {
+            std::unique_lock lock{test_init->mining_state->mutex};
+            BOOST_CHECK(test_init->mining_state->cv.wait_for(lock, std::chrono::seconds{5}, [&] {
+                return test_init->mining_state->cancellations > 0;
+            }));
+        }
+
+        watch_response.getWatch().cancelRequest().send().wait(io.waitScope);
+
+        auto create_template{mining.createNewBlockRequest()};
+        create_template.setCooldown(false);
+        auto template_response{create_template.send().wait(io.waitScope)};
+        BOOST_REQUIRE(template_response.getFound());
+        auto template_pair{kj::newPromiseAndFulfiller<messages::BlockTemplate::Client>()};
+        auto watch_template{template_response.getResult().watchNextRequest()};
+        watch_template.setListener(messages::BlockTemplateListener::Client(kj::heap<TestTemplateListener>(kj::mv(template_pair.fulfiller))));
+        auto template_watch_response{watch_template.send().wait(io.waitScope)};
+        auto next_template{template_pair.promise.wait(io.waitScope)};
+        auto fees_response{next_template.getTxFeesRequest().send().wait(io.waitScope)};
+        auto fees{fees_response.getResult()};
+        BOOST_REQUIRE_EQUAL(fees.size(), 2);
+        BOOST_CHECK_EQUAL(fees[0], 12);
+        BOOST_CHECK_EQUAL(fees[1], 34);
+        template_watch_response.getWatch().cancelRequest().send().wait(io.waitScope);
+
+        auto submit_block{mining.submitBlockRequest()};
+        const auto block_bytes{ipc::capnp::SerializeBytes(CBlock{})};
+        SetData(submit_block.initBlock(block_bytes.size()), block_bytes);
+        auto submit_response{submit_block.send().wait(io.waitScope)};
+        BOOST_CHECK(submit_response.getResult());
+        BOOST_CHECK_EQUAL(submit_response.getReason().cStr(), "submitted");
+        BOOST_CHECK_EQUAL(submit_response.getDebug().cStr(), "processed");
+
+        init_client.stopRequest().send().wait(io.waitScope);
+    }
+    thread.join();
+}
+
 //! Test ipc::Process bind() and connect() methods connecting over a unix socket.
 void IpcSocketTest(const fs::path& datadir)
 {
diff --git a/src/ipc/test/ipc_test.h b/src/ipc/test/ipc_test.h
index c9e1d120cfc3..59b4b3235f02 100644
--- a/src/ipc/test/ipc_test.h
+++ b/src/ipc/test/ipc_test.h
@@ -5,26 +5,10 @@
 #ifndef BITCOIN_IPC_TEST_IPC_TEST_H
 #define BITCOIN_IPC_TEST_IPC_TEST_H
 
-#include <primitives/transaction.h>
-#include <script/script.h>
-#include <univalue.h>
 #include <util/fs.h>
-#include <chainstate.h>
 
-class FooImplementation
-{
-public:
-    int add(int a, int b) { return a + b; }
-    COutPoint passOutPoint(COutPoint o) { return o; }
-    UniValue passUniValue(UniValue v) { return v; }
-    CTransactionRef passTransaction(CTransactionRef t) { return t; }
-    std::vector<char> passVectorChar(std::vector<char> v) { return v; }
-    BlockValidationState passBlockState(BlockValidationState s) { return s; }
-    CScript passScript(CScript s) { return s; }
-};
-
-void IpcPipeTest();
 void IpcSocketPairTest();
+void IpcNativeMiningWatchTest();
 void IpcSocketTest(const fs::path& datadir);
 
 #endif // BITCOIN_IPC_TEST_IPC_TEST_H
diff --git a/src/ipc/test/ipc_test_types.h b/src/ipc/test/ipc_test_types.h
deleted file mode 100644
index e7cdfa3f8731..000000000000
--- a/src/ipc/test/ipc_test_types.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) 2024-present The Bitcoin Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef BITCOIN_IPC_TEST_IPC_TEST_TYPES_H
-#define BITCOIN_IPC_TEST_IPC_TEST_TYPES_H
-
-#include <ipc/capnp/common-types.h>
-#include <ipc/capnp/mining-types.h>
-#include <ipc/test/ipc_test.capnp.h>
-
-#endif // BITCOIN_IPC_TEST_IPC_TEST_TYPES_H
diff --git a/src/ipc/test/ipc_tests.cpp b/src/ipc/test/ipc_tests.cpp
index ebe4b397afa1..08035675332b 100644
--- a/src/ipc/test/ipc_tests.cpp
+++ b/src/ipc/test/ipc_tests.cpp
@@ -4,16 +4,16 @@
 
 #include <ipc/process.h>
 #include <ipc/test/ipc_test.h>
-
 #include <test/util/common.h>
 #include <test/util/setup_common.h>
+
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(ipc_tests, BasicTestingSetup)
 BOOST_AUTO_TEST_CASE(ipc_tests)
 {
-    IpcPipeTest();
     IpcSocketPairTest();
+    IpcNativeMiningWatchTest();
     IpcSocketTest(m_args.GetDataDirNet());
 }
 
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 611db6bb2fdd..8f31d2cf7efe 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -13,6 +13,7 @@
 #include <common/settings.h>
 #include <consensus/amount.h>
 #include <consensus/merkle.h>
+#include <consensus/params.h>
 #include <consensus/validation.h>
 #include <init.h>
 #include <interfaces/chain.h>
@@ -47,6 +48,7 @@
 #include <policy/rbf.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
+#include <scheduler.h>
 #include <sync.h>
 #include <txmempool.h>
 #include <uint256.h>
@@ -59,15 +61,22 @@
 #include <util/translation.h>
 #include <validationinterface.h>
 
+#include <algorithm>
 #include <atomic>
+#include <compare>
 #include <condition_variable>
 #include <cstdint>
 #include <cstdlib>
+#include <deque>
+#include <exception>
 #include <functional>
 #include <map>
 #include <memory>
+#include <mutex>
+#include <numeric>
 #include <optional>
 #include <string>
+#include <thread>
 #include <tuple>
 #include <utility>
 #include <vector>
@@ -78,6 +87,7 @@ using interfaces::BlockTip;
 using interfaces::Chain;
 using interfaces::FoundBlock;
 using interfaces::Handler;
+using interfaces::MakeCleanupHandler;
 using interfaces::MakeSignalHandler;
 using interfaces::Mining;
 using interfaces::Node;
@@ -753,14 +763,135 @@ class ChainImpl : public Chain
     NodeContext& m_node;
 };
 
+class MiningTaskRunner
+{
+    struct TaskState {
+        std::atomic_bool cancelled{false};
+        std::function<void()> cancel;
+    };
+
+    struct Task {
+        std::shared_ptr<TaskState> state;
+        std::function<void(std::atomic_bool& cancelled)> task;
+    };
+
+public:
+    explicit MiningTaskRunner(size_t worker_count = 1)
+    {
+        worker_count = std::max<size_t>(1, worker_count);
+        m_workers.reserve(worker_count);
+        for (size_t i{0}; i < worker_count; ++i) {
+            m_workers.emplace_back([this] { WorkLoop(); });
+        }
+    }
+
+    ~MiningTaskRunner()
+    {
+        std::vector<std::shared_ptr<TaskState>> states;
+        {
+            std::lock_guard lock{m_mutex};
+            m_stop = true;
+            states = m_states;
+        }
+        for (const auto& state : states) {
+            Cancel(*state);
+        }
+        m_cv.notify_all();
+        for (auto& worker : m_workers) {
+            if (worker.joinable()) worker.join();
+        }
+    }
+
+    std::unique_ptr<Handler> schedule(std::function<void(std::atomic_bool& cancelled)> task, std::function<void()> cancel = {})
+    {
+        auto state{std::make_shared<TaskState>()};
+        state->cancel = std::move(cancel);
+        {
+            std::lock_guard lock{m_mutex};
+            if (m_stop) {
+                state->cancelled.store(true, std::memory_order_release);
+            } else {
+                m_states.push_back(state);
+                m_tasks.push_back({state, std::move(task)});
+            }
+        }
+        m_cv.notify_one();
+        return MakeCleanupHandler([state] {
+            Cancel(*state);
+        });
+    }
+
+private:
+    static void Cancel(TaskState& state) noexcept
+    {
+        if (state.cancelled.exchange(true, std::memory_order_acq_rel) || !state.cancel) return;
+        try {
+            state.cancel();
+        } catch (const std::exception& e) {
+            LogError("Mining task cancellation failed: %s\n", e.what());
+        } catch (...) {
+            LogError("Mining task cancellation failed with an unknown exception\n");
+        }
+    }
+
+    void WorkLoop()
+    {
+        while (true) {
+            Task task;
+            {
+                std::unique_lock lock{m_mutex};
+                m_cv.wait(lock, [&] { return m_stop || !m_tasks.empty(); });
+                if (m_stop && m_tasks.empty()) return;
+                task = std::move(m_tasks.front());
+                m_tasks.pop_front();
+            }
+            if (!task.state->cancelled.load(std::memory_order_acquire)) {
+                try {
+                    task.task(task.state->cancelled);
+                } catch (const std::exception& e) {
+                    LogError("Mining task failed: %s\n", e.what());
+                } catch (...) {
+                    LogError("Mining task failed with an unknown exception\n");
+                }
+            }
+            {
+                std::lock_guard lock{m_mutex};
+                std::erase(m_states, task.state);
+            }
+        }
+    }
+
+    std::mutex m_mutex;
+    std::condition_variable m_cv;
+    std::deque<Task> m_tasks;
+    std::vector<std::shared_ptr<TaskState>> m_states;
+    std::vector<std::thread> m_workers;
+    bool m_stop{false};
+};
+
+CAmount TotalTemplateFees(const CBlockTemplate& block_template)
+{
+    return std::accumulate(block_template.vTxFees.begin(), block_template.vTxFees.end(), CAmount{0});
+}
+
+bool ShouldCreateMinDifficultyTemplate(ChainstateManager& chainman)
+{
+    if (!chainman.GetParams().GetConsensus().fPowAllowMinDifficultyBlocks) return false;
+    LOCK(::cs_main);
+    const CBlockIndex* tip{chainman.ActiveChain().Tip()};
+    return tip && NodeClock::now() > NodeClock::time_point{std::chrono::seconds{tip->GetBlockTime()}} + std::chrono::minutes{20};
+}
+
 class BlockTemplateImpl : public BlockTemplate
 {
 public:
     explicit BlockTemplateImpl(BlockCreateOptions create_options,
                                std::unique_ptr<CBlockTemplate> block_template,
-                               const NodeContext& node) : m_create_options(std::move(create_options)),
-                                                          m_block_template(std::move(block_template)),
-                                                          m_node(node)
+                               NodeContext& node,
+                               std::shared_ptr<MiningTaskRunner> task_runner) : m_create_options(std::move(create_options)),
+                                                                                m_block_template(std::move(block_template)),
+                                                                                m_task_runner(std::move(task_runner)),
+                                                                                m_node(node)
     {
         assert(m_block_template);
     }
@@ -795,46 +926,172 @@ class BlockTemplateImpl : public BlockTemplate
         return TransactionMerklePath(m_block_template->block, 0);
     }
 
-    bool submitSolution(uint32_t version, uint32_t timestamp, uint32_t nonce, CTransactionRef coinbase) override
-    {
-        AddMerkleRootAndCoinbase(m_block_template->block, std::move(coinbase), version, timestamp, nonce);
-        std::string reason;
-        std::string debug;
-        return SubmitBlock(chainman(), std::make_shared<const CBlock>(m_block_template->block), /*new_block=*/nullptr, reason, debug);
+    std::unique_ptr<Handler> submitSolutionAsync(uint32_t version, uint32_t timestamp, uint32_t nonce, CTransactionRef coinbase, SubmitSolutionFn fn) override
+    {
+        auto block{m_block_template->block};
+        return m_task_runner->schedule([node = &m_node, block = std::move(block), version, timestamp, nonce, coinbase = std::move(coinbase), fn = std::move(fn)](std::atomic_bool& cancelled) mutable {
+            if (cancelled.load(std::memory_order_acquire)) return;
+            AddMerkleRootAndCoinbase(block, std::move(coinbase), version, timestamp, nonce);
+            std::string reason;
+            std::string debug;
+            const bool accepted{SubmitBlock(*Assert(node->chainman), std::make_shared<const CBlock>(block), /*new_block=*/nullptr, reason, debug)};
+            if (!cancelled.load(std::memory_order_acquire)) fn(accepted);
+        });
     }
 
-    std::unique_ptr<BlockTemplate> waitNext(BlockWaitOptions options) override
-    {
-        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;
-    }
+    std::unique_ptr<Handler> watchNext(BlockWaitOptions options, NextTemplateFn fn) override
+    {
+        struct WatchState : std::enable_shared_from_this<WatchState> {
+            std::atomic_bool done{false};
+            btcsignals::connection tip_connection;
+            std::shared_ptr<MiningTaskRunner> task_runner;
+            std::mutex task_mutex;
+            std::vector<std::shared_ptr<std::unique_ptr<Handler>>> tasks;
+            NodeContext* node{nullptr};
+            BlockCreateOptions create_options;
+            uint256 current_prev_hash;
+            CAmount current_fees{0};
+            BlockWaitOptions options;
+            NextTemplateFn fn;
 
-    void interruptWait() override
-    {
-        InterruptWait(notifications(), m_interrupt_wait);
+            void complete(std::unique_ptr<CBlockTemplate> block_template)
+            {
+                if (done.exchange(true, std::memory_order_acq_rel)) return;
+                tip_connection.disconnect();
+                {
+                    std::vector<std::shared_ptr<std::unique_ptr<Handler>>> tasks;
+                    {
+                        std::lock_guard lock{task_mutex};
+                        tasks.swap(this->tasks);
+                    }
+                    tasks.clear();
+                }
+                if (!fn) return;
+                if (block_template) {
+                    fn(std::make_unique<BlockTemplateImpl>(create_options, std::move(block_template), *node, task_runner));
+                } else {
+                    fn(nullptr);
+                }
+            }
+
+            bool should_refresh(bool tip_changed) const
+            {
+                return tip_changed || ShouldCreateMinDifficultyTemplate(*Assert(node->chainman));
+            }
+
+            void check(bool tip_changed, bool complete_on_miss = false)
+            {
+                if (done.load(std::memory_order_acquire)) return;
+                if (!tip_changed && options.fee_threshold == MAX_MONEY && !should_refresh(/*tip_changed=*/false)) {
+                    if (complete_on_miss) complete(nullptr);
+                    return;
+                }
+
+                auto holder{std::make_shared<std::unique_ptr<Handler>>()};
+                auto handler{task_runner->schedule([state = shared_from_this(), holder, tip_changed, complete_on_miss](std::atomic_bool& cancelled) {
+                    auto cleanup{[holder] {
+                        holder->reset();
+                    }};
+                    if (cancelled.load(std::memory_order_acquire) || state->done.load(std::memory_order_acquire)) return cleanup();
+                    const bool refresh{state->should_refresh(tip_changed)};
+                    auto new_template{BlockAssembler{
+                        Assert(state->node->chainman)->ActiveChainstate(),
+                        state->node->mempool.get(),
+                        state->create_options}
+                                          .CreateNewBlock()};
+                    if (cancelled.load(std::memory_order_acquire) || state->done.load(std::memory_order_acquire)) return cleanup();
+                    if (refresh) {
+                        state->complete(std::move(new_template));
+                        return cleanup();
+                    }
+
+                    const CAmount new_fees{TotalTemplateFees(*new_template)};
+                    if (new_fees >= state->current_fees + state->options.fee_threshold) {
+                        state->complete(std::move(new_template));
+                    } else if (complete_on_miss) {
+                        state->complete(nullptr);
+                    }
+                    cleanup();
+                })};
+                *holder = std::move(handler);
+                if (done.load(std::memory_order_acquire)) {
+                    holder->reset();
+                    return;
+                }
+                std::lock_guard lock{task_mutex};
+                std::erase_if(tasks, [](const auto& task) { return !*task; });
+                if (done.load(std::memory_order_acquire)) {
+                    holder->reset();
+                } else {
+                    tasks.push_back(std::move(holder));
+                }
+            }
+
+            void schedule_fee_tick()
+            {
+                if (done.load(std::memory_order_acquire) || options.fee_threshold == MAX_MONEY) return;
+                Assert(node->scheduler)->schedule([state = shared_from_this()] {
+                    if (state->done.load(std::memory_order_acquire)) return;
+                    state->check(/*tip_changed=*/false);
+                    state->schedule_fee_tick();
+                },
+                                                  std::chrono::steady_clock::now() + std::chrono::seconds{1});
+            }
+
+            void schedule_timeout()
+            {
+                if (options.timeout >= std::chrono::years{100}) return;
+                Assert(node->scheduler)->schedule([state = shared_from_this()] {
+                    if (state->options.fee_threshold < MAX_MONEY || state->should_refresh(/*tip_changed=*/false)) {
+                        state->check(/*tip_changed=*/false, /*complete_on_miss=*/true);
+                    } else {
+                        state->complete(nullptr);
+                    }
+                },
+                                                  std::chrono::time_point_cast<std::chrono::steady_clock::duration>(std::chrono::steady_clock::now() + options.timeout));
+            }
+        };
+
+        auto state{std::make_shared<WatchState>()};
+        state->task_runner = m_task_runner;
+        state->node = &m_node;
+        state->create_options = m_create_options;
+        state->current_prev_hash = m_block_template->block.hashPrevBlock;
+        state->current_fees = TotalTemplateFees(*m_block_template);
+        state->options = options;
+        state->fn = std::move(fn);
+        state->tip_connection = ::uiInterface.NotifyBlockTip_connect([state](SynchronizationState, const CBlockIndex& block, double) {
+            if (block.GetBlockHash() != state->current_prev_hash) state->check(/*tip_changed=*/true);
+        });
+        if (const auto tip{GetTip(*Assert(m_node.chainman))}; tip && tip->hash != state->current_prev_hash) {
+            state->check(/*tip_changed=*/true);
+        }
+        state->check(/*tip_changed=*/false, /*complete_on_miss=*/options.timeout <= MillisecondsDouble{0});
+        state->schedule_fee_tick();
+        if (options.timeout > MillisecondsDouble{0}) state->schedule_timeout();
+        return MakeCleanupHandler([state] {
+            state->done.store(true, std::memory_order_release);
+            state->tip_connection.disconnect();
+            std::vector<std::shared_ptr<std::unique_ptr<Handler>>> tasks;
+            {
+                std::lock_guard lock{state->task_mutex};
+                tasks.swap(state->tasks);
+            }
+        });
     }
 
     const BlockCreateOptions m_create_options;
 
     const std::unique_ptr<CBlockTemplate> m_block_template;
 
-    bool m_interrupt_wait{false};
-    ChainstateManager& chainman() { return *Assert(m_node.chainman); }
-    KernelNotifications& notifications() { return *Assert(m_node.notifications); }
-    const NodeContext& m_node;
+    std::shared_ptr<MiningTaskRunner> m_task_runner;
+    NodeContext& m_node;
 };
 
 class MinerImpl : public Mining
 {
 public:
-    explicit MinerImpl(const NodeContext& node) : m_node(node) {}
+    explicit MinerImpl(NodeContext& node) : m_task_runner(std::make_shared<MiningTaskRunner>()), m_node(node) {}
 
     bool isTestChain() override
     {
@@ -851,15 +1108,77 @@ class MinerImpl : public Mining
         return GetTip(chainman());
     }
 
-    std::optional<BlockRef> waitTipChanged(uint256 current_tip, MillisecondsDouble timeout) override
-    {
-        return WaitTipChanged(chainman(), notifications(), current_tip, timeout, m_interrupt_mining);
+    std::unique_ptr<Handler> watchTip(uint256 current_tip, MillisecondsDouble timeout, TipChangedFn fn) override
+    {
+        struct WatchState {
+            std::atomic_bool done{false};
+            btcsignals::connection tip_connection;
+            NodeContext* node{nullptr};
+            uint256 current_tip;
+            TipChangedFn fn;
+
+            void complete(std::optional<BlockRef> tip)
+            {
+                if (done.exchange(true, std::memory_order_acq_rel)) return;
+                tip_connection.disconnect();
+                if (fn) fn(std::move(tip));
+            }
+        };
+
+        auto state{std::make_shared<WatchState>()};
+        state->node = &m_node;
+        state->current_tip = current_tip;
+        state->fn = std::move(fn);
+
+        if (auto tip{getTip()}; tip && tip->hash != current_tip) {
+            Assert(m_node.scheduler)->schedule([state, tip] {
+                state->complete(tip);
+            },
+                                               std::chrono::steady_clock::now());
+        } else {
+            state->tip_connection = ::uiInterface.NotifyBlockTip_connect([state](SynchronizationState, const CBlockIndex& block, double) {
+                const BlockRef tip{block.GetBlockHash(), block.nHeight};
+                if (tip.hash != state->current_tip) state->complete(tip);
+            });
+            if (timeout < std::chrono::years{100}) {
+                Assert(m_node.scheduler)->schedule([state] {
+                    state->complete(GetTip(*Assert(state->node->chainman)));
+                },
+                                                   std::chrono::time_point_cast<std::chrono::steady_clock::duration>(std::chrono::steady_clock::now() + timeout));
+            }
+        }
+
+        return MakeCleanupHandler([state] {
+            state->done.store(true, std::memory_order_release);
+            state->tip_connection.disconnect();
+        });
     }
 
-    std::unique_ptr<BlockTemplate> createNewBlock(const BlockCreateOptions& options, bool cooldown) override
+    std::unique_ptr<Handler> createNewBlockAsync(const BlockCreateOptions& options, bool cooldown, CreateBlockFn fn) override
+    {
+        return m_task_runner->schedule([this, options, cooldown, fn = std::move(fn)](std::atomic_bool& cancelled) mutable {
+            try {
+                auto block_template{CreateNewBlock(options, cooldown, cancelled)};
+                if (!cancelled.load(std::memory_order_acquire)) fn(CreateBlockResult{std::move(block_template)});
+            } catch (const std::exception& e) {
+                LogError("CreateNewBlock failed: %s\n", e.what());
+                if (!cancelled.load(std::memory_order_acquire)) fn(util::Error{Untranslated(e.what())});
+            } catch (...) {
+                LogError("CreateNewBlock failed with an unknown exception\n");
+                if (!cancelled.load(std::memory_order_acquire)) fn(util::Error{Untranslated("unknown CreateNewBlock failure")});
+            }
+        }, [this] {
+            auto& notifications{*Assert(m_node.notifications)};
+            LOCK(notifications.m_tip_block_mutex);
+            notifications.m_tip_block_cv.notify_all();
+        });
+    }
+
+    std::unique_ptr<BlockTemplate> CreateNewBlock(const BlockCreateOptions& options, bool cooldown, std::atomic_bool& cancelled)
     {
         // Ensure m_tip_block is set so consumers of BlockTemplate can rely on that.
-        std::optional<BlockRef> maybe_tip{waitTipChanged(uint256::ZERO, MillisecondsDouble::max())};
+        MillisecondsDouble startup_timeout{MillisecondsDouble::max()};
+        std::optional<BlockRef> maybe_tip{WaitTipChanged(chainman(), notifications(), uint256::ZERO, startup_timeout, cancelled)};
 
         if (!maybe_tip) return {};
 
@@ -870,54 +1189,57 @@ class MinerImpl : public Mining
             // because on regtest and single miner signets this would wait
             // forever if no block was mined in the past day.
             while (chainman().IsInitialBlockDownload()) {
-                maybe_tip = waitTipChanged(maybe_tip->hash, MillisecondsDouble{1000});
-                if (!maybe_tip || chainman().m_interrupt || WITH_LOCK(notifications().m_tip_block_mutex, return m_interrupt_mining)) return {};
+                MillisecondsDouble timeout{1000};
+                maybe_tip = WaitTipChanged(chainman(), notifications(), maybe_tip->hash, timeout, cancelled);
+                if (!maybe_tip || chainman().m_interrupt || cancelled.load(std::memory_order_acquire)) return {};
             }
 
             // Also wait during the final catch-up moments after IBD.
-            if (!CooldownIfHeadersAhead(chainman(), notifications(), *maybe_tip, m_interrupt_mining)) return {};
+            if (!CooldownIfHeadersAhead(chainman(), notifications(), *maybe_tip, cancelled)) return {};
         }
         const BlockCreateOptions create_options{MergeMiningOptions(options, m_node.mining_args)};
+        if (cancelled.load(std::memory_order_acquire)) return {};
         return std::make_unique<BlockTemplateImpl>(create_options,
                                                    BlockAssembler{
                                                        chainman().ActiveChainstate(),
                                                        m_node.mempool.get(),
                                                        create_options,
                                                    }.CreateNewBlock(),
-                                                   m_node);
-    }
-
-    void interrupt() override
-    {
-        InterruptWait(notifications(), m_interrupt_mining);
+                                                   m_node,
+                                                   m_task_runner);
     }
 
-    bool checkBlock(const CBlock& block, const node::BlockCheckOptions& options, std::string& reason, std::string& debug) override
+    std::unique_ptr<Handler> checkBlockAsync(CBlock block, node::BlockCheckOptions options, CheckBlockFn fn) override
     {
-        LOCK(chainman().GetMutex());
-        BlockValidationState state{TestBlockValidity(chainman().ActiveChainstate(), block, /*check_pow=*/options.check_pow, /*check_merkle_root=*/options.check_merkle_root)};
-        reason = state.GetRejectReason();
-        debug = state.GetDebugMessage();
-        return state.IsValid();
+        return m_task_runner->schedule([this, block = std::move(block), options, fn = std::move(fn)](std::atomic_bool& cancelled) mutable {
+            if (cancelled.load(std::memory_order_acquire)) return;
+            LOCK(chainman().GetMutex());
+            BlockValidationState state{TestBlockValidity(chainman().ActiveChainstate(), block, /*check_pow=*/options.check_pow, /*check_merkle_root=*/options.check_merkle_root)};
+            if (!cancelled.load(std::memory_order_acquire)) fn(state.IsValid(), state.GetRejectReason(), state.GetDebugMessage());
+        });
     }
 
-    bool submitBlock(const CBlock& block_in, std::string& reason, std::string& debug) override
-    {
-        auto block = std::make_shared<const CBlock>(block_in);
-        bool new_block;
-        const bool accepted = SubmitBlock(chainman(), block, &new_block, reason, debug);
-        // ProcessNewBlock() can accept and store a block before it is checked
-        // for validity. Treat duplicates as errors for mining clients, and only
-        // return success when validation completed without setting a reason.
-        return accepted && new_block && reason.empty();
+    std::unique_ptr<Handler> submitBlockAsync(CBlock block_in, SubmitBlockFn fn) override
+    {
+        return m_task_runner->schedule([this, block_in = std::move(block_in), fn = std::move(fn)](std::atomic_bool& cancelled) mutable {
+            if (cancelled.load(std::memory_order_acquire)) return;
+            auto block{std::make_shared<const CBlock>(std::move(block_in))};
+            bool new_block;
+            std::string reason;
+            std::string debug;
+            const bool accepted{SubmitBlock(chainman(), block, &new_block, reason, debug)};
+            // ProcessNewBlock() can accept and store a block before it is checked
+            // for validity. Treat duplicates as errors for mining clients, and only
+            // return success when validation completed without setting a reason.
+            if (!cancelled.load(std::memory_order_acquire)) fn(accepted && new_block && reason.empty(), std::move(reason), std::move(debug));
+        });
     }
 
-    const NodeContext* context() override { return &m_node; }
+    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};
-    const NodeContext& m_node;
+    std::shared_ptr<MiningTaskRunner> m_task_runner;
+    NodeContext& m_node;
 };
 
 } // namespace
@@ -926,7 +1248,7 @@ class MinerImpl : public Mining
 namespace interfaces {
 std::unique_ptr<Node> MakeNode(node::NodeContext& context) { return std::make_unique<node::NodeImpl>(context); }
 std::unique_ptr<Chain> MakeChain(node::NodeContext& context) { return std::make_unique<node::ChainImpl>(context); }
-std::unique_ptr<Mining> MakeMining(const node::NodeContext& context, bool wait_loaded)
+std::unique_ptr<Mining> MakeMining(node::NodeContext& context, bool wait_loaded)
 {
     if (wait_loaded) {
         node::KernelNotifications& kernel_notifications(*Assert(context.notifications));
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index 882378d78a2e..d53c0ef3f8c8 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -41,11 +41,11 @@
 #include <versionbits.h>
 
 #include <algorithm>
+#include <atomic>
 #include <compare>
 #include <condition_variable>
 #include <cstddef>
 #include <functional>
-#include <numeric>
 #include <span>
 #include <stdexcept>
 #include <string>
@@ -413,102 +413,6 @@ bool SubmitBlock(ChainstateManager& chainman, const std::shared_ptr<const CBlock
     return accepted;
 }
 
-void InterruptWait(KernelNotifications& kernel_notifications, bool& interrupt_wait)
-{
-    LOCK(kernel_notifications.m_tip_block_mutex);
-    interrupt_wait = true;
-    kernel_notifications.m_tip_block_cv.notify_all();
-}
-
-std::unique_ptr<CBlockTemplate> WaitAndCreateNewBlock(ChainstateManager& chainman,
-                                                      KernelNotifications& kernel_notifications,
-                                                      CTxMemPool* mempool,
-                                                      const std::unique_ptr<CBlockTemplate>& block_template,
-                                                      const BlockWaitOptions& wait_options,
-                                                      const BlockCreateOptions& create_options,
-                                                      bool& interrupt_wait)
-{
-    // Delay calculating the current template fees, just in case a new block
-    // comes in before the next tick.
-    CAmount current_fees = -1;
-
-    // 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 + wait_options.timeout;
-    const MillisecondsDouble tick{1000};
-    const bool allow_min_difficulty{chainman.GetParams().GetConsensus().fPowAllowMinDifficultyBlocks};
-
-    do {
-        bool tip_changed{false};
-        {
-            WAIT_LOCK(kernel_notifications.m_tip_block_mutex, lock);
-            // Note that wait_until() checks the predicate before waiting
-            kernel_notifications.m_tip_block_cv.wait_until(lock, std::min(now + tick, deadline), [&]() EXCLUSIVE_LOCKS_REQUIRED(kernel_notifications.m_tip_block_mutex) {
-                AssertLockHeld(kernel_notifications.m_tip_block_mutex);
-                const auto tip_block{kernel_notifications.TipBlock()};
-                // We assume tip_block is set, because this is an instance
-                // method on BlockTemplate and no template could have been
-                // generated before a tip exists.
-                tip_changed = Assume(tip_block) && tip_block != block_template->block.hashPrevBlock;
-                return tip_changed || chainman.m_interrupt || interrupt_wait;
-            });
-            if (interrupt_wait) {
-                interrupt_wait = false;
-                return nullptr;
-            }
-        }
-
-        if (chainman.m_interrupt) return nullptr;
-        // At this point the tip changed, a full tick went by or we reached
-        // the deadline.
-
-        // Must release m_tip_block_mutex before locking cs_main, to avoid deadlocks.
-        LOCK(::cs_main);
-
-        // On test networks return a minimum difficulty block after 20 minutes
-        if (!tip_changed && allow_min_difficulty) {
-            const NodeClock::time_point tip_time{std::chrono::seconds{chainman.ActiveChain().Tip()->GetBlockTime()}};
-            if (now > tip_time + 20min) {
-                tip_changed = true;
-            }
-        }
-
-        /**
-         * We determine if fees increased compared to the previous template by generating
-         * a fresh template. There may be more efficient ways to determine how much
-         * (approximate) fees for the next block increased, perhaps more so after
-         * Cluster Mempool.
-         *
-         * We'll also create a new template if the tip changed during this iteration.
-         */
-        if (wait_options.fee_threshold < MAX_MONEY || tip_changed) {
-            auto new_tmpl{BlockAssembler{
-                chainman.ActiveChainstate(),
-                mempool,
-                create_options
-                }.CreateNewBlock()};
-
-            // If the tip changed, return the new template regardless of its fees.
-            if (tip_changed) return new_tmpl;
-
-            // Calculate the original template total fees if we haven't already
-            if (current_fees == -1) {
-                current_fees = std::accumulate(block_template->vTxFees.begin(), block_template->vTxFees.end(), CAmount{0});
-            }
-
-            // 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(wait_options.fee_threshold != MAX_MONEY);
-            if (new_fees >= current_fees + wait_options.fee_threshold) return new_tmpl;
-        }
-
-        now = NodeClock::now();
-    } while (now < deadline);
-
-    return nullptr;
-}
-
 std::optional<BlockRef> GetTip(ChainstateManager& chainman)
 {
     LOCK(::cs_main);
@@ -517,7 +421,7 @@ std::optional<BlockRef> GetTip(ChainstateManager& chainman)
     return BlockRef{tip->GetBlockHash(), tip->nHeight};
 }
 
-bool CooldownIfHeadersAhead(ChainstateManager& chainman, KernelNotifications& kernel_notifications, const BlockRef& last_tip, bool& interrupt_mining)
+bool CooldownIfHeadersAhead(ChainstateManager& chainman, KernelNotifications& kernel_notifications, const BlockRef& last_tip, std::atomic_bool& interrupt_mining)
 {
     uint256 last_tip_hash{last_tip.hash};
 
@@ -529,10 +433,9 @@ bool CooldownIfHeadersAhead(ChainstateManager& chainman, KernelNotifications& ke
             WAIT_LOCK(kernel_notifications.m_tip_block_mutex, lock);
             kernel_notifications.m_tip_block_cv.wait_until(lock, cooldown_deadline, [&]() EXCLUSIVE_LOCKS_REQUIRED(kernel_notifications.m_tip_block_mutex) {
                 const auto tip_block = kernel_notifications.TipBlock();
-                return chainman.m_interrupt || interrupt_mining || (tip_block && *tip_block != last_tip_hash);
+                return chainman.m_interrupt || interrupt_mining.load(std::memory_order_acquire) || (tip_block && *tip_block != last_tip_hash);
             });
-            if (chainman.m_interrupt || interrupt_mining) {
-                interrupt_mining = false;
+            if (chainman.m_interrupt || interrupt_mining.load(std::memory_order_acquire)) {
                 return false;
             }
 
@@ -551,7 +454,7 @@ bool CooldownIfHeadersAhead(ChainstateManager& chainman, KernelNotifications& ke
     return true;
 }
 
-std::optional<BlockRef> WaitTipChanged(ChainstateManager& chainman, KernelNotifications& kernel_notifications, const uint256& current_tip, MillisecondsDouble& timeout, bool& interrupt)
+std::optional<BlockRef> WaitTipChanged(ChainstateManager& chainman, KernelNotifications& kernel_notifications, const uint256& current_tip, MillisecondsDouble& timeout, std::atomic_bool& interrupt)
 {
     Assume(timeout >= 0ms); // No internal callers should use a negative timeout
     if (timeout < 0ms) timeout = 0ms;
@@ -564,19 +467,17 @@ std::optional<BlockRef> WaitTipChanged(ChainstateManager& chainman, KernelNotifi
         // always returns valid tip information when possible and only
         // returns null when shutting down, not when timing out.
         kernel_notifications.m_tip_block_cv.wait(lock, [&]() EXCLUSIVE_LOCKS_REQUIRED(kernel_notifications.m_tip_block_mutex) {
-            return kernel_notifications.TipBlock() || chainman.m_interrupt || interrupt;
+            return kernel_notifications.TipBlock() || chainman.m_interrupt || interrupt.load(std::memory_order_acquire);
         });
-        if (chainman.m_interrupt || interrupt) {
-            interrupt = false;
+        if (chainman.m_interrupt || interrupt.load(std::memory_order_acquire)) {
             return {};
         }
         // At this point TipBlock is set, so continue to wait until it is
         // different then `current_tip` provided by caller.
         kernel_notifications.m_tip_block_cv.wait_until(lock, deadline, [&]() EXCLUSIVE_LOCKS_REQUIRED(kernel_notifications.m_tip_block_mutex) {
-            return Assume(kernel_notifications.TipBlock()) != current_tip || chainman.m_interrupt || interrupt;
+            return Assume(kernel_notifications.TipBlock()) != current_tip || chainman.m_interrupt || interrupt.load(std::memory_order_acquire);
         });
-        if (chainman.m_interrupt || interrupt) {
-            interrupt = false;
+        if (chainman.m_interrupt || interrupt.load(std::memory_order_acquire)) {
             return {};
         }
     }
diff --git a/src/node/miner.h b/src/node/miner.h
index af3273073295..5ba123877552 100644
--- a/src/node/miner.h
+++ b/src/node/miner.h
@@ -15,6 +15,7 @@
 #include <util/feefrac.h>
 #include <util/time.h>
 
+#include <atomic>
 #include <cstdint>
 #include <memory>
 #include <optional>
@@ -134,20 +135,6 @@ void AddMerkleRootAndCoinbase(CBlock& block, CTransactionRef coinbase, uint32_t
 //! Returns whether ProcessNewBlock accepted the block.
 bool SubmitBlock(ChainstateManager& chainman, const std::shared_ptr<const CBlock>& block, bool* new_block, std::string& reason, std::string& debug);
 
-/* Interrupt a blocking call. */
-void InterruptWait(KernelNotifications& kernel_notifications, bool& interrupt_wait);
-/**
- * Return a new block template when fees rise to a certain threshold or after a
- * new tip; return nullopt if timeout is reached.
- */
-std::unique_ptr<CBlockTemplate> WaitAndCreateNewBlock(ChainstateManager& chainman,
-                                                      KernelNotifications& kernel_notifications,
-                                                      CTxMemPool* mempool,
-                                                      const std::unique_ptr<CBlockTemplate>& block_template,
-                                                      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.*/
 std::optional<BlockRef> GetTip(ChainstateManager& chainman);
 
@@ -155,7 +142,7 @@ std::optional<BlockRef> GetTip(ChainstateManager& chainman);
  * Returns the current tip, or nullopt if the node is shutting down or interrupt()
  * is called.
  */
-std::optional<BlockRef> WaitTipChanged(ChainstateManager& chainman, KernelNotifications& kernel_notifications, const uint256& current_tip, MillisecondsDouble& timeout, bool& interrupt);
+std::optional<BlockRef> WaitTipChanged(ChainstateManager& chainman, KernelNotifications& kernel_notifications, const uint256& current_tip, MillisecondsDouble& timeout, std::atomic_bool& interrupt);
 
 /**
  * Wait while the best known header extends the current chain tip AND at least
@@ -176,7 +163,7 @@ std::optional<BlockRef> WaitTipChanged(ChainstateManager& chainman, KernelNotifi
  *
  * @returns false if interrupted.
  */
-bool CooldownIfHeadersAhead(ChainstateManager& chainman, KernelNotifications& kernel_notifications, const BlockRef& last_tip, bool& interrupt_mining);
+bool CooldownIfHeadersAhead(ChainstateManager& chainman, KernelNotifications& kernel_notifications, const BlockRef& last_tip, std::atomic_bool& interrupt_mining);
 } // namespace node
 
 #endif // BITCOIN_NODE_MINER_H
diff --git a/src/test/fuzz/package_eval.cpp b/src/test/fuzz/package_eval.cpp
index 3ffe7ec67eb2..9008df158005 100644
--- a/src/test/fuzz/package_eval.cpp
+++ b/src/test/fuzz/package_eval.cpp
@@ -49,7 +49,7 @@ using node::NodeContext;
 
 namespace {
 
-const TestingSetup* g_setup;
+TestingSetup* g_setup;
 std::vector<COutPoint> g_outpoints_coinbase_init_mature;
 
 struct MockedTxPool : public CTxMemPool {
@@ -63,7 +63,7 @@ struct MockedTxPool : public CTxMemPool {
 
 void initialize_tx_pool()
 {
-    static const auto testing_setup = MakeNoLogFileContext<const TestingSetup>();
+    static const auto testing_setup = MakeNoLogFileContext<TestingSetup>();
     g_setup = testing_setup.get();
     SetMockTime(WITH_LOCK(g_setup->m_node.chainman->GetMutex(), return g_setup->m_node.chainman->ActiveTip()->Time()));
 
diff --git a/src/test/fuzz/tx_pool.cpp b/src/test/fuzz/tx_pool.cpp
index 2963b60885cb..c9df4b64531e 100644
--- a/src/test/fuzz/tx_pool.cpp
+++ b/src/test/fuzz/tx_pool.cpp
@@ -57,7 +57,7 @@ using util::ToString;
 
 namespace {
 
-const TestingSetup* g_setup;
+TestingSetup* g_setup;
 std::vector<COutPoint> g_outpoints_coinbase_init_mature;
 std::vector<COutPoint> g_outpoints_coinbase_init_immature;
 
@@ -72,7 +72,7 @@ struct MockedTxPool : public CTxMemPool {
 
 void initialize_tx_pool()
 {
-    static const auto testing_setup = MakeNoLogFileContext<const TestingSetup>();
+    static const auto testing_setup = MakeNoLogFileContext<TestingSetup>();
     g_setup = testing_setup.get();
     SetMockTime(WITH_LOCK(g_setup->m_node.chainman->GetMutex(), return g_setup->m_node.chainman->ActiveTip()->Time()));
 
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index 31d90541b9a0..67fd7d1c3432 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -23,6 +23,7 @@
 #include <serialize.h>
 #include <sync.h>
 #include <test/util/common.h>
+#include <test/util/mining.h>
 #include <test/util/setup_common.h>
 #include <test/util/transaction_utils.h>
 #include <test/util/txmempool.h>
@@ -56,9 +57,9 @@ using node::BlockCreateOptions;
 
 namespace miner_tests {
 struct MinerTestingSetup : public TestingSetup {
-    void TestPackageSelection(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
-    void TestBasicMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst, int baseheight) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
-    void TestPrioritisedMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    void TestPackageSelection(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst) NO_THREAD_SAFETY_ANALYSIS;
+    void TestBasicMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst, int baseheight) NO_THREAD_SAFETY_ANALYSIS;
+    void TestPrioritisedMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst) NO_THREAD_SAFETY_ANALYSIS;
     bool TestSequenceLocks(const CTransaction& tx, CTxMemPool& tx_mempool) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
     {
         CCoinsViewMemPool view_mempool{&m_node.chainman->ActiveChainstate().CoinsTip(), tx_mempool};
@@ -127,7 +128,7 @@ static std::unique_ptr<CBlockIndex> CreateBlockIndex(int nHeight, CBlockIndex* a
 // Test suite for ancestor feerate transaction selection.
 // Implemented as an additional function, rather than a separate test case,
 // to allow reusing the blockchain created in CreateNewBlock_validity.
-void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst)
+void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst) NO_THREAD_SAFETY_ANALYSIS
 {
     CTxMemPool& tx_mempool{MakeMempool()};
     auto mining{MakeMining()};
@@ -135,21 +136,20 @@ void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const
         .coinbase_output_script = scriptPubKey,
     };
 
-    LOCK(tx_mempool.cs);
-    BOOST_CHECK(tx_mempool.size() == 0);
+    BOOST_CHECK(WITH_LOCK(tx_mempool.cs, return tx_mempool.size()) == 0);
 
     // Block template should only have a coinbase when there's nothing in the mempool
-    std::unique_ptr<BlockTemplate> block_template = mining->createNewBlock(options, /*cooldown=*/false);
+    std::unique_ptr<BlockTemplate> block_template = CreateNewBlock(*mining, options, /*cooldown=*/false);
     BOOST_REQUIRE(block_template);
     CBlock block{block_template->getBlock()};
     BOOST_REQUIRE_EQUAL(block.vtx.size(), 1U);
 
     // waitNext() on an empty mempool should return nullptr because there is no better template
-    auto should_be_nullptr = block_template->waitNext({.timeout = MillisecondsDouble{0}, .fee_threshold = 1});
+    auto should_be_nullptr = WaitNext(*block_template, {.timeout = MillisecondsDouble{0}, .fee_threshold = 1});
     BOOST_REQUIRE(should_be_nullptr == nullptr);
 
     // Unless fee_threshold is 0
-    block_template = block_template->waitNext({.timeout = MillisecondsDouble{0}, .fee_threshold = 0});
+    block_template = WaitNext(*block_template, {.timeout = MillisecondsDouble{0}, .fee_threshold = 0});
     BOOST_REQUIRE(block_template);
 
     // Test the ancestor feerate transaction selection.
@@ -183,7 +183,7 @@ void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const
     const auto high_fee_tx{entry.Fee(50000).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx)};
     TryAddToMempool(tx_mempool, high_fee_tx);
 
-    block_template = mining->createNewBlock(options, /*cooldown=*/false);
+    block_template = CreateNewBlock(*mining, options, /*cooldown=*/false);
     BOOST_REQUIRE(block_template);
     block = block_template->getBlock();
     BOOST_REQUIRE_EQUAL(block.vtx.size(), 4U);
@@ -228,7 +228,7 @@ void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const
     TryAddToMempool(tx_mempool, entry.Fee(feeToUse).FromTx(tx));
 
     // waitNext() should return nullptr because there is no better template
-    should_be_nullptr = block_template->waitNext({.timeout = MillisecondsDouble{0}, .fee_threshold = 1});
+    should_be_nullptr = WaitNext(*block_template, {.timeout = MillisecondsDouble{0}, .fee_threshold = 1});
     BOOST_REQUIRE(should_be_nullptr == nullptr);
 
     block = block_template->getBlock();
@@ -241,13 +241,13 @@ void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const
     // Test that packages above the min relay fee do get included, even if one
     // of the transactions is below the min relay fee
     // Remove the low fee transaction and replace with a higher fee transaction
-    tx_mempool.removeRecursive(CTransaction(tx), MemPoolRemovalReason::REPLACED);
+    WITH_LOCK(tx_mempool.cs, tx_mempool.removeRecursive(CTransaction(tx), MemPoolRemovalReason::REPLACED));
     tx.vout[0].nValue -= 2; // Now we should be just over the min relay fee
     hashLowFeeTx = tx.GetHash();
     TryAddToMempool(tx_mempool, entry.Fee(feeToUse + 2).FromTx(tx));
 
     // waitNext() should return if fees for the new template are at least 1 sat up
-    block_template = block_template->waitNext({.fee_threshold = 1});
+    block_template = WaitNext(*block_template, {.fee_threshold = 1});
     BOOST_REQUIRE(block_template);
     block = block_template->getBlock();
     BOOST_REQUIRE_EQUAL(block.vtx.size(), 6U);
@@ -275,7 +275,7 @@ void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const
     tx.vout[0].nValue = 5000000000LL - 100000000 - feeToUse;
     Txid hashLowFeeTx2 = tx.GetHash();
     TryAddToMempool(tx_mempool, entry.Fee(feeToUse).SpendsCoinbase(false).FromTx(tx));
-    block_template = mining->createNewBlock(options, /*cooldown=*/false);
+    block_template = CreateNewBlock(*mining, options, /*cooldown=*/false);
     BOOST_REQUIRE(block_template);
     block = block_template->getBlock();
 
@@ -290,7 +290,7 @@ void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const
     tx.vin[0].prevout.n = 1;
     tx.vout[0].nValue = 100000000 - 10000; // 10k satoshi fee
     TryAddToMempool(tx_mempool, entry.Fee(10000).FromTx(tx));
-    block_template = mining->createNewBlock(options, /*cooldown=*/false);
+    block_template = CreateNewBlock(*mining, options, /*cooldown=*/false);
     BOOST_REQUIRE(block_template);
     block = block_template->getBlock();
     BOOST_REQUIRE_EQUAL(block.vtx.size(), 9U);
@@ -339,7 +339,7 @@ std::vector<CTransactionRef> CreateBigSigOpsCluster(const CTransactionRef& first
     return ret;
 }
 
-void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst, int baseheight)
+void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst, int baseheight) NO_THREAD_SAFETY_ANALYSIS
 {
     Txid hash;
     CMutableTransaction tx;
@@ -361,10 +361,8 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
 
     {
         CTxMemPool& tx_mempool{MakeMempool()};
-        LOCK(tx_mempool.cs);
-
         // Just to make sure we can still make simple blocks
-        auto block_template{mining->createNewBlock(options, /*cooldown=*/false)};
+        auto block_template{CreateNewBlock(*mining, options, /*cooldown=*/false)};
         BOOST_REQUIRE(block_template);
         CBlock block{block_template->getBlock()};
 
@@ -376,22 +374,21 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
             // template creation fails during sanity checks.
             TryAddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(t));
             legacy_sigops += GetLegacySigOpCount(*t);
-            BOOST_CHECK(tx_mempool.GetIter(t->GetHash()).has_value());
+            BOOST_CHECK(WITH_LOCK(tx_mempool.cs, return tx_mempool.GetIter(t->GetHash()).has_value()));
         }
-        assert(tx_mempool.mapTx.size() == 51);
+        assert(WITH_LOCK(tx_mempool.cs, return tx_mempool.mapTx.size()) == 51);
         assert(legacy_sigops == 20001);
-        BOOST_CHECK_EXCEPTION(mining->createNewBlock(options, /*cooldown=*/false), std::runtime_error, HasReason("bad-blk-sigops"));
+        BOOST_CHECK_EXCEPTION(CreateNewBlock(*mining, options, /*cooldown=*/false), std::runtime_error, HasReason("bad-blk-sigops"));
     }
 
     {
         CTxMemPool& tx_mempool{MakeMempool()};
-        LOCK(tx_mempool.cs);
 
         // Check that the mempool is empty.
-        assert(tx_mempool.mapTx.empty());
+        assert(WITH_LOCK(tx_mempool.cs, return tx_mempool.mapTx.empty()));
 
         // Just to make sure we can still make simple blocks
-        auto block_template{mining->createNewBlock(options, /*cooldown=*/false)};
+        auto block_template{CreateNewBlock(*mining, options, /*cooldown=*/false)};
         BOOST_REQUIRE(block_template);
         CBlock block{block_template->getBlock()};
 
@@ -401,17 +398,16 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
         for (auto& t : txs) {
             TryAddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).SigOpsCost(GetLegacySigOpCount(*t)*WITNESS_SCALE_FACTOR).FromTx(t));
             legacy_sigops += GetLegacySigOpCount(*t);
-            BOOST_CHECK(tx_mempool.GetIter(t->GetHash()).has_value());
+            BOOST_CHECK(WITH_LOCK(tx_mempool.cs, return tx_mempool.GetIter(t->GetHash()).has_value()));
         }
-        assert(tx_mempool.mapTx.size() == 51);
+        assert(WITH_LOCK(tx_mempool.cs, return tx_mempool.mapTx.size()) == 51);
         assert(legacy_sigops == 20001);
 
-        BOOST_REQUIRE(mining->createNewBlock(options, /*cooldown=*/false));
+        BOOST_REQUIRE(CreateNewBlock(*mining, options, /*cooldown=*/false));
     }
 
     {
         CTxMemPool& tx_mempool{MakeMempool()};
-        LOCK(tx_mempool.cs);
 
         // block size > limit
         tx.vin.resize(1);
@@ -433,25 +429,23 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
             hash = tx.GetHash();
             bool spendsCoinbase = i == 0; // only first tx spends coinbase
             TryAddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
-            BOOST_CHECK(tx_mempool.GetIter(hash).has_value());
+            BOOST_CHECK(WITH_LOCK(tx_mempool.cs, return tx_mempool.GetIter(hash).has_value()));
             tx.vin[0].prevout.hash = hash;
         }
-        BOOST_REQUIRE(mining->createNewBlock(options, /*cooldown=*/false));
+        BOOST_REQUIRE(CreateNewBlock(*mining, options, /*cooldown=*/false));
     }
 
     {
         CTxMemPool& tx_mempool{MakeMempool()};
-        LOCK(tx_mempool.cs);
 
         // orphan in tx_mempool, template creation fails
         hash = tx.GetHash();
         TryAddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).FromTx(tx));
-        BOOST_CHECK_EXCEPTION(mining->createNewBlock(options, /*cooldown=*/false), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
+        BOOST_CHECK_EXCEPTION(CreateNewBlock(*mining, options, /*cooldown=*/false), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
     }
 
     {
         CTxMemPool& tx_mempool{MakeMempool()};
-        LOCK(tx_mempool.cs);
 
         // child with higher feerate than parent
         tx.vin[0].scriptSig = CScript() << OP_1;
@@ -467,12 +461,11 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
         tx.vout[0].nValue = tx.vout[0].nValue + BLOCKSUBSIDY - HIGHERFEE; // First txn output + fresh coinbase - new txn fee
         hash = tx.GetHash();
         TryAddToMempool(tx_mempool, entry.Fee(HIGHERFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
-        BOOST_REQUIRE(mining->createNewBlock(options, /*cooldown=*/false));
+        BOOST_REQUIRE(CreateNewBlock(*mining, options, /*cooldown=*/false));
     }
 
     {
         CTxMemPool& tx_mempool{MakeMempool()};
-        LOCK(tx_mempool.cs);
 
         // coinbase in tx_mempool, template creation fails
         tx.vin.resize(1);
@@ -483,12 +476,11 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
         // give it a fee so it'll get mined
         TryAddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
         // Should throw bad-cb-multiple
-        BOOST_CHECK_EXCEPTION(mining->createNewBlock(options, /*cooldown=*/false), std::runtime_error, HasReason("bad-cb-multiple"));
+        BOOST_CHECK_EXCEPTION(CreateNewBlock(*mining, options, /*cooldown=*/false), std::runtime_error, HasReason("bad-cb-multiple"));
     }
 
     {
         CTxMemPool& tx_mempool{MakeMempool()};
-        LOCK(tx_mempool.cs);
 
         // double spend txn pair in tx_mempool, template creation fails
         tx.vin[0].prevout.hash = txFirst[0]->GetHash();
@@ -500,39 +492,44 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
         tx.vout[0].scriptPubKey = CScript() << OP_2;
         hash = tx.GetHash();
         TryAddToMempool(tx_mempool, entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
-        BOOST_CHECK_EXCEPTION(mining->createNewBlock(options, /*cooldown=*/false), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
+        BOOST_CHECK_EXCEPTION(CreateNewBlock(*mining, options, /*cooldown=*/false), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
     }
 
     {
         CTxMemPool& tx_mempool{MakeMempool()};
-        LOCK(tx_mempool.cs);
 
         // subsidy changing
-        int nHeight = m_node.chainman->ActiveChain().Height();
-        // Create an actual 209999-long block chain (without valid blocks).
-        while (m_node.chainman->ActiveChain().Tip()->nHeight < 209999) {
-            CBlockIndex* prev = m_node.chainman->ActiveChain().Tip();
-            CBlockIndex* next = new CBlockIndex();
-            next->phashBlock = new uint256(m_rng.rand256());
-            m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(next->GetBlockHash());
-            next->pprev = prev;
-            next->nHeight = prev->nHeight + 1;
-            next->BuildSkip();
-            m_node.chainman->ActiveChain().SetTip(*next);
+        const int nHeight = WITH_LOCK(cs_main, return m_node.chainman->ActiveChain().Height());
+        {
+            LOCK(cs_main);
+            // Create an actual 209999-long block chain (without valid blocks).
+            while (m_node.chainman->ActiveChain().Tip()->nHeight < 209999) {
+                CBlockIndex* prev = m_node.chainman->ActiveChain().Tip();
+                CBlockIndex* next = new CBlockIndex();
+                next->phashBlock = new uint256(m_rng.rand256());
+                m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(next->GetBlockHash());
+                next->pprev = prev;
+                next->nHeight = prev->nHeight + 1;
+                next->BuildSkip();
+                m_node.chainman->ActiveChain().SetTip(*next);
+            }
         }
-        BOOST_REQUIRE(mining->createNewBlock(options, /*cooldown=*/false));
-        // Extend to a 210000-long block chain.
-        while (m_node.chainman->ActiveChain().Tip()->nHeight < 210000) {
-            CBlockIndex* prev = m_node.chainman->ActiveChain().Tip();
-            CBlockIndex* next = new CBlockIndex();
-            next->phashBlock = new uint256(m_rng.rand256());
-            m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(next->GetBlockHash());
-            next->pprev = prev;
-            next->nHeight = prev->nHeight + 1;
-            next->BuildSkip();
-            m_node.chainman->ActiveChain().SetTip(*next);
+        BOOST_REQUIRE(CreateNewBlock(*mining, options, /*cooldown=*/false));
+        {
+            LOCK(cs_main);
+            // Extend to a 210000-long block chain.
+            while (m_node.chainman->ActiveChain().Tip()->nHeight < 210000) {
+                CBlockIndex* prev = m_node.chainman->ActiveChain().Tip();
+                CBlockIndex* next = new CBlockIndex();
+                next->phashBlock = new uint256(m_rng.rand256());
+                m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(next->GetBlockHash());
+                next->pprev = prev;
+                next->nHeight = prev->nHeight + 1;
+                next->BuildSkip();
+                m_node.chainman->ActiveChain().SetTip(*next);
+            }
         }
-        BOOST_REQUIRE(mining->createNewBlock(options, /*cooldown=*/false));
+        BOOST_REQUIRE(CreateNewBlock(*mining, options, /*cooldown=*/false));
 
         // invalid p2sh txn in tx_mempool, template creation fails
         tx.vin[0].prevout.hash = txFirst[0]->GetHash();
@@ -548,113 +545,120 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
         tx.vout[0].nValue -= LOWFEE;
         hash = tx.GetHash();
         TryAddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
-        BOOST_CHECK_EXCEPTION(mining->createNewBlock(options, /*cooldown=*/false), std::runtime_error, HasReason("block-script-verify-flag-failed"));
-
-        // Delete the dummy blocks again.
-        while (m_node.chainman->ActiveChain().Tip()->nHeight > nHeight) {
-            CBlockIndex* del = m_node.chainman->ActiveChain().Tip();
-            m_node.chainman->ActiveChain().SetTip(*Assert(del->pprev));
-            m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(del->pprev->GetBlockHash());
-            delete del->phashBlock;
-            delete del;
+        BOOST_CHECK_EXCEPTION(CreateNewBlock(*mining, options, /*cooldown=*/false), std::runtime_error, HasReason("block-script-verify-flag-failed"));
+
+        {
+            LOCK(cs_main);
+            // Delete the dummy blocks again.
+            while (m_node.chainman->ActiveChain().Tip()->nHeight > nHeight) {
+                CBlockIndex* del = m_node.chainman->ActiveChain().Tip();
+                m_node.chainman->ActiveChain().SetTip(*Assert(del->pprev));
+                m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(del->pprev->GetBlockHash());
+                delete del->phashBlock;
+                delete del;
+            }
         }
     }
 
     CTxMemPool& tx_mempool{MakeMempool()};
-    LOCK(tx_mempool.cs);
 
-    // non-final txs in mempool
-    SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1);
     const int flags{LOCKTIME_VERIFY_SEQUENCE};
+    const int SEQUENCE_LOCK_TIME = 512; // Sequence locks pass 512 seconds later
     // height map
     std::vector<int> prevheights;
 
-    // relative height locked
-    tx.version = 2;
-    tx.vin.resize(1);
-    prevheights.resize(1);
-    tx.vin[0].prevout.hash = txFirst[0]->GetHash(); // only 1 transaction
-    tx.vin[0].prevout.n = 0;
-    tx.vin[0].scriptSig = CScript() << OP_1;
-    tx.vin[0].nSequence = m_node.chainman->ActiveChain().Tip()->nHeight + 1; // txFirst[0] is the 2nd block
-    prevheights[0] = baseheight + 1;
-    tx.vout.resize(1);
-    tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;
-    tx.vout[0].scriptPubKey = CScript() << OP_1;
-    tx.nLockTime = 0;
-    hash = tx.GetHash();
-    TryAddToMempool(tx_mempool, entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
-    BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
-    BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
-
     {
-        CBlockIndex* active_chain_tip = m_node.chainman->ActiveChain().Tip();
-        BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, prevheights, *CreateBlockIndex(active_chain_tip->nHeight + 2, active_chain_tip))); // Sequence locks pass on 2nd block
-    }
+        LOCK(cs_main);
 
-    // relative time locked
-    tx.vin[0].prevout.hash = txFirst[1]->GetHash();
-    tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | (((m_node.chainman->ActiveChain().Tip()->GetMedianTimePast()+1-m_node.chainman->ActiveChain()[1]->GetMedianTimePast()) >> CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) + 1); // txFirst[1] is the 3rd block
-    prevheights[0] = baseheight + 2;
-    hash = tx.GetHash();
-    TryAddToMempool(tx_mempool, entry.Time(Now<NodeSeconds>()).FromTx(tx));
-    BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
-    BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
+        // non-final txs in mempool
+        SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1);
 
-    const int SEQUENCE_LOCK_TIME = 512; // Sequence locks pass 512 seconds later
-    for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i)
-        m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i)->nTime += SEQUENCE_LOCK_TIME; // Trick the MedianTimePast
-    {
-        CBlockIndex* active_chain_tip = m_node.chainman->ActiveChain().Tip();
-        BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, prevheights, *CreateBlockIndex(active_chain_tip->nHeight + 1, active_chain_tip)));
-    }
+        // relative height locked
+        tx.version = 2;
+        tx.vin.resize(1);
+        prevheights.resize(1);
+        tx.vin[0].prevout.hash = txFirst[0]->GetHash(); // only 1 transaction
+        tx.vin[0].prevout.n = 0;
+        tx.vin[0].scriptSig = CScript() << OP_1;
+        tx.vin[0].nSequence = m_node.chainman->ActiveChain().Tip()->nHeight + 1; // txFirst[0] is the 2nd block
+        prevheights[0] = baseheight + 1;
+        tx.vout.resize(1);
+        tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;
+        tx.vout[0].scriptPubKey = CScript() << OP_1;
+        tx.nLockTime = 0;
+        hash = tx.GetHash();
+        TryAddToMempool(tx_mempool, entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
+        BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
+        BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
+
+        {
+            CBlockIndex* active_chain_tip = m_node.chainman->ActiveChain().Tip();
+            BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, prevheights, *CreateBlockIndex(active_chain_tip->nHeight + 2, active_chain_tip))); // Sequence locks pass on 2nd block
+        }
+
+        // relative time locked
+        tx.vin[0].prevout.hash = txFirst[1]->GetHash();
+        tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | (((m_node.chainman->ActiveChain().Tip()->GetMedianTimePast()+1-m_node.chainman->ActiveChain()[1]->GetMedianTimePast()) >> CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) + 1); // txFirst[1] is the 3rd block
+        prevheights[0] = baseheight + 2;
+        hash = tx.GetHash();
+        TryAddToMempool(tx_mempool, entry.Time(Now<NodeSeconds>()).FromTx(tx));
+        BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
+        BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
+
+        for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i)
+            m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i)->nTime += SEQUENCE_LOCK_TIME; // Trick the MedianTimePast
+        {
+            CBlockIndex* active_chain_tip = m_node.chainman->ActiveChain().Tip();
+            BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, prevheights, *CreateBlockIndex(active_chain_tip->nHeight + 1, active_chain_tip)));
+        }
+
+        for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i) {
+            CBlockIndex* ancestor{Assert(m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i))};
+            ancestor->nTime -= SEQUENCE_LOCK_TIME; // undo tricked MTP
+        }
+
+        // absolute height locked
+        tx.vin[0].prevout.hash = txFirst[2]->GetHash();
+        tx.vin[0].nSequence = CTxIn::MAX_SEQUENCE_NONFINAL;
+        prevheights[0] = baseheight + 3;
+        tx.nLockTime = m_node.chainman->ActiveChain().Tip()->nHeight + 1;
+        hash = tx.GetHash();
+        TryAddToMempool(tx_mempool, entry.Time(Now<NodeSeconds>()).FromTx(tx));
+        BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails
+        BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
+        BOOST_CHECK(IsFinalTx(CTransaction(tx), m_node.chainman->ActiveChain().Tip()->nHeight + 2, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast())); // Locktime passes on 2nd block
+
+        // ensure tx is final for a specific case where there is no locktime and block height is zero
+        tx.nLockTime = 0;
+        BOOST_CHECK(IsFinalTx(CTransaction(tx), /*nBlockHeight=*/0, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast()));
+
+        // absolute time locked
+        tx.vin[0].prevout.hash = txFirst[3]->GetHash();
+        tx.nLockTime = m_node.chainman->ActiveChain().Tip()->GetMedianTimePast();
+        prevheights.resize(1);
+        prevheights[0] = baseheight + 4;
+        hash = tx.GetHash();
+        TryAddToMempool(tx_mempool, entry.Time(Now<NodeSeconds>()).FromTx(tx));
+        BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails
+        BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
+        BOOST_CHECK(IsFinalTx(CTransaction(tx), m_node.chainman->ActiveChain().Tip()->nHeight + 2, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1)); // Locktime passes 1 second later
 
-    for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i) {
-        CBlockIndex* ancestor{Assert(m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i))};
-        ancestor->nTime -= SEQUENCE_LOCK_TIME; // undo tricked MTP
+        // mempool-dependent transactions (not added)
+        tx.vin[0].prevout.hash = hash;
+        prevheights[0] = m_node.chainman->ActiveChain().Tip()->nHeight + 1;
+        tx.nLockTime = 0;
+        tx.vin[0].nSequence = 0;
+        BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
+        BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
+        tx.vin[0].nSequence = 1;
+        BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
+        tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG;
+        BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
+        tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | 1;
+        BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
     }
 
-    // absolute height locked
-    tx.vin[0].prevout.hash = txFirst[2]->GetHash();
-    tx.vin[0].nSequence = CTxIn::MAX_SEQUENCE_NONFINAL;
-    prevheights[0] = baseheight + 3;
-    tx.nLockTime = m_node.chainman->ActiveChain().Tip()->nHeight + 1;
-    hash = tx.GetHash();
-    TryAddToMempool(tx_mempool, entry.Time(Now<NodeSeconds>()).FromTx(tx));
-    BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails
-    BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
-    BOOST_CHECK(IsFinalTx(CTransaction(tx), m_node.chainman->ActiveChain().Tip()->nHeight + 2, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast())); // Locktime passes on 2nd block
-
-    // ensure tx is final for a specific case where there is no locktime and block height is zero
-    tx.nLockTime = 0;
-    BOOST_CHECK(IsFinalTx(CTransaction(tx), /*nBlockHeight=*/0, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast()));
-
-    // absolute time locked
-    tx.vin[0].prevout.hash = txFirst[3]->GetHash();
-    tx.nLockTime = m_node.chainman->ActiveChain().Tip()->GetMedianTimePast();
-    prevheights.resize(1);
-    prevheights[0] = baseheight + 4;
-    hash = tx.GetHash();
-    TryAddToMempool(tx_mempool, entry.Time(Now<NodeSeconds>()).FromTx(tx));
-    BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails
-    BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
-    BOOST_CHECK(IsFinalTx(CTransaction(tx), m_node.chainman->ActiveChain().Tip()->nHeight + 2, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1)); // Locktime passes 1 second later
-
-    // mempool-dependent transactions (not added)
-    tx.vin[0].prevout.hash = hash;
-    prevheights[0] = m_node.chainman->ActiveChain().Tip()->nHeight + 1;
-    tx.nLockTime = 0;
-    tx.vin[0].nSequence = 0;
-    BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
-    BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
-    tx.vin[0].nSequence = 1;
-    BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
-    tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG;
-    BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
-    tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | 1;
-    BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
-
-    auto block_template = mining->createNewBlock(options, /*cooldown=*/false);
+    auto block_template = CreateNewBlock(*mining, options, /*cooldown=*/false);
     BOOST_REQUIRE(block_template);
 
     // None of the of the absolute height/time locked tx should have made
@@ -664,20 +668,23 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
     CBlock block{block_template->getBlock()};
     BOOST_CHECK_EQUAL(block.vtx.size(), 3U);
     // However if we advance height by 1 and time by SEQUENCE_LOCK_TIME, all of them should be mined
-    for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i) {
-        CBlockIndex* ancestor{Assert(m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i))};
-        ancestor->nTime += SEQUENCE_LOCK_TIME; // Trick the MedianTimePast
+    {
+        LOCK(cs_main);
+        for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i) {
+            CBlockIndex* ancestor{Assert(m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i))};
+            ancestor->nTime += SEQUENCE_LOCK_TIME; // Trick the MedianTimePast
+        }
+        m_node.chainman->ActiveChain().Tip()->nHeight++;
+        SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1);
     }
-    m_node.chainman->ActiveChain().Tip()->nHeight++;
-    SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1);
 
-    block_template = mining->createNewBlock(options, /*cooldown=*/false);
+    block_template = CreateNewBlock(*mining, options, /*cooldown=*/false);
     BOOST_REQUIRE(block_template);
     block = block_template->getBlock();
     BOOST_CHECK_EQUAL(block.vtx.size(), 5U);
 }
 
-void MinerTestingSetup::TestPrioritisedMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst)
+void MinerTestingSetup::TestPrioritisedMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst) NO_THREAD_SAFETY_ANALYSIS
 {
     auto mining{MakeMining()};
     BOOST_REQUIRE(mining);
@@ -687,7 +694,6 @@ void MinerTestingSetup::TestPrioritisedMining(const CScript& scriptPubKey, const
     };
 
     CTxMemPool& tx_mempool{MakeMempool()};
-    LOCK(tx_mempool.cs);
 
     TestMemPoolEntryHelper entry;
 
@@ -701,7 +707,7 @@ void MinerTestingSetup::TestPrioritisedMining(const CScript& scriptPubKey, const
     tx.vout[0].nValue = 5000000000LL; // 0 fee
     Txid hashFreePrioritisedTx = tx.GetHash();
     TryAddToMempool(tx_mempool, entry.Fee(0).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
-    tx_mempool.PrioritiseTransaction(hashFreePrioritisedTx, 5 * COIN);
+    WITH_LOCK(tx_mempool.cs, tx_mempool.PrioritiseTransaction(hashFreePrioritisedTx, 5 * COIN));
 
     tx.vin[0].prevout.hash = txFirst[1]->GetHash();
     tx.vin[0].prevout.n = 0;
@@ -715,14 +721,14 @@ void MinerTestingSetup::TestPrioritisedMining(const CScript& scriptPubKey, const
     tx.vout[0].nValue = 5000000000LL - 10000;
     Txid hashMediumFeeTx = tx.GetHash();
     TryAddToMempool(tx_mempool, entry.Fee(10000).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
-    tx_mempool.PrioritiseTransaction(hashMediumFeeTx, -5 * COIN);
+    WITH_LOCK(tx_mempool.cs, tx_mempool.PrioritiseTransaction(hashMediumFeeTx, -5 * COIN));
 
     // This tx also has a low fee, but is prioritised
     tx.vin[0].prevout.hash = hashParentTx;
     tx.vout[0].nValue = 5000000000LL - 1000 - 1000; // 1000 satoshi fee
     Txid hashPrioritsedChild = tx.GetHash();
     TryAddToMempool(tx_mempool, entry.Fee(1000).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
-    tx_mempool.PrioritiseTransaction(hashPrioritsedChild, 2 * COIN);
+    WITH_LOCK(tx_mempool.cs, tx_mempool.PrioritiseTransaction(hashPrioritsedChild, 2 * COIN));
 
     // Test that transaction selection properly updates ancestor fee calculations as prioritised
     // parents get included in a block. Create a transaction with two prioritised ancestors, each
@@ -734,20 +740,20 @@ void MinerTestingSetup::TestPrioritisedMining(const CScript& scriptPubKey, const
     tx.vout[0].nValue = 5000000000LL; // 0 fee
     Txid hashFreeParent = tx.GetHash();
     TryAddToMempool(tx_mempool, entry.Fee(0).SpendsCoinbase(true).FromTx(tx));
-    tx_mempool.PrioritiseTransaction(hashFreeParent, 10 * COIN);
+    WITH_LOCK(tx_mempool.cs, tx_mempool.PrioritiseTransaction(hashFreeParent, 10 * COIN));
 
     tx.vin[0].prevout.hash = hashFreeParent;
     tx.vout[0].nValue = 5000000000LL; // 0 fee
     Txid hashFreeChild = tx.GetHash();
     TryAddToMempool(tx_mempool, entry.Fee(0).SpendsCoinbase(false).FromTx(tx));
-    tx_mempool.PrioritiseTransaction(hashFreeChild, 1 * COIN);
+    WITH_LOCK(tx_mempool.cs, tx_mempool.PrioritiseTransaction(hashFreeChild, 1 * COIN));
 
     tx.vin[0].prevout.hash = hashFreeChild;
     tx.vout[0].nValue = 5000000000LL; // 0 fee
     Txid hashFreeGrandchild = tx.GetHash();
     TryAddToMempool(tx_mempool, entry.Fee(0).SpendsCoinbase(false).FromTx(tx));
 
-    auto block_template = mining->createNewBlock(options, /*cooldown=*/false);
+    auto block_template = CreateNewBlock(*mining, options, /*cooldown=*/false);
     BOOST_REQUIRE(block_template);
     CBlock block{block_template->getBlock()};
     BOOST_REQUIRE_EQUAL(block.vtx.size(), 6U);
@@ -777,33 +783,31 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
     };
 
     // Create and check a simple template
-    std::unique_ptr<BlockTemplate> block_template = mining->createNewBlock(options, /*cooldown=*/false);
+    std::unique_ptr<BlockTemplate> block_template = CreateNewBlock(*mining, 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),
+    BOOST_CHECK_EXCEPTION(CreateNewBlock(*mining, invalid_options, /*cooldown=*/false),
                           std::runtime_error,
                           HasReason("block_reserved_weight (8000) exceeds block_max_weight (7999)"));
 
     {
         CBlock block{block_template->getBlock()};
         {
-            std::string reason;
-            std::string debug;
-            BOOST_REQUIRE(!mining->checkBlock(block, {.check_pow = false}, reason, debug));
-            BOOST_REQUIRE_EQUAL(reason, "bad-txnmrklroot");
-            BOOST_REQUIRE_EQUAL(debug, "hashMerkleRoot mismatch");
+            const auto result{CheckBlock(*mining, block, {.check_pow = false})};
+            BOOST_REQUIRE(!result.valid);
+            BOOST_REQUIRE_EQUAL(result.reason, "bad-txnmrklroot");
+            BOOST_REQUIRE_EQUAL(result.debug, "hashMerkleRoot mismatch");
         }
 
         block.hashMerkleRoot = BlockMerkleRoot(block);
 
         {
-            std::string reason;
-            std::string debug;
-            BOOST_REQUIRE(mining->checkBlock(block, {.check_pow = false}, reason, debug));
-            BOOST_REQUIRE_EQUAL(reason, "");
-            BOOST_REQUIRE_EQUAL(debug, "");
+            const auto result{CheckBlock(*mining, block, {.check_pow = false})};
+            BOOST_REQUIRE(result.valid);
+            BOOST_REQUIRE_EQUAL(result.reason, "");
+            BOOST_REQUIRE_EQUAL(result.debug, "");
         }
 
         {
@@ -813,11 +817,10 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
                 block.nNonce++;
             }
 
-            std::string reason;
-            std::string debug;
-            BOOST_REQUIRE(!mining->checkBlock(block, {.check_pow = true}, reason, debug));
-            BOOST_REQUIRE_EQUAL(reason, "high-hash");
-            BOOST_REQUIRE_EQUAL(debug, "proof of work failed");
+            const auto result{CheckBlock(*mining, block, {.check_pow = true})};
+            BOOST_REQUIRE(!result.valid);
+            BOOST_REQUIRE_EQUAL(result.reason, "high-hash");
+            BOOST_REQUIRE_EQUAL(result.debug, "proof of work failed");
         }
     }
 
@@ -835,7 +838,7 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
          * set at the end of the previous loop.
          */
         if (current_height % 2 == 0) {
-            block_template = mining->createNewBlock(options, /*cooldown=*/false);
+            block_template = CreateNewBlock(*mining, options, /*cooldown=*/false);
             BOOST_REQUIRE(block_template);
         }
 
@@ -860,19 +863,17 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
         // Alternate calls between submitBlock and submitSolution via the
         // Mining interface.
         if (current_height % 2 == 0) {
-            std::string reason{"stale reason"};
-            std::string debug{"stale debug"};
-            BOOST_REQUIRE(mining->submitBlock(block, reason, debug));
-            BOOST_REQUIRE_EQUAL(reason, "");
-            BOOST_REQUIRE_EQUAL(debug, "");
-
-            reason = "stale reason";
-            debug = "stale debug";
-            BOOST_REQUIRE(!mining->submitBlock(block, reason, debug));
-            BOOST_REQUIRE_EQUAL(reason, "duplicate");
-            BOOST_REQUIRE_EQUAL(debug, "");
+            auto result{SubmitBlock(*mining, block)};
+            BOOST_REQUIRE(result.valid);
+            BOOST_REQUIRE_EQUAL(result.reason, "");
+            BOOST_REQUIRE_EQUAL(result.debug, "");
+
+            result = SubmitBlock(*mining, block);
+            BOOST_REQUIRE(!result.valid);
+            BOOST_REQUIRE_EQUAL(result.reason, "duplicate");
+            BOOST_REQUIRE_EQUAL(result.debug, "");
         } else {
-            BOOST_REQUIRE(block_template->submitSolution(block.nVersion, block.nTime, block.nNonce, MakeTransactionRef(txCoinbase)));
+            BOOST_REQUIRE(SubmitSolution(*block_template, block.nVersion, block.nTime, block.nNonce, MakeTransactionRef(txCoinbase)));
         }
         {
             LOCK(cs_main);
@@ -882,24 +883,22 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
             BOOST_REQUIRE_EQUAL(maybe_new_tip->GetBlockHash(), block.GetHash());
         }
         if (current_height % 2 == 0) {
-            block_template = block_template->waitNext();
+            block_template = WaitNext(*block_template);
             BOOST_REQUIRE(block_template);
         } else {
             // This just adds coverage
-            mining->waitTipChanged(block.hashPrevBlock);
+            WaitTipChanged(*mining, block.hashPrevBlock);
         }
     }
 
-    LOCK(cs_main);
-
     TestBasicMining(scriptPubKey, txFirst, baseheight);
 
-    m_node.chainman->ActiveChain().Tip()->nHeight--;
+    WITH_LOCK(cs_main, m_node.chainman->ActiveChain().Tip()->nHeight--);
     SetMockTime(0);
 
     TestPackageSelection(scriptPubKey, txFirst);
 
-    m_node.chainman->ActiveChain().Tip()->nHeight--;
+    WITH_LOCK(cs_main, m_node.chainman->ActiveChain().Tip()->nHeight--);
     SetMockTime(0);
 
     TestPrioritisedMining(scriptPubKey, txFirst);
diff --git a/src/test/peerman_tests.cpp b/src/test/peerman_tests.cpp
index 869945f48f0d..bdc1c6d3232f 100644
--- a/src/test/peerman_tests.cpp
+++ b/src/test/peerman_tests.cpp
@@ -11,6 +11,7 @@
 #include <primitives/block.h>
 #include <protocol.h>
 #include <sync.h>
+#include <test/util/mining.h>
 #include <test/util/setup_common.h>
 #include <chainstate.h>
 
@@ -29,7 +30,7 @@ static void mineBlock(node::NodeContext& node, std::chrono::seconds block_time)
     auto curr_time = GetTime<std::chrono::seconds>();
     SetMockTime(block_time); // update time so the block is created with it
     auto mining{interfaces::MakeMining(node)};
-    auto block_template{mining->createNewBlock({}, /*cooldown=*/false)};
+    auto block_template{CreateNewBlock(*mining, {}, /*cooldown=*/false)};
     BOOST_REQUIRE(block_template);
     CBlock block{block_template->getBlock()};
     while (!CheckProofOfWork(block.GetHash(), block.nBits, node.chainman->GetConsensus())) ++block.nNonce;
diff --git a/src/test/testnet4_miner_tests.cpp b/src/test/testnet4_miner_tests.cpp
index baf5a6320a2b..5e0e6726082b 100644
--- a/src/test/testnet4_miner_tests.cpp
+++ b/src/test/testnet4_miner_tests.cpp
@@ -7,6 +7,7 @@
 #include <node/mining_types.h>
 #include <primitives/block.h>
 #include <sync.h>
+#include <test/util/mining.h>
 #include <test/util/setup_common.h>
 #include <test/util/time.h>
 #include <util/time.h>
@@ -43,7 +44,7 @@ BOOST_AUTO_TEST_CASE(MiningInterface)
     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({}, /*cooldown=*/false);
+    block_template = CreateNewBlock(*mining, {}, /*cooldown=*/false);
     BOOST_REQUIRE(block_template);
 
     // The template should use the mocked system time
@@ -53,19 +54,19 @@ BOOST_AUTO_TEST_CASE(MiningInterface)
     const BlockWaitOptions wait_options{.timeout = MillisecondsDouble{0}, .fee_threshold = 1};
 
     // waitNext() should return nullptr because there is no better template
-    auto should_be_nullptr = block_template->waitNext(wait_options);
+    auto should_be_nullptr = WaitNext(*block_template, wait_options);
     BOOST_REQUIRE(should_be_nullptr == nullptr);
 
     // This remains the case when exactly 20 minutes have gone by
     clock_ctx += 17min;
-    should_be_nullptr = block_template->waitNext(wait_options);
+    should_be_nullptr = WaitNext(*block_template, wait_options);
     BOOST_REQUIRE(should_be_nullptr == nullptr);
 
     // One second later the difficulty drops and it returns a new template
     // Note that we can't test the actual difficulty change, because the
     // difficulty is already at 1.
     clock_ctx += 1s;
-    block_template = block_template->waitNext(wait_options);
+    block_template = WaitNext(*block_template, wait_options);
     BOOST_REQUIRE(block_template);
 }
 
diff --git a/src/test/util/mining.cpp b/src/test/util/mining.cpp
index 0a72a08bd06a..ab66206a8cf1 100644
--- a/src/test/util/mining.cpp
+++ b/src/test/util/mining.cpp
@@ -19,18 +19,93 @@
 #include <test/util/script.h>
 #include <uint256.h>
 #include <util/check.h>
+#include <util/result.h>
 #include <chainstate.h>
 #include <validationinterface.h>
 #include <versionbits.h>
 
 #include <cstdint>
+#include <functional>
+#include <future>
 #include <memory>
 #include <optional>
+#include <stdexcept>
 #include <utility>
 
 using node::NodeContext;
 
-COutPoint generatetoaddress(const NodeContext& node, const std::string& address)
+namespace {
+template <typename Result, typename Start>
+Result WaitForAsync(Start&& start)
+{
+    std::promise<Result> promise;
+    auto future{promise.get_future()};
+    auto handler{start([&promise](Result result) mutable {
+        promise.set_value(std::move(result));
+    })};
+    (void)handler;
+    return future.get();
+}
+} // namespace
+
+std::unique_ptr<interfaces::BlockTemplate> CreateNewBlock(interfaces::Mining& mining,
+                                                          const node::BlockCreateOptions& options,
+                                                          bool cooldown)
+{
+    auto result{WaitForAsync<interfaces::Mining::CreateBlockResult>([&](interfaces::Mining::CreateBlockFn fn) {
+        return mining.createNewBlockAsync(options, cooldown, std::move(fn));
+    })};
+    if (!result) throw std::runtime_error{util::ErrorString(result).original};
+    return std::move(*result);
+}
+
+std::unique_ptr<interfaces::BlockTemplate> WaitNext(interfaces::BlockTemplate& block_template,
+                                                    node::BlockWaitOptions options)
+{
+    return WaitForAsync<std::unique_ptr<interfaces::BlockTemplate>>([&](interfaces::BlockTemplate::NextTemplateFn fn) {
+        return block_template.watchNext(options, std::move(fn));
+    });
+}
+
+bool SubmitSolution(interfaces::BlockTemplate& block_template,
+                    uint32_t version,
+                    uint32_t timestamp,
+                    uint32_t nonce,
+                    CTransactionRef coinbase)
+{
+    return WaitForAsync<bool>([&](interfaces::BlockTemplate::SubmitSolutionFn fn) {
+        return block_template.submitSolutionAsync(version, timestamp, nonce, std::move(coinbase), std::move(fn));
+    });
+}
+
+BlockTestResult CheckBlock(interfaces::Mining& mining, CBlock block, node::BlockCheckOptions options)
+{
+    return WaitForAsync<BlockTestResult>([&](std::function<void(BlockTestResult)> done) {
+        return mining.checkBlockAsync(std::move(block), options, [done = std::move(done)](bool valid, std::string reason, std::string debug) mutable {
+            done({valid, std::move(reason), std::move(debug)});
+        });
+    });
+}
+
+BlockTestResult SubmitBlock(interfaces::Mining& mining, CBlock block)
+{
+    return WaitForAsync<BlockTestResult>([&](std::function<void(BlockTestResult)> done) {
+        return mining.submitBlockAsync(std::move(block), [done = std::move(done)](bool accepted, std::string reason, std::string debug) mutable {
+            done({accepted, std::move(reason), std::move(debug)});
+        });
+    });
+}
+
+std::optional<interfaces::BlockRef> WaitTipChanged(interfaces::Mining& mining,
+                                                   uint256 current_tip,
+                                                   MillisecondsDouble timeout)
+{
+    return WaitForAsync<std::optional<interfaces::BlockRef>>([&](interfaces::Mining::TipChangedFn fn) {
+        return mining.watchTip(current_tip, timeout, std::move(fn));
+    });
+}
+
+COutPoint generatetoaddress(NodeContext& node, const std::string& address)
 {
     const auto dest = DecodeDestination(address);
     assert(IsValidDestination(dest));
@@ -74,7 +149,7 @@ std::vector<std::shared_ptr<CBlock>> CreateBlockChain(size_t total_height, const
     return ret;
 }
 
-COutPoint MineBlock(const NodeContext& node, const node::BlockCreateOptions& assembler_options)
+COutPoint MineBlock(NodeContext& node, const node::BlockCreateOptions& assembler_options)
 {
     auto block = PrepareBlock(node, assembler_options);
     auto valid = MineBlock(node, block);
@@ -98,7 +173,7 @@ struct BlockValidationStateCatcher : public CValidationInterface {
     }
 };
 
-COutPoint MineBlock(const NodeContext& node, std::shared_ptr<CBlock>& block)
+COutPoint MineBlock(NodeContext& node, std::shared_ptr<CBlock>& block)
 {
     while (!CheckProofOfWork(block->GetHash(), block->nBits, Params().GetConsensus())) {
         ++block->nNonce;
@@ -108,7 +183,7 @@ COutPoint MineBlock(const NodeContext& node, std::shared_ptr<CBlock>& block)
     return ProcessBlock(node, block);
 }
 
-COutPoint ProcessBlock(const NodeContext& node, const std::shared_ptr<CBlock>& block)
+COutPoint ProcessBlock(NodeContext& node, const std::shared_ptr<CBlock>& block)
 {
     auto& chainman{*Assert(node.chainman)};
     const auto old_height = WITH_LOCK(chainman.GetMutex(), return chainman.ActiveHeight());
@@ -127,11 +202,11 @@ COutPoint ProcessBlock(const NodeContext& node, const std::shared_ptr<CBlock>& b
     return {};
 }
 
-std::shared_ptr<CBlock> PrepareBlock(const NodeContext& node,
+std::shared_ptr<CBlock> PrepareBlock(NodeContext& node,
                                      const node::BlockCreateOptions& assembler_options)
 {
     auto mining = interfaces::MakeMining(node);
-    auto block_template = mining->createNewBlock(assembler_options, /*cooldown=*/false);
+    auto block_template = CreateNewBlock(*mining, assembler_options, /*cooldown=*/false);
     auto block = std::make_shared<CBlock>(Assert(block_template)->getBlock());
 
     LOCK(cs_main);
diff --git a/src/test/util/mining.h b/src/test/util/mining.h
index d1a071b3ee3a..2e921ca24061 100644
--- a/src/test/util/mining.h
+++ b/src/test/util/mining.h
@@ -5,42 +5,71 @@
 #ifndef BITCOIN_TEST_UTIL_MINING_H
 #define BITCOIN_TEST_UTIL_MINING_H
 
+#include <interfaces/mining.h>
+#include <node/mining_types.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
+#include <uint256.h>
+#include <util/time.h>
+
 #include <cstddef>
+#include <cstdint>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 
-class CBlock;
 class CChainParams;
 class COutPoint;
 namespace node {
-struct BlockCreateOptions;
 struct NodeContext;
 } // namespace node
 
+struct BlockTestResult {
+    bool valid{false};
+    std::string reason;
+    std::string debug;
+};
+
+std::unique_ptr<interfaces::BlockTemplate> CreateNewBlock(interfaces::Mining& mining,
+                                                          const node::BlockCreateOptions& options = {},
+                                                          bool cooldown = false);
+std::unique_ptr<interfaces::BlockTemplate> WaitNext(interfaces::BlockTemplate& block_template,
+                                                    node::BlockWaitOptions options = {});
+bool SubmitSolution(interfaces::BlockTemplate& block_template,
+                    uint32_t version,
+                    uint32_t timestamp,
+                    uint32_t nonce,
+                    CTransactionRef coinbase);
+BlockTestResult CheckBlock(interfaces::Mining& mining, CBlock block, node::BlockCheckOptions options);
+BlockTestResult SubmitBlock(interfaces::Mining& mining, CBlock block);
+std::optional<interfaces::BlockRef> WaitTipChanged(interfaces::Mining& mining,
+                                                   uint256 current_tip,
+                                                   MillisecondsDouble timeout = MillisecondsDouble::max());
+
 /** Create a blockchain, starting from genesis */
 std::vector<std::shared_ptr<CBlock>> CreateBlockChain(size_t total_height, const CChainParams& params);
 
 /** Returns the generated coin */
-COutPoint MineBlock(const node::NodeContext&,
+COutPoint MineBlock(node::NodeContext&,
                     const node::BlockCreateOptions& assembler_options);
 
 /**
  * Returns the generated coin (or Null if the block was invalid).
  * It is recommended to call RegenerateCommitments before mining the block to avoid merkle tree mismatches.
  **/
-COutPoint MineBlock(const node::NodeContext&, std::shared_ptr<CBlock>& block);
+COutPoint MineBlock(node::NodeContext&, std::shared_ptr<CBlock>& block);
 
 /**
  * Returns the generated coin (or Null if the block was invalid).
  */
-COutPoint ProcessBlock(const node::NodeContext&, const std::shared_ptr<CBlock>& block);
+COutPoint ProcessBlock(node::NodeContext&, const std::shared_ptr<CBlock>& block);
 
 /** Prepare a block to be mined */
-std::shared_ptr<CBlock> PrepareBlock(const node::NodeContext& node,
+std::shared_ptr<CBlock> PrepareBlock(node::NodeContext& node,
                                      const node::BlockCreateOptions& assembler_options);
 
 /** RPC-like helper function, returns the generated coin */
-COutPoint generatetoaddress(const node::NodeContext&, const std::string& address);
+COutPoint generatetoaddress(node::NodeContext&, const std::string& address);
 
 #endif // BITCOIN_TEST_UTIL_MINING_H
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 29e615e9e064..60906ed87f18 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -54,6 +54,7 @@
 #include <streams.h>
 #include <sync.h>
 #include <test/util/coverage.h>
+#include <test/util/mining.h>
 #include <test/util/net.h>
 #include <test/util/random.h>
 #include <test/util/txmempool.h>
@@ -438,7 +439,7 @@ CBlock TestChain100Setup::CreateBlock(
     const CScript& scriptPubKey)
 {
     auto mining{interfaces::MakeMining(m_node)};
-    auto block_template{mining->createNewBlock({
+    auto block_template{CreateNewBlock(*mining, {
         .use_mempool = false,
         .coinbase_output_script = scriptPubKey,
     }, /*cooldown=*/false)};
diff --git a/src/test/validation_block_tests.cpp b/src/test/validation_block_tests.cpp
index f343bf38e8d5..dffa5603dc31 100644
--- a/src/test/validation_block_tests.cpp
+++ b/src/test/validation_block_tests.cpp
@@ -19,6 +19,7 @@
 #include <script/script.h>
 #include <sync.h>
 #include <test/util/common.h> // IWYU pragma: keep
+#include <test/util/mining.h>
 #include <test/util/script.h>
 #include <test/util/setup_common.h>
 #include <util/time.h>
@@ -78,7 +79,7 @@ std::shared_ptr<CBlock> MinerTestingSetup::Block(const uint256& prev_hash)
     static uint64_t time = Params().GenesisBlock().nTime;
 
     auto mining{interfaces::MakeMining(m_node)};
-    auto block_template{mining->createNewBlock({
+    auto block_template{CreateNewBlock(*mining, {
         .coinbase_output_script = CScript{} << i++ << OP_TRUE,
     }, /*cooldown=*/false)};
     BOOST_REQUIRE(block_template);
@@ -344,11 +345,10 @@ BOOST_AUTO_TEST_CASE(mempool_locks_reorg)
 
 BOOST_AUTO_TEST_CASE(witness_commitment_index)
 {
-    LOCK(Assert(m_node.chainman)->GetMutex());
     CScript pubKey;
     pubKey << 1 << OP_TRUE;
     auto mining{interfaces::MakeMining(m_node)};
-    auto block_template{mining->createNewBlock({
+    auto block_template{CreateNewBlock(*mining, {
         .coinbase_output_script = pubKey,
     }, /*cooldown=*/false)};
     BOOST_REQUIRE(block_template);

From 21b70ec547014cfbfbca55e931b30e315f039dcd Mon Sep 17 00:00:00 2001
From: josibake <josibake@protonmail.com>
Date: Thu, 11 Jun 2026 06:05:50 +0100
Subject: [PATCH 2/3] build: drop vendored libmultiprocess

---
 cmake/libmultiprocess.cmake                   |  38 -
 depends/packages/native_libmultiprocess.mk    |  15 -
 depends/packages/packages.mk                  |   2 +-
 depends/toolchain.cmake.in                    |   1 -
 src/ipc/libmultiprocess/.clang-tidy           |  40 -
 .../.github/workflows/bitcoin-core-ci.yml     | 300 ------
 .../libmultiprocess/.github/workflows/ci.yml  | 183 ----
 src/ipc/libmultiprocess/.gitignore            |   5 -
 src/ipc/libmultiprocess/CMakeLists.txt        | 264 ------
 src/ipc/libmultiprocess/COPYING               |  22 -
 src/ipc/libmultiprocess/README.md             |   8 -
 src/ipc/libmultiprocess/ci/README.md          |  52 --
 .../libmultiprocess/ci/configs/default.bash   |   5 -
 .../libmultiprocess/ci/configs/freebsd.bash   |   5 -
 src/ipc/libmultiprocess/ci/configs/gnu32.bash |  11 -
 src/ipc/libmultiprocess/ci/configs/llvm.bash  |  11 -
 src/ipc/libmultiprocess/ci/configs/macos.bash |   5 -
 .../libmultiprocess/ci/configs/netbsd.bash    |  11 -
 .../libmultiprocess/ci/configs/olddeps.bash   |   5 -
 .../libmultiprocess/ci/configs/openbsd.bash   |   5 -
 .../libmultiprocess/ci/configs/sanitize.bash  |   8 -
 .../ci/patches/spaceship.patch                |  29 -
 .../ci/scripts/bitcoin_core_ci.sh             | 152 ---
 src/ipc/libmultiprocess/ci/scripts/ci.sh      |  37 -
 .../libmultiprocess/ci/scripts/ci_helpers.sh  |  94 --
 src/ipc/libmultiprocess/ci/scripts/config.sh  |  26 -
 src/ipc/libmultiprocess/ci/scripts/run.sh     |  24 -
 src/ipc/libmultiprocess/cmake/Config.cmake.in |  33 -
 .../cmake/TargetCapnpSources.cmake            | 120 ---
 .../libmultiprocess/cmake/compat_config.cmake |  59 --
 .../libmultiprocess/cmake/compat_find.cmake   |  20 -
 .../cmake/pthread_checks.cmake                |  41 -
 src/ipc/libmultiprocess/doc/design.md         | 227 -----
 src/ipc/libmultiprocess/doc/install.md        |  52 --
 src/ipc/libmultiprocess/doc/usage.md          |  27 -
 src/ipc/libmultiprocess/doc/versions.md       |  78 --
 .../libmultiprocess/example/CMakeLists.txt    |  28 -
 .../libmultiprocess/example/calculator.capnp  |  16 -
 .../libmultiprocess/example/calculator.cpp    |  64 --
 src/ipc/libmultiprocess/example/calculator.h  |  17 -
 src/ipc/libmultiprocess/example/example.cpp   |  77 --
 src/ipc/libmultiprocess/example/init.capnp    |  21 -
 src/ipc/libmultiprocess/example/init.h        |  20 -
 src/ipc/libmultiprocess/example/printer.capnp |  16 -
 src/ipc/libmultiprocess/example/printer.cpp   |  57 --
 src/ipc/libmultiprocess/example/printer.h     |  17 -
 src/ipc/libmultiprocess/example/types.h       |  23 -
 .../libmultiprocess/include/mp/config.h.in    |  16 -
 src/ipc/libmultiprocess/include/mp/proxy-io.h | 882 ------------------
 .../libmultiprocess/include/mp/proxy-types.h  | 829 ----------------
 .../libmultiprocess/include/mp/proxy.capnp    |  65 --
 src/ipc/libmultiprocess/include/mp/proxy.h    | 338 -------
 .../libmultiprocess/include/mp/type-char.h    |  36 -
 .../libmultiprocess/include/mp/type-chrono.h  |  34 -
 .../libmultiprocess/include/mp/type-context.h | 229 -----
 .../libmultiprocess/include/mp/type-data.h    |  49 -
 .../libmultiprocess/include/mp/type-decay.h   |  38 -
 .../include/mp/type-exception.h               |  22 -
 .../include/mp/type-function.h                |  67 --
 .../include/mp/type-interface.h               | 112 ---
 src/ipc/libmultiprocess/include/mp/type-map.h |  81 --
 .../libmultiprocess/include/mp/type-message.h |  64 --
 .../libmultiprocess/include/mp/type-number.h  |  93 --
 .../include/mp/type-optional.h                |  47 -
 .../libmultiprocess/include/mp/type-pair.h    |  50 -
 .../libmultiprocess/include/mp/type-pointer.h | 113 ---
 src/ipc/libmultiprocess/include/mp/type-set.h |  48 -
 .../libmultiprocess/include/mp/type-string.h  |  34 -
 .../libmultiprocess/include/mp/type-struct.h  |  85 --
 .../include/mp/type-threadmap.h               |  41 -
 .../libmultiprocess/include/mp/type-tuple.h   |  45 -
 .../libmultiprocess/include/mp/type-vector.h  |  71 --
 .../libmultiprocess/include/mp/type-void.h    |  23 -
 src/ipc/libmultiprocess/include/mp/util.h     | 342 -------
 src/ipc/libmultiprocess/include/mp/version.h  |  34 -
 src/ipc/libmultiprocess/include/mpgen.mk      |   4 -
 .../pkgconfig/libmultiprocess.pc.in           |  12 -
 src/ipc/libmultiprocess/shell.nix             |  84 --
 src/ipc/libmultiprocess/src/mp/gen.cpp        | 711 --------------
 src/ipc/libmultiprocess/src/mp/proxy.cpp      | 453 ---------
 src/ipc/libmultiprocess/src/mp/util.cpp       | 195 ----
 src/ipc/libmultiprocess/test/CMakeLists.txt   |  40 -
 .../libmultiprocess/test/mp/test/foo-types.h  | 109 ---
 .../libmultiprocess/test/mp/test/foo.capnp    |  79 --
 src/ipc/libmultiprocess/test/mp/test/foo.h    |  98 --
 .../test/mp/test/spawn_tests.cpp              | 112 ---
 src/ipc/libmultiprocess/test/mp/test/test.cpp | 485 ----------
 test/lint/lint_ignore_dirs.py                 |   1 -
 test/lint/test_runner/src/lint_cpp.rs         |   1 -
 89 files changed, 1 insertion(+), 8642 deletions(-)
 delete mode 100644 cmake/libmultiprocess.cmake
 delete mode 100644 depends/packages/native_libmultiprocess.mk
 delete mode 100644 src/ipc/libmultiprocess/.clang-tidy
 delete mode 100644 src/ipc/libmultiprocess/.github/workflows/bitcoin-core-ci.yml
 delete mode 100644 src/ipc/libmultiprocess/.github/workflows/ci.yml
 delete mode 100644 src/ipc/libmultiprocess/.gitignore
 delete mode 100644 src/ipc/libmultiprocess/CMakeLists.txt
 delete mode 100644 src/ipc/libmultiprocess/COPYING
 delete mode 100644 src/ipc/libmultiprocess/README.md
 delete mode 100644 src/ipc/libmultiprocess/ci/README.md
 delete mode 100644 src/ipc/libmultiprocess/ci/configs/default.bash
 delete mode 100644 src/ipc/libmultiprocess/ci/configs/freebsd.bash
 delete mode 100644 src/ipc/libmultiprocess/ci/configs/gnu32.bash
 delete mode 100644 src/ipc/libmultiprocess/ci/configs/llvm.bash
 delete mode 100644 src/ipc/libmultiprocess/ci/configs/macos.bash
 delete mode 100644 src/ipc/libmultiprocess/ci/configs/netbsd.bash
 delete mode 100644 src/ipc/libmultiprocess/ci/configs/olddeps.bash
 delete mode 100644 src/ipc/libmultiprocess/ci/configs/openbsd.bash
 delete mode 100644 src/ipc/libmultiprocess/ci/configs/sanitize.bash
 delete mode 100644 src/ipc/libmultiprocess/ci/patches/spaceship.patch
 delete mode 100755 src/ipc/libmultiprocess/ci/scripts/bitcoin_core_ci.sh
 delete mode 100755 src/ipc/libmultiprocess/ci/scripts/ci.sh
 delete mode 100755 src/ipc/libmultiprocess/ci/scripts/ci_helpers.sh
 delete mode 100755 src/ipc/libmultiprocess/ci/scripts/config.sh
 delete mode 100755 src/ipc/libmultiprocess/ci/scripts/run.sh
 delete mode 100644 src/ipc/libmultiprocess/cmake/Config.cmake.in
 delete mode 100644 src/ipc/libmultiprocess/cmake/TargetCapnpSources.cmake
 delete mode 100644 src/ipc/libmultiprocess/cmake/compat_config.cmake
 delete mode 100644 src/ipc/libmultiprocess/cmake/compat_find.cmake
 delete mode 100644 src/ipc/libmultiprocess/cmake/pthread_checks.cmake
 delete mode 100644 src/ipc/libmultiprocess/doc/design.md
 delete mode 100644 src/ipc/libmultiprocess/doc/install.md
 delete mode 100644 src/ipc/libmultiprocess/doc/usage.md
 delete mode 100644 src/ipc/libmultiprocess/doc/versions.md
 delete mode 100644 src/ipc/libmultiprocess/example/CMakeLists.txt
 delete mode 100644 src/ipc/libmultiprocess/example/calculator.capnp
 delete mode 100644 src/ipc/libmultiprocess/example/calculator.cpp
 delete mode 100644 src/ipc/libmultiprocess/example/calculator.h
 delete mode 100644 src/ipc/libmultiprocess/example/example.cpp
 delete mode 100644 src/ipc/libmultiprocess/example/init.capnp
 delete mode 100644 src/ipc/libmultiprocess/example/init.h
 delete mode 100644 src/ipc/libmultiprocess/example/printer.capnp
 delete mode 100644 src/ipc/libmultiprocess/example/printer.cpp
 delete mode 100644 src/ipc/libmultiprocess/example/printer.h
 delete mode 100644 src/ipc/libmultiprocess/example/types.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/config.h.in
 delete mode 100644 src/ipc/libmultiprocess/include/mp/proxy-io.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/proxy-types.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/proxy.capnp
 delete mode 100644 src/ipc/libmultiprocess/include/mp/proxy.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-char.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-chrono.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-context.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-data.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-decay.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-exception.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-function.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-interface.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-map.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-message.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-number.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-optional.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-pair.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-pointer.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-set.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-string.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-struct.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-threadmap.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-tuple.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-vector.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/type-void.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/util.h
 delete mode 100644 src/ipc/libmultiprocess/include/mp/version.h
 delete mode 100644 src/ipc/libmultiprocess/include/mpgen.mk
 delete mode 100644 src/ipc/libmultiprocess/pkgconfig/libmultiprocess.pc.in
 delete mode 100644 src/ipc/libmultiprocess/shell.nix
 delete mode 100644 src/ipc/libmultiprocess/src/mp/gen.cpp
 delete mode 100644 src/ipc/libmultiprocess/src/mp/proxy.cpp
 delete mode 100644 src/ipc/libmultiprocess/src/mp/util.cpp
 delete mode 100644 src/ipc/libmultiprocess/test/CMakeLists.txt
 delete mode 100644 src/ipc/libmultiprocess/test/mp/test/foo-types.h
 delete mode 100644 src/ipc/libmultiprocess/test/mp/test/foo.capnp
 delete mode 100644 src/ipc/libmultiprocess/test/mp/test/foo.h
 delete mode 100644 src/ipc/libmultiprocess/test/mp/test/spawn_tests.cpp
 delete mode 100644 src/ipc/libmultiprocess/test/mp/test/test.cpp

diff --git a/cmake/libmultiprocess.cmake b/cmake/libmultiprocess.cmake
deleted file mode 100644
index 027109a90511..000000000000
--- a/cmake/libmultiprocess.cmake
+++ /dev/null
@@ -1,38 +0,0 @@
-# Copyright (c) 2025-present The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or https://opensource.org/license/mit/.
-
-function(add_libmultiprocess subdir)
-  # Set BUILD_TESTING to match BUILD_TESTS. BUILD_TESTING is a standard cmake
-  # option that controls whether enable_testing() is called, but in the bitcoin
-  # build a BUILD_TESTS option is used instead.
-  set(BUILD_TESTING "${BUILD_TESTS}")
-  add_subdirectory(${subdir} EXCLUDE_FROM_ALL)
-  # Apply core_interface compile options to libmultiprocess runtime library.
-  target_link_libraries(multiprocess PUBLIC $<BUILD_INTERFACE:core_interface>)
-  target_link_libraries(mputil PUBLIC $<BUILD_INTERFACE:core_interface>)
-  target_link_libraries(mpgen PUBLIC $<BUILD_INTERFACE:core_interface>)
-  # Mark capproto options as advanced to hide by default from cmake UI
-  mark_as_advanced(CapnProto_DIR)
-  mark_as_advanced(CapnProto_capnpc_IMPORTED_LOCATION)
-  mark_as_advanced(CapnProto_capnp_IMPORTED_LOCATION)
-  mark_as_advanced(CapnProto_capnp-json_IMPORTED_LOCATION)
-  mark_as_advanced(CapnProto_capnp-rpc_IMPORTED_LOCATION)
-  mark_as_advanced(CapnProto_capnp-websocket_IMPORTED_LOCATION)
-  mark_as_advanced(CapnProto_kj-async_IMPORTED_LOCATION)
-  mark_as_advanced(CapnProto_kj-gzip_IMPORTED_LOCATION)
-  mark_as_advanced(CapnProto_kj-http_IMPORTED_LOCATION)
-  mark_as_advanced(CapnProto_kj_IMPORTED_LOCATION)
-  mark_as_advanced(CapnProto_kj-test_IMPORTED_LOCATION)
-  mark_as_advanced(CapnProto_kj-tls_IMPORTED_LOCATION)
-  if(BUILD_TESTS)
-    # Add tests to "all" target so ctest can run them
-    set_target_properties(mptest PROPERTIES EXCLUDE_FROM_ALL OFF)
-  endif()
-  # Exclude examples from compilation database, because the examples are not
-  # built by default, and they contain generated c++ code. Without this
-  # exclusion, tools like clang-tidy and IWYU that make use of compilation
-  # database would complain that the generated c++ source files do not exist. An
-  # alternate fix could build "mpexamples" by default like "mptests" above.
-  set_target_properties(mpcalculator mpprinter mpexample PROPERTIES EXPORT_COMPILE_COMMANDS OFF)
-endfunction()
diff --git a/depends/packages/native_libmultiprocess.mk b/depends/packages/native_libmultiprocess.mk
deleted file mode 100644
index f494f6e8a580..000000000000
--- a/depends/packages/native_libmultiprocess.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-package=native_libmultiprocess
-$(package)_local_dir=../src/ipc/libmultiprocess
-$(package)_dependencies=native_capnp
-
-define $(package)_config_cmds
-  $($(package)_cmake) .
-endef
-
-define $(package)_build_cmds
-  $(MAKE)
-endef
-
-define $(package)_stage_cmds
-  $(MAKE) DESTDIR=$($(package)_staging_dir) install-bin
-endef
diff --git a/depends/packages/packages.mk b/depends/packages/packages.mk
index 7f8f35a895a6..580d27187333 100644
--- a/depends/packages/packages.mk
+++ b/depends/packages/packages.mk
@@ -3,6 +3,6 @@ packages:=
 boost_packages = boost
 
 ipc_packages = capnp
-multiprocess_native_packages = native_libmultiprocess native_capnp
+multiprocess_native_packages = native_capnp
 
 usdt_linux_packages=systemtap
diff --git a/depends/toolchain.cmake.in b/depends/toolchain.cmake.in
index 820d6cd8e925..863a6b370e31 100644
--- a/depends/toolchain.cmake.in
+++ b/depends/toolchain.cmake.in
@@ -136,6 +136,5 @@ else()
   set(USDT_INCLUDE_DIR "${CMAKE_CURRENT_LIST_DIR}/systemtap/include" CACHE PATH "")
 endif()
 
-set(MPGEN_EXECUTABLE "${CMAKE_CURRENT_LIST_DIR}/native/bin/mpgen" CACHE FILEPATH "")
 set(CAPNP_EXECUTABLE "${CMAKE_CURRENT_LIST_DIR}/native/bin/capnp" CACHE FILEPATH "")
 set(CAPNPC_CXX_EXECUTABLE "${CMAKE_CURRENT_LIST_DIR}/native/bin/capnpc-c++" CACHE FILEPATH "")
diff --git a/src/ipc/libmultiprocess/.clang-tidy b/src/ipc/libmultiprocess/.clang-tidy
deleted file mode 100644
index 9a2afcc5248c..000000000000
--- a/src/ipc/libmultiprocess/.clang-tidy
+++ /dev/null
@@ -1,40 +0,0 @@
-Checks: '
--*,
-bugprone-argument-comment,
-bugprone-move-forwarding-reference,
-bugprone-string-constructor,
-bugprone-use-after-move,
-bugprone-lambda-function-name,
-bugprone-unhandled-self-assignment,
-misc-unused-using-decls,
-misc-no-recursion,
-modernize-deprecated-headers,
-modernize-use-default-member-init,
-modernize-use-emplace,
-modernize-use-equals-default,
-modernize-use-noexcept,
-modernize-use-nullptr,
-modernize-use-starts-ends-with,
-performance-*,
--performance-avoid-endl,
--performance-enum-size,
--performance-inefficient-string-concatenation,
--performance-no-int-to-ptr,
--performance-noexcept-move-constructor,
--performance-unnecessary-value-param,
-readability-const-return-type,
-readability-redundant-declaration,
-readability-redundant-string-init,
-clang-analyzer-core.*,
--clang-analyzer-core.UndefinedBinaryOperatorResult,
-clang-analyzer-optin.core.*,
-'
-HeaderFilterRegex: '.'
-WarningsAsErrors: '*'
-CheckOptions:
- - key: modernize-deprecated-headers.CheckHeaderFile
-   value: false
- - key: performance-move-const-arg.CheckTriviallyCopyableMove
-   value: false
- - key: bugprone-unhandled-self-assignment.WarnOnlyIfThisHasSuspiciousField
-   value: false
diff --git a/src/ipc/libmultiprocess/.github/workflows/bitcoin-core-ci.yml b/src/ipc/libmultiprocess/.github/workflows/bitcoin-core-ci.yml
deleted file mode 100644
index e6ac83f0bd45..000000000000
--- a/src/ipc/libmultiprocess/.github/workflows/bitcoin-core-ci.yml
+++ /dev/null
@@ -1,300 +0,0 @@
-# Copyright (c) The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or https://opensource.org/license/mit.
-
-# Test libmultiprocess inside Bitcoin Core by replacing the subtree copy
-# with the version from this PR, then building and running IPC-related
-# unit & functional tests.
-
-name: Bitcoin Core CI
-
-on:
-  push:
-  pull_request:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-env:
-  BITCOIN_REPO: bitcoin/bitcoin
-  LLVM_VERSION: 22
-  LIBCXX_DIR: /tmp/libcxx-build/
-
-jobs:
-  bitcoin-core:
-    name: ${{ matrix.name }}
-    runs-on: ${{ matrix.runner }}
-    timeout-minutes: 120
-
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - name: 'ASan + UBSan'
-            unit_test_runs: 15
-            functional_test_runs: 20
-            nproc_multiplier: 2
-            functional_timeout_factor: 40
-            runner: ubuntu-24.04
-            apt-llvm: true
-            packages: >-
-              ccache
-              clang-22
-              llvm-22
-              libclang-rt-22-dev
-              libevent-dev
-              libboost-dev
-              libsqlite3-dev
-              libcapnp-dev
-              capnproto
-              ninja-build
-              pkgconf
-              python3-pip
-            pip-packages: --break-system-packages pycapnp
-            cmake-args: |-
-              -DSANITIZERS=address,float-divide-by-zero,integer,undefined
-              -DCMAKE_C_COMPILER=clang
-              -DCMAKE_CXX_COMPILER=clang++
-              -DCMAKE_C_FLAGS=-ftrivial-auto-var-init=pattern
-              -DCMAKE_CXX_FLAGS=-ftrivial-auto-var-init=pattern
-
-          - name: 'macOS'
-            unit_test_runs: 50
-            functional_test_runs: 20
-            nproc_multiplier: 2
-            functional_timeout_factor: 40
-            runner: macos-15
-            brew-packages: ccache capnp boost libevent sqlite pkgconf ninja
-            pip-packages: --break-system-packages pycapnp
-            cmake-args: |-
-              -DREDUCE_EXPORTS=ON
-
-    env:
-      CCACHE_MAXSIZE: 400M
-      CCACHE_DIR: ${{ github.workspace }}/.ccache
-
-    steps:
-      - name: Checkout Bitcoin Core
-        uses: actions/checkout@v4
-        with:
-          repository: ${{ env.BITCOIN_REPO }}
-          fetch-depth: 1
-
-      - name: Checkout libmultiprocess
-        uses: actions/checkout@v4
-        with:
-          path: _libmultiprocess
-
-      - name: Replace libmultiprocess subtree
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh replace_subtree
-
-      - name: Add LLVM apt repository
-        if: matrix.apt-llvm
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh add_llvm_apt_repository
-
-      - name: Install APT packages
-        if: matrix.packages
-        run: _libmultiprocess/ci/scripts/ci_helpers.sh install_apt_packages ${{ matrix.packages }}
-
-      - name: Configure LLVM alternatives
-        if: matrix.packages
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh install_llvm_alternatives
-
-      - name: Install Homebrew packages
-        if: matrix.brew-packages
-        run: _libmultiprocess/ci/scripts/ci_helpers.sh install_homebrew_packages ${{ matrix.brew-packages }}
-
-      - name: Install pip packages
-        if: matrix.pip-packages
-        run: _libmultiprocess/ci/scripts/ci_helpers.sh install_pip_packages ${{ matrix.pip-packages }}
-
-      - name: Determine parallelism
-        run: _libmultiprocess/ci/scripts/ci_helpers.sh determine_parallelism "${{ matrix.nproc_multiplier }}"
-
-      - name: Restore ccache
-        id: ccache-restore
-        uses: actions/cache/restore@v4
-        with:
-          path: ${{ env.CCACHE_DIR }}
-          key: ccache-${{ matrix.name }}-${{ github.ref }}-${{ github.sha }}
-          restore-keys: |
-            ccache-${{ matrix.name }}-${{ github.ref }}-
-            ccache-${{ matrix.name }}-
-
-      - name: Reset ccache stats
-        if: matrix.packages || matrix.brew-packages
-        run: _libmultiprocess/ci/scripts/ci_helpers.sh reset_ccache_stats
-
-      - name: CMake configure
-        env:
-          BITCOIN_CORE_CMAKE_ARGS: ${{ matrix.cmake-args }}
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh configure_bitcoin_core
-
-      - name: Build
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh build_bitcoin_core
-
-      - name: Show ccache stats
-        if: matrix.packages || matrix.brew-packages
-        run: _libmultiprocess/ci/scripts/ci_helpers.sh show_ccache_stats
-
-      - name: Run IPC unit tests
-        env:
-          ASAN_OPTIONS: detect_leaks=1:detect_stack_use_after_return=1:check_initialization_order=1:strict_init_order=1
-          LSAN_OPTIONS: suppressions=${{ github.workspace }}/test/sanitizer_suppressions/lsan
-          UBSAN_OPTIONS: suppressions=${{ github.workspace }}/test/sanitizer_suppressions/ubsan:print_stacktrace=1:halt_on_error=1:report_error_type=1
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh run_ipc_unit_tests "${{ matrix.unit_test_runs }}"
-
-      - name: Run IPC functional tests
-        env:
-          ASAN_OPTIONS: detect_leaks=1:detect_stack_use_after_return=1:check_initialization_order=1:strict_init_order=1
-          LSAN_OPTIONS: suppressions=${{ github.workspace }}/test/sanitizer_suppressions/lsan
-          UBSAN_OPTIONS: suppressions=${{ github.workspace }}/test/sanitizer_suppressions/ubsan:print_stacktrace=1:halt_on_error=1:report_error_type=1
-          CI_FAILFAST_TEST_LEAVE_DANGLING: 1
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh run_ipc_functional_tests "${{ matrix.functional_test_runs }}" "${{ matrix.functional_timeout_factor }}"
-
-      - name: Save ccache
-        uses: actions/cache/save@v4
-        if: github.ref == 'refs/heads/master' || steps.ccache-restore.outputs.cache-hit != 'true'
-        with:
-          path: ${{ env.CCACHE_DIR }}
-          key: ccache-${{ matrix.name }}-${{ github.ref }}-${{ github.sha }}
-
-  bitcoin-core-tsan:
-    name: ${{ matrix.name }}
-    runs-on: ubuntu-24.04
-    timeout-minutes: 180
-
-    strategy:
-      matrix:
-        include:
-          - name: TSan
-            unit_test_runs: 8
-            functional_test_runs: 25
-            nproc_multiplier: 2
-            functional_timeout_factor: 40
-
-    env:
-      CCACHE_MAXSIZE: 400M
-      CCACHE_DIR: ${{ github.workspace }}/.ccache
-      LIBCXX_FLAGS: >-
-        -fsanitize=thread
-        -nostdinc++
-        -nostdlib++
-        -isystem /tmp/libcxx-build/include/c++/v1
-        -L/tmp/libcxx-build/lib
-        -Wl,-rpath,/tmp/libcxx-build/lib
-        -lc++
-        -lc++abi
-        -lpthread
-        -Wno-unused-command-line-argument
-      TSAN_OPTIONS: suppressions=${{ github.workspace }}/test/sanitizer_suppressions/tsan:halt_on_error=1:second_deadlock_stack=1
-
-    steps:
-      - name: Checkout Bitcoin Core
-        uses: actions/checkout@v4
-        with:
-          repository: ${{ env.BITCOIN_REPO }}
-          fetch-depth: 1
-
-      - name: Checkout libmultiprocess
-        uses: actions/checkout@v4
-        with:
-          path: _libmultiprocess
-
-      - name: Add LLVM apt repository
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh add_llvm_apt_repository
-
-      - name: Install packages
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh install_tsan_packages
-
-      - name: Determine parallelism
-        run: _libmultiprocess/ci/scripts/ci_helpers.sh determine_parallelism "${{ matrix.nproc_multiplier }}"
-
-      - name: Restore instrumented libc++ cache
-        id: libcxx-cache
-        uses: actions/cache@v4
-        with:
-          path: ${{ env.LIBCXX_DIR }}
-          key: libcxx-Thread-llvmorg-${{ env.LLVM_VERSION }}.1.0
-
-      - name: Build instrumented libc++
-        if: steps.libcxx-cache.outputs.cache-hit != 'true'
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh build_instrumented_libcxx
-
-      - name: Determine host
-        id: host
-        run: _libmultiprocess/ci/scripts/ci_helpers.sh determine_host
-
-      - name: Restore depends cache
-        id: depends-cache
-        uses: actions/cache/restore@v4
-        with:
-          path: |
-            depends/built
-            depends/${{ steps.host.outputs.host }}
-          key: depends-tsan-${{ hashFiles('depends/packages/*.mk') }}-${{ env.LLVM_VERSION }}
-
-      - name: Build depends (stage 1, without IPC)
-        if: steps.depends-cache.outputs.cache-hit != 'true'
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh build_depends_without_ipc
-
-      - name: Save depends cache
-        uses: actions/cache/save@v4
-        if: steps.depends-cache.outputs.cache-hit != 'true'
-        with:
-          path: |
-            depends/built
-            depends/${{ steps.host.outputs.host }}
-          key: depends-tsan-${{ hashFiles('depends/packages/*.mk') }}-${{ env.LLVM_VERSION }}
-
-      - name: Replace libmultiprocess subtree
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh replace_subtree
-
-      - name: Build depends (stage 2, IPC packages including libmultiprocess)
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh build_depends_with_ipc
-
-      - name: Restore ccache
-        id: ccache-restore
-        uses: actions/cache/restore@v4
-        with:
-          path: ${{ env.CCACHE_DIR }}
-          key: ccache-TSan-${{ github.ref }}-${{ github.sha }}
-          restore-keys: |
-            ccache-TSan-${{ github.ref }}-
-            ccache-TSan-
-
-      - name: Reset ccache stats
-        run: _libmultiprocess/ci/scripts/ci_helpers.sh reset_ccache_stats
-
-      - name: CMake configure
-        env:
-          BITCOIN_CORE_CMAKE_ARGS: |-
-            -DSANITIZERS=thread
-            -DAPPEND_CPPFLAGS=-DARENA_DEBUG -DDEBUG_LOCKCONTENTION -D_LIBCPP_REMOVE_TRANSITIVE_INCLUDES
-            -DCMAKE_TOOLCHAIN_FILE=depends/${{ steps.host.outputs.host }}/toolchain.cmake
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh configure_bitcoin_core
-
-      - name: Build
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh build_bitcoin_core
-
-      - name: Show ccache stats
-        run: _libmultiprocess/ci/scripts/ci_helpers.sh show_ccache_stats
-
-      - name: Run IPC unit tests
-        env:
-          LD_LIBRARY_PATH: depends/${{ steps.host.outputs.host }}/lib
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh run_ipc_unit_tests "${{ matrix.unit_test_runs }}"
-
-      - name: Run IPC functional tests
-        env:
-          LD_LIBRARY_PATH: depends/${{ steps.host.outputs.host }}/lib
-          CI_FAILFAST_TEST_LEAVE_DANGLING: 1
-        run: _libmultiprocess/ci/scripts/bitcoin_core_ci.sh run_ipc_functional_tests "${{ matrix.functional_test_runs }}" "${{ matrix.functional_timeout_factor }}"
-
-      - name: Save ccache
-        uses: actions/cache/save@v4
-        if: github.ref == 'refs/heads/master' || steps.ccache-restore.outputs.cache-hit != 'true'
-        with:
-          path: ${{ env.CCACHE_DIR }}
-          key: ccache-TSan-${{ github.ref }}-${{ github.sha }}
diff --git a/src/ipc/libmultiprocess/.github/workflows/ci.yml b/src/ipc/libmultiprocess/.github/workflows/ci.yml
deleted file mode 100644
index ffaca1cac93c..000000000000
--- a/src/ipc/libmultiprocess/.github/workflows/ci.yml
+++ /dev/null
@@ -1,183 +0,0 @@
-name: CI
-
-on:
-  push:
-  pull_request:
-
-jobs:
-  build-netbsd:
-    runs-on: ubuntu-latest
-    name: build • netbsd ${{ matrix.release }}
-    defaults:
-      run:
-        shell: netbsd {0}
-    strategy:
-      fail-fast: false
-      matrix:
-        # Test all supported releases.
-        # See https://www.netbsd.org/releases/.
-        include:
-          - release: 9.4
-            capnproto-cppflags: 'CPPFLAGS="-DKJ_NO_EXCEPTIONS=0 -DKJ_USE_KQUEUE=0"'
-          - release: 10.1
-            capnproto-cppflags: 'CPPFLAGS="-DKJ_NO_EXCEPTIONS=0"'
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Start NetBSD VM
-        uses: vmactions/netbsd-vm@v1
-        with:
-          release: ${{ matrix.release }}
-          # The installed compiler version must match the CXX variable
-          # defined in `ci/configs/netbsd.bash`.
-          prepare: |
-            pkg_add cmake ninja-build gcc14
-          # capnproto prerequisites.
-          # See the following "Install capnproto" step.
-          run: |
-            set -e
-            pkg_add digest libtool-base mktools pkgconf cwrappers
-            pkg_admin -K /usr/pkg/pkgdb fetch-pkg-vulnerabilities
-            cd /usr
-            cvs -danoncvs@anoncvs.NetBSD.org:/cvsroot checkout -P \
-              pkgsrc/devel/capnproto \
-              pkgsrc/devel/libtool-base \
-              pkgsrc/devel/pkgconf \
-              pkgsrc/devel/zlib \
-              `# gcc15 is referenced here because the pkgsrc framework requires lang/gcc15/version.mk to exist` \
-              `# during the "make install" step below, even though we compile our project with gcc14.` \
-              pkgsrc/lang/gcc15 \
-              pkgsrc/mk \
-              pkgsrc/pkgtools \
-              pkgsrc/security/openssl \
-              pkgsrc/sysutils/install-sh/files
-          sync: 'rsync'
-          copyback: false
-
-      - name: Install capnproto
-        run: |
-          cd /usr/pkgsrc/devel/capnproto/
-          unset PKG_PATH
-          make ${{ matrix.capnproto-cppflags }} install
-
-      - name: Run CI script
-        run: |
-          cd ${{ github.workspace }}
-          CI_CONFIG="ci/configs/netbsd.bash" bash ci/scripts/ci.sh
-
-  build-openbsd:
-    runs-on: ubuntu-latest
-    name: build • openbsd
-    defaults:
-      run:
-        shell: openbsd {0}
-    steps:
-      - uses: actions/checkout@v5
-
-      - name: Start OpenBSD VM
-        uses: vmactions/openbsd-vm@v1
-        with:
-          prepare: |
-            pkg_add -v cmake ninja bash capnproto
-          sync: 'rsync'
-          copyback: false
-
-      - name: Run CI script
-        run: |
-          cd ${{ github.workspace }}
-          CI_CONFIG="ci/configs/openbsd.bash" bash ci/scripts/ci.sh
-
-  build-freebsd:
-    runs-on: ubuntu-latest
-    name: build • freebsd
-    defaults:
-      run:
-        shell: freebsd {0}
-    steps:
-      - uses: actions/checkout@v5
-
-      - name: Start FreeBSD VM
-        uses: vmactions/freebsd-vm@v1
-        with:
-          prepare: |
-            pkg install -y cmake ninja bash capnproto
-          sync: 'rsync'
-          copyback: false
-
-      - name: Run CI script
-        run: |
-          cd ${{ github.workspace }}
-          CI_CONFIG="ci/configs/freebsd.bash" bash ci/scripts/ci.sh
-
-  build-macos:
-    runs-on: macos-latest
-    name: build • macos
-
-    steps:
-      - uses: actions/checkout@v5
-
-      - name: Install dependencies
-        env:
-          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: 1
-        run: |
-          brew install --quiet ninja capnp llvm
-
-      - name: Run CI script
-        run: |
-          export PATH="$(brew --prefix llvm)/bin:$PATH"
-          CI_CONFIG="ci/configs/macos.bash" bash ci/scripts/ci.sh
-
-  build:
-    runs-on: ubuntu-latest
-
-    env:
-      NIXPKGS_CHANNEL: nixos-25.05
-      NIX_EXTRA_CONFIG: |
-        keep-env-derivations = true
-        keep-outputs = true
-      NIX_EXTRA_CONFIG_ACT: |
-        sandbox = false
-        filter-syscalls = false
-
-    strategy:
-      fail-fast: false
-      matrix:
-        config: [default, llvm, gnu32, sanitize, olddeps]
-
-    name: build • ${{ matrix.config }}
-
-    steps:
-      - uses: actions/checkout@v5
-
-      - name: Determine CI configuration
-        id: config
-        env:
-          CI_CONFIG: ci/configs/${{ matrix.config }}.bash
-        run: ci/scripts/config.sh
-
-      - name: Install Nix
-        uses: cachix/install-nix-action@v31       # 2025-05-27, from https://github.com/cachix/install-nix-action/tags
-        with:
-          nix_path: nixpkgs=https://github.com/NixOS/nixpkgs/archive/${{ steps.config.outputs.nixpkgs_rev }}.tar.gz
-          # Act executes inside an unprivileged container (Docker or Podman),
-          # so KVM support isn't available.
-          enable_kvm: "${{ github.actor != 'nektos/act' }}"
-          extra_nix_config: |
-            ${{ env.NIX_EXTRA_CONFIG }}
-            ${{ github.actor == 'nektos/act' && env.NIX_EXTRA_CONFIG_ACT || '' }}
-
-      - name: Cache Nix store
-        if: steps.config.outputs.cache_nix_store == 'true'
-        uses: nix-community/cache-nix-action@v7
-        with:
-          primary-key: nix-${{ runner.os }}-${{ matrix.config }}-${{ steps.config.outputs.nixpkgs_rev }}-${{ hashFiles('shell.nix', 'ci/patches/*.patch', format('ci/configs/{0}.bash', matrix.config)) }}
-          restore-prefixes-first-match: |
-            nix-${{ runner.os }}-${{ matrix.config }}-${{ steps.config.outputs.nixpkgs_rev }}-
-            nix-${{ runner.os }}-${{ matrix.config }}-
-            nix-${{ runner.os }}-
-          gc-max-store-size-linux: 10G
-
-      - name: Run CI script
-        env:
-          CI_CONFIG: ci/configs/${{ matrix.config }}.bash
-        run: ci/scripts/run.sh
diff --git a/src/ipc/libmultiprocess/.gitignore b/src/ipc/libmultiprocess/.gitignore
deleted file mode 100644
index 30b4b7864881..000000000000
--- a/src/ipc/libmultiprocess/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-# CMake artifacts
-/*build*
-
-# Git artifacts
-*.patch
diff --git a/src/ipc/libmultiprocess/CMakeLists.txt b/src/ipc/libmultiprocess/CMakeLists.txt
deleted file mode 100644
index a36023b18101..000000000000
--- a/src/ipc/libmultiprocess/CMakeLists.txt
+++ /dev/null
@@ -1,264 +0,0 @@
-# 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.
-
-cmake_minimum_required(VERSION 3.12)
-
-project("Libmultiprocess" CXX)
-if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
-  set(CMAKE_CXX_STANDARD 20)
-  set(CMAKE_CXX_STANDARD_REQUIRED YES)
-endif()
-
-include("cmake/compat_find.cmake")
-
-find_package(Threads REQUIRED)
-find_package(CapnProto 0.7 QUIET NO_MODULE)
- if(NOT CapnProto_FOUND)
-   message(FATAL_ERROR
-     "Cap'n Proto is required but was not found.\n"
-     "To resolve, choose one of the following:\n"
-     "  - Install Cap'n Proto (version 1.0+ recommended)\n"
-     "  - For Bitcoin Core compilation build with -DENABLE_IPC=OFF to disable multiprocess support\n"
-   )
- endif()
-
-# Cap'n Proto compatibility checks
-set(CAPNPROTO_ISSUES "")
-set(CAPNPROTO_CVE_AFFECTED FALSE)
-set(CAPNPROTO_CLANG_INCOMPATIBLE FALSE)
-
-# Check for list-of-pointers memory access bug from Nov 2022
-# https://nvd.nist.gov/vuln/detail/CVE-2022-46149
-# https://github.com/advisories/GHSA-qqff-4vw4-f6hx
-# https://github.com/capnproto/capnproto/security/advisories/GHSA-qqff-4vw4-f6hx
-# https://github.com/capnproto/capnproto/blob/master/security-advisories/2022-11-30-0-pointer-list-bounds.md
-# https://capnproto.org/news/2022-11-30-CVE-2022-46149-security-advisory.html
-# https://dwrensha.github.io/capnproto-rust/2022/11/30/out_of_bounds_memory_access_bug.html
-if(CapnProto_VERSION STREQUAL "0.7.0"
-   OR CapnProto_VERSION STREQUAL "0.8.0"
-   OR CapnProto_VERSION STREQUAL "0.9.0"
-   OR CapnProto_VERSION STREQUAL "0.9.1"
-   OR CapnProto_VERSION STREQUAL "0.10.0"
-   OR CapnProto_VERSION STREQUAL "0.10.1"
-   OR CapnProto_VERSION STREQUAL "0.10.2")
-  set(CAPNPROTO_CVE_AFFECTED TRUE)
-  string(APPEND CAPNPROTO_ISSUES "- CVE-2022-46149 security vulnerability (details: https://github.com/advisories/GHSA-qqff-4vw4-f6hx)\n")
-endif()
-
-# Check for Cap'n Proto / Clang / C++20 incompatibility
-# Cap'n Proto 0.9.x and 0.10.x are incompatible with Clang 16+ when using C++20
-# due to P2468R2 implementation. This was fixed in Cap'n Proto 1.0+.
-# See: https://github.com/bitcoin-core/libmultiprocess/issues/199
-if((CapnProto_VERSION VERSION_GREATER_EQUAL "0.9.0") AND
-   (CapnProto_VERSION VERSION_LESS "1.0.0") AND
-   (CMAKE_CXX_COMPILER_ID STREQUAL "Clang") AND
-   (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "16") AND
-   (CMAKE_CXX_STANDARD EQUAL 20))
-  set(CAPNPROTO_CLANG_INCOMPATIBLE TRUE)
-  string(APPEND CAPNPROTO_ISSUES "- Incompatible with Clang ${CMAKE_CXX_COMPILER_VERSION} when using C++20\n")
-endif()
-
-if(CAPNPROTO_CVE_AFFECTED OR CAPNPROTO_CLANG_INCOMPATIBLE)
-  set(RESOLUTION_OPTIONS "")
-
-  # Fixes both issues
-  string(APPEND RESOLUTION_OPTIONS "  - Upgrade to Cap'n Proto version 1.0 or newer (recommended)\n")
-
-  if(CAPNPROTO_CVE_AFFECTED AND NOT CAPNPROTO_CLANG_INCOMPATIBLE)
-    string(APPEND RESOLUTION_OPTIONS "  - Upgrade to a patched minor version (0.7.1, 0.8.1, 0.9.2, 0.10.3, or later)\n")
-  elseif(CAPNPROTO_CLANG_INCOMPATIBLE AND NOT CAPNPROTO_CVE_AFFECTED)
-    string(APPEND RESOLUTION_OPTIONS "  - Use GCC instead of Clang\n")
-  endif()
-
-  string(APPEND RESOLUTION_OPTIONS "  - For Bitcoin Core compilation build with -DENABLE_IPC=OFF to disable multiprocess support\n")
-
-  message(FATAL_ERROR
-    "The version of Cap'n Proto detected: ${CapnProto_VERSION} has known compatibility issues:\n"
-    "${CAPNPROTO_ISSUES}"
-    "To resolve, choose one of the following:\n"
-    "${RESOLUTION_OPTIONS}"
-  )
-endif()
-
-set(MPGEN_EXECUTABLE "" CACHE FILEPATH "If specified, should be full path to an external mpgen binary to use rather than the one built internally.")
-
-option(MP_ENABLE_CLANG_TIDY "Run clang-tidy with the compiler." OFF)
-if(MP_ENABLE_CLANG_TIDY)
-  find_program(CLANG_TIDY_EXECUTABLE NAMES clang-tidy)
-  if(NOT CLANG_TIDY_EXECUTABLE)
-    message(FATAL_ERROR "MP_ENABLE_CLANG_TIDY is ON but clang-tidy is not found.")
-  endif()
-  set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_EXECUTABLE}")
-
-  # Workaround for nix from https://gitlab.kitware.com/cmake/cmake/-/issues/20912#note_793338
-  # Nix injects header paths via $NIX_CFLAGS_COMPILE; CMake tags these as
-  # CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES and omits them from the compile
-  # database, so clang-tidy, which ignores $NIX_CFLAGS_COMPILE, can't find capnp
-  # headers. Setting them as standard passes them to clang-tidy.
-  set(CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES ${CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES})
-endif()
-
-option(MP_ENABLE_IWYU "Run include-what-you-use with the compiler." OFF)
-if(MP_ENABLE_IWYU)
-  find_program(IWYU_EXECUTABLE NAMES include-what-you-use iwyu)
-  if(NOT IWYU_EXECUTABLE)
-    message(FATAL_ERROR "MP_ENABLE_IWYU is ON but include-what-you-use was not found.")
-  endif()
-  set(CMAKE_CXX_INCLUDE_WHAT_YOU_USE "${IWYU_EXECUTABLE};-Xiwyu;--error")
-  if(DEFINED ENV{IWYU_MAPPING_FILE})
-    list(APPEND CMAKE_CXX_INCLUDE_WHAT_YOU_USE "-Xiwyu" "--mapping_file=$ENV{IWYU_MAPPING_FILE}")
-  endif()
-endif()
-
-include("cmake/compat_config.cmake")
-include("cmake/pthread_checks.cmake")
-include(GNUInstallDirs)
-
-# Set MP_INCLUDE_DIR as a global property so target_capnp_sources function can
-# use it, and its callers don't need to specify the include directory manually
-# to avoid "error: Import failed: /mp/proxy.capnp" failures from capnproto.
-set_property(GLOBAL PROPERTY MP_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
-
-# Set a convenience variable for subdirectories.
-if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
-  set(MP_STANDALONE TRUE)
-  include(CTest)
-else()
-  set(MP_STANDALONE FALSE)
-endif()
-
-# Prevent include directories from parent project from leaking into this one.
-set_property(DIRECTORY PROPERTY INCLUDE_DIRECTORIES "")
-
-# Generated C++ preprocessor defines
-configure_file(include/mp/config.h.in "${CMAKE_CURRENT_BINARY_DIR}/include/mp/config.h")
-
-# Generated C++ Capn'Proto schema files
-capnp_generate_cpp(MP_PROXY_SRCS MP_PROXY_HDRS include/mp/proxy.capnp)
-set_source_files_properties("${MP_PROXY_SRCS}" PROPERTIES SKIP_LINTING TRUE) # Ignored before cmake 3.27
-
-# util library
-add_library(mputil OBJECT src/mp/util.cpp)
-target_include_directories(mputil PRIVATE
-  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-  $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>)
-target_link_libraries(mputil PUBLIC CapnProto::kj)
-
-# libmultiprocess.a runtime library
-set(MP_PUBLIC_HEADERS
-  ${MP_PROXY_HDRS}
-  include/mp/proxy-io.h
-  include/mp/proxy-types.h
-  include/mp/proxy.h
-  include/mp/type-char.h
-  include/mp/type-chrono.h
-  include/mp/type-context.h
-  include/mp/type-data.h
-  include/mp/type-decay.h
-  include/mp/type-exception.h
-  include/mp/type-function.h
-  include/mp/type-interface.h
-  include/mp/type-map.h
-  include/mp/type-message.h
-  include/mp/type-number.h
-  include/mp/type-optional.h
-  include/mp/type-pair.h
-  include/mp/type-pointer.h
-  include/mp/type-set.h
-  include/mp/type-string.h
-  include/mp/type-struct.h
-  include/mp/type-threadmap.h
-  include/mp/type-tuple.h
-  include/mp/type-vector.h
-  include/mp/type-void.h
-  include/mp/util.h)
-add_library(multiprocess STATIC
-  ${MP_PROXY_SRCS}
-  ${MP_PUBLIC_HEADERS}
-  src/mp/proxy.cpp
-  $<TARGET_OBJECTS:mputil>)
-add_library(Libmultiprocess::multiprocess ALIAS multiprocess)
-target_include_directories(multiprocess PUBLIC
-  $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
-  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-  $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
-target_link_libraries(multiprocess PUBLIC CapnProto::capnp)
-target_link_libraries(multiprocess PUBLIC CapnProto::capnp-rpc)
-target_link_libraries(multiprocess PUBLIC CapnProto::kj)
-target_link_libraries(multiprocess PUBLIC CapnProto::kj-async)
-set_target_properties(multiprocess PROPERTIES
-    PUBLIC_HEADER "${MP_PUBLIC_HEADERS}")
-install(TARGETS multiprocess EXPORT LibTargets
-  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT lib
-  PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/mp COMPONENT lib)
-
-# mpgen code generator
-add_executable(mpgen src/mp/gen.cpp $<TARGET_OBJECTS:mputil>)
-add_executable(Libmultiprocess::mpgen ALIAS mpgen)
-target_include_directories(mpgen PRIVATE $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>)
-target_include_directories(mpgen PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include> $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
-target_link_libraries(mpgen PRIVATE CapnProto::capnp)
-target_link_libraries(mpgen PRIVATE CapnProto::capnp-rpc)
-target_link_libraries(mpgen PRIVATE CapnProto::capnpc)
-target_link_libraries(mpgen PRIVATE CapnProto::kj)
-target_link_libraries(mpgen PRIVATE Threads::Threads)
-set_target_properties(mpgen PROPERTIES
-    INSTALL_RPATH_USE_LINK_PATH TRUE)
-set_target_properties(mpgen PROPERTIES
-    PUBLIC_HEADER include/mp/proxy.capnp)
-install(TARGETS mpgen EXPORT BinTargets
-  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT bin
-  PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/mp COMPONENT bin)
-
-# makefile include to invoke mpgen code generator, for downstream Make projects
-install(FILES "include/mpgen.mk"
-  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} COMPONENT bin)
-
-# pkg-config module to build against libmultiprocess library, for downstream autoconf projects
-configure_file(pkgconfig/libmultiprocess.pc.in "${CMAKE_CURRENT_BINARY_DIR}/pkgconfig/libmultiprocess.pc" @ONLY)
-install(FILES "${CMAKE_CURRENT_BINARY_DIR}/pkgconfig/libmultiprocess.pc"
-  DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig COMPONENT lib)
-
-# cmake include to invoke mpgen code generator, for downstream CMake projects
-install(
-  FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/cmake/TargetCapnpSources.cmake
-  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Libmultiprocess COMPONENT bin)
-
-# CMake target import files, for downstream CMake projects
-install(EXPORT BinTargets
-  NAMESPACE Libmultiprocess::
-  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Libmultiprocess COMPONENT bin)
-install(EXPORT LibTargets
-  NAMESPACE Libmultiprocess::
-  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Libmultiprocess COMPONENT lib)
-
-# CMake find_package config file, for downstream CMake projects
-include(CMakePackageConfigHelpers)
-configure_package_config_file(
-  ${PROJECT_SOURCE_DIR}/cmake/Config.cmake.in
-  LibmultiprocessConfig.cmake
-  INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Libmultiprocess
-  NO_SET_AND_CHECK_MACRO)
-install(
-  FILES
-    ${CMAKE_CURRENT_BINARY_DIR}/LibmultiprocessConfig.cmake
-  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Libmultiprocess
-  COMPONENT common)
-
-# Makefile targets to support "make install-bin" "make install-lib"
-add_custom_target(install-bin
-  COMMAND ${CMAKE_COMMAND} -DCOMPONENT=bin -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_install.cmake
-  COMMAND ${CMAKE_COMMAND} -DCOMPONENT=common -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_install.cmake
-  VERBATIM)
-add_dependencies(install-bin mpgen)
-add_custom_target(install-lib
-  COMMAND ${CMAKE_COMMAND} -DCOMPONENT=lib -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_install.cmake
-  COMMAND ${CMAKE_COMMAND} -DCOMPONENT=common -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_install.cmake
-  VERBATIM)
-add_dependencies(install-lib multiprocess)
-
-# Example and test subdirectories
-add_subdirectory(example EXCLUDE_FROM_ALL)
-add_subdirectory(test EXCLUDE_FROM_ALL)
diff --git a/src/ipc/libmultiprocess/COPYING b/src/ipc/libmultiprocess/COPYING
deleted file mode 100644
index 9d54ecbde122..000000000000
--- a/src/ipc/libmultiprocess/COPYING
+++ /dev/null
@@ -1,22 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2009-2019 The Bitcoin Core developers
-Copyright (c) 2009-2019 Bitcoin Developers
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/src/ipc/libmultiprocess/README.md b/src/ipc/libmultiprocess/README.md
deleted file mode 100644
index 9a6e65795b3f..000000000000
--- a/src/ipc/libmultiprocess/README.md
+++ /dev/null
@@ -1,8 +0,0 @@
-# libmultiprocess
-
-`libmultiprocess` is a C++ library and code generator making it easy to call functions and reference objects in different processes.
-
-For more information see the [usage instructions](doc/usage.md), [installation instructions](doc/install.md), or [design documentation](doc/design.md).
-
-If you have any questions, comments, or feedback, please submit an [issue](https://github.com/bitcoin-core/libmultiprocess/issues/new).
-Duplicate issues are perfectly fine and all discussion about the project is welcome, since there isn't another discussion forum currently.
diff --git a/src/ipc/libmultiprocess/ci/README.md b/src/ipc/libmultiprocess/ci/README.md
deleted file mode 100644
index fef1c022b5c8..000000000000
--- a/src/ipc/libmultiprocess/ci/README.md
+++ /dev/null
@@ -1,52 +0,0 @@
-### CI quick-reference
-
-All CI is just bash and nix.
-
-* **Workflow**:
-  -  `.github/workflows/ci.yml` – lists the jobs (`default`, `llvm`, …).
-* **Scripts**:
-  - `ci/scripts/run.sh` – spins up the Nix shell then calls…
-  - `ci/scripts/ci.sh` – …to configure, build, and test.
-* **Configuration**:
-  - `ci/configs/*.sh` – defines flags for each job.
-  - `shell.nix` – defines build environment (compilers, tools, libraries).
-* **Build directories**:
-  - `build-*/` – separate build directories (like `build-default`, `build-llvm`) will be created for each job.
-
-To run jobs locally:
-
-```bash
-CI_CONFIG=ci/configs/default.bash  ci/scripts/run.sh
-CI_CONFIG=ci/configs/llvm.bash     ci/scripts/run.sh
-CI_CONFIG=ci/configs/gnu32.bash    ci/scripts/run.sh
-CI_CONFIG=ci/configs/sanitize.bash ci/scripts/run.sh
-CI_CONFIG=ci/configs/olddeps.bash  ci/scripts/run.sh
-```
-
-By default CI jobs will reuse their build directories. `CI_CLEAN=1` can be specified to delete them before running instead.
-
-### Running workflows with `act`
-
-You can run either the entire workflow or a single matrix entry locally. On
-macOS or Linux:
-
-1. Install [`act`](https://github.com/nektos/act) and either Docker or
-  Podman.
-2. Inside the Podman VM, create a named volume for the Nix store (ext4,
-  case-sensitive) so builds persist across runs. Recreate it any time you want
-  a clean cache:
-  ```bash
-  podman volume create libmultiprocess-nix
-  ```
-3. From the repo root, launch the workflow. The example below targets the
-  sanitize matrix entry; drop the `--matrix` flag to run every configuration.
-  ```bash
-  act \
-    --reuse \
-    -P ubuntu-latest=ghcr.io/catthehacker/ubuntu:act-24.04 \
-    --container-options "-v libmultiprocess-nix:/nix" \
-    -j build \
-    --matrix config:sanitize
-  ```
-
-
diff --git a/src/ipc/libmultiprocess/ci/configs/default.bash b/src/ipc/libmultiprocess/ci/configs/default.bash
deleted file mode 100644
index 56231228d4f3..000000000000
--- a/src/ipc/libmultiprocess/ci/configs/default.bash
+++ /dev/null
@@ -1,5 +0,0 @@
-CI_DESC="CI job using default libraries and tools, and running IWYU"
-CI_DIR=build-default
-export CXXFLAGS="-Werror -Wall -Wextra -Wpedantic -Wno-unused-parameter"
-CMAKE_ARGS=(-DMP_ENABLE_IWYU=ON)
-BUILD_ARGS=(-k)
diff --git a/src/ipc/libmultiprocess/ci/configs/freebsd.bash b/src/ipc/libmultiprocess/ci/configs/freebsd.bash
deleted file mode 100644
index 017f2186653e..000000000000
--- a/src/ipc/libmultiprocess/ci/configs/freebsd.bash
+++ /dev/null
@@ -1,5 +0,0 @@
-CI_DESC="CI config for FreeBSD"
-CI_DIR=build-freebsd
-export CXXFLAGS="-Werror -Wall -Wextra -Wpedantic -Wno-unused-parameter"
-CMAKE_ARGS=(-G Ninja)
-BUILD_ARGS=(-k 0)
diff --git a/src/ipc/libmultiprocess/ci/configs/gnu32.bash b/src/ipc/libmultiprocess/ci/configs/gnu32.bash
deleted file mode 100644
index 04d78a24fc5c..000000000000
--- a/src/ipc/libmultiprocess/ci/configs/gnu32.bash
+++ /dev/null
@@ -1,11 +0,0 @@
-CI_DESC="CI job cross-compiling to 32-bit"
-CI_DIR=build-gnu32
-# Cache the heaviest Nix job to stay within GitHub's cache budget.
-CI_CACHE_NIX_STORE=true
-NIX_ARGS=(
-  --arg minimal true
-  --arg crossPkgs 'import <nixpkgs> { crossSystem = { config = "i686-unknown-linux-gnu"; }; }'
-)
-export CXXFLAGS="-Werror -Wall -Wextra -Wpedantic -Wno-unused-parameter"
-CMAKE_ARGS=(-G Ninja)
-BUILD_ARGS=(-k 0)
diff --git a/src/ipc/libmultiprocess/ci/configs/llvm.bash b/src/ipc/libmultiprocess/ci/configs/llvm.bash
deleted file mode 100644
index ba34cbf467bb..000000000000
--- a/src/ipc/libmultiprocess/ci/configs/llvm.bash
+++ /dev/null
@@ -1,11 +0,0 @@
-CI_DESC="CI job using LLVM-based libraries and tools (clang, libc++, clang-tidy, iwyu) and testing Ninja"
-CI_DIR=build-llvm
-NIX_ARGS=(--arg enableLibcxx true)
-export CXX=clang++
-export CXXFLAGS="-Werror -Wall -Wextra -Wpedantic -Wthread-safety -Wno-unused-parameter"
-CMAKE_ARGS=(
-  -G Ninja
-  -DMP_ENABLE_CLANG_TIDY=ON
-  -DMP_ENABLE_IWYU=ON
-)
-BUILD_ARGS=(-k 0)
diff --git a/src/ipc/libmultiprocess/ci/configs/macos.bash b/src/ipc/libmultiprocess/ci/configs/macos.bash
deleted file mode 100644
index 895d795f8912..000000000000
--- a/src/ipc/libmultiprocess/ci/configs/macos.bash
+++ /dev/null
@@ -1,5 +0,0 @@
-CI_DESC="CI config for macOS"
-CI_DIR=build-macos
-export CXXFLAGS="-Werror -Wall -Wextra -Wpedantic -Wno-unused-parameter"
-CMAKE_ARGS=(-G Ninja -DMP_ENABLE_CLANG_TIDY=ON)
-BUILD_ARGS=(-k 0)
diff --git a/src/ipc/libmultiprocess/ci/configs/netbsd.bash b/src/ipc/libmultiprocess/ci/configs/netbsd.bash
deleted file mode 100644
index c3e7d258e685..000000000000
--- a/src/ipc/libmultiprocess/ci/configs/netbsd.bash
+++ /dev/null
@@ -1,11 +0,0 @@
-CI_DESC="CI config for NetBSD"
-CI_DIR=build-netbsd
-export CXXFLAGS="-Werror -Wall -Wextra -Wpedantic -Wno-unused-parameter"
-# Hardcode GCC 14, since default GCC versions installed by NetBSD are older
-# and may not be compatible with libmultiprocess. GCC 14 was chosen because
-# it's the latest compiler available on all versions of NetBSD that we test.
-# Note that the GCC version specified here must match the version specified
-# in pkg_add in ci.yml.
-export CXX="/usr/pkg/gcc14/bin/g++"
-CMAKE_ARGS=(-G Ninja)
-BUILD_ARGS=(-k 0)
diff --git a/src/ipc/libmultiprocess/ci/configs/olddeps.bash b/src/ipc/libmultiprocess/ci/configs/olddeps.bash
deleted file mode 100644
index 95f44128d90c..000000000000
--- a/src/ipc/libmultiprocess/ci/configs/olddeps.bash
+++ /dev/null
@@ -1,5 +0,0 @@
-CI_DESC="CI job using old Cap'n Proto and cmake versions"
-CI_DIR=build-olddeps
-export CXXFLAGS="-Werror -Wall -Wextra -Wpedantic -Wno-unused-parameter -Wno-error=array-bounds"
-NIX_ARGS=(--argstr capnprotoVersion "0.7.1" --argstr cmakeVersion "3.12.4")
-BUILD_ARGS=(-k)
diff --git a/src/ipc/libmultiprocess/ci/configs/openbsd.bash b/src/ipc/libmultiprocess/ci/configs/openbsd.bash
deleted file mode 100644
index a404e2bc630a..000000000000
--- a/src/ipc/libmultiprocess/ci/configs/openbsd.bash
+++ /dev/null
@@ -1,5 +0,0 @@
-CI_DESC="CI config for OpenBSD"
-CI_DIR=build-openbsd
-export CXXFLAGS="-Werror -Wall -Wextra -Wpedantic -Wno-unused-parameter"
-CMAKE_ARGS=(-G Ninja)
-BUILD_ARGS=(-k 0)
diff --git a/src/ipc/libmultiprocess/ci/configs/sanitize.bash b/src/ipc/libmultiprocess/ci/configs/sanitize.bash
deleted file mode 100644
index 0375fd3ab2d2..000000000000
--- a/src/ipc/libmultiprocess/ci/configs/sanitize.bash
+++ /dev/null
@@ -1,8 +0,0 @@
-CI_DESC="CI job running ThreadSanitizer"
-CI_DIR=build-sanitize
-NIX_ARGS=(--arg enableLibcxx true --argstr libcxxSanitizers "Thread" --argstr capnprotoSanitizers "thread")
-export CXX=clang++
-export CXXFLAGS="-ggdb -Werror -Wall -Wextra -Wpedantic -Wthread-safety -Wno-unused-parameter -fsanitize=thread"
-CMAKE_ARGS=()
-BUILD_ARGS=(-k -j4)
-BUILD_TARGETS=(mptest)
diff --git a/src/ipc/libmultiprocess/ci/patches/spaceship.patch b/src/ipc/libmultiprocess/ci/patches/spaceship.patch
deleted file mode 100644
index 08a885ddf0ab..000000000000
--- a/src/ipc/libmultiprocess/ci/patches/spaceship.patch
+++ /dev/null
@@ -1,29 +0,0 @@
-commit e3da7da967b94f373c29a198ce45f30fb9f0e517
-Author: Ed Catmur <ed@catmur.uk>
-Date:   Tue Jan 31 16:27:04 2023 +0000
-
-    Remove operator!= synthesized by spaceship
-    
-    An operator!= suppresses the reversed equality comparison candidate generation.
-    
-    This is visible in clang 16 (rc0 just released) and in gcc trunk (so probably gcc 13).
-
-diff --git a/c++/src/kj/string.h b/c++/src/kj/string.h
-index 193442aa..17835892 100644
---- a/c++/src/kj/string.h
-+++ b/c++/src/kj/string.h
-@@ -122,10 +122,14 @@ public:
-   inline constexpr const char* end() const { return content.end() - 1; }
- 
-   inline constexpr bool operator==(decltype(nullptr)) const { return content.size() <= 1; }
-+#if !__cpp_impl_three_way_comparison
-   inline constexpr bool operator!=(decltype(nullptr)) const { return content.size() > 1; }
-+#endif
- 
-   inline bool operator==(const StringPtr& other) const;
-+#if !__cpp_impl_three_way_comparison
-   inline bool operator!=(const StringPtr& other) const { return !(*this == other); }
-+#endif
-   inline bool operator< (const StringPtr& other) const;
-   inline bool operator> (const StringPtr& other) const { return other < *this; }
-   inline bool operator<=(const StringPtr& other) const { return !(other < *this); }
diff --git a/src/ipc/libmultiprocess/ci/scripts/bitcoin_core_ci.sh b/src/ipc/libmultiprocess/ci/scripts/bitcoin_core_ci.sh
deleted file mode 100755
index d4998b00e124..000000000000
--- a/src/ipc/libmultiprocess/ci/scripts/bitcoin_core_ci.sh
+++ /dev/null
@@ -1,152 +0,0 @@
-#!/usr/bin/env bash
-
-export LC_ALL=C
-
-set -o errexit -o nounset -o pipefail -o xtrace
-
-readonly SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
-
-source "${SCRIPT_DIR}/ci_helpers.sh"
-
-replace_subtree() {
-  rm -rf src/ipc/libmultiprocess
-  cp -a _libmultiprocess src/ipc/libmultiprocess
-  rm -rf src/ipc/libmultiprocess/.git
-}
-
-add_llvm_apt_repository() {
-  curl -s "https://apt.llvm.org/llvm-snapshot.gpg.key" | sudo tee "/etc/apt/trusted.gpg.d/apt.llvm.org.asc" > /dev/null
-  source /etc/os-release
-  echo "deb http://apt.llvm.org/${VERSION_CODENAME}/ llvm-toolchain-${VERSION_CODENAME}-${LLVM_VERSION} main" | sudo tee "/etc/apt/sources.list.d/llvm.list"
-  sudo apt-get update
-}
-
-install_llvm_alternatives() {
-  sudo update-alternatives --install /usr/bin/clang++ clang++ "/usr/bin/clang++-${LLVM_VERSION}" 100
-  sudo update-alternatives --install /usr/bin/clang clang "/usr/bin/clang-${LLVM_VERSION}" 100
-  sudo update-alternatives --install /usr/bin/llvm-symbolizer llvm-symbolizer "/usr/bin/llvm-symbolizer-${LLVM_VERSION}" 100
-}
-
-set_llvm_alternatives() {
-  sudo update-alternatives --set clang "/usr/bin/clang-${LLVM_VERSION}"
-  sudo update-alternatives --set clang++ "/usr/bin/clang++-${LLVM_VERSION}"
-  sudo update-alternatives --set llvm-symbolizer "/usr/bin/llvm-symbolizer-${LLVM_VERSION}"
-}
-
-install_tsan_packages() {
-  install_apt_packages \
-    ccache \
-    "clang-${LLVM_VERSION}" \
-    "llvm-${LLVM_VERSION}" \
-    "llvm-${LLVM_VERSION}-dev" \
-    "libclang-${LLVM_VERSION}-dev" \
-    "libclang-rt-${LLVM_VERSION}-dev" \
-    ninja-build \
-    pkgconf \
-    python3-pip \
-    bison
-  install_llvm_alternatives
-  set_llvm_alternatives
-  install_pip_packages --break-system-packages pycapnp
-}
-
-build_instrumented_libcxx() {
-  export PATH="/usr/lib/llvm-${LLVM_VERSION}/bin:${PATH}"
-
-  ls -l /usr/bin/clang /usr/bin/clang++ /usr/bin/llvm-symbolizer
-  which clang clang++ llvm-symbolizer
-  clang --version
-  clang++ --version
-  "/usr/bin/clang-${LLVM_VERSION}" --version
-  "/usr/bin/clang++-${LLVM_VERSION}" --version
-  git clone --depth=1 https://github.com/llvm/llvm-project -b "llvmorg-${LLVM_VERSION}.1.0" /tmp/llvm-project
-  cmake -G Ninja -B "${LIBCXX_DIR}" \
-    -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi;libunwind" \
-    -DCMAKE_BUILD_TYPE=Release \
-    -DLLVM_USE_SANITIZER=Thread \
-    -DCMAKE_C_COMPILER="/usr/bin/clang-${LLVM_VERSION}" \
-    -DCMAKE_CXX_COMPILER="/usr/bin/clang++-${LLVM_VERSION}" \
-    -DLLVM_TARGETS_TO_BUILD=Native \
-    -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=OFF \
-    -DLIBCXX_INCLUDE_TESTS=OFF \
-    -DLIBCXXABI_INCLUDE_TESTS=OFF \
-    -DLIBUNWIND_INCLUDE_TESTS=OFF \
-    -DLIBCXXABI_USE_LLVM_UNWINDER=OFF \
-    -S /tmp/llvm-project/runtimes
-  grep -E 'CMAKE_(C|CXX)_COMPILER' "${LIBCXX_DIR}/CMakeCache.txt"
-  ninja -C "${LIBCXX_DIR}" -j "${BUILD_PARALLEL}" -v
-  rm -rf /tmp/llvm-project
-}
-
-configure_bitcoin_core() {
-  local cmake_arg
-  local cmake_args=()
-
-  if [[ -n "${BITCOIN_CORE_CMAKE_ARGS:-}" ]]; then
-    while IFS= read -r cmake_arg; do
-      [[ -n "${cmake_arg}" ]] || continue
-      cmake_args+=("${cmake_arg}")
-    done <<< "${BITCOIN_CORE_CMAKE_ARGS}"
-  fi
-
-  cmake -S . -B build \
-    --preset=dev-mode \
-    -DCMAKE_BUILD_TYPE=Debug \
-    -DWITH_ZMQ=OFF \
-    -DWITH_USDT=OFF \
-    -DBUILD_BENCH=OFF \
-    -DBUILD_FUZZ_BINARY=OFF \
-    -G Ninja \
-    "${cmake_args[@]}"
-}
-
-build_bitcoin_core() {
-  cmake --build build --parallel "${BUILD_PARALLEL}"
-}
-
-build_depends_without_ipc() {
-  make -C depends -j "${BUILD_PARALLEL}" \
-    CC=clang \
-    CXX=clang++ \
-    CXXFLAGS="${LIBCXX_FLAGS}" \
-    NO_ZMQ=1 \
-    NO_USDT=1 \
-    NO_IPC=1
-}
-
-build_depends_with_ipc() {
-  make -C depends -j "${BUILD_PARALLEL}" \
-    CC=clang \
-    CXX=clang++ \
-    CXXFLAGS="${LIBCXX_FLAGS}" \
-    NO_ZMQ=1 \
-    NO_USDT=1
-}
-
-run_ipc_unit_tests() {
-  local runs="$1"
-
-  for _ in $(seq 1 "${runs}"); do
-    build/bin/test_bitcoin --run_test=ipc_tests,miner_tests --catch_system_error=no --log_level=nothing --report_level=no
-  done
-}
-
-
-main() {
-  local command="${1:?missing command}"
-  shift
-
-  [[ "${command}" =~ ^[a-z_][a-z0-9_]*$ ]] || {
-    echo "Invalid command: ${command}" >&2
-    exit 1
-  }
-
-  if declare -F "${command}" >/dev/null; then
-    "${command}" "$@"
-  else
-    echo "Unknown command: ${command}" >&2
-    exit 1
-  fi
-}
-
-main "$@"
diff --git a/src/ipc/libmultiprocess/ci/scripts/ci.sh b/src/ipc/libmultiprocess/ci/scripts/ci.sh
deleted file mode 100755
index d989e9f45969..000000000000
--- a/src/ipc/libmultiprocess/ci/scripts/ci.sh
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/usr/bin/env bash
-#
-# 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.
-
-export LC_ALL=C.UTF-8
-
-set -o errexit -o nounset -o pipefail -o xtrace
-
-[ "${CI_CONFIG+x}" ] && source "$CI_CONFIG"
-
-: "${CI_DIR:=build}"
-if ! [ -v BUILD_TARGETS ]; then
-  BUILD_TARGETS=(all tests mpexamples)
-fi
-
-[ -n "${CI_CLEAN-}" ] && rm -rf "${CI_DIR}"
-
-cmake --version
-cmake_ver=$(cmake --version | awk '/version/{print $3; exit}')
-ver_ge() { [ "$(printf '%s\n' "$2" "$1" | sort -V | head -n1)" = "$2" ]; }
-
-src_dir=$PWD
-mkdir -p "$CI_DIR"
-cd "$CI_DIR"
-cmake "$src_dir" "${CMAKE_ARGS[@]+"${CMAKE_ARGS[@]}"}"
-if ver_ge "$cmake_ver" "3.15"; then
-  cmake --build . -t "${BUILD_TARGETS[@]}" -- "${BUILD_ARGS[@]+"${BUILD_ARGS[@]}"}"
-else
-  # Older versions of cmake can only build one target at a time with --target,
-  # and do not support -t shortcut
-  for t in "${BUILD_TARGETS[@]}"; do
-    cmake --build . --target "$t" -- "${BUILD_ARGS[@]+"${BUILD_ARGS[@]}"}"
-  done
-fi
-ctest --output-on-failure
diff --git a/src/ipc/libmultiprocess/ci/scripts/ci_helpers.sh b/src/ipc/libmultiprocess/ci/scripts/ci_helpers.sh
deleted file mode 100755
index 1b6d0121969e..000000000000
--- a/src/ipc/libmultiprocess/ci/scripts/ci_helpers.sh
+++ /dev/null
@@ -1,94 +0,0 @@
-#!/usr/bin/env bash
-
-export LC_ALL=C
-
-set -o errexit -o nounset -o pipefail -o xtrace
-
-write_env_var() {
-  local key="$1"
-  local value="$2"
-
-  if [[ -n "${GITHUB_ENV:-}" ]]; then
-    echo "${key}=${value}" >> "${GITHUB_ENV}"
-  else
-    export "${key}=${value}"
-  fi
-}
-
-write_output_var() {
-  local key="$1"
-  local value="$2"
-
-  if [[ -n "${GITHUB_OUTPUT:-}" ]]; then
-    echo "${key}=${value}" >> "${GITHUB_OUTPUT}"
-  else
-    echo "${key}=${value}"
-  fi
-}
-
-available_nproc() {
-  if command -v nproc >/dev/null 2>&1; then
-    nproc
-  else
-    sysctl -n hw.logicalcpu
-  fi
-}
-
-determine_parallelism() {
-  local multiplier="$1"
-  local available
-
-  available="$(available_nproc)"
-  write_env_var BUILD_PARALLEL "${available}"
-  write_env_var PARALLEL "$((available * multiplier))"
-}
-
-reset_ccache_stats() {
-  which ccache
-  ccache --version
-  ccache --zero-stats
-}
-
-show_ccache_stats() {
-  ccache --show-stats
-}
-
-install_apt_packages() {
-  sudo apt-get install --no-install-recommends -y "$@"
-}
-
-install_homebrew_packages() {
-  HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 brew install --quiet "$@"
-}
-
-install_pip_packages() {
-  pip3 install "$@"
-}
-
-determine_host() {
-  local config_guess="${1:-./depends/config.guess}"
-  local output_key="${2:-host}"
-
-  write_output_var "${output_key}" "$("${config_guess}")"
-}
-
-ci_helpers_main() {
-  local command="${1:?missing command}"
-  shift
-
-  [[ "${command}" =~ ^[a-z_][a-z0-9_]*$ ]] || {
-    echo "Invalid command: ${command}" >&2
-    exit 1
-  }
-
-  if declare -F "${command}" >/dev/null; then
-    "${command}" "$@"
-  else
-    echo "Unknown command: ${command}" >&2
-    exit 1
-  fi
-}
-
-if [[ "${BASH_SOURCE[0]}" == "$0" ]]; then
-  ci_helpers_main "$@"
-fi
diff --git a/src/ipc/libmultiprocess/ci/scripts/config.sh b/src/ipc/libmultiprocess/ci/scripts/config.sh
deleted file mode 100755
index 7fe8118d7bee..000000000000
--- a/src/ipc/libmultiprocess/ci/scripts/config.sh
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/usr/bin/env bash
-#
-# 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.
-#
-# Source CI configuration and output variables needed by the workflow.
-
-export LC_ALL=C
-
-set -o errexit -o nounset -o pipefail -o xtrace
-
-readonly SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
-
-source "${SCRIPT_DIR}/ci_helpers.sh"
-
-[ "${CI_CONFIG+x}" ] && source "$CI_CONFIG"
-
-# Resolve the nixpkgs channel to a specific revision for use in cache keys.
-if [[ -n "${NIXPKGS_CHANNEL:-}" ]]; then
-  rev="$(curl --fail --location --silent --show-error "https://channels.nixos.org/${NIXPKGS_CHANNEL}/git-revision")"
-  test -n "${rev}"
-  write_output_var nixpkgs_rev "${rev}"
-fi
-
-write_output_var cache_nix_store "${CI_CACHE_NIX_STORE:-false}"
diff --git a/src/ipc/libmultiprocess/ci/scripts/run.sh b/src/ipc/libmultiprocess/ci/scripts/run.sh
deleted file mode 100755
index 04ac8596d490..000000000000
--- a/src/ipc/libmultiprocess/ci/scripts/run.sh
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/usr/bin/env bash
-#
-# 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.
-
-export LC_ALL=C.UTF-8
-
-set -o errexit -o nounset -o pipefail -o xtrace
-
-[ "${CI_CONFIG+x}" ] && source "$CI_CONFIG"
-
-nix develop --ignore-environment --keep CI_CONFIG --keep CI_CLEAN "${NIX_ARGS[@]+"${NIX_ARGS[@]}"}" -f shell.nix --command ci/scripts/ci.sh
-
-# Create a GC root for the shell closure so the cache-nix-action save step
-# does not garbage-collect it.
-if [ -n "${CI_CACHE_NIX_STORE-}" ]; then
-  nix-build shell.nix \
-    -o "$CI_DIR/gcroot" \
-    "${NIX_ARGS[@]+"${NIX_ARGS[@]}"}"
-  # Verify the closure is complete so the cache-nix-action save step has
-  # everything it needs.
-  nix-store --query --requisites "$CI_DIR/gcroot" >/dev/null
-fi
diff --git a/src/ipc/libmultiprocess/cmake/Config.cmake.in b/src/ipc/libmultiprocess/cmake/Config.cmake.in
deleted file mode 100644
index 60187f08f4d4..000000000000
--- a/src/ipc/libmultiprocess/cmake/Config.cmake.in
+++ /dev/null
@@ -1,33 +0,0 @@
-@PACKAGE_INIT@
-
-# CMake find_package compatible package file, for downstream CMake projects
-#
-# Based on https://cmake.org/cmake/help/latest/guide/importing-exporting/index.html#adding-components
-
-set(_Libmultiprocess_supported_components Bin Lib)
-
-# If no components specified, include all components.
-list(LENGTH ${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS ${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS_len)
-if(${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS_len EQUAL 0)
-  set(${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS ${_Libmultiprocess_supported_components})
-endif()
-
-if ("Bin" IN_LIST ${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS)
-  include("${CMAKE_CURRENT_LIST_DIR}/TargetCapnpSources.cmake")
-endif()
-
-if ("Lib" IN_LIST ${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS)
-  # Setting FOUND_LIBATOMIC is needed on Debian & Ubuntu systems to work around bug in
-  # their capnproto packages. See compat_find.cmake for a more complete explanation.
-  set(FOUND_LIBATOMIC TRUE)
-  include(CMakeFindDependencyMacro)
-  find_dependency(CapnProto)
-endif()
-
-foreach(_comp ${${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS})
-  if (NOT _comp IN_LIST _Libmultiprocess_supported_components)
-    set(${CMAKE_FIND_PACKAGE_NAME}_FOUND False)
-    set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "Unsupported component: ${_comp}")
-  endif()
-  include("${CMAKE_CURRENT_LIST_DIR}/${_comp}Targets.cmake")
-endforeach()
diff --git a/src/ipc/libmultiprocess/cmake/TargetCapnpSources.cmake b/src/ipc/libmultiprocess/cmake/TargetCapnpSources.cmake
deleted file mode 100644
index abcca70f94ec..000000000000
--- a/src/ipc/libmultiprocess/cmake/TargetCapnpSources.cmake
+++ /dev/null
@@ -1,120 +0,0 @@
-# Copyright (c) 2024-present The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or https://opensource.org/license/mit/.
-
-#[=[
-
-target_capnp_sources
---------------------
-
-This function adds build steps to generate C++ files from Cap'n Proto files
-and build them as part of a specified target.
-
-Arguments:
-
-  target: The name of the CMake target (e.g., a library or executable) to
-    which the generated source files will be added. This target must already
-    be defined elsewhere in the CMake scripts.
-
-  include_prefix: Absolute path indicating what portion of capnp source paths
-    should be used in relative #include statements in the generated C++
-    files. For example, if the .capnp path is /home/src/lib/schema.capnp
-    and include_prefix is /home/src, generated includes look like:
-
-      #include <lib/schema.capnp.h>
-
-    And if include_prefix is /home/src/lib, generated includes look like:
-
-      #include <schema.capnp.h>
-
-    The specified include_prefix should be ${CMAKE_SOURCE_DIR} or a
-    subdirectory of it to include files relative to the project root. It can
-    be ${CMAKE_CURRENT_SOURCE_DIR} to include files relative to the current
-    source directory.
-
-Additional Unnamed Arguments:
-
-  After `target` and `include_prefix`, all unnamed arguments are treated as
-  paths to `.capnp` schema files. These should be paths relative to
-  ${CMAKE_CURRENT_SOURCE_DIR}.
-
-Optional Keyword Arguments:
-
-  IMPORT_PATHS: Specifies additional directories to search for imported
-    `.capnp` files.
-
-Example:
-  # Assuming `my_library` is a target and `lib/` contains `.capnp` schema
-  # files with imports from `include/`.
-  target_capnp_sources(my_library "${CMAKE_SOURCE_DIR}"
-                       lib/schema1.capnp lib/schema2.capnp
-                       IMPORT_PATHS ${CMAKE_SOURCE_DIR}/include)
-
-#]=]
-
-function(target_capnp_sources target include_prefix)
-  cmake_parse_arguments(PARSE_ARGV 2
-    "TCS"           # prefix
-    "ONLY_CAPNP"    # options
-    ""              # one_value_keywords
-    "IMPORT_PATHS"  # multi_value_keywords
-  )
-
-  set(MPGEN_BINARY "")
-  if(MPGEN_EXECUTABLE)
-    set(MPGEN_BINARY "${MPGEN_EXECUTABLE}")
-    if(NOT EXISTS "${MPGEN_BINARY}")
-      message(FATAL_ERROR "MPGEN_EXECUTABLE: \"${MPGEN_BINARY}\" does not exist.")
-    endif()
-  elseif(TARGET Libmultiprocess::multiprocess)
-    set(MPGEN_BINARY Libmultiprocess::mpgen)
-  else()
-    message(FATAL_ERROR "No usable mpgen. Set MPGEN_EXECUTABLE or enable the internal target.")
-  endif()
-
-  get_property(mp_include_dir GLOBAL PROPERTY MP_INCLUDE_DIR)
-  set(generated_headers "")
-  foreach(capnp_file IN LISTS TCS_UNPARSED_ARGUMENTS)
-    add_custom_command(
-      OUTPUT ${capnp_file}.c++ ${capnp_file}.h ${capnp_file}.proxy-client.c++ ${capnp_file}.proxy-types.h ${capnp_file}.proxy-server.c++ ${capnp_file}.proxy-types.c++ ${capnp_file}.proxy.h
-      COMMAND ${MPGEN_BINARY} ${CMAKE_CURRENT_SOURCE_DIR} ${include_prefix} ${CMAKE_CURRENT_SOURCE_DIR}/${capnp_file} ${TCS_IMPORT_PATHS} ${mp_include_dir}
-      DEPENDS ${capnp_file}
-      VERBATIM
-    )
-    # Skip linting for capnp-generated files but keep it for mpgen-generated ones
-    set_source_files_properties(${capnp_file}.c++ PROPERTIES SKIP_LINTING TRUE) # Ignored before cmake 3.27
-    target_sources(${target} PRIVATE
-      ${CMAKE_CURRENT_BINARY_DIR}/${capnp_file}.c++
-    )
-    if(NOT TCS_ONLY_CAPNP)
-      target_sources(${target} PRIVATE
-        ${CMAKE_CURRENT_BINARY_DIR}/${capnp_file}.proxy-client.c++
-        ${CMAKE_CURRENT_BINARY_DIR}/${capnp_file}.proxy-server.c++
-        ${CMAKE_CURRENT_BINARY_DIR}/${capnp_file}.proxy-types.c++
-      )
-    endif()
-    list(APPEND generated_headers ${capnp_file}.h)
-  endforeach()
-
-  # Translate include_prefix from a source path to a binary path and add it as a
-  # target include directory.
-  set(build_include_prefix ${CMAKE_BINARY_DIR})
-  file(RELATIVE_PATH relative_path ${CMAKE_SOURCE_DIR} ${include_prefix})
-  if(relative_path)
-    string(APPEND build_include_prefix "/" "${relative_path}")
-  endif()
-  target_include_directories(${target} PUBLIC $<BUILD_INTERFACE:${build_include_prefix}> ${mp_include_dir})
-
-  if(TARGET Libmultiprocess::multiprocess)
-    target_link_libraries(${target} PRIVATE Libmultiprocess::multiprocess)
-  endif()
-
-  # Add a custom target that can be specified as a dependency of c++ targets
-  # that include generated headers. It can be necessary to specify these
-  # dependencies explicitly because while cmake detect dependencies of non
-  # generated files on generated headers, it does not reliably detect
-  # dependencies of generated headers on other generated headers.
-  if(NOT TARGET "${target}_headers")
-    add_custom_target("${target}_headers" DEPENDS ${generated_headers})
-  endif()
-endfunction()
diff --git a/src/ipc/libmultiprocess/cmake/compat_config.cmake b/src/ipc/libmultiprocess/cmake/compat_config.cmake
deleted file mode 100644
index f9d3004f05c3..000000000000
--- a/src/ipc/libmultiprocess/cmake/compat_config.cmake
+++ /dev/null
@@ -1,59 +0,0 @@
-# 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.
-
-# compat_config.cmake -- compatibility workarounds meant to be included after
-# cmake find_package() calls are made, before configuring the ebuild
-
-# Define capnp_PREFIX if not defined to avoid issue on macos
-# https://github.com/bitcoin-core/libmultiprocess/issues/26
-
-if (NOT DEFINED capnp_PREFIX AND DEFINED CAPNP_INCLUDE_DIRS)
-  get_filename_component(capnp_PREFIX "${CAPNP_INCLUDE_DIRS}" DIRECTORY)
-endif()
-
-if (NOT DEFINED CAPNPC_OUTPUT_DIR)
-  set(CAPNPC_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}")
-endif()
-
-# CMake target definitions for backwards compatibility with Ubuntu bionic
-# capnproto 0.6.1 package (https://packages.ubuntu.com/bionic/libcapnp-dev)
-# https://github.com/bitcoin-core/libmultiprocess/issues/27
-
-if (NOT DEFINED CAPNP_LIB_CAPNPC AND DEFINED CAPNP_LIB_CAPNP-RPC)
-  string(REPLACE "-rpc" "c" CAPNP_LIB_CAPNPC "${CAPNP_LIB_CAPNP-RPC}")
-endif()
-
-if (NOT DEFINED CapnProto_capnpc_IMPORTED_LOCATION AND DEFINED CapnProto_capnp-rpc_IMPORTED_LOCATION)
-  string(REPLACE "-rpc" "c" CapnProto_capnpc_IMPORTED_LOCATION "${CapnProto_capnp-rpc_IMPORTED_LOCATION}")
-endif()
-
-if (NOT TARGET CapnProto::capnp AND DEFINED CAPNP_LIB_CAPNP)
-  add_library(CapnProto::capnp SHARED IMPORTED)
-  set_target_properties(CapnProto::capnp PROPERTIES IMPORTED_LOCATION "${CAPNP_LIB_CAPNP}")
-endif()
-
-if (NOT TARGET CapnProto::capnpc AND DEFINED CAPNP_LIB_CAPNPC)
-  add_library(CapnProto::capnpc SHARED IMPORTED)
-  set_target_properties(CapnProto::capnpc PROPERTIES IMPORTED_LOCATION "${CAPNP_LIB_CAPNPC}")
-endif()
-
-if (NOT TARGET CapnProto::capnpc AND DEFINED CapnProto_capnpc_IMPORTED_LOCATION)
-  add_library(CapnProto::capnpc SHARED IMPORTED)
-  set_target_properties(CapnProto::capnpc PROPERTIES IMPORTED_LOCATION "${CapnProto_capnpc_IMPORTED_LOCATION}")
-endif()
-
-if (NOT TARGET CapnProto::capnp-rpc AND DEFINED CAPNP_LIB_CAPNP-RPC)
-  add_library(CapnProto::capnp-rpc SHARED IMPORTED)
-  set_target_properties(CapnProto::capnp-rpc PROPERTIES IMPORTED_LOCATION "${CAPNP_LIB_CAPNP-RPC}")
-endif()
-
-if (NOT TARGET CapnProto::kj AND DEFINED CAPNP_LIB_KJ)
-  add_library(CapnProto::kj SHARED IMPORTED)
-  set_target_properties(CapnProto::kj PROPERTIES IMPORTED_LOCATION "${CAPNP_LIB_KJ}")
-endif()
-
-if (NOT TARGET CapnProto::kj-async AND DEFINED CAPNP_LIB_KJ-ASYNC)
-  add_library(CapnProto::kj-async SHARED IMPORTED)
-  set_target_properties(CapnProto::kj-async PROPERTIES IMPORTED_LOCATION "${CAPNP_LIB_KJ-ASYNC}")
-endif()
diff --git a/src/ipc/libmultiprocess/cmake/compat_find.cmake b/src/ipc/libmultiprocess/cmake/compat_find.cmake
deleted file mode 100644
index d3d7bc6d3f89..000000000000
--- a/src/ipc/libmultiprocess/cmake/compat_find.cmake
+++ /dev/null
@@ -1,20 +0,0 @@
-# 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.
-
-# compat_find.cmake -- compatibility workarounds meant to be included before
-# cmake find_package() calls are made
-
-# Set FOUND_LIBATOMIC to work around bug in Debian capnproto package that is
-# Debian-specific and does not happen upstream. Debian includes a patch
-# https://sources.debian.org/patches/capnproto/1.0.1-4/07_libatomic.patch/ which
-# uses check_library_exists(atomic __atomic_load_8 ...) and it fails because the
-# symbol name conflicts with a compiler intrinsic as described
-# https://github.com/bitcoin-core/libmultiprocess/issues/68#issuecomment-1135150171.
-# This could be fixed by improving the check_library_exists function as
-# described in the github comment, or by changing the Debian patch to check for
-# the symbol a different way, but simplest thing to do is work around the
-# problem by setting FOUND_LIBATOMIC. This problem has probably not
-# been noticed upstream because it only affects CMake packages depending on
-# capnproto, not autoconf packages.
-set(FOUND_LIBATOMIC TRUE)
diff --git a/src/ipc/libmultiprocess/cmake/pthread_checks.cmake b/src/ipc/libmultiprocess/cmake/pthread_checks.cmake
deleted file mode 100644
index 877114165a60..000000000000
--- a/src/ipc/libmultiprocess/cmake/pthread_checks.cmake
+++ /dev/null
@@ -1,41 +0,0 @@
-# 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.
-
-# Define HAVE_PTHREAD_* variables depending on what pthread functions are
-# available.
-
-include(CMakePushCheckState)
-include(CheckCXXSourceCompiles)
-
-cmake_push_check_state()
-set(CMAKE_REQUIRED_LIBRARIES Threads::Threads)
-check_cxx_source_compiles("
-  #include <pthread.h>
-  int main(int argc, char** argv)
-  {
-    char thread_name[16];
-    return pthread_getname_np(pthread_self(), thread_name, sizeof(thread_name));
-  }"
-  HAVE_PTHREAD_GETNAME_NP)
-
-check_cxx_source_compiles("
-  #include <cstdint>
-  #include <pthread.h>
-  int main(int argc, char** argv)
-  {
-    uint64_t tid;
-    pthread_threadid_np(nullptr, &tid);
-    return 0;
-  }"
-  HAVE_PTHREAD_THREADID_NP)
-
-check_cxx_source_compiles("
-  #include <pthread.h>
-  #include <pthread_np.h>
-  int main(int argc, char** argv)
-  {
-    return pthread_getthreadid_np();
-  }"
-  HAVE_PTHREAD_GETTHREADID_NP)
-cmake_pop_check_state()
diff --git a/src/ipc/libmultiprocess/doc/design.md b/src/ipc/libmultiprocess/doc/design.md
deleted file mode 100644
index 094602e93aef..000000000000
--- a/src/ipc/libmultiprocess/doc/design.md
+++ /dev/null
@@ -1,227 +0,0 @@
-# libmultiprocess Design
-
-Given an interface description of an object with one or more methods, libmultiprocess generates:
-
-* A C++ `ProxyClient` class template specialization with an implementation of each interface method that sends a request over a socket, waits for a response, and returns the result.
-* A C++ `ProxyServer` class template specialization that listens for requests over a socket and calls a wrapped C++ object implementing the same interface to actually execute the requests.
-
-The function call ⇆ request translation supports input and output arguments, standard types like `unique_ptr`, `vector`, `map`, and `optional`, and bidirectional calls between processes through interface pointer and `std::function` arguments.
-
-If the wrapped C++ object inherits from an abstract base class declaring virtual methods, the generated `ProxyClient` objects can inherit from the same class, allowing interprocess calls to replace local calls without changes to existing code.
-
-There is also optional support for thread mapping, so each thread making interprocess calls can have a dedicated thread processing requests from it, and callbacks from processing threads are executed on corresponding request threads (so recursive mutexes and thread names function as expected in callbacks).
-
-Libmultiprocess acts as a pure wrapper or layer over the underlying protocol. Clients and servers written in other languages, but using a shared capnproto schema can communicate with interprocess counterparties using libmultiprocess without having to use libmultiprocess themselves or having to know about the implementation details of libmultiprocess.
-
-## Core Architecture
-
-The `ProxyClient` and `ProxyServer` generated classes are not directly exposed to the user, as described in [usage.md](usage.md). Instead, they wrap C++ interfaces and appear to the user as pointers to an interface. They are first instantiated when calling `ConnectStream` and `ServeStream` respectively for creating the `InitInterface`. These methods establish connections through sockets, internally creating `Connection` objects wrapping a `capnp::RpcSystem` configured for client and server mode respectively.
-
-The `InitInterface` interface will typically have methods which return other interfaces, giving the connecting process the ability to call other functions in the serving process. Interfaces can also have methods accepting other interfaces as parameters, giving serving processes the ability to call back and invoke functions in connecting processes. Creating new interfaces does not create new connections, and typically many interface objects will share the same connection.
-
-Both `ConnectStream` and `ServeStream` also require an instantiation of the `EventLoop`. The `EventLoop` owns pending requests, notifies on request dispatch, allows clients from multiple threads to make synchronous calls, and handles some cleanup routines on exit. It must be run in a separate thread so it is always active and can process incoming requests from local clients and remote connections.
-
-When a generated method on the `ProxyClient` is called, it calls `clientInvoke` with the capnp-translated types. `clientInvoke` creates a self-executing promise (`kj::TaskSet`) that drives the execution of the request and gives ownership of it to the `EventLoop`. `clientInvoke` blocks until a response is received, or until there is a call from the server that needs to run on the same client thread, using a `Waiter` object.
-
-On the server side, the `capnp::RpcSystem` receives the capnp request and invokes the corresponding C++ method through the corresponding `ProxyServer` and the heavily templated `serverInvoke` triggering a `ServerCall`. The return values from the actual C++ methods are copied into capnp responses by `ServerRet` and exceptions are caught and copied by `ServerExcept`. The two are connected through `ServerField`. The main method driving execution of a request is `PassField`, which is invoked through `ServerField`. Instantiated interfaces, or capabilities in capnp speak, are tracked and owned by the server's `capnp::RpcSystem`.
-
-## Request and Response Flow
-
-Method parameters and return values are serialized using Cap'n Proto's Builder objects (for sending) and Reader objects (for receiving). Input parameters flow from the client to the server, while output parameters (return values) flow back from the server to the client.
-
-```mermaid
-sequenceDiagram
-    participant clientInvoke
-    participant BuildField as BuildField<br/>(Client)
-    participant ReadField_C as ReadField<br/>(Client)
-    participant Request as Request<br/>message
-    participant serverInvoke
-    participant ReadField as ReadField<br/>(Server)
-    participant BuildField_S as BuildField<br/>(Server)
-    participant Response as Response<br/>message
-
-    Note over clientInvoke,ReadField: Input Parameter Flow
-    clientInvoke->>BuildField: BuildField(input_arg)
-    BuildField->>Request: Serialize input
-    Request->>serverInvoke: Cap'n Proto message
-    serverInvoke->>ReadField: Deserialize input
-
-    Note over clientInvoke,Response: Output Parameter Flow
-    serverInvoke-->>BuildField_S: BuildField(output)
-    BuildField_S-->Response: Serialize output
-    Response-->>ReadField_C: Cap'n Proto message
-    ReadField_C-->>clientInvoke: Deserialize output
-```
-
-### Detailed Serialization Mechanism
-
-Parameters are represented as Fields that must be set on Cap'n Proto Builder objects (for sending) and read from Reader objects (for receiving).
-
-#### Building Fields
-
-`BuildField` uses a generated parameter `Accessor` to set the appropriate field in the Cap'n Proto Builder object.
-
-```mermaid
-sequenceDiagram
-    participant clientInvoke as clientInvoke or<br/>serverInvoke
-    participant BuildField
-    participant Accessor
-    participant Builder as Params::Builder
-
-    Note over clientInvoke,Builder: Serializing Parameters
-    clientInvoke->>BuildField: BuildField(param1)
-    BuildField->>Accessor: Use generated field accessor
-    Accessor->>Builder: builder.setField1(param1)
-
-    clientInvoke->>BuildField: BuildField(param2)
-    BuildField->>Accessor: Use generated field Accessor
-    Accessor->>Builder: builder.setField2(param2)
-```
-
-#### Reading Fields
-
-`ReadField` uses a generated parameter `Accessor` to read the appropriate field from the Cap'n Proto Reader object and reconstruct C++ parameters.
-
-```mermaid
-sequenceDiagram
-    participant serverInvoke as clientInvoke or<br/>serverInvoke
-    participant ReadField
-    participant Accessor
-    participant Reader as Params::Reader
-    participant ServerCall
-
-    Note over serverInvoke,ServerCall: Deserializing Parameters
-    serverInvoke->>ReadField: Read param1
-    ReadField->>Accessor: Use generated field accessor
-    Accessor->>Reader: reader.getField1()
-    Reader-->>ServerCall: call function with param1
-```
-
-## Server-Side Request Processing
-
-The generated server code uses a Russian nesting doll structure to process method fields. Each `ServerField` wraps another `ServerField` (for the next parameter), or wraps `ServerRet` (for the return value), which finally wraps `ServerCall` (which invokes the actual C++ method).
-
-Each `ServerField` invokes `PassField`, which:
-1. Calls `ReadField` to deserialize the parameter from the `Params::Reader`
-2. Calls the next nested layer's `invoke()` with the accumulated parameters
-3. Calls `BuildField` to serialize the parameter back if it's an output parameter
-
-`ServerRet` invokes the next layer (typically `ServerCall`), stores the result, and calls `BuildField` to serialize it into the `Results::Builder`.
-
-`ServerCall` uses the generated `ProxyMethod<MethodParams>::impl` pointer-to-member to invoke the actual C++ method on the wrapped implementation object.
-
-```mermaid
-sequenceDiagram
-    participant serverInvoke
-    participant SF1 as ServerField<br/>(param 1)
-    participant SF2 as ServerField<br/>(param 2)
-    participant SR as ServerRet<br/>(return value)
-    participant SC as ServerCall
-    participant PMT as ProxyMethodTraits
-    participant Impl as Actual C++ Method
-
-    serverInvoke->>SF1: SF1::invoke
-    SF1->>SF2: SF2::invoke
-    SF2->>SR: SR::invoke
-    SR->>SC: SC::invoke
-    SC->>PMT: PMT::invoke
-    PMT->>Impl: Call impl method
-    Impl->>PMT: return
-    PMT->>SC: return
-    SC->>SR: return
-    SR->>SF2: return
-    SF2->>SF1: return
-    SF1->>serverInvoke: return
-```
-
-## Advanced Features
-
-### Callbacks
-
-Callbacks (passed as `std::function` arguments) are intercepted by `CustomBuildField` and converted into Cap'n Proto capabilities that can be invoked across process boundaries. On the receiving end, `CustomReadField` intercepts the capability and constructs a `ProxyCallFn` object with an `operator()` that sends function calls back over the socket to invoke the original callback.
-
-```mermaid
-sequenceDiagram
-    participant CT as Client Thread
-    participant C as clientInvoke
-    participant CBF1 as CustomBuildField (Client)
-    participant S as Socket
-    participant CRF1 as CustomReadField (Server)
-    participant Srv as Server Code
-    participant PCF as ProxyCallFn
-
-    C->>CBF1: send function parameter
-    CBF1->>S: creates a Server for the function and sends a capability
-    S->>CRF1: receives a capability and creates ProxyCallFn
-    CRF1->>Srv:
-    Srv->>PCF: call the callback
-    PCF-->>CT: sends request to Client
-```
-
-### Thread Mapping
-
-Thread mapping enables each client thread to have a dedicated server thread processing its requests, preserving thread-local state and allowing recursive mutex usage across process boundaries.
-
-Thread mapping is initialized by defining an interface method with a `ThreadMap` parameter and/or response. The example below adds `ThreadMap` to the `construct` method because libmultiprocess calls the `construct` method automatically.
-
-```capnp
-interface InitInterface $Proxy.wrap("Init") {
-    construct @0 (threadMap: Proxy.ThreadMap) -> (threadMap :Proxy.ThreadMap);
-}
-```
-
-- **ThreadMap in parameter**: The client's `CustomBuildField` creates a `ThreadMap::Server` capability and sends it to the server, where `CustomReadField` stores the `ThreadMap::Client` in `connection.m_thread_map`
-- **ThreadMap in response**: The server's `CustomBuildField` creates a `ThreadMap::Server` capability and sends it to the client, where `CustomReadField` stores the `ThreadMap::Client` in `connection.m_thread_map`
-
-You can specify ThreadMap in the parameter only, response only, or both:
-- **Parameter only**: Server can create threads on the client
-- **Response only**: Client can create threads on the server
-- **Both (as shown)**: Bidirectional thread creation
-
-When both parameter and response include ThreadMap, both processes end up with `ThreadMap::Client` capabilities pointing to each other's `ThreadMap::Server`, allowing both sides to create threads on the other process.
-
-### Async Processing with Context
-
-By adding a `Context` parameter to a method in the capnp interface file, you enable async processing where the client tells the server to execute the request in a separate worker thread. For example:
-
-```capnp
-processData @5 (context :Proxy.Context, data :Data) -> (result :Result);
-```
-
-If a method does not have a `Context` parameter, then libmultiprocess will execute IPC requests invoking that method on the I/O event loop thread. This is fine for fast and non-blocking methods, but should be avoided for any methods that are slow or blocking or make any IPC calls(including callbacks to the client), since as long as the method is executing, the Cap'n Proto event loop will not be able to perform any I/O.
-
-When a method has a `Context` parameter:
-
-**Client side** (`CustomBuildField`):
-If this is the first asynchronous request made from the current client thread, `CustomBuildField` will:
-1. Call `connection.m_thread_map.makeThreadRequest()` to request a dedicated worker thread on the server (stored in `request_threads` map)
-2. Set the remote thread capability in `Context.thread`
-3. Create a local `Thread::Server` object for the current thread (stored in `callback_threads` map)
-4. Set the local thread capability in `Context.callbackThread`
-
-Subsequent requests will reuse the existing thread capabilities held in `callback_threads` and `request_threads`.
-
-**Server side** (`PassField`):
-1. Looks up the local `Thread::Server` object specified by `context.thread`
-2. The worker thread:
-   - Stores `context.callbackThread` in its `request_threads` map (so callbacks go to the right client thread)
-   - Posts the work lambda to that thread's queue via `waiter->post(invoke)`
-   - Cleans up the `request_threads` entry
-
-## Interface Definitions
-
-As explained in the [usage](usage.md) document, interface descriptions need to be consumed both by the _libmultiprocess_ code generator, and by C++ code that calls and implements the interfaces. The C++ code only needs to know about C++ arguments and return types, while the code generator only needs to know about capnp arguments and return types, but both need to know class and method names, so the corresponding `.h` and `.capnp` source files contain some of the same information, and have to be kept in sync manually when methods or parameters change. Despite the redundancy, reconciling the interface definitions is designed to be _straightforward_ and _safe_. _Straightforward_ because there is no need to write manual serialization code or use awkward intermediate types like [`UniValue`](https://github.com/bitcoin/bitcoin/blob/master/src/univalue/include/univalue.h) instead of native types. _Safe_ because if there are any inconsistencies between API and data definitions (even minor ones like using a narrow int data type for a wider int API input), there are errors at build time instead of errors or bugs at runtime.
-
-In the future, it would be possible to combine API and data definitions together using [C++ attributes](https://en.cppreference.com/w/cpp/language/attributes). To do this we would add attributes to the API definition files, and then generate the data definitions from the API definitions and attributes. I didn't take this approach mostly because it would be extra work, but also because until C++ standardizes reflection, this would require either hooking into compiler APIs like https://github.com/RosettaCommons/binder, or parsing C++ code manually like http://www.swig.org/.
-
-## What is `kj`?
-
-KJ is a concurrency framework [bundled with
-capnproto](https://capnproto.org/cxxrpc.html#kj-concurrency-framework); it is used as a
-basis in this library to construct the event-loop necessary to service IPC requests.
-
-## Future directions
-
-_libmultiprocess_ uses the [Cap'n Proto](https://capnproto.org) interface description language and protocol, but it could be extended or changed to use a different IDL/protocol like [gRPC](https://grpc.io). The nice thing about _Cap'n Proto_ compared to _gRPC_ and most other lower level protocols is that it allows interface pointers (_Services_ in gRPC parlance) to be passed as method arguments and return values, so object references and bidirectional requests work out of the box. Supporting a lower-level protocol would require adding maps and tracking code to proxy objects.
-
-_libmultiprocess_ is currently compatible with sandboxing but could add platform-specific sandboxing support or integration with a sandboxing library like [SAPI](https://github.com/google/sandboxed-api).
diff --git a/src/ipc/libmultiprocess/doc/install.md b/src/ipc/libmultiprocess/doc/install.md
deleted file mode 100644
index ac2f7f6a777c..000000000000
--- a/src/ipc/libmultiprocess/doc/install.md
+++ /dev/null
@@ -1,52 +0,0 @@
-# libmultiprocess Installation
-
-Installation currently requires Cap'n Proto 0.7 or higher:
-
-```sh
-apt install libcapnp-dev capnproto
-brew install capnp cmake
-dnf install capnproto
-```
-
-Installation steps are:
-
-```sh
-mkdir build
-cd build
-cmake ..
-make
-make check # Optionally build and run tests
-make install
-```
-
-To build with libmultiprocess in a CMake project can specify:
-
-```cmake
-find_package(Libmultiprocess)
-target_capnp_sources(mytarget ${CMAKE_CURRENT_SOURCE_DIR} myschema.capnp)
-```
-
-Which will locate the libmultiprocess cmake package, and call the
-`target_capnp_sources` function to generate C++ files and link them into a
-library or executable target. See `example/CMakeLists.txt` for a complete
-example.
-
-To build with libmultiprocess in a non-CMake project can use installed
-`<prefix>/include/mpgen.mk` Makefile rule to generate C++ files, and
-`<prefix>/lib/pkgconfig/libmultiprocess.pc` pkg-config definition to link
-against the runtime library.
-
-For cross-compilation, it may be useful to build the runtime library and code
-generation binaries separately, which can be done with:
-
-```sh
-make install-bin # install bin/mpgen and related files
-make install-lib # install lib/libmultiprocess.a and related files
-```
-
-It is also possible to import CMake targets separately with:
-
-```cmake
-find_package(Libmultiprocess COMPONENTS Bin)
-find_package(Libmultiprocess COMPONENTS Lib)
-```
diff --git a/src/ipc/libmultiprocess/doc/usage.md b/src/ipc/libmultiprocess/doc/usage.md
deleted file mode 100644
index f387db4d8d8a..000000000000
--- a/src/ipc/libmultiprocess/doc/usage.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# libmultiprocess Usage
-
-## Overview
-
-_libmultiprocess_ is a library and code generator that allows calling C++ class interfaces across different processes. For an interface to be available from other processes, it needs two definitions:
-
-- An **API definition** declaring how the interface is called. Included examples: [calculator.h](../example/calculator.h), [printer.h](../example/printer.h), [init.h](../example/init.h). Bitcoin examples: [node.h](https://github.com/bitcoin/bitcoin/blob/master/src/interfaces/node.h), [wallet.h](https://github.com/bitcoin/bitcoin/blob/master/src/interfaces/wallet.h), [echo.h](https://github.com/bitcoin/bitcoin/blob/master/src/interfaces/echo.h), [init.h](https://github.com/bitcoin/bitcoin/blob/master/src/interfaces/init.h).
-
-- A **data definition** declaring how interface calls get sent across the wire. Included examples: [calculator.capnp](../example/calculator.capnp), [printer.capnp](../example/printer.capnp), [init.capnp](../example/init.capnp). Bitcoin examples: [node.capnp](https://github.com/ryanofsky/bitcoin/blob/ipc-export/src/ipc/capnp/node.capnp), [wallet.capnp](https://github.com/ryanofsky/bitcoin/blob/ipc-export/src/ipc/capnp/wallet.capnp), [echo.capnp](https://github.com/bitcoin/bitcoin/blob/master/src/ipc/capnp/echo.capnp), [init.capnp](https://github.com/bitcoin/bitcoin/blob/master/src/ipc/capnp/init.capnp).
-
-The `*.capnp` data definition files are consumed by the _libmultiprocess_ code generator and each `X.capnp` file generates `X.capnp.c++`, `X.capnp.h`, `X.capnp.proxy-client.c++`, `X.capnp.proxy-server.c++`, `X.capnp.proxy-types.c++`, `X.capnp.proxy-types.h`, and `X.capnp.proxy.h` output files. The generated files include `mp::ProxyClient<Interface>` and `mp::ProxyServer<Interface>` class specializations for all the interfaces in the `.capnp` files. These allow methods on C++ objects in one process to be called from other processes over IPC sockets.
-
-The `ProxyServer` objects help translate IPC requests from a socket to method calls on a local object. The `ProxyServer` objects are just used internally by the `mp::ServeStream(loop, socket, wrapped_object)` and `mp::ListenConnections(loop, socket, wrapped_object)` functions, and aren't exposed externally. The `ProxyClient` classes are exposed, and returned from the `mp::ConnectStream(loop, socket)` function and meant to be used directly. The classes implement methods described in `.capnp` definitions, and whenever any method is called, a request with the method arguments is sent over the associated IPC connection, and the corresponding `wrapped_object` method on the other end of the connection is called, with the `ProxyClient` method blocking until it returns and forwarding back any return value to the `ProxyClient` method caller.
-
-## Example
-
-A simple interface description can be found at [test/mp/test/foo.capnp](../test/mp/test/foo.capnp), implementation in [test/mp/test/foo.h](../test/mp/test/foo.h), and usage in [test/mp/test/test.cpp](../test/mp/test/test.cpp).
-
-A more complete example can be found in [example](../example/) and run with:
-
-```sh
-mkdir build
-cd build
-cmake ..
-make mpexamples
-example/mpexample
-```
diff --git a/src/ipc/libmultiprocess/doc/versions.md b/src/ipc/libmultiprocess/doc/versions.md
deleted file mode 100644
index 2c2ec50e7c6d..000000000000
--- a/src/ipc/libmultiprocess/doc/versions.md
+++ /dev/null
@@ -1,78 +0,0 @@
-# libmultiprocess Versions
-
-Library versions are tracked with simple
-[tags](https://github.com/bitcoin-core/libmultiprocess/tags) and
-[branches](https://github.com/bitcoin-core/libmultiprocess/branches).
-
-Versioning policy is described in the [version.h](../include/mp/version.h)
-include.
-
-## v10
-- Current unstable version.
-
-## [v9.0](https://github.com/bitcoin-core/libmultiprocess/commits/v9.0)
-- Fixes race conditions where worker thread could be used after destruction, where getParams() could be called after request cancel, and where m_on_cancel could be called after request finishes.
-- Adds `CustomHasField` hook to map Cap'n Proto null values to C++ null values.
-- Improves `CustomBuildField` for `std::optional` to use move semantics.
-- Adds LLVM 22 compatibility fix in type-map.
-- Used in Bitcoin Core master branch, pulled in by [#34804](https://github.com/bitcoin/bitcoin/pull/34804). Also pulled into Bitcoin Core 31.x stable branch by [#34952](https://github.com/bitcoin/bitcoin/pull/34952).
-
-## [v8.0](https://github.com/bitcoin-core/libmultiprocess/commits/v8.0)
-- Better support for non-libmultiprocess IPC clients: avoiding errors on unclean disconnects, and allowing simultaneous requests to worker threads which previously triggered "thread busy" errors.
-- Intermediate version used in Bitcoin Core master branch between 30.x and 31.x branches, pulled in by [#34422](https://github.com/bitcoin/bitcoin/pull/34422).
-
-## [v7.0](https://github.com/bitcoin-core/libmultiprocess/commits/v7.0)
-- Adds SpawnProcess race fix, cmake `target_capnp_sources` option, ci and documentation improvements. Adds `version.h` header declaring major and minor version numbers.
-- Intermediate version used in Bitcoin Core master branch between 30.x and 31.x branches, pulled in by [#34363](https://github.com/bitcoin/bitcoin/pull/34363).
-
-## [v7.0-pre2](https://github.com/bitcoin-core/libmultiprocess/commits/v7.0-pre2)
-- Fixes intermittent mptest hang and makes other minor improvements.
-- Used in Bitcoin Core 30.1 and 30.2 releases and 30.x branch, pulled in by [#33518](https://github.com/bitcoin/bitcoin/pull/33518) and [#33519](https://github.com/bitcoin/bitcoin/pull/33519).
-
-## [v7.0-pre1](https://github.com/bitcoin-core/libmultiprocess/commits/v7.0-pre1)
-- Adds support for log levels to reduce logging and "thread busy" error to avoid a crash on misuse.
-- Minimum required version since Bitcoin Core 30.1, pulled in by [#33412](https://github.com/bitcoin/bitcoin/pull/33412), [#33518](https://github.com/bitcoin/bitcoin/pull/33518), and [#33519](https://github.com/bitcoin/bitcoin/pull/33519).
-
-## [v6.0](https://github.com/bitcoin-core/libmultiprocess/commits/v6.0)
-- Adds CI scripts and build and test fixes.
-- Used in Bitcoin Core 30.0 release, pulled in by [#32345](https://github.com/bitcoin/bitcoin/pull/32345), [#33241](https://github.com/bitcoin/bitcoin/pull/33241), and [#33322](https://github.com/bitcoin/bitcoin/pull/33322).
-
-## [v6.0-pre1](https://github.com/bitcoin-core/libmultiprocess/commits/v6.0-pre1)
-- Adds fixes for unclean shutdowns and thread sanitizer issues.
-- Drops `EventLoop::addClient` and `EventLoop::removeClient` methods,
-  requiring clients to use new `EventLoopRef` class instead.
-- Minimum required version for Bitcoin Core 30.0 release, pulled in by [#31741](https://github.com/bitcoin/bitcoin/pull/31741), [#32641](https://github.com/bitcoin/bitcoin/pull/32641), and [#32345](https://github.com/bitcoin/bitcoin/pull/32345).
-
-## [v5.0](https://github.com/bitcoin-core/libmultiprocess/commits/v5.0)
-- Adds build improvements and tidy/warning fixes.
-- Used in Bitcoin Core 29 releases, pulled in by [#31945](https://github.com/bitcoin/bitcoin/pull/31945).
-
-## [v5.0-pre1](https://github.com/bitcoin-core/libmultiprocess/commits/v5.0-pre1)
-- Adds many improvements to Bitcoin Core mining interface: splitting up type headers, fixing shutdown bugs, adding subtree build support.
-- Broke up `proxy-types.h` into `type-*.h` files requiring clients to explicitly
-  include overloads needed for C++ ↔️ Cap'n Proto type conversions.
-- Now requires C++ 20 support.
-- Minimum required version for Bitcoin Core 29 releases, pulled in by [#30509](https://github.com/bitcoin/bitcoin/pull/30509), [#30510](https://github.com/bitcoin/bitcoin/pull/30510), [#31105](https://github.com/bitcoin/bitcoin/pull/31105), [#31740](https://github.com/bitcoin/bitcoin/pull/31740).
-
-## [v4.0](https://github.com/bitcoin-core/libmultiprocess/commits/v4.0)
-- Added better cmake support, installing cmake package files so clients do not
-  need to use pkgconfig.
-- Used in Bitcoin Core 28 releases, pulled in by [#30490](https://github.com/bitcoin/bitcoin/pull/30490) and [#30513](https://github.com/bitcoin/bitcoin/pull/30513).
-
-## [v3.0](https://github.com/bitcoin-core/libmultiprocess/commits/v3.0)
-- Dropped compatibility with Cap'n Proto versions before 0.7.
-- Used in Bitcoin Core 27 releases, pulled in by [#28735](https://github.com/bitcoin/bitcoin/pull/28735), [#28907](https://github.com/bitcoin/bitcoin/pull/28907), and [#29276](https://github.com/bitcoin/bitcoin/pull/29276).
-
-## [v2.0](https://github.com/bitcoin-core/libmultiprocess/commits/v2.0)
-- Changed `PassField` function signature.
-- Now requires C++17 support.
-- Used in Bitcoin Core 25 and 26 releases, pulled in by [#26672](https://github.com/bitcoin/bitcoin/pull/26672).
-
-## [v1.0](https://github.com/bitcoin-core/libmultiprocess/commits/v1.0)
-- Dropped hardcoded includes in generated files, now requiring `include` and
-  `includeTypes` annotations.
-- Used in Bitcoin Core 22, 23, and 24 releases, pulled in by [#19160](https://github.com/bitcoin/bitcoin/pull/19160).
-
-## [v0.0](https://github.com/bitcoin-core/libmultiprocess/commits/v0.0)
-- Initial version used in a downstream release.
-- Used in Bitcoin Core 21 releases, pulled in by [#16367](https://github.com/bitcoin/bitcoin/pull/16367), [#18588](https://github.com/bitcoin/bitcoin/pull/18588), and [#18677](https://github.com/bitcoin/bitcoin/pull/18677).
diff --git a/src/ipc/libmultiprocess/example/CMakeLists.txt b/src/ipc/libmultiprocess/example/CMakeLists.txt
deleted file mode 100644
index 7da049c3a3f7..000000000000
--- a/src/ipc/libmultiprocess/example/CMakeLists.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-# 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(${PROJECT_SOURCE_DIR}/cmake/TargetCapnpSources.cmake)
-
-add_executable(mpcalculator
-  calculator.cpp
-)
-target_capnp_sources(mpcalculator ${CMAKE_CURRENT_SOURCE_DIR} init.capnp calculator.capnp printer.capnp)
-target_include_directories(mpcalculator PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
-target_link_libraries(mpcalculator PRIVATE Threads::Threads)
-
-add_executable(mpprinter
-  printer.cpp
-)
-target_capnp_sources(mpprinter ${CMAKE_CURRENT_SOURCE_DIR} init.capnp calculator.capnp printer.capnp)
-target_include_directories(mpprinter PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
-target_link_libraries(mpprinter PRIVATE Threads::Threads)
-
-add_executable(mpexample
-  example.cpp
-)
-target_capnp_sources(mpexample ${CMAKE_CURRENT_SOURCE_DIR} init.capnp calculator.capnp printer.capnp)
-target_include_directories(mpexample PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
-target_link_libraries(mpexample PRIVATE Threads::Threads)
-
-add_custom_target(mpexamples DEPENDS mpexample mpcalculator mpprinter)
diff --git a/src/ipc/libmultiprocess/example/calculator.capnp b/src/ipc/libmultiprocess/example/calculator.capnp
deleted file mode 100644
index 945518836016..000000000000
--- a/src/ipc/libmultiprocess/example/calculator.capnp
+++ /dev/null
@@ -1,16 +0,0 @@
-# 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.
-
-@0xb67dbf34061180a9;
-
-using Cxx = import "/capnp/c++.capnp";
-using Proxy = import "/mp/proxy.capnp";
-
-$Proxy.include("calculator.h");
-$Proxy.includeTypes("types.h");
-
-interface CalculatorInterface $Proxy.wrap("Calculator") {
-    destroy @0 (context :Proxy.Context) -> ();
-    solveEquation @1 (context :Proxy.Context, eqn: Text) -> ();
-}
diff --git a/src/ipc/libmultiprocess/example/calculator.cpp b/src/ipc/libmultiprocess/example/calculator.cpp
deleted file mode 100644
index 86ce388b0cf9..000000000000
--- a/src/ipc/libmultiprocess/example/calculator.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-// 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 <calculator.h>
-#include <init.capnp.h>
-#include <init.capnp.proxy.h> // NOLINT(misc-include-cleaner) // IWYU pragma: keep
-
-#include <charconv>
-#include <cstring>
-#include <fstream>
-#include <functional>
-#include <iostream>
-#include <kj/async.h>
-#include <kj/common.h>
-#include <kj/memory.h>
-#include <memory>
-#include <mp/proxy-io.h>
-#include <stdexcept>
-#include <string>
-#include <system_error>
-#include <utility>
-
-class CalculatorImpl : public Calculator
-{
-public:
-    CalculatorImpl(std::unique_ptr<Printer> printer) : m_printer(std::move(printer)) {}
-    void solveEquation(const std::string& eqn) override { m_printer->print("Wow " + eqn + ", that's a tough one.\n"); }
-    std::unique_ptr<Printer> m_printer;
-};
-
-class InitImpl : public Init
-{
-public:
-    std::unique_ptr<Calculator> makeCalculator(std::unique_ptr<Printer> printer) override
-    {
-        return std::make_unique<CalculatorImpl>(std::move(printer));
-    }
-};
-
-// Exercises deprecated log callback signature
-static void LogPrint(bool raise, const std::string& message)
-{
-    if (raise) throw std::runtime_error(message);
-    std::ofstream("debug.log", std::ios_base::app) << message << std::endl;
-}
-
-int main(int argc, char** argv)
-{
-    if (argc != 2) {
-        std::cout << "Usage: mpcalculator <fd>\n";
-        return 1;
-    }
-    int fd;
-    if (std::from_chars(argv[1], argv[1] + strlen(argv[1]), fd).ec != std::errc{}) {
-        std::cerr << argv[1] << " is not a number or is larger than an int\n";
-        return 1;
-    }
-    mp::EventLoop loop("mpcalculator", LogPrint);
-    std::unique_ptr<Init> init = std::make_unique<InitImpl>();
-    mp::ServeStream<InitInterface>(loop, fd, *init);
-    loop.loop();
-    return 0;
-}
diff --git a/src/ipc/libmultiprocess/example/calculator.h b/src/ipc/libmultiprocess/example/calculator.h
deleted file mode 100644
index 342a3c1d154a..000000000000
--- a/src/ipc/libmultiprocess/example/calculator.h
+++ /dev/null
@@ -1,17 +0,0 @@
-// 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 EXAMPLE_CALCULATOR_H
-#define EXAMPLE_CALCULATOR_H
-
-#include <string>
-
-class Calculator
-{
-public:
-    virtual ~Calculator() = default;
-    virtual void solveEquation(const std::string& eqn) = 0;
-};
-
-#endif // EXAMPLE_CALCULATOR_H
diff --git a/src/ipc/libmultiprocess/example/example.cpp b/src/ipc/libmultiprocess/example/example.cpp
deleted file mode 100644
index 3831397781ce..000000000000
--- a/src/ipc/libmultiprocess/example/example.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-// 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 <init.capnp.h>
-#include <init.capnp.proxy.h>
-
-#include <cstring> // IWYU pragma: keep
-#include <filesystem>
-#include <fstream>
-#include <future>
-#include <iostream>
-#include <kj/async.h>
-#include <kj/common.h>
-#include <memory>
-#include <mp/proxy-io.h>
-#include <mp/util.h>
-#include <stdexcept>
-#include <string>
-#include <thread>
-#include <tuple>
-#include <vector>
-
-namespace fs = std::filesystem;
-
-static auto Spawn(mp::EventLoop& loop, const std::string& process_argv0, const std::string& new_exe_name)
-{
-    int pid;
-    const int fd = mp::SpawnProcess(pid, [&](int fd) -> std::vector<std::string> {
-        fs::path path = process_argv0;
-        path.remove_filename();
-        path.append(new_exe_name);
-        return {path.string(), std::to_string(fd)};
-    });
-    return std::make_tuple(mp::ConnectStream<InitInterface>(loop, fd), pid);
-}
-
-static void LogPrint(mp::LogMessage log_data)
-{
-    if (log_data.level == mp::Log::Raise) throw std::runtime_error(log_data.message);
-    std::ofstream("debug.log", std::ios_base::app) << log_data.message << std::endl;
-}
-
-int main(int argc, char** argv)
-{
-    if (argc != 1) {
-        std::cout << "Usage: mpexample\n";
-        return 1;
-    }
-
-    std::promise<mp::EventLoop*> promise;
-    std::thread loop_thread([&] {
-        mp::EventLoop loop("mpexample", LogPrint);
-        promise.set_value(&loop);
-        loop.loop();
-    });
-    mp::EventLoop* loop = promise.get_future().get();
-
-    auto [printer_init, printer_pid] = Spawn(*loop, argv[0], "mpprinter");
-    auto [calc_init, calc_pid] = Spawn(*loop, argv[0], "mpcalculator");
-    auto calc = calc_init->makeCalculator(printer_init->makePrinter());
-    while (true) {
-        std::string eqn;
-        std::cout << "Enter the equation, or \"exit\" to quit: ";
-        std::getline(std::cin, eqn);
-        if (eqn == "exit") break;
-        calc->solveEquation(eqn);
-    }
-    calc.reset();
-    calc_init.reset();
-    mp::WaitProcess(calc_pid);
-    printer_init.reset();
-    mp::WaitProcess(printer_pid);
-    loop_thread.join();
-    std::cout << "Bye!" << std::endl;
-    return 0;
-}
diff --git a/src/ipc/libmultiprocess/example/init.capnp b/src/ipc/libmultiprocess/example/init.capnp
deleted file mode 100644
index 01897f13dca4..000000000000
--- a/src/ipc/libmultiprocess/example/init.capnp
+++ /dev/null
@@ -1,21 +0,0 @@
-# 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.
-
-@0xba5a7448664901b1;
-
-using Cxx = import "/capnp/c++.capnp";
-using Proxy = import "/mp/proxy.capnp";
-using Calculator = import "calculator.capnp";
-using Printer = import "printer.capnp";
-
-$Proxy.include("calculator.h");
-$Proxy.include("init.h");
-$Proxy.include("printer.h");
-$Proxy.includeTypes("types.h");
-
-interface InitInterface $Proxy.wrap("Init") {
-    construct @0 (threadMap: Proxy.ThreadMap) -> (threadMap :Proxy.ThreadMap);
-    makeCalculator @1 (context :Proxy.Context, print :Printer.PrinterInterface) -> (result :Calculator.CalculatorInterface);
-    makePrinter @2 (context :Proxy.Context) -> (result :Printer.PrinterInterface);
-}
diff --git a/src/ipc/libmultiprocess/example/init.h b/src/ipc/libmultiprocess/example/init.h
deleted file mode 100644
index 54e36da8db1d..000000000000
--- a/src/ipc/libmultiprocess/example/init.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// 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 EXAMPLE_INIT_H
-#define EXAMPLE_INIT_H
-
-#include <calculator.h>
-#include <memory>
-#include <printer.h>
-
-class Init
-{
-public:
-    virtual ~Init() = default;
-    virtual std::unique_ptr<Printer> makePrinter() { return nullptr; }
-    virtual std::unique_ptr<Calculator> makeCalculator(std::unique_ptr<Printer> printer) { return nullptr; }
-};
-
-#endif // EXAMPLE_INIT_H
diff --git a/src/ipc/libmultiprocess/example/printer.capnp b/src/ipc/libmultiprocess/example/printer.capnp
deleted file mode 100644
index 0f407b771411..000000000000
--- a/src/ipc/libmultiprocess/example/printer.capnp
+++ /dev/null
@@ -1,16 +0,0 @@
-# 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.
-
-@0x893db95f456ed0e3;
-
-using Cxx = import "/capnp/c++.capnp";
-using Proxy = import "/mp/proxy.capnp";
-
-$Proxy.include("printer.h");
-$Proxy.includeTypes("types.h");
-
-interface PrinterInterface $Proxy.wrap("Printer") {
-    destroy @0 (context :Proxy.Context) -> ();
-    print @1 (context :Proxy.Context, text: Text) -> ();
-}
diff --git a/src/ipc/libmultiprocess/example/printer.cpp b/src/ipc/libmultiprocess/example/printer.cpp
deleted file mode 100644
index 9150d59b5d30..000000000000
--- a/src/ipc/libmultiprocess/example/printer.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-// 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 <printer.h>
-
-#include <init.capnp.h>
-#include <init.capnp.proxy.h> // NOLINT(misc-include-cleaner) // IWYU pragma: keep
-
-#include <charconv>
-#include <cstring>
-#include <fstream>
-#include <iostream>
-#include <kj/async.h>
-#include <kj/common.h>
-#include <kj/memory.h>
-#include <memory>
-#include <mp/proxy-io.h>
-#include <stdexcept>
-#include <string>
-#include <system_error>
-
-class PrinterImpl : public Printer
-{
-public:
-    void print(const std::string& message) override { std::cout << "mpprinter: " << message << std::endl; }
-};
-
-class InitImpl : public Init
-{
-public:
-    std::unique_ptr<Printer> makePrinter() override { return std::make_unique<PrinterImpl>(); }
-};
-
-static void LogPrint(mp::LogMessage log_data)
-{
-    if (log_data.level == mp::Log::Raise) throw std::runtime_error(log_data.message);
-    std::ofstream("debug.log", std::ios_base::app) << log_data.message << std::endl;
-}
-
-int main(int argc, char** argv)
-{
-    if (argc != 2) {
-        std::cout << "Usage: mpprinter <fd>\n";
-        return 1;
-    }
-    int fd;
-    if (std::from_chars(argv[1], argv[1] + strlen(argv[1]), fd).ec != std::errc{}) {
-        std::cerr << argv[1] << " is not a number or is larger than an int\n";
-        return 1;
-    }
-    mp::EventLoop loop("mpprinter", LogPrint);
-    std::unique_ptr<Init> init = std::make_unique<InitImpl>();
-    mp::ServeStream<InitInterface>(loop, fd, *init);
-    loop.loop();
-    return 0;
-}
diff --git a/src/ipc/libmultiprocess/example/printer.h b/src/ipc/libmultiprocess/example/printer.h
deleted file mode 100644
index fbdb35c057ea..000000000000
--- a/src/ipc/libmultiprocess/example/printer.h
+++ /dev/null
@@ -1,17 +0,0 @@
-// 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 EXAMPLE_PRINTER_H
-#define EXAMPLE_PRINTER_H
-
-#include <string>
-
-class Printer
-{
-public:
-    virtual ~Printer() = default;
-    virtual void print(const std::string& message) = 0;
-};
-
-#endif // EXAMPLE_PRINTER_H
diff --git a/src/ipc/libmultiprocess/example/types.h b/src/ipc/libmultiprocess/example/types.h
deleted file mode 100644
index c926a00b40df..000000000000
--- a/src/ipc/libmultiprocess/example/types.h
+++ /dev/null
@@ -1,23 +0,0 @@
-// 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 EXAMPLE_TYPES_H
-#define EXAMPLE_TYPES_H
-
-#include <calculator.capnp.proxy-types.h>
-#include <printer.capnp.proxy-types.h>
-
-// IWYU pragma: begin_exports
-#include <mp/type-context.h>
-#include <mp/type-decay.h>
-#include <mp/type-interface.h>
-#include <mp/type-string.h>
-#include <mp/type-threadmap.h>
-// IWYU pragma: end_exports
-
-struct InitInterface; // IWYU pragma: export
-struct CalculatorInterface; // IWYU pragma: export
-struct PrinterInterface; // IWYU pragma: export
-
-#endif // EXAMPLE_TYPES_H
diff --git a/src/ipc/libmultiprocess/include/mp/config.h.in b/src/ipc/libmultiprocess/include/mp/config.h.in
deleted file mode 100644
index 9d3c62409ae7..000000000000
--- a/src/ipc/libmultiprocess/include/mp/config.h.in
+++ /dev/null
@@ -1,16 +0,0 @@
-// 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 MP_CONFIG_H
-#define MP_CONFIG_H
-
-#cmakedefine CMAKE_INSTALL_PREFIX "@CMAKE_INSTALL_PREFIX@"
-#cmakedefine capnp_PREFIX "@capnp_PREFIX@"
-#cmakedefine HAVE_KJ_FILESYSTEM
-
-#cmakedefine HAVE_PTHREAD_GETNAME_NP @HAVE_PTHREAD_GETNAME_NP@
-#cmakedefine HAVE_PTHREAD_THREADID_NP @HAVE_PTHREAD_THREADID_NP@
-#cmakedefine HAVE_PTHREAD_GETTHREADID_NP @HAVE_PTHREAD_GETTHREADID_NP@
-
-#endif // MP_CONFIG_H
diff --git a/src/ipc/libmultiprocess/include/mp/proxy-io.h b/src/ipc/libmultiprocess/include/mp/proxy-io.h
deleted file mode 100644
index d7b9f0e54683..000000000000
--- a/src/ipc/libmultiprocess/include/mp/proxy-io.h
+++ /dev/null
@@ -1,882 +0,0 @@
-// 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 MP_PROXY_IO_H
-#define MP_PROXY_IO_H
-
-#include <mp/proxy.h>
-#include <mp/util.h>
-
-#include <mp/proxy.capnp.h>
-
-#include <capnp/rpc-twoparty.h>
-
-#include <assert.h>
-#include <condition_variable>
-#include <functional>
-#include <kj/function.h>
-#include <map>
-#include <memory>
-#include <optional>
-#include <sstream>
-#include <string>
-#include <thread>
-
-namespace mp {
-struct ThreadContext;
-
-struct InvokeContext
-{
-    Connection& connection;
-};
-
-struct ClientInvokeContext : InvokeContext
-{
-    ThreadContext& thread_context;
-    ClientInvokeContext(Connection& conn, ThreadContext& thread_context)
-        : InvokeContext{conn}, thread_context{thread_context}
-    {
-    }
-};
-
-template <typename ProxyServer, typename CallContext_>
-struct ServerInvokeContext : InvokeContext
-{
-    using CallContext = CallContext_;
-
-    ProxyServer& proxy_server;
-    CallContext& call_context;
-    int req;
-    //! For IPC methods that execute asynchronously, not on the event-loop
-    //! thread: lock preventing the event-loop thread from freeing the params or
-    //! results structs if the request is canceled while the worker thread is
-    //! reading params (`call_context.getParams()`) or writing results
-    //! (`call_context.getResults()`).
-    Lock* cancel_lock{nullptr};
-    //! For IPC methods that execute asynchronously, not on the event-loop
-    //! thread, this is set to true if the IPC call was canceled by the client
-    //! or canceled by a disconnection. If the call runs on the event-loop
-    //! thread, it can't be canceled. This should be accessed with cancel_lock
-    //! held if it is not null, since in the asynchronous case it is accessed
-    //! from multiple threads.
-    bool request_canceled{false};
-
-    ServerInvokeContext(ProxyServer& proxy_server, CallContext& call_context, int req)
-        : InvokeContext{*proxy_server.m_context.connection}, proxy_server{proxy_server}, call_context{call_context}, req{req}
-    {
-    }
-};
-
-template <typename Interface, typename Params, typename Results>
-using ServerContext = ServerInvokeContext<ProxyServer<Interface>, ::capnp::CallContext<Params, Results>>;
-
-template <>
-struct ProxyClient<Thread> : public ProxyClientBase<Thread, ::capnp::Void>
-{
-    using ProxyClientBase::ProxyClientBase;
-    // https://stackoverflow.com/questions/22357887/comparing-two-mapiterators-why-does-it-need-the-copy-constructor-of-stdpair
-    ProxyClient(const ProxyClient&) = delete;
-    ~ProxyClient();
-
-    //! Reference to callback function that is run if there is a sudden
-    //! disconnect and the Connection object is destroyed before this
-    //! ProxyClient<Thread> object. The callback will destroy this object and
-    //! remove its entry from the thread's request_threads or callback_threads
-    //! map. It will also reset m_disconnect_cb so the destructor does not
-    //! access it. In the normal case where there is no sudden disconnect, the
-    //! destructor will unregister m_disconnect_cb so the callback is never run.
-    //! Since this variable is accessed from multiple threads, accesses should
-    //! be guarded with the associated Waiter::m_mutex.
-    std::optional<CleanupIt> m_disconnect_cb;
-};
-
-template <>
-struct ProxyServer<Thread> final : public Thread::Server
-{
-public:
-    ProxyServer(Connection& connection, ThreadContext& thread_context, std::thread&& thread);
-    ~ProxyServer();
-    kj::Promise<void> getName(GetNameContext context) override;
-
-    //! Run a callback function fn returning T on this thread. The function will
-    //! be queued and executed as soon as the thread is idle, and when fn
-    //! returns, the promise returned by this method will be fulfilled with the
-    //! value fn returned.
-    template<typename T, typename Fn>
-    kj::Promise<T> post(Fn&& fn);
-
-    EventLoopRef m_loop;
-    ThreadContext& m_thread_context;
-    std::thread m_thread;
-    //! Promise signaled when m_thread_context.waiter is ready and there is no
-    //! post() callback function waiting to execute.
-    kj::Promise<void> m_thread_ready{kj::READY_NOW};
-};
-
-//! Handler for kj::TaskSet failed task events.
-class LoggingErrorHandler : public kj::TaskSet::ErrorHandler
-{
-public:
-    LoggingErrorHandler(EventLoop& loop) : m_loop(loop) {}
-    void taskFailed(kj::Exception&& exception) override;
-    EventLoop& m_loop;
-};
-
-//! Log flags. Update stringify function if changed!
-enum class Log {
-    Trace = 0,
-    Debug,
-    Info,
-    Warning,
-    Error,
-    Raise,
-};
-
-kj::StringPtr KJ_STRINGIFY(Log flags);
-
-struct LogMessage {
-
-    //! Message to be logged
-    std::string message;
-
-    //! The severity level of this message
-    Log level;
-};
-
-using LogFn = std::function<void(LogMessage)>;
-
-struct LogOptions {
-
-    //! External logging callback.
-    LogFn log_fn;
-
-    //! Maximum number of characters to use when representing
-    //! request and response structs as strings.
-    size_t max_chars{200};
-
-    //! Messages with a severity level less than log_level will not be
-    //! reported.
-    Log log_level{Log::Trace};
-};
-
-class Logger
-{
-public:
-    Logger(const LogOptions& options, Log log_level) : m_options(options), m_log_level(log_level) {}
-
-    Logger(Logger&&) = delete;
-    Logger& operator=(Logger&&) = delete;
-    Logger(const Logger&) = delete;
-    Logger& operator=(const Logger&) = delete;
-
-    ~Logger() noexcept(false)
-    {
-        if (enabled()) m_options.log_fn({std::move(m_buffer).str(), m_log_level});
-    }
-
-    template <typename T>
-    friend Logger& operator<<(Logger& logger, T&& value)
-    {
-        if (logger.enabled()) logger.m_buffer << std::forward<T>(value);
-        return logger;
-    }
-
-    template <typename T>
-    friend Logger& operator<<(Logger&& logger, T&& value)
-    {
-        return logger << std::forward<T>(value);
-    }
-
-    explicit operator bool() const
-    {
-        return enabled();
-    }
-
-private:
-    bool enabled() const
-    {
-        return m_options.log_fn && m_log_level >= m_options.log_level;
-    }
-
-    const LogOptions& m_options;
-    Log m_log_level;
-    std::ostringstream m_buffer;
-};
-
-#define MP_LOGPLAIN(loop, ...) if (mp::Logger logger{(loop).m_log_opts, __VA_ARGS__}; logger) logger
-
-#define MP_LOG(loop, ...) MP_LOGPLAIN(loop, __VA_ARGS__) << "{" << LongThreadName((loop).m_exe_name) << "} "
-
-std::string LongThreadName(const char* exe_name);
-
-//! Event loop implementation.
-//!
-//! Cap'n Proto threading model is very simple: all I/O operations are
-//! asynchronous and must be performed on a single thread. This includes:
-//!
-//! - Code starting an asynchronous operation (calling a function that returns a
-//!   promise object)
-//! - Code notifying that an asynchronous operation is complete (code using a
-//!   fulfiller object)
-//! - Code handling a completed operation (code chaining or waiting for a promise)
-//!
-//! All of this code needs to access shared state, and there is no mutex that
-//! can be acquired to lock this state because Cap'n Proto
-//! assumes it will only be accessed from one thread. So all this code needs to
-//! actually run on one thread, and the EventLoop::loop() method is the entry point for
-//! this thread. ProxyClient and ProxyServer objects that use other threads and
-//! need to perform I/O operations post to this thread using EventLoop::post()
-//! and EventLoop::sync() methods.
-//!
-//! Specifically, because ProxyClient methods can be called from arbitrary
-//! threads, and ProxyServer methods can run on arbitrary threads, ProxyClient
-//! methods use the EventLoop thread to send requests, and ProxyServer methods
-//! use the thread to return results.
-//!
-//! Based on https://groups.google.com/d/msg/capnproto/TuQFF1eH2-M/g81sHaTAAQAJ
-class EventLoop
-{
-public:
-    //! Construct event loop object with default logging options.
-    EventLoop(const char* exe_name, LogFn log_fn, void* context = nullptr)
-        : EventLoop(exe_name, LogOptions{std::move(log_fn)}, context){}
-
-    //! Construct event loop object with specified logging options.
-    EventLoop(const char* exe_name, LogOptions log_opts, void* context = nullptr);
-
-    //! Backwards-compatible constructor for previous (deprecated) logging callback signature
-    EventLoop(const char* exe_name, std::function<void(bool, std::string)> old_callback, void* context = nullptr)
-        : EventLoop(exe_name,
-                LogFn{[old_callback = std::move(old_callback)](LogMessage log_data) {old_callback(log_data.level == Log::Raise, std::move(log_data.message));}},
-                context){}
-
-    ~EventLoop();
-
-    //! Run event loop. Does not return until shutdown. This should only be
-    //! called once from the m_thread_id thread. This will block until
-    //! the m_num_clients reference count is 0.
-    void loop();
-
-    //! Run function on event loop thread. Does not return until function completes.
-    //! Must be called while the loop() function is active.
-    void post(kj::Function<void()> fn);
-
-    //! Wrapper around EventLoop::post that takes advantage of the
-    //! fact that callable will not go out of scope to avoid requirement that it
-    //! be copyable.
-    template <typename Callable>
-    void sync(Callable&& callable)
-    {
-        post(std::forward<Callable>(callable));
-    }
-
-    //! Register cleanup function to run on asynchronous worker thread without
-    //! blocking the event loop thread.
-    void addAsyncCleanup(std::function<void()> fn);
-
-    //! Start asynchronous worker thread if necessary. This is only done if
-    //! there are ProxyServerBase::m_impl objects that need to be destroyed
-    //! asynchronously, without tying up the event loop thread. This can happen
-    //! when an interface does not declare a destroy() method that would allow
-    //! the client to wait for the destructor to finish and run it on a
-    //! dedicated thread. It can also happen whenever this is a broken
-    //! connection and the client is no longer around to call the destructors
-    //! and the server objects need to be garbage collected. In both cases, it
-    //! is important that ProxyServer::m_impl destructors do not run on the
-    //! eventloop thread because they may need it to do I/O if they perform
-    //! other IPC calls.
-    void startAsyncThread() MP_REQUIRES(m_mutex);
-
-    //! Check if loop should exit.
-    bool done() const MP_REQUIRES(m_mutex);
-
-    //! Process name included in thread names so combined debug output from
-    //! multiple processes is easier to understand.
-    const char* m_exe_name;
-
-    //! ID of the event loop thread
-    std::thread::id m_thread_id = std::this_thread::get_id();
-
-    //! Handle of an async worker thread. Joined on destruction. Unset if async
-    //! method has not been called.
-    std::thread m_async_thread;
-
-    //! Callback function to run on event loop thread during post() or sync() call.
-    kj::Function<void()>* m_post_fn MP_GUARDED_BY(m_mutex) = nullptr;
-
-    //! Callback functions to run on async thread.
-    std::optional<CleanupList> m_async_fns MP_GUARDED_BY(m_mutex);
-
-    //! Pipe read handle used to wake up the event loop thread.
-    int m_wait_fd = -1;
-
-    //! Pipe write handle used to wake up the event loop thread.
-    int m_post_fd = -1;
-
-    //! Number of clients holding references to ProxyServerBase objects that
-    //! reference this event loop.
-    int m_num_clients MP_GUARDED_BY(m_mutex) = 0;
-
-    //! Mutex and condition variable used to post tasks to event loop and async
-    //! thread.
-    Mutex m_mutex;
-    std::condition_variable m_cv;
-
-    //! Capnp IO context.
-    kj::AsyncIoContext m_io_context;
-
-    //! Capnp error handler. Needs to outlive m_task_set.
-    LoggingErrorHandler m_error_handler{*this};
-
-    //! Capnp list of pending promises.
-    std::unique_ptr<kj::TaskSet> m_task_set;
-
-    //! List of connections.
-    std::list<Connection> m_incoming_connections;
-
-    //! Logging options
-    LogOptions m_log_opts;
-
-    //! External context pointer.
-    void* m_context;
-
-    //! Hook called when ProxyServer<ThreadMap>::makeThread() is called.
-    std::function<void()> testing_hook_makethread;
-
-    //! Hook called on the worker thread inside makeThread(), after the thread
-    //! context is set up and thread_context promise is fulfilled, but before it
-    //! starts waiting for requests.
-    std::function<void()> testing_hook_makethread_created;
-
-    //! Hook called on the worker thread when it starts to execute an async
-    //! request. Used by tests to control timing or inject behavior at this
-    //! point in execution.
-    std::function<void()> testing_hook_async_request_start;
-
-    //! Hook called on the worker thread just before returning results.
-    std::function<void()> testing_hook_async_request_done;
-};
-
-//! Single element task queue used to handle recursive capnp calls. (If the
-//! server makes a callback into the client in the middle of a request, while the client
-//! thread is blocked waiting for server response, this is what allows the
-//! client to run the request in the same thread, the same way code would run in a
-//! single process, with the callback sharing the same thread stack as the original
-//! call.) To support this, the clientInvoke function calls Waiter::wait() to
-//! block the client IPC thread while initial request is in progress. Then if
-//! there is a callback, it is executed with Waiter::post().
-//!
-//! The Waiter class is also used server-side by `ProxyServer<Thread>::post()`
-//! to execute IPC calls on worker threads.
-struct Waiter
-{
-    Waiter() = default;
-
-    template <typename Fn>
-    bool post(Fn&& fn)
-    {
-        const Lock lock(m_mutex);
-        if (m_fn) return false;
-        m_fn = std::forward<Fn>(fn);
-        m_cv.notify_all();
-        return true;
-    }
-
-    template <class Predicate>
-    void wait(Lock& lock, Predicate pred)
-    {
-        m_cv.wait(lock.m_lock, [&]() MP_REQUIRES(m_mutex) {
-            // Important for this to be "while (m_fn)", not "if (m_fn)" to avoid
-            // a lost-wakeup bug. A new m_fn and m_cv notification might be sent
-            // after the fn() call and before the lock.lock() call in this loop
-            // in the case where a capnp response is sent and a brand new
-            // request is immediately received.
-            while (m_fn) {
-                auto fn = std::move(*m_fn);
-                m_fn.reset();
-                Unlock(lock, fn);
-            }
-            const bool done = pred();
-            return done;
-        });
-    }
-
-    //! Mutex mainly used internally by waiter class, but also used externally
-    //! to guard access to related state. Specifically, since the thread_local
-    //! ThreadContext struct owns a Waiter, the Waiter::m_mutex is used to guard
-    //! access to other parts of the struct to avoid needing to deal with more
-    //! mutexes than necessary. This mutex can be held at the same time as
-    //! EventLoop::m_mutex as long as Waiter::mutex is locked first and
-    //! EventLoop::m_mutex is locked second.
-    Mutex m_mutex;
-    std::condition_variable m_cv;
-    std::optional<kj::Function<void()>> m_fn MP_GUARDED_BY(m_mutex);
-};
-
-//! Object holding network & rpc state associated with either an incoming server
-//! connection, or an outgoing client connection. It must be created and destroyed
-//! on the event loop thread.
-//! In addition to Cap'n Proto state, it also holds lists of callbacks to run
-//! when the connection is closed.
-class Connection
-{
-public:
-    Connection(EventLoop& loop, kj::Own<kj::AsyncIoStream>&& stream_)
-        : m_loop(loop), m_stream(kj::mv(stream_)),
-          m_network(*m_stream, ::capnp::rpc::twoparty::Side::CLIENT, ::capnp::ReaderOptions()),
-          m_rpc_system(::capnp::makeRpcClient(m_network)) {}
-    Connection(EventLoop& loop,
-        kj::Own<kj::AsyncIoStream>&& stream_,
-        const std::function<::capnp::Capability::Client(Connection&)>& make_client)
-        : m_loop(loop), m_stream(kj::mv(stream_)),
-          m_network(*m_stream, ::capnp::rpc::twoparty::Side::SERVER, ::capnp::ReaderOptions()),
-          m_rpc_system(::capnp::makeRpcServer(m_network, make_client(*this))) {}
-
-    //! Run cleanup functions. Must be called from the event loop thread. First
-    //! calls synchronous cleanup functions while blocked (to free capnp
-    //! Capability::Client handles owned by ProxyClient objects), then schedules
-    //! asynchronous cleanup functions to run in a worker thread (to run
-    //! destructors of m_impl instances owned by ProxyServer objects).
-    ~Connection();
-
-    //! Register synchronous cleanup function to run on event loop thread (with
-    //! access to capnp thread local variables) when disconnect() is called.
-    //! any new i/o.
-    CleanupIt addSyncCleanup(std::function<void()> fn);
-    void removeSyncCleanup(CleanupIt it);
-
-    //! Add disconnect handler.
-    template <typename F>
-    void onDisconnect(F&& f)
-    {
-        // Add disconnect handler to local TaskSet to ensure it is canceled and
-        // will never run after connection object is destroyed. But when disconnect
-        // handler fires, do not call the function f right away, instead add it
-        // to the EventLoop TaskSet to avoid "Promise callback destroyed itself"
-        // error in the typical case where f deletes this Connection object.
-        m_on_disconnect.add(m_network.onDisconnect().then(
-            [f = std::forward<F>(f), this]() mutable { m_loop->m_task_set->add(kj::evalLater(kj::mv(f))); }));
-    }
-
-    EventLoopRef m_loop;
-    kj::Own<kj::AsyncIoStream> m_stream;
-    LoggingErrorHandler m_error_handler{*m_loop};
-    //! TaskSet used to cancel the m_network.onDisconnect() handler for remote
-    //! disconnections, if the connection is closed locally first by deleting
-    //! this Connection object.
-    kj::TaskSet m_on_disconnect{m_error_handler};
-    ::capnp::TwoPartyVatNetwork m_network;
-    std::optional<::capnp::RpcSystem<::capnp::rpc::twoparty::VatId>> m_rpc_system;
-
-    // ThreadMap interface client, used to create a remote server thread when an
-    // client IPC call is being made for the first time from a new thread.
-    ThreadMap::Client m_thread_map{nullptr};
-
-    //! Collection of server-side IPC worker threads (ProxyServer<Thread> objects previously returned by
-    //! ThreadMap.makeThread) used to service requests to clients.
-    ::capnp::CapabilityServerSet<Thread> m_threads;
-
-    //! Canceler for canceling promises that we want to discard when the
-    //! connection is destroyed. This is used to interrupt method calls that are
-    //! still executing at time of disconnection.
-    kj::Canceler m_canceler;
-
-    //! Cleanup functions to run if connection is broken unexpectedly.  List
-    //! will be empty if all ProxyClient are destroyed cleanly before the
-    //! connection is destroyed.
-    CleanupList m_sync_cleanup_fns;
-};
-
-//! Vat id for server side of connection. Required argument to RpcSystem::bootStrap()
-//!
-//! "Vat" is Cap'n Proto nomenclature for a host of various objects that facilitates
-//! bidirectional communication with other vats; it is often but not always 1-1 with
-//! processes. Cap'n Proto doesn't reference clients or servers per se; instead everything
-//! is just a vat.
-//!
-//! See also: https://github.com/capnproto/capnproto/blob/9021f0c722b36cb11e3690b0860939255ebad39c/c%2B%2B/src/capnp/rpc.capnp#L42-L56
-struct ServerVatId
-{
-    ::capnp::word scratch[4]{};
-    ::capnp::MallocMessageBuilder message{scratch};
-    ::capnp::rpc::twoparty::VatId::Builder vat_id{message.getRoot<::capnp::rpc::twoparty::VatId>()};
-    ServerVatId() { vat_id.setSide(::capnp::rpc::twoparty::Side::SERVER); }
-};
-
-template <typename Interface, typename Impl>
-ProxyClientBase<Interface, Impl>::ProxyClientBase(typename Interface::Client client,
-    Connection* connection,
-    bool destroy_connection)
-    : m_client(std::move(client)), m_context(connection)
-
-{
-    // Handler for the connection getting destroyed before this client object.
-    auto disconnect_cb = m_context.connection->addSyncCleanup([this]() {
-        // Release client capability by move-assigning to temporary.
-        {
-            typename Interface::Client(std::move(m_client));
-        }
-        Lock lock{m_context.loop->m_mutex};
-        m_context.connection = nullptr;
-    });
-
-    // Two shutdown sequences are supported:
-    //
-    // - A normal sequence where client proxy objects are deleted by external
-    //   code that no longer needs them
-    //
-    // - A garbage collection sequence where the connection or event loop shuts
-    //   down while external code is still holding client references.
-    //
-    // The first case is handled here when m_context.connection is not null. The
-    // second case is handled by the disconnect_cb function, which sets
-    // m_context.connection to null so nothing happens here.
-    m_context.cleanup_fns.emplace_front([this, destroy_connection, disconnect_cb]{
-    {
-        // If the capnp interface defines a destroy method, call it to destroy
-        // the remote object, waiting for it to be deleted server side. If the
-        // capnp interface does not define a destroy method, this will just call
-        // an empty stub defined in the ProxyClientBase class and do nothing.
-        Sub::destroy(*this);
-
-        // FIXME: Could just invoke removed addCleanup fn here instead of duplicating code
-        m_context.loop->sync([&]() {
-            // Remove disconnect callback on cleanup so it doesn't run and try
-            // to access this object after it's destroyed. This call needs to
-            // run inside loop->sync() on the event loop thread because
-            // otherwise, if there were an ill-timed disconnect, the
-            // onDisconnect handler could fire and delete the Connection object
-            // before the removeSyncCleanup call.
-            if (m_context.connection) m_context.connection->removeSyncCleanup(disconnect_cb);
-
-            // Release client capability by move-assigning to temporary.
-            {
-                typename Interface::Client(std::move(m_client));
-            }
-            if (destroy_connection) {
-                delete m_context.connection;
-                m_context.connection = nullptr;
-            }
-        });
-    }
-    });
-    Sub::construct(*this);
-}
-
-template <typename Interface, typename Impl>
-ProxyClientBase<Interface, Impl>::~ProxyClientBase() noexcept
-{
-    CleanupRun(m_context.cleanup_fns);
-}
-
-template <typename Interface, typename Impl>
-ProxyServerBase<Interface, Impl>::ProxyServerBase(std::shared_ptr<Impl> impl, Connection& connection)
-    : m_impl(std::move(impl)), m_context(&connection)
-{
-    assert(m_impl);
-}
-
-//! ProxyServer destructor, called from the EventLoop thread by Cap'n Proto
-//! garbage collection code after there are no more references to this object.
-//! This will typically happen when the corresponding ProxyClient object on the
-//! other side of the connection is destroyed. It can also happen earlier if the
-//! connection is broken or destroyed. In the latter case this destructor will
-//! typically be called inside m_rpc_system.reset() call in the ~Connection
-//! destructor while the Connection object still exists. However, because
-//! ProxyServer objects are refcounted, and the Connection object could be
-//! destroyed while asynchronous IPC calls are still in-flight, it's possible
-//! for this destructor to be called after the Connection object no longer
-//! exists, so it is NOT valid to dereference the m_context.connection pointer
-//! from this function.
-template <typename Interface, typename Impl>
-ProxyServerBase<Interface, Impl>::~ProxyServerBase()
-{
-    if (m_impl) {
-        // If impl is non-null at this point, it means no client is waiting for
-        // the m_impl server object to be destroyed synchronously. This can
-        // happen either if the interface did not define a "destroy" method (see
-        // invokeDestroy method below), or if a destroy method was defined, but
-        // the connection was broken before it could be called.
-        //
-        // In either case, be conservative and run the cleanup on an
-        // asynchronous thread, to avoid destructors or cleanup functions
-        // blocking or deadlocking the current EventLoop thread, since they
-        // could be making IPC calls.
-        //
-        // Technically this is a little too conservative since if the interface
-        // defines a "destroy" method, but the destroy method does not accept a
-        // Context parameter specifying a worker thread, the cleanup method
-        // would run on the EventLoop thread normally (when connection is
-        // unbroken), but will not run on the EventLoop thread now (when
-        // connection is broken). Probably some refactoring of the destructor
-        // and invokeDestroy function is possible to make this cleaner and more
-        // consistent.
-        m_context.loop->addAsyncCleanup([impl=std::move(m_impl), fns=std::move(m_context.cleanup_fns)]() mutable {
-            impl.reset();
-            CleanupRun(fns);
-        });
-    }
-    assert(m_context.cleanup_fns.empty());
-}
-
-//! If the capnp interface defined a special "destroy" method, as described the
-//! ProxyClientBase class, this method will be called and synchronously destroy
-//! m_impl before returning to the client.
-//!
-//! If the capnp interface does not define a "destroy" method, this will never
-//! be called and the ~ProxyServerBase destructor will be responsible for
-//! deleting m_impl asynchronously, whenever the ProxyServer object gets garbage
-//! collected by Cap'n Proto.
-//!
-//! This method is called in the same way other proxy server methods are called,
-//! via the serverInvoke function. Basically serverInvoke just calls this as a
-//! substitute for a non-existent m_impl->destroy() method. If the destroy
-//! method has any parameters or return values they will be handled in the
-//! normal way by PassField/ReadField/BuildField functions. Particularly if a
-//! Context.thread parameter was passed, this method will run on the worker
-//! thread specified by the client. Otherwise it will run on the EventLoop
-//! thread, like other server methods without an assigned thread.
-template <typename Interface, typename Impl>
-void ProxyServerBase<Interface, Impl>::invokeDestroy()
-{
-    m_impl.reset();
-    CleanupRun(m_context.cleanup_fns);
-}
-
-//! Map from Connection to local or remote thread handle which will be used over
-//! that connection. This map will typically only contain one entry, but can
-//! contain multiple if a single thread makes IPC calls over multiple
-//! connections. A std::optional value type is used to avoid the map needing to
-//! be locked while ProxyClient<Thread> objects are constructed, see
-//! ThreadContext "Synchronization note" below.
-using ConnThreads = std::map<Connection*, std::optional<ProxyClient<Thread>>>;
-using ConnThread = ConnThreads::iterator;
-
-// Retrieve ProxyClient<Thread> object associated with this connection from a
-// map, or create a new one and insert it into the map. Return map iterator and
-// inserted bool.
-std::tuple<ConnThread, bool> SetThread(GuardedRef<ConnThreads> threads, Connection* connection, const std::function<Thread::Client()>& make_thread);
-
-//! The thread_local ThreadContext g_thread_context struct provides information
-//! about individual threads and a way of communicating between them. Because
-//! it's a thread local struct, each ThreadContext instance is initialized by
-//! the thread that owns it.
-//!
-//! ThreadContext is used for any client threads created externally which make
-//! IPC calls, and for server threads created by
-//! ProxyServer<ThreadMap>::makeThread() which execute IPC calls for clients.
-//!
-//! In both cases, the struct holds information like the thread name, and a
-//! Waiter object where the EventLoop can post incoming IPC requests to execute
-//! on the thread. The struct also holds ConnThread maps associating the thread
-//! with local and remote ProxyClient<Thread> objects.
-struct ThreadContext
-{
-    //! Identifying string for debug.
-    std::string thread_name;
-
-    //! Waiter object used to allow remote clients to execute code on this
-    //! thread. For server threads created by
-    //! ProxyServer<ThreadMap>::makeThread(), this is initialized in that
-    //! function. Otherwise, for client threads created externally, this is
-    //! initialized the first time the thread tries to make an IPC call. Having
-    //! a waiter is necessary for threads making IPC calls in case a server they
-    //! are calling expects them to execute a callback during the call, before
-    //! it sends a response.
-    //!
-    //! For IPC client threads, the Waiter pointer is never cleared and the Waiter
-    //! just gets destroyed when the thread does. For server threads created by
-    //! makeThread(), this pointer is set to null in the ~ProxyServer<Thread> as
-    //! a signal for the thread to exit and destroy itself. In both cases, the
-    //! same Waiter object is used across different calls and only created and
-    //! destroyed once for the lifetime of the thread.
-    std::unique_ptr<Waiter> waiter = nullptr;
-
-    //! When client is making a request to a server, this is the
-    //! `callbackThread` argument it passes in the request, used by the server
-    //! in case it needs to make callbacks into the client that need to execute
-    //! while the client is waiting. This will be set to a local thread object.
-    //!
-    //! Synchronization note: The callback_thread and request_thread maps are
-    //! only ever accessed internally by this thread's destructor and externally
-    //! by Cap'n Proto event loop threads. Since it's possible for IPC client
-    //! threads to make calls over different connections that could have
-    //! different event loops, these maps are guarded by Waiter::m_mutex in case
-    //! different event loop threads add or remove map entries simultaneously.
-    //! However, individual ProxyClient<Thread> objects in the maps will only be
-    //! associated with one event loop and guarded by EventLoop::m_mutex. So
-    //! Waiter::m_mutex does not need to be held while accessing individual
-    //! ProxyClient<Thread> instances, and may even need to be released to
-    //! respect lock order and avoid locking Waiter::m_mutex before
-    //! EventLoop::m_mutex.
-    ConnThreads callback_threads MP_GUARDED_BY(waiter->m_mutex);
-
-    //! When client is making a request to a server, this is the `thread`
-    //! argument it passes in the request, used to control which thread on
-    //! server will be responsible for executing it. If client call is being
-    //! made from a local thread, this will be a remote thread object returned
-    //! by makeThread. If a client call is being made from a thread currently
-    //! handling a server request, this will be set to the `callbackThread`
-    //! request thread argument passed in that request.
-    //!
-    //! Synchronization note: \ref callback_threads note applies here as well.
-    ConnThreads request_threads MP_GUARDED_BY(waiter->m_mutex);
-
-    //! Whether this thread is a capnp event loop thread. Not really used except
-    //! to assert false if there's an attempt to execute a blocking operation
-    //! which could deadlock the thread.
-    bool loop_thread = false;
-};
-
-template<typename T, typename Fn>
-kj::Promise<T> ProxyServer<Thread>::post(Fn&& fn)
-{
-    auto ready = kj::newPromiseAndFulfiller<void>(); // Signaled when waiter is ready to post again.
-    auto cancel_monitor_ptr = kj::heap<CancelMonitor>();
-    CancelMonitor& cancel_monitor = *cancel_monitor_ptr;
-    // Keep a reference to the ProxyServer<Thread> instance by assigning it to
-    // the self variable. ProxyServer instances are reference-counted and if the
-    // client drops its reference, this variable keeps the instance alive until
-    // the thread finishes executing. The self variable needs to be destroyed on
-    // the event loop thread so it is freed in a sync() call below.
-    auto self = thisCap();
-    auto ret = m_thread_ready.then([this, self = std::move(self), fn = std::forward<Fn>(fn), ready_fulfiller = kj::mv(ready.fulfiller), cancel_monitor_ptr = kj::mv(cancel_monitor_ptr)]() mutable {
-        auto result = kj::newPromiseAndFulfiller<T>(); // Signaled when fn() is called, with its return value.
-        bool posted = m_thread_context.waiter->post([this, self = std::move(self), fn = std::forward<Fn>(fn), ready_fulfiller = kj::mv(ready_fulfiller), result_fulfiller = kj::mv(result.fulfiller), cancel_monitor_ptr = kj::mv(cancel_monitor_ptr)]() mutable {
-            // Fulfill ready.promise now, as soon as the Waiter starts executing
-            // this lambda, so the next ProxyServer<Thread>::post() call can
-            // immediately call waiter->post(). It is important to do this
-            // before calling fn() because fn() can make an IPC call back to the
-            // client, which can make another IPC call to this server thread.
-            // (This typically happens when IPC methods take std::function
-            // parameters.) When this happens the second call to the server
-            // thread should not be blocked waiting for the first call.
-            m_loop->sync([ready_fulfiller = kj::mv(ready_fulfiller)]() mutable {
-                ready_fulfiller->fulfill();
-                ready_fulfiller = nullptr;
-            });
-            std::optional<T> result_value;
-            kj::Maybe<kj::Exception> exception{kj::runCatchingExceptions([&]{ result_value.emplace(fn(*cancel_monitor_ptr)); })};
-            m_loop->sync([this, &result_value, &exception, self = kj::mv(self), result_fulfiller = kj::mv(result_fulfiller), cancel_monitor_ptr = kj::mv(cancel_monitor_ptr)]() mutable {
-                // Destroy CancelMonitor here before fulfilling or rejecting the
-                // promise so it doesn't get triggered when the promise is
-                // destroyed.
-                cancel_monitor_ptr = nullptr;
-                // Send results to the fulfiller. Technically it would be ok to
-                // skip this if promise was canceled, but it's simpler to just
-                // do it unconditionally.
-                KJ_IF_MAYBE(e, exception) {
-                    assert(!result_value);
-                    result_fulfiller->reject(kj::mv(*e));
-                } else {
-                    assert(result_value);
-                    result_fulfiller->fulfill(kj::mv(*result_value));
-                    result_value.reset();
-                }
-                result_fulfiller = nullptr;
-                // Use evalLater to destroy the ProxyServer<Thread> self
-                // reference, if it is the last reference, because the
-                // ProxyServer<Thread> destructor needs to join the thread,
-                // which can't happen until this sync() block has exited.
-                m_loop->m_task_set->add(kj::evalLater([self = kj::mv(self)] {}));
-            });
-        });
-        // Assert that calling Waiter::post did not fail. It could only return
-        // false if a new function was posted before the previous one finished
-        // executing, but new functions are only posted when m_thread_ready is
-        // signaled, so this should never happen.
-        assert(posted);
-        return kj::mv(result.promise);
-    }).attach(kj::heap<CancelProbe>(cancel_monitor));
-    m_thread_ready = kj::mv(ready.promise);
-    return ret;
-}
-
-//! Given stream file descriptor, make a new ProxyClient object to send requests
-//! over the stream. Also create a new Connection object embedded in the
-//! client that is freed when the client is closed.
-template <typename InitInterface>
-std::unique_ptr<ProxyClient<InitInterface>> ConnectStream(EventLoop& loop, int fd)
-{
-    typename InitInterface::Client init_client(nullptr);
-    std::unique_ptr<Connection> connection;
-    loop.sync([&] {
-        auto stream =
-            loop.m_io_context.lowLevelProvider->wrapSocketFd(fd, kj::LowLevelAsyncIoProvider::TAKE_OWNERSHIP);
-        connection = std::make_unique<Connection>(loop, kj::mv(stream));
-        init_client = connection->m_rpc_system->bootstrap(ServerVatId().vat_id).castAs<InitInterface>();
-        Connection* connection_ptr = connection.get();
-        connection->onDisconnect([&loop, connection_ptr] {
-            MP_LOG(loop, Log::Warning) << "IPC client: unexpected network disconnect.";
-            delete connection_ptr;
-        });
-    });
-    return std::make_unique<ProxyClient<InitInterface>>(
-        kj::mv(init_client), connection.release(), /* destroy_connection= */ true);
-}
-
-//! Given stream and init objects, construct a new ProxyServer object that
-//! handles requests from the stream by calling the init object. Embed the
-//! ProxyServer in a Connection object that is stored and erased if
-//! disconnected. This should be called from the event loop thread.
-template <typename InitInterface, typename InitImpl>
-void _Serve(EventLoop& loop, kj::Own<kj::AsyncIoStream>&& stream, InitImpl& init)
-{
-    loop.m_incoming_connections.emplace_front(loop, kj::mv(stream), [&](Connection& connection) {
-        // Disable deleter so proxy server object doesn't attempt to delete the
-        // init implementation when the proxy client is destroyed or
-        // disconnected.
-        return kj::heap<ProxyServer<InitInterface>>(std::shared_ptr<InitImpl>(&init, [](InitImpl*){}), connection);
-    });
-    auto it = loop.m_incoming_connections.begin();
-    MP_LOG(loop, Log::Info) << "IPC server: socket connected.";
-    it->onDisconnect([&loop, it] {
-        MP_LOG(loop, Log::Info) << "IPC server: socket disconnected.";
-        loop.m_incoming_connections.erase(it);
-    });
-}
-
-//! Given connection receiver and an init object, handle incoming connections by
-//! calling _Serve, to create ProxyServer objects and forward requests to the
-//! init object.
-template <typename InitInterface, typename InitImpl>
-void _Listen(EventLoop& loop, kj::Own<kj::ConnectionReceiver>&& listener, InitImpl& init)
-{
-    auto* ptr = listener.get();
-    loop.m_task_set->add(ptr->accept().then(
-        [&loop, &init, listener = kj::mv(listener)](kj::Own<kj::AsyncIoStream>&& stream) mutable {
-            _Serve<InitInterface>(loop, kj::mv(stream), init);
-            _Listen<InitInterface>(loop, kj::mv(listener), init);
-        }));
-}
-
-//! Given stream file descriptor and an init object, handle requests on the
-//! stream by calling methods on the Init object.
-template <typename InitInterface, typename InitImpl>
-void ServeStream(EventLoop& loop, int fd, InitImpl& init)
-{
-    _Serve<InitInterface>(
-        loop, loop.m_io_context.lowLevelProvider->wrapSocketFd(fd, kj::LowLevelAsyncIoProvider::TAKE_OWNERSHIP), init);
-}
-
-//! Given listening socket file descriptor and an init object, handle incoming
-//! connections and requests by calling methods on the Init object.
-template <typename InitInterface, typename InitImpl>
-void ListenConnections(EventLoop& loop, int fd, InitImpl& init)
-{
-    loop.sync([&]() {
-        _Listen<InitInterface>(loop,
-            loop.m_io_context.lowLevelProvider->wrapListenSocketFd(fd, kj::LowLevelAsyncIoProvider::TAKE_OWNERSHIP),
-            init);
-    });
-}
-
-extern thread_local ThreadContext g_thread_context; // NOLINT(bitcoin-nontrivial-threadlocal)
-// Silence nonstandard bitcoin tidy error "Variable with non-trivial destructor
-// cannot be thread_local" which should not be a problem on modern platforms, and
-// could lead to a small memory leak at worst on older ones.
-
-} // namespace mp
-
-#endif // MP_PROXY_IO_H
diff --git a/src/ipc/libmultiprocess/include/mp/proxy-types.h b/src/ipc/libmultiprocess/include/mp/proxy-types.h
deleted file mode 100644
index c13debf361d9..000000000000
--- a/src/ipc/libmultiprocess/include/mp/proxy-types.h
+++ /dev/null
@@ -1,829 +0,0 @@
-// 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 MP_PROXY_TYPES_H
-#define MP_PROXY_TYPES_H
-
-#include <mp/proxy-io.h>
-
-#include <exception>
-#include <optional>
-#include <set>
-#include <typeindex>
-#include <vector>
-
-namespace mp {
-
-template <typename Value>
-class ValueField
-{
-public:
-    ValueField(Value& value) : m_value(value) {}
-    ValueField(Value&& value) : m_value(value) {}
-    Value& m_value;
-
-    const Value& get() const { return m_value; }
-    Value& get() { return m_value; }
-    Value& init() { return m_value; }
-    bool has() const { return true; }
-};
-
-template <typename Accessor, typename Struct>
-struct StructField
-{
-    template <typename S>
-    StructField(S& struct_) : m_struct(struct_)
-    {
-    }
-    Struct& m_struct;
-
-    decltype(auto) get() const { return Accessor::get(this->m_struct); }
-
-    bool has() const {
-      if constexpr (Accessor::optional) {
-        return Accessor::getHas(m_struct);
-      } else if constexpr (Accessor::boxed) {
-        return Accessor::has(m_struct);
-      } else {
-        return true;
-      }
-    }
-
-    bool want() const {
-      if constexpr (Accessor::requested) {
-        return Accessor::getWant(m_struct);
-      } else {
-        return true;
-      }
-    }
-
-    template <typename... Args> decltype(auto) set(Args &&...args) const {
-      return Accessor::set(this->m_struct, std::forward<Args>(args)...);
-    }
-
-    template <typename... Args> decltype(auto) init(Args &&...args) const {
-      return Accessor::init(this->m_struct, std::forward<Args>(args)...);
-    }
-
-    void setHas() const {
-      if constexpr (Accessor::optional) {
-        Accessor::setHas(m_struct);
-      }
-    }
-
-    void setWant() const {
-      if constexpr (Accessor::requested) {
-        Accessor::setWant(m_struct);
-      }
-    }
-};
-
-
-
-// Destination parameter type that can be passed to ReadField function as an
-// alternative to ReadDestUpdate. It allows the ReadField implementation to call
-// the provided emplace_fn function with constructor arguments, so it only needs
-// to determine the arguments, and can let the emplace function decide how to
-// actually construct the read destination object. For example, if a std::string
-// is being read, the ReadField call will call the custom emplace_fn with char*
-// and size_t arguments, and the emplace function can decide whether to call the
-// constructor via the operator, make_shared, emplace or just return a
-// temporary string that is moved from.
-template <typename LocalType, typename EmplaceFn>
-struct ReadDestEmplace
-{
-    ReadDestEmplace(TypeList<LocalType>, EmplaceFn emplace_fn) : m_emplace_fn(std::move(emplace_fn)) {}
-
-    //! Simple case. If ReadField implementation calls this construct() method
-    //! with constructor arguments, just pass them on to the emplace function.
-    template <typename... Args>
-    decltype(auto) construct(Args&&... args)
-    {
-        return m_emplace_fn(std::forward<Args>(args)...);
-    }
-
-    //! More complicated case. If ReadField implementation works by calling this
-    //! update() method, adapt it call construct() instead. This requires
-    //! LocalType to have a default constructor to create new object that can be
-    //! passed to update()
-    template <typename UpdateFn>
-    decltype(auto) update(UpdateFn&& update_fn)
-    {
-        if constexpr (std::is_const_v<std::remove_reference_t<std::invoke_result_t<EmplaceFn>>>) {
-            // If destination type is const, default construct temporary
-            // to pass to update, then call move constructor via construct() to
-            // move from that temporary.
-            std::remove_cv_t<LocalType> temp;
-            update_fn(temp);
-            return construct(std::move(temp));
-        } else {
-            // Default construct object and pass it to update_fn.
-            decltype(auto) temp = construct();
-            update_fn(temp);
-            return temp;
-        }
-    }
-    EmplaceFn m_emplace_fn;
-};
-
-//! Helper function to create a ReadDestEmplace object that constructs a
-//! temporary, ReadField can return.
-template <typename LocalType>
-auto ReadDestTemp()
-{
-    return ReadDestEmplace{TypeList<LocalType>(), [](auto&&... args) -> decltype(auto) {
-        return LocalType{std::forward<decltype(args)>(args)...};
-    }};
-}
-
-//! Destination parameter type that can be passed to ReadField function as an
-//! alternative to ReadDestEmplace. Instead of requiring an emplace callback to
-//! construct a new value, it just takes a reference to an existing value and
-//! assigns a new value to it.
-template <typename Value>
-struct ReadDestUpdate
-{
-    ReadDestUpdate(Value& value) : m_value(value) {}
-
-    //! Simple case. If ReadField works by calling update() just forward arguments to update_fn.
-    template <typename UpdateFn>
-    Value& update(UpdateFn&& update_fn)
-    {
-        update_fn(m_value);
-        return m_value;
-    }
-
-    //! More complicated case. If ReadField works by calling construct(), need
-    //! to reconstruct m_value in place.
-    template <typename... Args>
-    Value& construct(Args&&... args)
-    {
-        m_value.~Value();
-        new (&m_value) Value(std::forward<Args>(args)...);
-        return m_value;
-    }
-
-    Value& m_value;
-};
-
-//! Return whether to read a C++ value from a Cap'n Proto field. Returning
-//! false can be useful to interpret certain Cap'n Proto field values as null
-//! C++ values when initializing nullable C++ std::optional / std::unique_ptr /
-//! std::shared_ptr types.
-//!
-//! For example, when reading from a `List(Data)` field into a
-//! `std::vector<std::shared_ptr<const CTransaction>>` value, it's useful to be
-//! able to interpret empty `Data` values as null pointers. This is useful
-//! because the Cap'n Proto C++ API does not currently provide a way to
-//! distinguish between null and empty Data values in a List[*], so we need to
-//! choose some Data value to represent null if we want to allow passing null
-//! pointers. Since no CTransaction is ever serialized as empty Data, it's safe
-//! to use empty Data values to represent null pointers.
-//!
-//! [*] The Cap'n Proto wire format actually does distinguish between null and
-//! empty Data values inside Lists, and the C++ API does allow distinguishing
-//! between null and empty Data values in other contexts, just not the List
-//! context, so this limitation could be removed in the future.
-//!
-//! Design note: CustomHasField() and CustomHasValue() are inverses of each
-//! other.  CustomHasField() allows leaving Cap'n Proto fields unset when C++
-//! types have certain values, and CustomHasValue() allows leaving C++ values
-//! unset when Cap'n Proto fields have certain values. But internally the
-//! functions get called in different ways. This is because in C++, unlike in
-//! Cap'n Proto not every C++ type is default constructible, and it may be
-//! impossible to leave certain C++ values unset. For example if a C++ method
-//! requires function parameters, there's no way to call the function without
-//! constructing values for each of the parameters. Similarly there's no way to
-//! add values to C++ vectors or maps without initializing those values.  This
-//! is not the case in Cap'n Proto where all values are optional and it's
-//! possible to skip initializing parameters and list elements.
-//!
-//! Because of this difference, CustomHasValue() works universally and can be
-//! used to disable BuildField() calls in every context, while CustomHasField()
-//! can only be used to disable ReadField() calls in certain contexts like
-//! std::optional and pointer contexts.
-template <typename... LocalTypes, typename Input>
-bool CustomHasField(TypeList<LocalTypes...>, InvokeContext& invoke_context, const Input& input)
-{
-    return input.has();
-}
-
-template <typename... LocalTypes, typename Input, typename... Args>
-decltype(auto) ReadField(TypeList<LocalTypes...>, InvokeContext& invoke_context, Input&& input, Args&&... args)
-{
-    return CustomReadField(TypeList<RemoveCvRef<LocalTypes>...>(), Priority<2>(), invoke_context, std::forward<Input>(input), std::forward<Args>(args)...);
-}
-
-template <typename LocalType, typename Input>
-void ThrowField(TypeList<LocalType>, InvokeContext& invoke_context, Input&& input)
-{
-    ReadField(
-        TypeList<LocalType>(), invoke_context, input, ReadDestEmplace(TypeList<LocalType>(),
-            [](auto&& ...args) -> const LocalType& { throw LocalType{std::forward<decltype(args)>(args)...}; }));
-}
-
-//! Special case for generic std::exception. It's an abstract type so it can't
-//! be created directly. Rethrow as std::runtime_error so callers expecting it
-//! will still catch it.
-template <typename Input>
-void ThrowField(TypeList<std::exception>, InvokeContext& invoke_context, Input&& input)
-{
-    auto data = input.get();
-    throw std::runtime_error(std::string(CharCast(data.begin()), data.size()));
-}
-
-//! Return whether to write a C++ value into a Cap'n Proto field. Returning
-//! false can be useful to map certain C++ values to unset Cap'n Proto fields.
-//!
-//! For example the bitcoin `Coin` class asserts false when a spent coin is
-//! serialized. But some C++ methods return these coins, so there needs to be a
-//! way to represent them in Cap'n Proto and a null Data field is a convenient
-//! representation.
-template <typename... Values>
-bool CustomHasValue(InvokeContext& invoke_context, const Values&... value)
-{
-    return true;
-}
-
-template <typename... LocalTypes, typename Context, typename... Values, typename Output>
-void BuildField(TypeList<LocalTypes...>, Context& context, Output&& output, Values&&... values)
-{
-    if (CustomHasValue(context, values...)) {
-        CustomBuildField(TypeList<LocalTypes...>(), Priority<3>(), context, std::forward<Values>(values)...,
-            std::forward<Output>(output));
-    }
-}
-
-// Adapter that allows BuildField overloads to work with, set, and initialize list
-// elements as if they were fields of a struct. If BuildField is changed to use some
-// kind of accessor class instead of calling method pointers, then maybe this could
-// go away or be simplified, because there would no longer be a need to return
-// ListOutput method pointers emulating capnp struct method pointers.
-template <typename ListType>
-struct ListOutput;
-
-template <typename T, ::capnp::Kind kind>
-struct ListOutput<::capnp::List<T, kind>>
-{
-    using Builder = typename ::capnp::List<T, kind>::Builder;
-
-    ListOutput(Builder& builder, size_t index) : m_builder(builder), m_index(index) {}
-    Builder& m_builder;
-    size_t m_index;
-
-    // clang-format off
-    decltype(auto) get() const { return this->m_builder[this->m_index]; }
-    decltype(auto) init() const { return this->m_builder[this->m_index]; }
-    template<typename B = Builder, typename Arg> decltype(auto) set(Arg&& arg) const { return static_cast<B&>(this->m_builder).set(m_index, std::forward<Arg>(arg)); }
-    template<typename B = Builder, typename Arg> decltype(auto) init(Arg&& arg) const { return static_cast<B&>(this->m_builder).init(m_index, std::forward<Arg>(arg)); }
-    // clang-format on
-};
-
-template <typename LocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<LocalType>, Priority<0>, InvokeContext& invoke_context, Value&& value, Output&& output)
-{
-    output.set(BuildPrimitive(invoke_context, std::forward<Value>(value), TypeList<decltype(output.get())>()));
-}
-
-//! PassField override for callable interface reference arguments.
-template <typename Accessor, typename LocalType, typename ServerContext, typename Fn, typename... Args>
-auto PassField(Priority<1>, TypeList<LocalType&>, ServerContext& server_context, Fn&& fn, Args&&... args)
-    -> Require<typename decltype(Accessor::get(server_context.call_context.getParams()))::Calls>
-{
-    // Just create a temporary ProxyClient if argument is a reference to an
-    // interface client. If argument needs to have a longer lifetime and not be
-    // destroyed after this call, a CustomPassField overload can be implemented
-    // to bypass this code, and a custom ProxyServerMethodTraits overload can be
-    // implemented in order to read the capability pointer out of params and
-    // construct a ProxyClient with a longer lifetime.
-    const auto& params = server_context.call_context.getParams();
-    const auto& input = Make<StructField, Accessor>(params);
-    using Interface = typename Decay<decltype(input.get())>::Calls;
-    auto param = std::make_unique<ProxyClient<Interface>>(input.get(), server_context.proxy_server.m_context.connection, false);
-    fn.invoke(server_context, std::forward<Args>(args)..., *param);
-}
-
-template <typename... Args>
-void MaybeBuildField(std::true_type, Args&&... args)
-{
-    BuildField(std::forward<Args>(args)...);
-}
-template <typename... Args>
-void MaybeBuildField(std::false_type, Args&&...)
-{
-}
-template <typename... Args>
-void MaybeReadField(std::true_type, Args&&... args)
-{
-    ReadField(std::forward<Args>(args)...);
-}
-template <typename... Args>
-void MaybeReadField(std::false_type, Args&&...)
-{
-}
-
-template <typename LocalType, typename Value, typename Output>
-void MaybeSetWant(TypeList<LocalType*>, Priority<1>, const Value& value, Output&& output)
-{
-    if (value) {
-        output.setWant();
-    }
-}
-
-template <typename LocalTypes, typename... Args>
-void MaybeSetWant(LocalTypes, Priority<0>, const Args&...)
-{
-}
-
-//! Default PassField implementation calling MaybeReadField/MaybeBuildField.
-template <typename Accessor, typename LocalType, typename ServerContext, typename Fn, typename... Args>
-void PassField(Priority<0>, TypeList<LocalType>, ServerContext& server_context, Fn&& fn, Args&&... args)
-{
-    InvokeContext& invoke_context = server_context;
-    using ArgType = RemoveCvRef<LocalType>;
-    std::optional<ArgType> param;
-    const auto& params = server_context.call_context.getParams();
-    MaybeReadField(std::integral_constant<bool, Accessor::in>(), TypeList<ArgType>(), invoke_context,
-        Make<StructField, Accessor>(params), ReadDestEmplace(TypeList<ArgType>(), [&](auto&&... args) -> auto& {
-            param.emplace(std::forward<decltype(args)>(args)...);
-            return *param;
-        }));
-    if constexpr (Accessor::in) {
-        assert(param);
-    } else {
-        if (!param) param.emplace();
-    }
-    fn.invoke(server_context, std::forward<Args>(args)..., static_cast<LocalType&&>(*param));
-    auto&& results = server_context.call_context.getResults();
-    MaybeBuildField(std::integral_constant<bool, Accessor::out>(), TypeList<LocalType>(), invoke_context,
-        Make<StructField, Accessor>(results), *param);
-}
-
-//! Default PassField implementation for count(0) arguments, calling ReadField/BuildField
-template <typename Accessor, typename ServerContext, typename Fn, typename... Args>
-void PassField(Priority<0>, TypeList<>, ServerContext& server_context, const Fn& fn, Args&&... args)
-{
-    const auto& params = server_context.call_context.getParams();
-    const auto& input = Make<StructField, Accessor>(params);
-    ReadField(TypeList<>(), server_context, input);
-    fn.invoke(server_context, std::forward<Args>(args)...);
-    auto&& results = server_context.call_context.getResults();
-    BuildField(TypeList<>(), server_context, Make<StructField, Accessor>(results));
-}
-
-template <typename Derived, size_t N = 0>
-struct IterateFieldsHelper
-{
-    template <typename Arg1, typename Arg2, typename ParamList, typename NextFn, typename... NextFnArgs>
-    void handleChain(Arg1& arg1, Arg2& arg2, ParamList, NextFn&& next_fn, NextFnArgs&&... next_fn_args)
-    {
-        using S = Split<N, ParamList>;
-        handleChain(arg1, arg2, typename S::First());
-        next_fn.handleChain(arg1, arg2, typename S::Second(),
-            std::forward<NextFnArgs>(next_fn_args)...);
-    }
-
-    template <typename Arg1, typename Arg2, typename ParamList>
-    void handleChain(Arg1& arg1, Arg2& arg2, ParamList)
-    {
-        static_cast<Derived*>(this)->handleField(arg1, arg2, ParamList());
-    }
-private:
-    IterateFieldsHelper() = default;
-    friend Derived;
-};
-
-struct IterateFields : IterateFieldsHelper<IterateFields, 0>
-{
-    template <typename Arg1, typename Arg2, typename ParamList>
-    void handleField(Arg1&&, Arg2&&, ParamList)
-    {
-    }
-};
-
-template <typename Exception, typename Accessor>
-struct ClientException
-{
-    struct BuildParams : IterateFieldsHelper<BuildParams, 0>
-    {
-        template <typename Params, typename ParamList>
-        void handleField(InvokeContext& invoke_context, Params& params, ParamList)
-        {
-        }
-
-        BuildParams(ClientException* client_exception) : m_client_exception(client_exception) {}
-        ClientException* m_client_exception;
-    };
-
-    struct ReadResults : IterateFieldsHelper<ReadResults, 0>
-    {
-        template <typename Results, typename ParamList>
-        void handleField(InvokeContext& invoke_context, Results& results, ParamList)
-        {
-            StructField<Accessor, Results> input(results);
-            if (CustomHasField(TypeList<Exception>(), invoke_context, input)) {
-                ThrowField(TypeList<Exception>(), invoke_context, input);
-            }
-        }
-
-        ReadResults(ClientException* client_exception) : m_client_exception(client_exception) {}
-        ClientException* m_client_exception;
-    };
-};
-
-template <typename Accessor, typename... Types>
-struct ClientParam
-{
-    ClientParam(Types&&... values) : m_values{std::forward<Types>(values)...} {}
-
-    struct BuildParams : IterateFieldsHelper<BuildParams, sizeof...(Types)>
-    {
-        template <typename Params, typename ParamList>
-        void handleField(ClientInvokeContext& invoke_context, Params& params, ParamList)
-        {
-            auto const fun = [&]<typename... Values>(Values&&... values) {
-                MaybeSetWant(
-                    ParamList(), Priority<1>(), values..., Make<StructField, Accessor>(params));
-                MaybeBuildField(std::integral_constant<bool, Accessor::in>(), ParamList(), invoke_context,
-                    Make<StructField, Accessor>(params), std::forward<Values>(values)...);
-            };
-
-            // Note: The m_values tuple just consists of lvalue and rvalue
-            // references, so calling std::move doesn't change the tuple, it
-            // just causes std::apply to call the std::get overload that returns
-            // && instead of &, so rvalue references are preserved and not
-            // turned into lvalue references. This allows the BuildField call to
-            // move from the argument if it is an rvalue reference or was passed
-            // by value.
-            std::apply(fun, std::move(m_client_param->m_values));
-        }
-
-        BuildParams(ClientParam* client_param) : m_client_param(client_param) {}
-        ClientParam* m_client_param;
-    };
-
-    struct ReadResults : IterateFieldsHelper<ReadResults, sizeof...(Types)>
-    {
-        template <typename Results, typename... Params>
-        void handleField(ClientInvokeContext& invoke_context, Results& results, TypeList<Params...>)
-        {
-            auto const fun = [&]<typename... Values>(Values&&... values) {
-                MaybeReadField(std::integral_constant<bool, Accessor::out>(), TypeList<Decay<Params>...>(), invoke_context,
-                    Make<StructField, Accessor>(results), ReadDestUpdate(values)...);
-            };
-
-            std::apply(fun, m_client_param->m_values);
-        }
-
-        ReadResults(ClientParam* client_param) : m_client_param(client_param) {}
-        ClientParam* m_client_param;
-    };
-
-    std::tuple<Types&&...> m_values;
-};
-
-template <typename Accessor, typename... Types>
-ClientParam<Accessor, Types...> MakeClientParam(Types&&... values)
-{
-    return {std::forward<Types>(values)...};
-}
-
-struct ServerCall
-{
-    // FIXME: maybe call call_context.releaseParams()
-    template <typename ServerContext, typename... Args>
-    decltype(auto) invoke(ServerContext& server_context, TypeList<>, Args&&... args) const
-    {
-        // If cancel_lock is set, release it while executing the method, and
-        // reacquire it afterwards. The lock is needed to prevent params and
-        // response structs from being deleted by the event loop thread if the
-        // request is canceled, so it is only needed before and after method
-        // execution. It is important to release the lock during execution
-        // because the method can take arbitrarily long to return and the event
-        // loop will need the lock itself in on_cancel if the call is canceled.
-        if (server_context.cancel_lock) server_context.cancel_lock->m_lock.unlock();
-        return TryFinally(
-            [&]() -> decltype(auto) {
-                return ProxyServerMethodTraits<
-                    typename decltype(server_context.call_context.getParams())::Reads
-                >::invoke(server_context, std::forward<Args>(args)...);
-            },
-            [&] {
-                if (server_context.cancel_lock) server_context.cancel_lock->m_lock.lock();
-                // If the IPC request was canceled, throw InterruptException
-                // because there is no point continuing and trying to fill the
-                // call_context.getResults() struct. It's also important to stop
-                // executing because the connection may have been destroyed as
-                // described in https://github.com/bitcoin/bitcoin/issues/34250
-                // and there could be invalid references to the destroyed
-                // Connection object if this continued.
-                // If the IPC method itself threw an exception, the
-                // InterruptException thrown below will take precedence over it.
-                // Since the call has been canceled that exception can't be
-                // returned to the caller, so it needs to be discarded like
-                // other result values.
-                if (server_context.request_canceled) throw InterruptException{"canceled"};
-            });
-    }
-};
-
-struct ServerDestroy
-{
-    template <typename ServerContext, typename... Args>
-    void invoke(ServerContext& server_context, TypeList<>, Args&&... args) const
-    {
-        server_context.proxy_server.invokeDestroy(std::forward<Args>(args)...);
-    }
-};
-
-template <typename Accessor, typename Parent>
-struct ServerRet : Parent
-{
-    ServerRet(Parent parent) : Parent(parent) {}
-
-    template <typename ServerContext, typename... Args>
-    void invoke(ServerContext& server_context, TypeList<>, Args&&... args) const
-    {
-        auto&& result = Parent::invoke(server_context, TypeList<>(), std::forward<Args>(args)...);
-        auto&& results = server_context.call_context.getResults();
-        InvokeContext& invoke_context = server_context;
-        BuildField(TypeList<decltype(result)>(), invoke_context, Make<StructField, Accessor>(results),
-            std::forward<decltype(result)>(result));
-    }
-};
-
-template <typename Exception, typename Accessor, typename Parent>
-struct ServerExcept : Parent
-{
-    ServerExcept(Parent parent) : Parent(parent) {}
-
-    template <typename ServerContext, typename... Args>
-    void invoke(ServerContext& server_context, TypeList<>, Args&&... args) const
-    {
-        try {
-            return Parent::invoke(server_context, TypeList<>(), std::forward<Args>(args)...);
-        } catch (const Exception& exception) {
-            auto&& results = server_context.call_context.getResults();
-            BuildField(TypeList<Exception>(), server_context, Make<StructField, Accessor>(results), exception);
-        }
-    }
-};
-
-//! Helper for CustomPassField below. Call Accessor::get method if it has one,
-//! otherwise return capnp::Void.
-template <typename Accessor, typename Message>
-decltype(auto) MaybeGet(Message&& message, decltype(Accessor::get(message))* enable = nullptr)
-{
-    return Accessor::get(message);
-}
-
-template <typename Accessor>
-::capnp::Void MaybeGet(...)
-{
-    return {};
-}
-
-template <class Accessor>
-void CustomPassField();
-
-//! PassField override calling CustomPassField function, if it exists.
-//! Defining a CustomPassField or CustomPassMessage overload is useful for
-//! input/output parameters. If an overload is not defined these parameters will
-//! just be deserialized on the server side with ReadField into a temporary
-//! variable, then the server method will be called passing the temporary
-//! variable as a parameter, then the temporary variable will be serialized and
-//! sent back to the client with BuildField. But if a PassField or PassMessage
-//! overload is defined, the overload is called with a callback to invoke and
-//! pass parameters to the server side function, and run arbitrary code before
-//! and after invoking the function.
-template <typename Accessor, typename... Args>
-auto PassField(Priority<2>, Args&&... args) -> decltype(CustomPassField<Accessor>(std::forward<Args>(args)...))
-{
-    return CustomPassField<Accessor>(std::forward<Args>(args)...);
-};
-
-template <int argc, typename Accessor, typename Parent>
-struct ServerField : Parent
-{
-    ServerField(Parent parent) : Parent(parent) {}
-
-    const Parent& parent() const { return *this; }
-
-    template <typename ServerContext, typename ArgTypes, typename... Args>
-    decltype(auto) invoke(ServerContext& server_context, ArgTypes, Args&&... args) const
-    {
-        return PassField<Accessor>(Priority<2>(),
-            typename Split<argc, ArgTypes>::First(),
-            server_context,
-            this->parent(),
-            typename Split<argc, ArgTypes>::Second(),
-            std::forward<Args>(args)...);
-    }
-};
-
-template <int argc, typename Accessor, typename Parent>
-ServerField<argc, Accessor, Parent> MakeServerField(Parent parent)
-{
-    return {parent};
-}
-
-template <typename Request>
-struct CapRequestTraits;
-
-template <typename _Params, typename _Results>
-struct CapRequestTraits<::capnp::Request<_Params, _Results>>
-{
-    using Params = _Params;
-    using Results = _Results;
-};
-
-//! Entry point called by all generated ProxyClient destructors. This only logs
-//! the object destruction. The actual cleanup happens in the ProxyClient base
-//! destructor.
-template <typename Client>
-void clientDestroy(Client& client)
-{
-    if (client.m_context.connection) {
-        MP_LOG(*client.m_context.loop, Log::Debug) << "IPC client destroy " << typeid(client).name();
-    } else {
-        KJ_LOG(INFO, "IPC interrupted client destroy", typeid(client).name());
-    }
-}
-
-template <typename Server>
-void serverDestroy(Server& server)
-{
-    MP_LOG(*server.m_context.loop, Log::Debug) << "IPC server destroy " << typeid(server).name();
-}
-
-//! Entry point called by generated client code that looks like:
-//!
-//! ProxyClient<ClassName>::M0::Result ProxyClient<ClassName>::methodName(M0::Param<0> arg0, M0::Param<1> arg1) {
-//!     typename M0::Result result;
-//!     clientInvoke(*this, &InterfaceName::Client::methodNameRequest, MakeClientParam<...>(M0::Fwd<0>(arg0)), MakeClientParam<...>(M0::Fwd<1>(arg1)), MakeClientParam<...>(result));
-//!     return result;
-//! }
-//!
-//! Ellipses above are where generated Accessor<> type declarations are inserted.
-template <typename ProxyClient, typename GetRequest, typename... FieldObjs>
-void clientInvoke(ProxyClient& proxy_client, const GetRequest& get_request, FieldObjs&&... fields)
-{
-    if (!g_thread_context.waiter) {
-        assert(g_thread_context.thread_name.empty());
-        g_thread_context.thread_name = ThreadName(proxy_client.m_context.loop->m_exe_name);
-        // If next assert triggers, it means clientInvoke is being called from
-        // the capnp event loop thread. This can happen when a ProxyServer
-        // method implementation that runs synchronously on the event loop
-        // thread tries to make a blocking callback to the client. Any server
-        // method that makes a blocking callback or blocks in general needs to
-        // run asynchronously off the event loop thread. This is easy to fix by
-        // just adding a 'context :Proxy.Context' argument to the capnp method
-        // declaration so the server method runs in a dedicated thread.
-        assert(!g_thread_context.loop_thread);
-        g_thread_context.waiter = std::make_unique<Waiter>();
-        MP_LOGPLAIN(*proxy_client.m_context.loop, Log::Info)
-            << "{" << g_thread_context.thread_name
-            << "} IPC client first request from current thread, constructing waiter";
-    }
-    ThreadContext& thread_context{g_thread_context};
-    std::optional<ClientInvokeContext> invoke_context; // Must outlive waiter->wait() call below
-    std::exception_ptr exception;
-    std::string kj_exception;
-    bool done = false;
-    const char* disconnected = nullptr;
-    proxy_client.m_context.loop->sync([&]() {
-        if (!proxy_client.m_context.connection) {
-            const Lock lock(thread_context.waiter->m_mutex);
-            done = true;
-            disconnected = "IPC client method called after disconnect.";
-            thread_context.waiter->m_cv.notify_all();
-            return;
-        }
-
-        auto request = (proxy_client.m_client.*get_request)(nullptr);
-        using Request = CapRequestTraits<decltype(request)>;
-        using FieldList = typename ProxyClientMethodTraits<typename Request::Params>::Fields;
-        invoke_context.emplace(*proxy_client.m_context.connection, thread_context);
-        IterateFields().handleChain(*invoke_context, request, FieldList(), typename FieldObjs::BuildParams{&fields}...);
-        MP_LOGPLAIN(*proxy_client.m_context.loop, Log::Debug)
-            << "{" << thread_context.thread_name << "} IPC client send "
-            << TypeName<typename Request::Params>();
-        MP_LOGPLAIN(*proxy_client.m_context.loop, Log::Trace)
-            << "send data: " << LogEscape(request.toString(), proxy_client.m_context.loop->m_log_opts.max_chars);
-
-        proxy_client.m_context.loop->m_task_set->add(request.send().then(
-            [&](::capnp::Response<typename Request::Results>&& response) {
-                MP_LOGPLAIN(*proxy_client.m_context.loop, Log::Debug)
-                    << "{" << thread_context.thread_name << "} IPC client recv "
-                    << TypeName<typename Request::Results>();
-                MP_LOGPLAIN(*proxy_client.m_context.loop, Log::Trace)
-                    << "recv data: " << LogEscape(response.toString(), proxy_client.m_context.loop->m_log_opts.max_chars);
-                try {
-                    IterateFields().handleChain(
-                        *invoke_context, response, FieldList(), typename FieldObjs::ReadResults{&fields}...);
-                } catch (...) {
-                    exception = std::current_exception();
-                }
-                const Lock lock(thread_context.waiter->m_mutex);
-                done = true;
-                thread_context.waiter->m_cv.notify_all();
-            },
-            [&](const ::kj::Exception& e) {
-                if (e.getType() == ::kj::Exception::Type::DISCONNECTED) {
-                    disconnected = "IPC client method call interrupted by disconnect.";
-                } else {
-                    kj_exception = kj::str("kj::Exception: ", e).cStr();
-                    MP_LOGPLAIN(*proxy_client.m_context.loop, Log::Info)
-                        << "{" << thread_context.thread_name << "} IPC client exception " << kj_exception;
-                }
-                const Lock lock(thread_context.waiter->m_mutex);
-                done = true;
-                thread_context.waiter->m_cv.notify_all();
-            }));
-    });
-
-    Lock lock(thread_context.waiter->m_mutex);
-    thread_context.waiter->wait(lock, [&done]() { return done; });
-    if (exception) std::rethrow_exception(exception);
-    if (!kj_exception.empty()) MP_LOGPLAIN(*proxy_client.m_context.loop, Log::Raise) << kj_exception;
-    if (disconnected) MP_LOGPLAIN(*proxy_client.m_context.loop, Log::Raise) << disconnected;
-}
-
-//! Invoke callable `fn()` that may return void. If it does return void, replace
-//! return value with value of `ret()`. This is useful for avoiding code
-//! duplication and branching in generic code that forwards calls to functions.
-template <typename Fn, typename Ret>
-auto ReplaceVoid(Fn&& fn, Ret&& ret)
-{
-    if constexpr (std::is_same_v<decltype(fn()), void>) {
-        fn();
-        return ret();
-    } else {
-        return fn();
-    }
-}
-
-extern std::atomic<int> server_reqs;
-
-//! Entry point called by generated server code that looks like:
-//!
-//! kj::Promise<void> ProxyServer<InterfaceName>::methodName(CallContext call_context) {
-//!     return serverInvoke(*this, call_context, MakeServerField<0, ...>(MakeServerField<1, ...>(Make<ServerRet, ...>(ServerCall()))));
-//! }
-//!
-//! Ellipses above are where generated Accessor<> type declarations are inserted.
-template <typename Server, typename CallContext, typename Fn>
-kj::Promise<void> serverInvoke(Server& server, CallContext& call_context, Fn fn)
-{
-    auto params = call_context.getParams();
-    using Params = decltype(params);
-    using Results = typename decltype(call_context.getResults())::Builds;
-
-    int req = ++server_reqs;
-    MP_LOG(*server.m_context.loop, Log::Debug) << "IPC server recv request  #" << req << " "
-                                     << TypeName<typename Params::Reads>();
-    MP_LOG(*server.m_context.loop, Log::Trace) << "request data: "
-        << LogEscape(params.toString(), server.m_context.loop->m_log_opts.max_chars);
-
-    try {
-        using ServerContext = ServerInvokeContext<Server, CallContext>;
-        using ArgList = typename ProxyClientMethodTraits<typename Params::Reads>::Params;
-        ServerContext server_context{server, call_context, req};
-        // ReplaceVoid is used to support fn.invoke implementations that
-        // execute asynchronously and return promises, as well as
-        // implementations that execute synchronously and return void. The
-        // invoke function will be synchronous by default, but asynchronous if
-        // an mp.Context argument is passed, and the mp.Context PassField
-        // overload returns a promise executing the request in a worker thread
-        // and waiting for it to complete.
-        return ReplaceVoid([&]() { return fn.invoke(server_context, ArgList()); },
-            [&]() { return kj::Promise<CallContext>(kj::mv(call_context)); })
-            .then([&server, req](CallContext call_context) {
-                MP_LOG(*server.m_context.loop, Log::Debug) << "IPC server send response #" << req << " " << TypeName<Results>();
-                MP_LOG(*server.m_context.loop, Log::Trace) << "response data: "
-                    << LogEscape(call_context.getResults().toString(), server.m_context.loop->m_log_opts.max_chars);
-            });
-    } catch (const std::exception& e) {
-        MP_LOG(*server.m_context.loop, Log::Error) << "IPC server unhandled exception: " << e.what();
-        throw;
-    } catch (...) {
-        MP_LOG(*server.m_context.loop, Log::Error) << "IPC server unhandled exception";
-        throw;
-    }
-}
-
-//! Map to convert client interface pointers to ProxyContext struct references
-//! at runtime using typeids.
-struct ProxyTypeRegister {
-    template<typename Interface>
-    ProxyTypeRegister(TypeList<Interface>) {
-        types().emplace(typeid(Interface), [](void* iface) -> ProxyContext& { return static_cast<typename mp::ProxyType<Interface>::Client&>(*static_cast<Interface*>(iface)).m_context; });
-    }
-    using Types = std::map<std::type_index, ProxyContext&(*)(void*)>;
-    static Types& types() { static Types types; return types; }
-};
-
-} // namespace mp
-
-#endif // MP_PROXY_TYPES_H
diff --git a/src/ipc/libmultiprocess/include/mp/proxy.capnp b/src/ipc/libmultiprocess/include/mp/proxy.capnp
deleted file mode 100644
index 386f8f7abe01..000000000000
--- a/src/ipc/libmultiprocess/include/mp/proxy.capnp
+++ /dev/null
@@ -1,65 +0,0 @@
-# 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.
-
-@0xcc316e3f71a040fb;
-
-using Cxx = import "/capnp/c++.capnp";
-$Cxx.namespace("mp");
-
-annotation include(file): Text;
-annotation includeTypes(file): Text;
-# Extra include paths to add to generated files.
-
-annotation wrap(interface, struct): Text;
-# Wrap capnp interface generating ProxyClient / ProxyServer C++ classes that
-# forward calls to a C++ interface with same methods and parameters. Text
-# string should be the name of the C++ interface.
-# If applied to struct rather than an interface, this will generate a ProxyType
-# struct with get methods for introspection and copying fields between C++ and
-# capnp structs.
-
-annotation count(param, struct, interface): Int32;
-# Indicate how many C++ method parameters there are corresponding to one capnp
-# parameter (default is 1). If not 1, multiple C++ method arguments will be
-# condensed into a single capnp parameter by the client and then expanded by
-# the server by CustomReadField/CustomBuildField overloads which need to be
-# provided separately. An example would be a capnp Text parameter initialized
-# from C++ char* and size arguments. Can be 0 to fill an implicit capnp
-# parameter from client or server side context. If annotation is applied to an
-# interface or struct type it will apply to all parameters of that type.
-
-annotation exception(param): Text;
-# Indicate that a result parameter corresponds to a C++ exception. Text string
-# should be the name of a C++ exception type that the generated server class
-# will catch and the client class will rethrow.
-
-annotation name(field, method): Text;
-# Name of the C++ method or field corresponding to a capnp method or field.
-
-annotation skip(field): Void;
-# Synonym for count(0).
-
-interface ThreadMap $count(0) {
-    # Interface letting clients control which thread a method call should
-    # execute on. Clients create and name threads and pass the thread handle as
-    # a call parameter.
-    makeThread @0 (name :Text) -> (result :Thread);
-}
-
-interface Thread {
-    # Thread handle returned by makeThread corresponding to one server thread.
-
-    getName @0 () -> (result: Text);
-}
-
-struct Context $count(0) {
-   # Execution context passed as a parameter from the client class to the server class.
-
-   thread @0 : Thread;
-   # Handle of the server thread the current method call should execute on.
-
-   callbackThread @1 : Thread;
-   # Handle of the client thread that is calling the current method, and that
-   # any callbacks made by the server thread should be made on.
-}
diff --git a/src/ipc/libmultiprocess/include/mp/proxy.h b/src/ipc/libmultiprocess/include/mp/proxy.h
deleted file mode 100644
index c55380c1c9cc..000000000000
--- a/src/ipc/libmultiprocess/include/mp/proxy.h
+++ /dev/null
@@ -1,338 +0,0 @@
-// 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 MP_PROXY_H
-#define MP_PROXY_H
-
-#include <mp/util.h>
-
-#include <cassert>
-#include <functional>
-#include <list>
-#include <memory>
-#include <stddef.h>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <variant> // IWYU pragma: keep
-
-namespace mp {
-class Connection;
-class EventLoop;
-//! Mapping from capnp interface type to proxy client implementation (specializations are generated by
-//! proxy-codegen.cpp).
-template <typename Interface> struct ProxyClient; // IWYU pragma: export
-//! Mapping from capnp interface type to proxy server implementation (specializations are generated by
-//! proxy-codegen.cpp).
-template <typename Interface> struct ProxyServer; // IWYU pragma: export
-//! Mapping from capnp method params type to method traits (specializations are generated by proxy-codegen.cpp).
-template <typename Params> struct ProxyMethod; // IWYU pragma: export
-//! Mapping from capnp struct type to struct traits (specializations are generated by proxy-codegen.cpp).
-template <typename Struct> struct ProxyStruct; // IWYU pragma: export
-//! Mapping from local c++ type to capnp type and traits (specializations are generated by proxy-codegen.cpp).
-template <typename Type> struct ProxyType; // IWYU pragma: export
-
-using CleanupList = std::list<std::function<void()>>;
-using CleanupIt = typename CleanupList::iterator;
-
-inline void CleanupRun(CleanupList& fns) {
-    while (!fns.empty()) {
-        auto fn = std::move(fns.front());
-        fns.pop_front();
-        fn();
-    }
-}
-
-//! Event loop smart pointer automatically managing m_num_clients.
-//! If a lock pointer argument is passed, the specified lock will be used,
-//! otherwise EventLoop::m_mutex will be locked when needed.
-class EventLoopRef
-{
-public:
-    explicit EventLoopRef(EventLoop& loop, Lock* lock = nullptr);
-    EventLoopRef(EventLoopRef&& other) noexcept : m_loop(other.m_loop) { other.m_loop = nullptr; }
-    EventLoopRef(const EventLoopRef&) = delete;
-    EventLoopRef& operator=(const EventLoopRef&) = delete;
-    EventLoopRef& operator=(EventLoopRef&&) = delete;
-    ~EventLoopRef() { reset(); }
-    EventLoop& operator*() const { assert(m_loop); return *m_loop; }
-    EventLoop* operator->() const { assert(m_loop); return m_loop; }
-    void reset(bool relock=false);
-
-    EventLoop* m_loop{nullptr};
-    Lock* m_lock{nullptr};
-};
-
-//! Context data associated with proxy client and server classes.
-struct ProxyContext
-{
-    Connection* connection;
-    EventLoopRef loop;
-    CleanupList cleanup_fns;
-
-    ProxyContext(Connection* connection);
-};
-
-//! Base class for generated ProxyClient classes that implement a C++ interface
-//! and forward calls to a capnp interface.
-template <typename Interface_, typename Impl_>
-class ProxyClientBase : public Impl_
-{
-public:
-    using Interface = Interface_;
-    using Impl = Impl_;
-    using Sub = ProxyClient<Interface>;
-    using Super = ProxyClientBase<Interface, Impl>;
-
-    //! Construct libmultiprocess client object wrapping Cap'n Proto client
-    //! object with a reference to the associated mp::Connection object.
-    //!
-    //! The destroy_connection option determines whether destroying this client
-    //! object closes the connection. It is set to true for the
-    //! ProxyClient<InitInterface> object returned by ConnectStream, to let IPC
-    //! clients close the connection by freeing the object. It is false for
-    //! other client objects so they can be destroyed without affecting the
-    //! connection.
-    ProxyClientBase(typename Interface::Client client, Connection* connection, bool destroy_connection);
-    ~ProxyClientBase() noexcept;
-
-    // construct/destroy methods called during client construction/destruction
-    // that can optionally be defined in capnp interfaces to invoke code on the
-    // server when proxy client objects are created and destroyed.
-    //
-    // The construct() method is not generally very useful, but can be used to
-    // run custom code on the server automatically when a ProxyClient client is
-    // constructed. The only current use is adding a construct method to Init
-    // interfaces that is called automatically on construction, so client and
-    // server exchange ThreadMap references and set Connection::m_thread_map
-    // values as soon as the Init client is created.
-    //
-    //     construct @0 (threadMap: Proxy.ThreadMap) -> (threadMap: Proxy.ThreadMap);
-    //
-    // But construct() is not necessary for this, thread maps could be passed
-    // through a normal method that is just called explicitly rather than
-    // implicitly.
-    //
-    // The destroy() method is more generally useful than construct(), because
-    // it ensures that the server object will be destroyed synchronously before
-    // the client destructor returns, instead of asynchronously at some
-    // unpredictable time after the client object is already destroyed and
-    // client code has moved on. If the destroy method accepts a Context
-    // parameter like:
-    //
-    //     destroy @0 (context: Proxy.Context) -> ();
-    //
-    // then it will also ensure that the destructor runs on the same thread the
-    // client used to make other RPC calls, instead of running on the server
-    // EventLoop thread and possibly blocking it.
-    static void construct(Super&) {}
-    static void destroy(Super&) {}
-
-    typename Interface::Client m_client;
-    ProxyContext m_context;
-};
-
-//! Customizable (through template specialization) base class used in generated ProxyClient implementations from
-//! proxy-codegen.cpp.
-template <typename Interface, typename Impl>
-class ProxyClientCustom : public ProxyClientBase<Interface, Impl>
-{
-    using ProxyClientBase<Interface, Impl>::ProxyClientBase;
-};
-
-//! Base class for generated ProxyServer classes that implement capnp server
-//! methods and forward calls to a wrapped c++ implementation class.
-template <typename Interface_, typename Impl_>
-struct ProxyServerBase : public virtual Interface_::Server
-{
-public:
-    using Interface = Interface_;
-    using Impl = Impl_;
-
-    ProxyServerBase(std::shared_ptr<Impl> impl, Connection& connection);
-    virtual ~ProxyServerBase();
-    void invokeDestroy();
-    using Interface_::Server::thisCap;
-
-    /**
-     * Implementation pointer that may or may not be owned and deleted when this
-     * capnp server goes out of scope. It is owned for servers created to wrap
-     * unique_ptr<Impl> method arguments, but unowned for servers created to
-     * wrap Impl& method arguments.
-     *
-     * In the case of Impl& arguments, custom code is required on other side of
-     * the connection to delete the capnp client & server objects since native
-     * code on that side of the connection will just be taking a plain reference
-     * rather than a pointer, so won't be able to do its own cleanup. Right now
-     * this is implemented with addCloseHook callbacks to delete clients at
-     * appropriate times depending on semantics of the particular method being
-     * wrapped. */
-    std::shared_ptr<Impl> m_impl;
-    ProxyContext m_context;
-};
-
-//! Customizable (through template specialization) base class which ProxyServer
-//! classes produced by generated code will inherit from. The default
-//! specialization of this class just inherits from ProxyServerBase, but custom
-//! specializations can be defined to control ProxyServer behavior.
-//!
-//! Specifically, it can be useful to specialize this class to add additional
-//! state to ProxyServer classes, for example to cache state between IPC calls.
-//! If this is done, however, care should be taken to ensure that the extra
-//! state can be destroyed without blocking, because ProxyServer destructors are
-//! called from the EventLoop thread, and if they block, it could deadlock the
-//! program. One way to do avoid blocking is to clean up the state by pushing
-//! cleanup callbacks to the m_context.cleanup_fns list, which run after the server
-//! m_impl object is destroyed on the same thread destroying it (which will
-//! either be an IPC worker thread if the ProxyServer is being explicitly
-//! destroyed by a client calling a destroy() method with a Context argument and
-//! Context.thread value set, or the temporary EventLoop::m_async_thread used to
-//! run destructors without blocking the event loop when no-longer used server
-//! objects are garbage collected by Cap'n Proto.) Alternately, if cleanup needs
-//! to run before m_impl is destroyed, the specialization can override
-//! invokeDestroy and destructor methods to do that.
-template <typename Interface, typename Impl>
-struct ProxyServerCustom : public ProxyServerBase<Interface, Impl>
-{
-    using ProxyServerBase<Interface, Impl>::ProxyServerBase;
-};
-
-//! Function traits class used to get method parameter and result types, used in
-//! generated ProxyClient and ProxyServer classes produced by gen.cpp to get C++
-//! method type information. The generated code accesses these traits via
-//! intermediate ProxyClientMethodTraits and ProxyServerMethodTraits classes,
-//! which it is possible to specialize to change the way method arguments and
-//! return values are handled.
-//!
-//! Fields of the trait class are:
-//!
-//! Params   - TypeList of C++ ClassName::methodName parameter types
-//! Result   - Return type of ClassName::method
-//! Param<N> - helper to access individual parameter types by index number.
-//! Fwd<N>   - helper to forward arguments by index number.
-//! Fields   - helper alias that appends Result type to the Params typelist if
-//!            it not void.
-template <class Fn>
-struct FunctionTraits;
-
-//! Specialization of above extracting result and params types assuming the
-//! template argument is a pointer-to-method type,
-//! decltype(&ClassName::methodName)
-template <class _Class, class _Result, class... _Params>
-struct FunctionTraits<_Result (_Class::*const)(_Params...)>
-{
-    using Params = TypeList<_Params...>;
-    using Result = _Result;
-    template <size_t N>
-    using Param = typename std::tuple_element<N, std::tuple<_Params...>>::type;
-    using Fields =
-        std::conditional_t<std::is_same_v<void, Result>, Params, TypeList<_Params..., _Result>>;
-
-    //! Enable perfect forwarding for clientInvoke calls. If parameter is a
-    //! value type or rvalue reference type, pass it as an rvalue-reference to
-    //! MakeClientParam and BuildField calls so it can be moved from, and if it
-    //! is an lvalue reference, pass it an lvalue reference so it won't be moved
-    //! from. This method does the same thing as std::forward except it takes a
-    //! parameter number instead of a type as a template argument, so generated
-    //! code calling this can be less repetitive and verbose.
-    template <size_t N>
-    static decltype(auto) Fwd(Param<N>& arg) { return static_cast<Param<N>&&>(arg); }
-};
-
-//! Traits class for a proxy method, providing the same
-//! Params/Result/Param/Fields described in the FunctionTraits class above, plus
-//! an additional invoke() method that calls the C++ method which is being
-//! proxied, forwarding any arguments.
-//!
-//! The template argument should be the InterfaceName::MethodNameParams class
-//! (generated by Cap'n Proto) associated with the method.
-//!
-//! Note: The class definition here is just the fallback definition used when
-//! the other specialization below doesn't match. The fallback is only used for
-//! capnp methods which do not have corresponding C++ methods, which in practice
-//! is just the two special construct() and destroy() methods described in \ref
-//! ProxyClientBase. These methods don't have any C++ parameters or return
-//! types, so the trait information below reflects that.
-template <typename MethodParams, typename Enable = void>
-struct ProxyMethodTraits
-{
-    using Params = TypeList<>;
-    using Result = void;
-    using Fields = Params;
-
-    template <typename ServerContext>
-    static void invoke(ServerContext&)
-    {
-    }
-};
-
-//! Specialization of above for proxy methods that have a
-//! ProxyMethod<InterfaceName::MethodNameParams>::impl pointer-to-method
-//! constant defined by generated code. This includes all functions defined in
-//! the capnp interface except any construct() or destroy() methods, that are
-//! assumed not to correspond to real member functions in the C++ class, and
-//! will use the fallback traits definition above. The generated code this
-//! specialization relies on looks like:
-//!
-//! struct ProxyMethod<InterfaceName::MethodNameParams>
-//! {
-//!     static constexpr auto impl = &ClassName::methodName;
-//! };
-template <typename MethodParams>
-struct ProxyMethodTraits<MethodParams, Require<decltype(ProxyMethod<MethodParams>::impl)>>
-    : public FunctionTraits<decltype(ProxyMethod<MethodParams>::impl)>
-{
-    template <typename ServerContext, typename... Args>
-    static decltype(auto) invoke(ServerContext& server_context, Args&&... args)
-    {
-        return (server_context.proxy_server.m_impl.get()->*ProxyMethod<MethodParams>::impl)(std::forward<Args>(args)...);
-    }
-};
-
-//! Customizable (through template specialization) traits class used in generated ProxyClient implementations from
-//! proxy-codegen.cpp.
-template <typename MethodParams>
-struct ProxyClientMethodTraits : public ProxyMethodTraits<MethodParams>
-{
-};
-
-//! Customizable (through template specialization) traits class used in generated ProxyServer implementations from
-//! proxy-codegen.cpp.
-template <typename MethodParams>
-struct ProxyServerMethodTraits : public ProxyMethodTraits<MethodParams>
-{
-};
-
-static constexpr int FIELD_IN = 1;
-static constexpr int FIELD_OUT = 2;
-static constexpr int FIELD_OPTIONAL = 4;
-static constexpr int FIELD_REQUESTED = 8;
-static constexpr int FIELD_BOXED = 16;
-
-//! Accessor type holding flags that determine how to access a message field.
-template <typename Field, int flags>
-struct Accessor : public Field
-{
-    static const bool in = flags & FIELD_IN;
-    static const bool out = flags & FIELD_OUT;
-    static const bool optional = flags & FIELD_OPTIONAL;
-    static const bool requested = flags & FIELD_REQUESTED;
-    static const bool boxed = flags & FIELD_BOXED;
-};
-
-//! Wrapper around std::function for passing std::function objects between client and servers.
-template <typename Fn>
-class ProxyCallback;
-
-//! Specialization of above to separate Result and Arg types.
-template <typename Result, typename... Args>
-class ProxyCallback<std::function<Result(Args...)>>
-{
-public:
-    virtual Result call(Args&&... args) = 0;
-};
-
-} // namespace mp
-
-#endif // MP_PROXY_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-char.h b/src/ipc/libmultiprocess/include/mp/type-char.h
deleted file mode 100644
index b51ffeb1928b..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-char.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// 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 MP_PROXY_TYPE_CHAR_H
-#define MP_PROXY_TYPE_CHAR_H
-
-#include <mp/util.h>
-
-namespace mp {
-template <typename Output, size_t size>
-void CustomBuildField(TypeList<const unsigned char*>,
-    Priority<3>,
-    InvokeContext& invoke_context,
-    const unsigned char (&value)[size],
-    Output&& output)
-{
-    auto result = output.init(size);
-    memcpy(result.begin(), value, size);
-}
-
-template <size_t size, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<unsigned char[size]>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest)
-{
-    return read_dest.update([&](auto& value) {
-        auto data = input.get();
-        memcpy(value, data.begin(), size);
-    });
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_CHAR_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-chrono.h b/src/ipc/libmultiprocess/include/mp/type-chrono.h
deleted file mode 100644
index d71549864c16..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-chrono.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// 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 MP_PROXY_TYPE_CHRONO_H
-#define MP_PROXY_TYPE_CHRONO_H
-
-#include <mp/util.h>
-
-#include <chrono>
-
-namespace mp {
-//! Overload CustomBuildField and CustomReadField to serialize std::chrono
-//! parameters and return values as numbers.
-template <class Rep, class Period, typename Value, typename Output>
-void CustomBuildField(TypeList<std::chrono::duration<Rep, Period>>, Priority<1>, InvokeContext& invoke_context, Value&& value,
-                      Output&& output)
-{
-    static_assert(std::numeric_limits<decltype(output.get())>::lowest() <= std::numeric_limits<Rep>::lowest(),
-                  "capnp type does not have enough range to hold lowest std::chrono::duration value");
-    static_assert(std::numeric_limits<decltype(output.get())>::max() >= std::numeric_limits<Rep>::max(),
-                  "capnp type does not have enough range to hold highest std::chrono::duration value");
-    output.set(value.count());
-}
-
-template <class Rep, class Period, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<std::chrono::duration<Rep, Period>>, Priority<1>, InvokeContext& invoke_context,
-                               Input&& input, ReadDest&& read_dest)
-{
-    return read_dest.construct(input.get());
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_CHRONO_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-context.h b/src/ipc/libmultiprocess/include/mp/type-context.h
deleted file mode 100644
index 46952f49f870..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-context.h
+++ /dev/null
@@ -1,229 +0,0 @@
-// 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 MP_PROXY_TYPE_CONTEXT_H
-#define MP_PROXY_TYPE_CONTEXT_H
-
-#include <mp/proxy-io.h>
-#include <mp/util.h>
-
-#include <kj/string.h>
-
-namespace mp {
-template <typename Output>
-void CustomBuildField(TypeList<>,
-    Priority<1>,
-    ClientInvokeContext& invoke_context,
-    Output&& output,
-    typename std::enable_if<std::is_same<decltype(output.get()), Context::Builder>::value>::type* enable = nullptr)
-{
-    auto& connection = invoke_context.connection;
-    auto& thread_context = invoke_context.thread_context;
-
-    // Create local Thread::Server object corresponding to the current thread
-    // and pass a Thread::Client reference to it in the Context.callbackThread
-    // field so the function being called can make callbacks to this thread.
-    // Also store the Thread::Client reference in the callback_threads map so
-    // future calls over this connection can reuse it.
-    auto [callback_thread, _]{SetThread(
-        GuardedRef{thread_context.waiter->m_mutex, thread_context.callback_threads}, &connection,
-        [&] { return connection.m_threads.add(kj::heap<ProxyServer<Thread>>(connection, thread_context, std::thread{})); })};
-
-    // Call remote ThreadMap.makeThread function so server will create a
-    // dedicated worker thread to run function calls from this thread. Store the
-    // Thread::Client reference it returns in the request_threads map.
-    auto make_request_thread{[&]{
-        // This code will only run if an IPC client call is being made for the
-        // first time on this thread. After the first call, subsequent calls
-        // will use the existing request thread. This code will also never run at
-        // all if the current thread is a request thread created for a different
-        // IPC client, because in that case PassField code (below) will have set
-        // request_thread to point to the calling thread.
-        auto request = connection.m_thread_map.makeThreadRequest();
-        request.setName(thread_context.thread_name);
-        return request.send().getResult(); // Nonblocking due to capnp request pipelining.
-    }};
-    auto [request_thread, _1]{SetThread(
-        GuardedRef{thread_context.waiter->m_mutex, thread_context.request_threads},
-        &connection, make_request_thread)};
-
-    auto context = output.init();
-    context.setThread(request_thread->second->m_client);
-    context.setCallbackThread(callback_thread->second->m_client);
-}
-
-//! PassField override for mp.Context arguments. Return asynchronously and call
-//! function on other thread found in context.
-template <typename Accessor, typename ServerContext, typename Fn, typename... Args>
-auto PassField(Priority<1>, TypeList<>, ServerContext& server_context, const Fn& fn, Args&&... args) ->
-    typename std::enable_if<
-        std::is_same<decltype(Accessor::get(server_context.call_context.getParams())), Context::Reader>::value,
-        kj::Promise<typename ServerContext::CallContext>>::type
-{
-    auto& server = server_context.proxy_server;
-    EventLoop& loop = *server.m_context.loop;
-    int req = server_context.req;
-    // Keep a reference to the ProxyServer instance by assigning it to the self
-    // variable. ProxyServer instances are reference-counted and if the client
-    // drops its reference and the IPC call is canceled, this variable keeps the
-    // instance alive until the method finishes executing. The self variable
-    // needs to be destroyed on the event loop thread so it is freed in a sync()
-    // call below.
-    auto self = server.thisCap();
-    auto invoke = [self = kj::mv(self), call_context = kj::mv(server_context.call_context), &server, &loop, req, fn, args...](CancelMonitor& cancel_monitor) mutable {
-        MP_LOG(loop, Log::Debug) << "IPC server executing request #" << req;
-        if (loop.testing_hook_async_request_start) loop.testing_hook_async_request_start();
-        KJ_DEFER(if (loop.testing_hook_async_request_done) loop.testing_hook_async_request_done());
-        ServerContext server_context{server, call_context, req};
-        // Before invoking the function, store a reference to the
-        // callbackThread provided by the client in the
-        // thread_local.request_threads map. This way, if this
-        // server thread needs to execute any RPCs that call back to
-        // the client, they will happen on the same client thread
-        // that is waiting for this function, just like what would
-        // happen if this were a normal function call made on the
-        // local stack.
-        //
-        // If the request_threads map already has an entry for this
-        // connection, it will be left unchanged, and it indicates
-        // that the current thread is an RPC client thread which is
-        // in the middle of an RPC call, and the current RPC call is
-        // a nested call from the remote thread handling that RPC
-        // call. In this case, the callbackThread value should point
-        // to the same thread already in the map, so there is no
-        // need to update the map.
-        auto& thread_context = g_thread_context;
-        auto& request_threads = thread_context.request_threads;
-        ConnThread request_thread;
-        bool inserted{false};
-        Mutex cancel_mutex;
-        Lock cancel_lock{cancel_mutex};
-        server_context.cancel_lock = &cancel_lock;
-        loop.sync([&] {
-            // Detect request being canceled before it executes.
-            if (cancel_monitor.m_canceled) {
-                server_context.request_canceled = true;
-                return;
-            }
-            // Detect request being canceled while it executes.
-            assert(!cancel_monitor.m_on_cancel);
-            cancel_monitor.m_on_cancel = [&loop, &server_context, &cancel_mutex, req]() {
-                MP_LOG(loop, Log::Info) << "IPC server request #" << req << " canceled while executing.";
-                // Lock cancel_mutex here to block the event loop
-                // thread and prevent it from deleting the request's
-                // params and response structs while the execution
-                // thread is accessing them. Because this lock is
-                // released before the event loop thread does delete
-                // the structs, the mutex does not provide any
-                // protection from the event loop deleting the
-                // structs _before_ the execution thread acquires
-                // it. So in addition to locking the mutex, the
-                // execution thread always checks request_canceled
-                // as well before accessing the structs.
-                Lock cancel_lock{cancel_mutex};
-                server_context.request_canceled = true;
-            };
-            // Update requests_threads map if not canceled. We know
-            // the request is not canceled currently because
-            // cancel_monitor.m_canceled was checked above and this
-            // code is running on the event loop thread.
-            std::tie(request_thread, inserted) = SetThread(
-                GuardedRef{thread_context.waiter->m_mutex, request_threads}, server.m_context.connection,
-                [&] { return Accessor::get(call_context.getParams()).getCallbackThread(); });
-        });
-
-        // If an entry was inserted into the request_threads map,
-        // remove it after calling fn.invoke. If an entry was not
-        // inserted, one already existed, meaning this must be a
-        // recursive call (IPC call calling back to the caller which
-        // makes another IPC call), so avoid modifying the map.
-        const bool erase_thread{inserted};
-        KJ_DEFER(
-            // Release the cancel lock before calling loop->sync and
-            // waiting for the event loop thread, because if a
-            // cancellation happened, it needs to run the on_cancel
-            // callback above. It's safe to release cancel_lock at
-            // this point because the fn.invoke() call below will be
-            // finished and no longer accessing the params or
-            // results structs.
-            cancel_lock.m_lock.unlock();
-            // Erase the request_threads entry on the event loop
-            // thread with loop->sync(), so if the connection is
-            // broken there is not a race between this thread and
-            // the disconnect handler trying to destroy the thread
-            // client object.
-            loop.sync([&] {
-                // Clear cancellation callback. At this point the
-                // method invocation finished and the result is
-                // either being returned, or discarded if a
-                // cancellation happened. So we do not need to be
-                // notified of cancellations after this point. Also
-                // we do not want to be notified because
-                // cancel_mutex and server_context could be out of
-                // scope when it happens.
-                cancel_monitor.m_on_cancel = nullptr;
-                auto self_dispose{kj::mv(self)};
-                if (erase_thread) {
-                    // Look up the thread again without using existing
-                    // iterator since entry may no longer be there after
-                    // a disconnect. Destroy node after releasing
-                    // Waiter::m_mutex, so the ProxyClient<Thread>
-                    // destructor is able to use EventLoop::mutex
-                    // without violating lock order.
-                    ConnThreads::node_type removed;
-                    {
-                        Lock lock(thread_context.waiter->m_mutex);
-                        removed = request_threads.extract(server.m_context.connection);
-                    }
-                }
-            });
-        );
-        if (server_context.request_canceled) {
-            MP_LOG(loop, Log::Info) << "IPC server request #" << req << " canceled before it could be executed";
-        } else KJ_IF_MAYBE(exception, kj::runCatchingExceptions([&]{
-            try {
-                fn.invoke(server_context, args...);
-            } catch (const InterruptException& e) {
-                MP_LOG(loop, Log::Info) << "IPC server request #" << req << " interrupted (" << e.what() << ")";
-            }
-        })) {
-            MP_LOG(loop, Log::Error) << "IPC server request #" << req << " uncaught exception (" << kj::str(*exception).cStr() << ")";
-            kj::throwRecoverableException(kj::mv(*exception));
-        }
-        return call_context;
-        // End of scope: if KJ_DEFER was reached, it runs here
-    };
-
-    // Lookup Thread object specified by the client. The specified thread should
-    // be a local Thread::Server object, but it needs to be looked up
-    // asynchronously with getLocalServer().
-    const auto& params = server_context.call_context.getParams();
-    Context::Reader context_arg = Accessor::get(params);
-    auto thread_client = context_arg.getThread();
-    auto result = server.m_context.connection->m_threads.getLocalServer(thread_client)
-        .then([&loop, invoke = kj::mv(invoke), req](const kj::Maybe<Thread::Server&>& perhaps) mutable {
-            // Assuming the thread object is found, pass it a pointer to the
-            // `invoke` lambda above which will invoke the function on that
-            // thread.
-            KJ_IF_MAYBE (thread_server, perhaps) {
-                auto& thread = static_cast<ProxyServer<Thread>&>(*thread_server);
-                MP_LOG(loop, Log::Debug)
-                    << "IPC server post request  #" << req << " {" << thread.m_thread_context.thread_name << "}";
-                return thread.template post<typename ServerContext::CallContext>(std::move(invoke));
-            } else {
-                MP_LOG(loop, Log::Error)
-                    << "IPC server error request #" << req << ", missing thread to execute request";
-                throw std::runtime_error("invalid thread handle");
-            }
-        });
-    // Use connection m_canceler object to cancel the result promise if the
-    // connection is destroyed. (By default Cap'n Proto does not cancel requests
-    // on disconnect, since it's possible clients might want to make requests
-    // and immediately disconnect without waiting for results, but not want the
-    // requests to be canceled.)
-    return server.m_context.connection->m_canceler.wrap(kj::mv(result));
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_CONTEXT_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-data.h b/src/ipc/libmultiprocess/include/mp/type-data.h
deleted file mode 100644
index cdcdd30eb4c6..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-data.h
+++ /dev/null
@@ -1,49 +0,0 @@
-// 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 MP_PROXY_TYPE_DATA_H
-#define MP_PROXY_TYPE_DATA_H
-
-#include <mp/util.h>
-
-#include <concepts>
-#include <span>
-
-namespace mp {
-template <typename T, typename U>
-concept IsSpanOf =
-    std::convertible_to<T, std::span<const U>> &&
-    std::constructible_from<T, const U*, const U*>;
-
-template <typename T>
-concept IsByteSpan =
-    IsSpanOf<T, std::byte> ||
-    IsSpanOf<T, char> ||
-    IsSpanOf<T, unsigned char> ||
-    IsSpanOf<T, signed char>;
-
-//! Generic ::capnp::Data field builder for any C++ type that can be converted
-//! to a span of bytes, like std::vector<char> or std::array<uint8_t>, or custom
-//! blob types like uint256 or PKHash with data() and size() methods pointing to
-//! bytes.
-template <typename LocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<LocalType>, Priority<2>, InvokeContext& invoke_context, Value&& value, Output&& output)
-requires (std::is_same_v<decltype(output.get()), ::capnp::Data::Builder> && IsByteSpan<LocalType>)
-{
-    auto data = std::span{value};
-    auto result = output.init(data.size());
-    memcpy(result.begin(), data.data(), data.size());
-}
-
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<LocalType>, Priority<2>, InvokeContext& invoke_context, Input&& input, ReadDest&& read_dest)
-requires (std::is_same_v<decltype(input.get()), ::capnp::Data::Reader> && IsByteSpan<LocalType>)
-{
-    using ByteType = decltype(std::span{std::declval<LocalType>().begin(), std::declval<LocalType>().end()})::element_type;
-    const kj::byte *begin{input.get().begin()}, *end{input.get().end()};
-    return read_dest.construct(reinterpret_cast<const ByteType*>(begin), reinterpret_cast<const ByteType*>(end));
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_DATA_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-decay.h b/src/ipc/libmultiprocess/include/mp/type-decay.h
deleted file mode 100644
index 65934372e4a2..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-decay.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// 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 MP_PROXY_TYPE_DECAY_H
-#define MP_PROXY_TYPE_DECAY_H
-
-#include <mp/util.h>
-
-namespace mp {
-template <typename LocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<const LocalType>,
-    Priority<0>,
-    InvokeContext& invoke_context,
-    Value&& value,
-    Output&& output)
-{
-    BuildField(TypeList<LocalType>(), invoke_context, output, std::forward<Value>(value));
-}
-
-template <typename LocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<LocalType&>, Priority<0>, InvokeContext& invoke_context, Value&& value, Output&& output)
-{
-    BuildField(TypeList<LocalType>(), invoke_context, output, std::forward<Value>(value));
-}
-
-template <typename LocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<LocalType&&>,
-    Priority<0>,
-    InvokeContext& invoke_context,
-    Value&& value,
-    Output&& output)
-{
-    BuildField(TypeList<LocalType>(), invoke_context, output, std::forward<Value>(value));
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_DECAY_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-exception.h b/src/ipc/libmultiprocess/include/mp/type-exception.h
deleted file mode 100644
index 3f04d7a97f5e..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-exception.h
+++ /dev/null
@@ -1,22 +0,0 @@
-// 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 MP_PROXY_TYPE_EXCEPTION_H
-#define MP_PROXY_TYPE_EXCEPTION_H
-
-#include <mp/util.h>
-
-namespace mp {
-template <typename Output>
-void CustomBuildField(TypeList<std::exception>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    const std::exception& value,
-    Output&& output)
-{
-    BuildField(TypeList<std::string>(), invoke_context, output, std::string(value.what()));
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_EXCEPTION_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-function.h b/src/ipc/libmultiprocess/include/mp/type-function.h
deleted file mode 100644
index 951e08852d31..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-function.h
+++ /dev/null
@@ -1,67 +0,0 @@
-// 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 MP_PROXY_TYPE_FUNCTION_H
-#define MP_PROXY_TYPE_FUNCTION_H
-
-#include <mp/util.h>
-
-namespace mp {
-//! Adapter to convert ProxyCallback object call to function object call.
-template <typename Result, typename... Args>
-class ProxyCallbackImpl final : public ProxyCallback<std::function<Result(Args...)>>
-{
-    using Fn = std::function<Result(Args...)>;
-    Fn m_fn;
-
-public:
-    ProxyCallbackImpl(Fn fn) : m_fn(std::move(fn)) {}
-    Result call(Args&&... args) override { return m_fn(std::forward<Args>(args)...); }
-};
-
-template <typename Value, typename FnR, typename... FnParams, typename Output>
-void CustomBuildField(TypeList<std::function<FnR(FnParams...)>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Value&& value,
-    Output&& output)
-{
-    if (value) {
-        using Interface = typename decltype(output.get())::Calls;
-        using Callback = ProxyCallbackImpl<FnR, FnParams...>;
-        output.set(kj::heap<ProxyServer<Interface>>(
-            std::make_shared<Callback>(std::forward<Value>(value)), invoke_context.connection));
-    }
-}
-
-// ProxyCallFn class is needed because c++11 doesn't support auto lambda parameters.
-// It's equivalent c++14: [invoke_context](auto&& params) {
-// invoke_context->call(std::forward<decltype(params)>(params)...)
-template <typename InvokeContext>
-struct ProxyCallFn
-{
-    InvokeContext m_proxy;
-
-    template <typename... CallParams>
-    decltype(auto) operator()(CallParams&&... params) { return this->m_proxy->call(std::forward<CallParams>(params)...); }
-};
-
-template <typename FnR, typename... FnParams, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<std::function<FnR(FnParams...)>> types,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest)
-{
-    if (CustomHasField(types, invoke_context, input)) {
-        using Interface = typename Decay<decltype(input.get())>::Calls;
-        auto client = std::make_shared<ProxyClient<Interface>>(
-            input.get(), &invoke_context.connection, /* destroy_connection= */ false);
-        return read_dest.construct(ProxyCallFn<decltype(client)>{std::move(client)});
-    }
-    return read_dest.construct();
-};
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_FUNCTION_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-interface.h b/src/ipc/libmultiprocess/include/mp/type-interface.h
deleted file mode 100644
index a32c53d268f8..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-interface.h
+++ /dev/null
@@ -1,112 +0,0 @@
-// 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 MP_PROXY_TYPE_INTERFACE_H
-#define MP_PROXY_TYPE_INTERFACE_H
-
-#include <mp/util.h>
-
-namespace mp {
-template <typename Interface, typename Impl>
-kj::Own<typename Interface::Server> MakeProxyServer(InvokeContext& context, std::shared_ptr<Impl> impl)
-{
-    return kj::heap<ProxyServer<Interface>>(std::move(impl), context.connection);
-}
-
-template <typename Interface, typename Impl>
-kj::Own<typename Interface::Server> CustomMakeProxyServer(InvokeContext& context, std::shared_ptr<Impl>&& impl)
-{
-    return MakeProxyServer<Interface, Impl>(context, std::move(impl));
-}
-
-template <typename Impl, typename Value, typename Output>
-void CustomBuildField(TypeList<std::unique_ptr<Impl>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Value&& value,
-    Output&& output,
-    typename Decay<decltype(output.get())>::Calls* enable = nullptr)
-{
-    if (value) {
-        using Interface = typename decltype(output.get())::Calls;
-        output.set(CustomMakeProxyServer<Interface, Impl>(invoke_context, std::shared_ptr<Impl>(value.release())));
-    }
-}
-
-template <typename Impl, typename Value, typename Output>
-void CustomBuildField(TypeList<std::shared_ptr<Impl>>,
-    Priority<2>,
-    InvokeContext& invoke_context,
-    Value&& value,
-    Output&& output,
-    typename Decay<decltype(output.get())>::Calls* enable = nullptr)
-{
-    if (value) {
-        using Interface = typename decltype(output.get())::Calls;
-        output.set(CustomMakeProxyServer<Interface, Impl>(invoke_context, std::forward<Value>(value)));
-    }
-}
-
-template <typename Impl, typename Output>
-void CustomBuildField(TypeList<Impl&>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Impl& value,
-    Output&& output,
-    typename decltype(output.get())::Calls* enable = nullptr)
-{
-    // Disable deleter so proxy server object doesn't attempt to delete the
-    // wrapped implementation when the proxy client is destroyed or
-    // disconnected.
-    using Interface = typename decltype(output.get())::Calls;
-    output.set(CustomMakeProxyServer<Interface, Impl>(invoke_context, std::shared_ptr<Impl>(&value, [](Impl*){})));
-}
-
-template <typename Interface, typename Impl>
-std::unique_ptr<Impl> MakeProxyClient(InvokeContext& context, typename Interface::Client&& client)
-{
-    return std::make_unique<ProxyClient<Interface>>(
-        std::move(client), &context.connection, /* destroy_connection= */ false);
-}
-
-template <typename Interface, typename Impl>
-std::unique_ptr<Impl> CustomMakeProxyClient(InvokeContext& context, typename Interface::Client&& client)
-{
-    return MakeProxyClient<Interface, Impl>(context, kj::mv(client));
-}
-
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<std::unique_ptr<LocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest,
-    typename Decay<decltype(input.get())>::Calls* enable = nullptr)
-{
-    using Interface = typename Decay<decltype(input.get())>::Calls;
-    if (CustomHasField(TypeList<LocalType>(), invoke_context, input)) {
-        return read_dest.construct(
-                                   CustomMakeProxyClient<Interface, LocalType>(invoke_context, std::move(input.get())));
-    }
-    return read_dest.construct();
-}
-
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<std::shared_ptr<LocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest,
-    typename Decay<decltype(input.get())>::Calls* enable = nullptr)
-{
-    using Interface = typename Decay<decltype(input.get())>::Calls;
-    if (CustomHasField(TypeList<LocalType>(), invoke_context, input)) {
-        return read_dest.construct(
-            CustomMakeProxyClient<Interface, LocalType>(invoke_context, std::move(input.get())));
-    }
-    return read_dest.construct();
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_INTERFACE_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-map.h b/src/ipc/libmultiprocess/include/mp/type-map.h
deleted file mode 100644
index 50a590cbc3fc..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-map.h
+++ /dev/null
@@ -1,81 +0,0 @@
-// 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 MP_PROXY_TYPE_MAP_H
-#define MP_PROXY_TYPE_MAP_H
-
-#include <mp/proxy-types.h>
-#include <mp/type-pair.h>
-#include <mp/util.h>
-
-namespace mp {
-template <typename KeyLocalType, typename ValueLocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<std::map<KeyLocalType, ValueLocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Value&& value,
-    Output&& output)
-{
-    // FIXME dededup with vector handler above
-    auto list = output.init(value.size());
-    size_t i = 0;
-    for (const auto& elem : value) {
-        BuildField(TypeList<std::pair<KeyLocalType, ValueLocalType>>(), invoke_context,
-            ListOutput<typename decltype(list)::Builds>(list, i), elem);
-        ++i;
-    }
-}
-
-// Replacement for `m.emplace(piecewise_construct, t1, t2)` to work around a
-// Clang 22 regression triggered by libc++'s std::map piecewise emplace: when
-// the key constructor argument tuple is empty (std::tuple<>), libc++'s internal
-// "try key extraction" SFINAE probe instantiates std::tuple_element<0,
-// std::tuple<>>, which Clang 22 diagnoses as an out-of-bounds pack access ("a
-// parameter pack may not be accessed at an out of bounds index") instead of
-// treating it as substitution failure. See LLVM issue #167709 and the upstream
-// fix in llvm/llvm-project PR #183614.
-// https://github.com/llvm/llvm-project/issues/167709
-// https://github.com/llvm/llvm-project/pull/183614
-template <class Map, class Tuple1, class Tuple2>
-auto EmplacePiecewiseSafe(
-    Map& m,
-    const std::piecewise_construct_t&,
-    Tuple1&& t1,
-    Tuple2&& t2)
-{
-    if constexpr (std::tuple_size_v<std::remove_reference_t<Tuple1>> == 0) {
-        // Avoid tuple<> / tuple<> (LLVM 22 libc++ regression path)
-        return m.emplace(std::piecewise_construct,
-                         std::forward_as_tuple(typename Map::key_type{}),
-                         std::forward<Tuple2>(t2));
-    } else {
-        return m.emplace(std::piecewise_construct,
-                         std::forward<Tuple1>(t1),
-                         std::forward<Tuple2>(t2));
-    }
-}
-
-template <typename KeyLocalType, typename ValueLocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<std::map<KeyLocalType, ValueLocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest)
-{
-    return read_dest.update([&](auto& value) {
-        auto data = input.get();
-        value.clear();
-        for (auto item : data) {
-            ReadField(TypeList<std::pair<const KeyLocalType, ValueLocalType>>(), invoke_context,
-                Make<ValueField>(item),
-                ReadDestEmplace(
-                    TypeList<std::pair<const KeyLocalType, ValueLocalType>>(), [&](auto&&... args) -> auto& {
-                        return *EmplacePiecewiseSafe(value, std::forward<decltype(args)>(args)...).first;
-                    }));
-        }
-    });
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_MAP_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-message.h b/src/ipc/libmultiprocess/include/mp/type-message.h
deleted file mode 100644
index b1cec13d6c1f..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-message.h
+++ /dev/null
@@ -1,64 +0,0 @@
-// 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 MP_PROXY_TYPE_MESSAGE_H
-#define MP_PROXY_TYPE_MESSAGE_H
-
-#include <mp/util.h>
-
-namespace mp {
-//! Overload CustomBuildField to serialize objects that have CustomBuildMessage
-//! overloads. Defining a CustomBuildMessage overload is simpler than defining a
-//! CustomBuildField overload because it only requires defining a normal
-//! function, not a template function, but less flexible.
-template <typename LocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<LocalType>, Priority<2>, InvokeContext& invoke_context, Value&& value, Output&& output,
-                      decltype(CustomBuildMessage(invoke_context, value, std::move(output.get())))* enable = nullptr)
-{
-    CustomBuildMessage(invoke_context, value, std::move(output.init()));
-}
-
-//! Overload CustomReadField to serialize objects that have CustomReadMessage
-//! overloads. Defining a CustomReadMessage overload is simpler than defining a
-//! CustomReadField overload because it only requires defining a normal
-//! function, not a template function, but less flexible.
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<LocalType>, Priority<2>, InvokeContext& invoke_context, Input&& input,
-                               ReadDest&& read_dest,
-                               decltype(CustomReadMessage(invoke_context, input.get(),
-                                                          std::declval<LocalType&>()))* enable = nullptr)
-{
-    return read_dest.update([&](auto& value) { if (CustomHasField(TypeList<LocalType>(), invoke_context, input)) CustomReadMessage(invoke_context, input.get(), value); });
-}
-
-//! Helper for CustomPassField below. Call Accessor::init method if it has one,
-//! otherwise do nothing.
-template <typename Accessor, typename Message>
-decltype(auto) MaybeInit(Message&& message, decltype(Accessor::get(message))* enable = nullptr)
-{
-    return Accessor::init(message);
-}
-
-template <typename Accessor>
-::capnp::Void MaybeInit(...)
-{
-    return {};
-}
-
-//! Overload CustomPassField to serialize objects that have CustomPassMessage
-//! overloads. Defining a CustomPassMessage overload is simpler than defining a
-//! CustomPassField overload because it only requires defining a normal
-//! function, not a template function, but less flexible.
-template <typename Accessor, typename... LocalTypes, typename ServerContext, typename Fn, typename... Args>
-auto CustomPassField(TypeList<LocalTypes...>, ServerContext& server_context, Fn&& fn, Args&&... args)
-    -> decltype(CustomPassMessage(server_context, MaybeGet<Accessor>(server_context.call_context.getParams()),
-                                  MaybeGet<Accessor>(server_context.call_context.getResults()), nullptr))
-{
-    CustomPassMessage(server_context, MaybeGet<Accessor>(server_context.call_context.getParams()),
-                      MaybeInit<Accessor>(server_context.call_context.getResults()),
-                      [&](LocalTypes... param) { fn.invoke(server_context, std::forward<Args>(args)..., param...); });
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_MESSAGE_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-number.h b/src/ipc/libmultiprocess/include/mp/type-number.h
deleted file mode 100644
index 5c997f54bc8a..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-number.h
+++ /dev/null
@@ -1,93 +0,0 @@
-// 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 MP_PROXY_TYPE_NUMBER_H
-#define MP_PROXY_TYPE_NUMBER_H
-
-#include <mp/util.h>
-
-namespace mp {
-template <typename LocalType, typename Value>
-LocalType BuildPrimitive(InvokeContext& invoke_context,
-    const Value& value,
-    TypeList<LocalType>,
-    typename std::enable_if<std::is_enum<Value>::value>::type* enable = nullptr)
-{
-    using E = std::make_unsigned_t<std::underlying_type_t<Value>>;
-    using T = std::make_unsigned_t<LocalType>;
-    static_assert(std::numeric_limits<T>::max() >= std::numeric_limits<E>::max(), "mismatched integral/enum types");
-    return static_cast<LocalType>(value);
-}
-
-template <typename LocalType, typename Value>
-LocalType BuildPrimitive(InvokeContext& invoke_context,
-    const Value& value,
-    TypeList<LocalType>,
-    typename std::enable_if<std::is_integral<Value>::value, int>::type* enable = nullptr)
-{
-    static_assert(
-        std::numeric_limits<LocalType>::lowest() <= std::numeric_limits<Value>::lowest(), "mismatched integral types");
-    static_assert(
-        std::numeric_limits<LocalType>::max() >= std::numeric_limits<Value>::max(), "mismatched integral types");
-    return value;
-}
-
-template <typename LocalType, typename Value>
-LocalType BuildPrimitive(InvokeContext& invoke_context,
-    const Value& value,
-    TypeList<LocalType>,
-    typename std::enable_if<std::is_floating_point<Value>::value>::type* enable = nullptr)
-{
-    static_assert(std::is_same<Value, LocalType>::value,
-        "mismatched floating point types. please fix message.capnp type declaration to match wrapped interface");
-    return value;
-}
-
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<LocalType>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest,
-    typename std::enable_if<std::is_enum<LocalType>::value>::type* enable = nullptr)
-{
-    // Disable clang-tidy out-of-range enum value check which triggers when
-    // using an enum type that does not have a 0 value. The check correctly
-    // triggers when it detects that Cap'n Proto returns 0 when reading an
-    // integer field that is unset. But the warning is spurious because the
-    // corresponding BuildField call should never leave the field unset.
-    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
-    return read_dest.construct(static_cast<LocalType>(input.get()));
-}
-
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<LocalType>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest,
-    typename std::enable_if<std::is_integral<LocalType>::value>::type* enable = nullptr)
-{
-    auto value = input.get();
-    if (value < std::numeric_limits<LocalType>::min() || value > std::numeric_limits<LocalType>::max()) {
-        throw std::range_error("out of bound int received");
-    }
-    return read_dest.construct(static_cast<LocalType>(value));
-}
-
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<LocalType>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest,
-    typename std::enable_if<std::is_floating_point<LocalType>::value>::type* enable = 0)
-{
-    auto value = input.get();
-    static_assert(std::is_same<LocalType, decltype(value)>::value, "floating point type mismatch");
-    return read_dest.construct(value);
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_NUMBER_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-optional.h b/src/ipc/libmultiprocess/include/mp/type-optional.h
deleted file mode 100644
index 80a8f4f3026e..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-optional.h
+++ /dev/null
@@ -1,47 +0,0 @@
-// 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 MP_PROXY_TYPE_OPTIONAL_H
-#define MP_PROXY_TYPE_OPTIONAL_H
-
-#include <mp/util.h>
-
-namespace mp {
-template <typename LocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<std::optional<LocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Value&& value,
-    Output&& output)
-{
-    if (value) {
-        output.setHas();
-        BuildField(TypeList<LocalType>(), invoke_context, output, *std::forward<Value>(value));
-    }
-}
-
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<std::optional<LocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest)
-{
-    return read_dest.update([&](auto& value) {
-        if (!CustomHasField(TypeList<LocalType>(), invoke_context, input)) {
-            value.reset();
-        } else if (value) {
-            ReadField(TypeList<LocalType>(), invoke_context, input, ReadDestUpdate(*value));
-        } else {
-            ReadField(TypeList<LocalType>(), invoke_context, input,
-                ReadDestEmplace(TypeList<LocalType>(), [&](auto&&... args) -> auto& {
-                    value.emplace(std::forward<decltype(args)>(args)...);
-                    return *value;
-                }));
-        }
-    });
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_OPTIONAL_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-pair.h b/src/ipc/libmultiprocess/include/mp/type-pair.h
deleted file mode 100644
index b1914c9d9c64..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-pair.h
+++ /dev/null
@@ -1,50 +0,0 @@
-// 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 MP_PROXY_TYPE_PAIR_H
-#define MP_PROXY_TYPE_PAIR_H
-
-#include <mp/util.h>
-
-namespace mp {
-// FIXME: Overload on output type instead of value type and switch to std::get and merge with next overload
-template <typename KeyLocalType, typename ValueLocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<std::pair<KeyLocalType, ValueLocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Value&& value,
-    Output&& output)
-{
-    auto pair = output.init();
-    using Accessors = typename ProxyStruct<typename decltype(pair)::Builds>::Accessors;
-    BuildField(TypeList<KeyLocalType>(), invoke_context, Make<StructField, std::tuple_element_t<0, Accessors>>(pair), value.first);
-    BuildField(TypeList<ValueLocalType>(), invoke_context, Make<StructField, std::tuple_element_t<1, Accessors>>(pair), value.second);
-}
-
-template <typename KeyLocalType, typename ValueLocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<std::pair<KeyLocalType, ValueLocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest)
-{
-    const auto& pair = input.get();
-    using Accessors = typename ProxyStruct<typename Decay<decltype(pair)>::Reads>::Accessors;
-
-    ReadField(TypeList<KeyLocalType>(), invoke_context, Make<StructField, std::tuple_element_t<0, Accessors>>(pair),
-        ReadDestEmplace(TypeList<KeyLocalType>(), [&](auto&&... key_args) -> auto& {
-            KeyLocalType* key = nullptr;
-            ReadField(TypeList<ValueLocalType>(), invoke_context, Make<StructField, std::tuple_element_t<1, Accessors>>(pair),
-                ReadDestEmplace(TypeList<ValueLocalType>(), [&](auto&&... value_args) -> auto& {
-                    auto& ret = read_dest.construct(std::piecewise_construct, std::forward_as_tuple(key_args...),
-                        std::forward_as_tuple(value_args...));
-                    key = &ret.first;
-                    return ret.second;
-                }));
-            return *key;
-        }));
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_PAIR_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-pointer.h b/src/ipc/libmultiprocess/include/mp/type-pointer.h
deleted file mode 100644
index 192e1b034a36..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-pointer.h
+++ /dev/null
@@ -1,113 +0,0 @@
-// 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 MP_PROXY_TYPE_POINTER_H
-#define MP_PROXY_TYPE_POINTER_H
-
-#include <mp/util.h>
-
-namespace mp {
-template <typename LocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<LocalType*>, Priority<3>, InvokeContext& invoke_context, Value&& value, Output&& output)
-{
-    if (value) {
-        BuildField(TypeList<LocalType>(), invoke_context, output, *value);
-    }
-}
-
-template <typename LocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<std::shared_ptr<LocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Value&& value,
-    Output&& output)
-{
-    if (value) {
-        BuildField(TypeList<LocalType>(), invoke_context, output, *value);
-    }
-}
-
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<LocalType*>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest)
-{
-    return read_dest.update([&](auto& value) {
-        if (value) {
-            ReadField(TypeList<LocalType>(), invoke_context, std::forward<Input>(input), ReadDestUpdate(*value));
-        }
-    });
-}
-
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<std::shared_ptr<LocalType>>,
-    Priority<0>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest)
-{
-    return read_dest.update([&](auto& value) {
-        if (!CustomHasField(TypeList<LocalType>(), invoke_context, input)) {
-            value.reset();
-        } else if (value) {
-            ReadField(TypeList<LocalType>(), invoke_context, input, ReadDestUpdate(*value));
-        } else {
-            ReadField(TypeList<LocalType>(), invoke_context, input,
-                ReadDestEmplace(TypeList<LocalType>(), [&](auto&&... args) -> auto& {
-                    value = std::make_shared<LocalType>(std::forward<decltype(args)>(args)...);
-                    return *value;
-                }));
-        }
-    });
-}
-
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<std::shared_ptr<const LocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest)
-{
-    return read_dest.update([&](auto& value) {
-        if (!CustomHasField(TypeList<LocalType>(), invoke_context, input)) {
-            value.reset();
-            return;
-        }
-        ReadField(TypeList<LocalType>(), invoke_context, std::forward<Input>(input),
-            ReadDestEmplace(TypeList<LocalType>(), [&](auto&&... args) -> auto& {
-                value = std::make_shared<LocalType>(std::forward<decltype(args)>(args)...);
-                return *value;
-            }));
-    });
-}
-
-//! PassField override for C++ pointer arguments.
-template <typename Accessor, typename LocalType, typename ServerContext, typename Fn, typename... Args>
-void PassField(Priority<1>, TypeList<LocalType*>, ServerContext& server_context, const Fn& fn, Args&&... args)
-{
-    const auto& params = server_context.call_context.getParams();
-    const auto& input = Make<StructField, Accessor>(params);
-
-    if (!input.want()) {
-        fn.invoke(server_context, std::forward<Args>(args)..., nullptr);
-        return;
-    }
-
-    InvokeContext& invoke_context = server_context;
-    Decay<LocalType> param;
-
-    MaybeReadField(std::integral_constant<bool, Accessor::in>(), TypeList<LocalType>(), invoke_context, input,
-        ReadDestUpdate(param));
-
-    fn.invoke(server_context, std::forward<Args>(args)..., &param);
-
-    auto&& results = server_context.call_context.getResults();
-    MaybeBuildField(std::integral_constant<bool, Accessor::out>(), TypeList<LocalType>(), invoke_context,
-        Make<StructField, Accessor>(results), param);
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_POINTER_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-set.h b/src/ipc/libmultiprocess/include/mp/type-set.h
deleted file mode 100644
index 699c6e9e03aa..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-set.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// 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 MP_PROXY_TYPE_SET_H
-#define MP_PROXY_TYPE_SET_H
-
-#include <mp/proxy-types.h>
-#include <mp/util.h>
-
-namespace mp {
-template <typename LocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<std::set<LocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Value&& value,
-    Output&& output)
-{
-    // FIXME dededup with vector handler above
-    auto list = output.init(value.size());
-    size_t i = 0;
-    for (const auto& elem : value) {
-        BuildField(TypeList<LocalType>(), invoke_context, ListOutput<typename decltype(list)::Builds>(list, i), elem);
-        ++i;
-    }
-}
-
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<std::set<LocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest)
-{
-    return read_dest.update([&](auto& value) {
-        auto data = input.get();
-        value.clear();
-        for (auto item : data) {
-            ReadField(TypeList<LocalType>(), invoke_context, Make<ValueField>(item),
-                ReadDestEmplace(TypeList<const LocalType>(), [&](auto&&... args) -> auto& {
-                    return *value.emplace(std::forward<decltype(args)>(args)...).first;
-                }));
-        }
-    });
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_SET_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-string.h b/src/ipc/libmultiprocess/include/mp/type-string.h
deleted file mode 100644
index d4c3383bdfea..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-string.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// 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 MP_PROXY_TYPE_STRING_H
-#define MP_PROXY_TYPE_STRING_H
-
-#include <mp/util.h>
-
-namespace mp {
-template <typename Value, typename Output>
-void CustomBuildField(TypeList<std::string>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Value&& value,
-    Output&& output)
-{
-    auto result = output.init(value.size());
-    memcpy(result.begin(), value.data(), value.size());
-}
-
-template <typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<std::string>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest)
-{
-    auto data = input.get();
-    return read_dest.construct(CharCast(data.begin()), data.size());
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_STRING_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-struct.h b/src/ipc/libmultiprocess/include/mp/type-struct.h
deleted file mode 100644
index 6d396387ffe1..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-struct.h
+++ /dev/null
@@ -1,85 +0,0 @@
-// 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 MP_PROXY_TYPE_STRUCT_H
-#define MP_PROXY_TYPE_STRUCT_H
-
-#include <mp/util.h>
-
-namespace mp {
-template <size_t index, typename LocalType, typename Value, typename Output>
-void BuildOne(TypeList<LocalType> param,
-    InvokeContext& invoke_context,
-    Output&& output,
-    Value&& value,
-    typename std::enable_if < index<ProxyType<LocalType>::fields>::type * enable = nullptr)
-{
-    using Index = std::integral_constant<size_t, index>;
-    using Struct = typename ProxyType<LocalType>::Struct;
-    using Accessor = typename std::tuple_element<index, typename ProxyStruct<Struct>::Accessors>::type;
-    auto&& field_output = Make<StructField, Accessor>(output);
-    auto&& field_value = value.*ProxyType<LocalType>::get(Index());
-    BuildField(TypeList<Decay<decltype(field_value)>>(), invoke_context, field_output, field_value);
-    BuildOne<index + 1>(param, invoke_context, output, value);
-}
-
-template <size_t index, typename LocalType, typename Value, typename Output>
-void BuildOne(TypeList<LocalType> param,
-    InvokeContext& invoke_context,
-    Output&& output,
-    Value&& value,
-    typename std::enable_if<index == ProxyType<LocalType>::fields>::type* enable = nullptr)
-{
-}
-
-template <typename LocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<LocalType> local_type,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Value&& value,
-    Output&& output,
-    typename ProxyType<LocalType>::Struct* enable = nullptr)
-{
-    BuildOne<0>(local_type, invoke_context, output.init(), value);
-}
-
-template <size_t index, typename LocalType, typename Input, typename Value>
-void ReadOne(TypeList<LocalType> param,
-    InvokeContext& invoke_context,
-    Input&& input,
-    Value&& value,
-    typename std::enable_if<index != ProxyType<LocalType>::fields>::type* enable = nullptr)
-{
-    using Index = std::integral_constant<size_t, index>;
-    using Struct = typename ProxyType<LocalType>::Struct;
-    using Accessor = typename std::tuple_element<index, typename ProxyStruct<Struct>::Accessors>::type;
-    const auto& struc = input.get();
-    auto&& field_value = value.*ProxyType<LocalType>::get(Index());
-    ReadField(TypeList<RemoveCvRef<decltype(field_value)>>(), invoke_context, Make<StructField, Accessor>(struc),
-        ReadDestUpdate(field_value));
-    ReadOne<index + 1>(param, invoke_context, input, value);
-}
-
-template <size_t index, typename LocalType, typename Input, typename Value>
-void ReadOne(TypeList<LocalType> param,
-    InvokeContext& invoke_context,
-    Input& input,
-    Value& value,
-    typename std::enable_if<index == ProxyType<LocalType>::fields>::type* enable = nullptr)
-{
-}
-
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<LocalType> param,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest,
-    typename ProxyType<LocalType>::Struct* enable = nullptr)
-{
-    return read_dest.update([&](auto& value) { ReadOne<0>(param, invoke_context, input, value); });
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_STRUCT_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-threadmap.h b/src/ipc/libmultiprocess/include/mp/type-threadmap.h
deleted file mode 100644
index 3005d9de0fc8..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-threadmap.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// 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 MP_PROXY_TYPE_THREADMAP_H
-#define MP_PROXY_TYPE_THREADMAP_H
-
-#include <mp/util.h>
-
-namespace mp {
-template <>
-struct ProxyServer<ThreadMap> final : public virtual ThreadMap::Server
-{
-public:
-    ProxyServer(Connection& connection);
-    kj::Promise<void> makeThread(MakeThreadContext context) override;
-    Connection& m_connection;
-};
-
-template <typename Output>
-void CustomBuildField(TypeList<>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Output&& output,
-    typename std::enable_if<std::is_same<decltype(output.get()), ThreadMap::Client>::value>::type* enable = nullptr)
-{
-    output.set(kj::heap<ProxyServer<ThreadMap>>(invoke_context.connection));
-}
-
-template <typename Input>
-decltype(auto) CustomReadField(TypeList<>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    typename std::enable_if<std::is_same<decltype(input.get()), ThreadMap::Client>::value>::type* enable = nullptr)
-{
-    invoke_context.connection.m_thread_map = input.get();
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_THREADMAP_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-tuple.h b/src/ipc/libmultiprocess/include/mp/type-tuple.h
deleted file mode 100644
index 597ffbfb270e..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-tuple.h
+++ /dev/null
@@ -1,45 +0,0 @@
-// 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 MP_PROXY_TYPE_TUPLE_H
-#define MP_PROXY_TYPE_TUPLE_H
-
-#include <mp/util.h>
-
-namespace mp {
-// TODO: Should generalize this to work with arbitrary length tuples, not just length 2-tuples.
-template <typename KeyLocalType, typename ValueLocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<std::tuple<KeyLocalType, ValueLocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Value&& value,
-    Output&& output)
-{
-    auto pair = output.init();
-    using Accessors = typename ProxyStruct<typename decltype(pair)::Builds>::Accessors;
-    BuildField(TypeList<KeyLocalType>(), invoke_context, Make<StructField, std::tuple_element_t<0, Accessors>>(pair), std::get<0>(value));
-    BuildField(TypeList<ValueLocalType>(), invoke_context, Make<StructField, std::tuple_element_t<1, Accessors>>(pair), std::get<1>(value));
-}
-
-// TODO: Should generalize this to work with arbitrary length tuples, not just length 2-tuples.
-template <typename KeyLocalType, typename ValueLocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<std::tuple<KeyLocalType, ValueLocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest)
-{
-    return read_dest.update([&](auto& value) {
-        const auto& pair = input.get();
-        using Struct = ProxyStruct<typename Decay<decltype(pair)>::Reads>;
-        using Accessors = typename Struct::Accessors;
-        ReadField(TypeList<KeyLocalType>(), invoke_context, Make<StructField, std::tuple_element_t<0, Accessors>>(pair),
-            ReadDestUpdate(std::get<0>(value)));
-        ReadField(TypeList<ValueLocalType>(), invoke_context, Make<StructField, std::tuple_element_t<1, Accessors>>(pair),
-            ReadDestUpdate(std::get<1>(value)));
-    });
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_TUPLE_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-vector.h b/src/ipc/libmultiprocess/include/mp/type-vector.h
deleted file mode 100644
index 90605ddf8643..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-vector.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// 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 MP_PROXY_TYPE_VECTOR_H
-#define MP_PROXY_TYPE_VECTOR_H
-
-#include <mp/proxy-types.h>
-#include <mp/util.h>
-
-namespace mp {
-template <typename LocalType, typename Value, typename Output>
-void CustomBuildField(TypeList<std::vector<LocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Value&& value,
-    Output&& output)
-{
-    // FIXME dedup with set handler below
-    auto list = output.init(value.size());
-    size_t i = 0;
-    for (auto it = value.begin(); it != value.end(); ++it, ++i) {
-        BuildField(TypeList<LocalType>(), invoke_context, ListOutput<typename decltype(list)::Builds>(list, i), *it);
-    }
-}
-
-inline static bool BuildPrimitive(InvokeContext& invoke_context, std::vector<bool>::const_reference value, TypeList<bool>)
-{
-    return value;
-}
-
-template <typename LocalType, typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<std::vector<LocalType>>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    ReadDest&& read_dest)
-{
-    return read_dest.update([&](auto& value) {
-        auto data = input.get();
-        value.clear();
-        value.reserve(data.size());
-        for (auto item : data) {
-            ReadField(TypeList<LocalType>(), invoke_context, Make<ValueField>(item),
-                ReadDestEmplace(TypeList<LocalType>(), [&](auto&&... args) -> auto& {
-                    value.emplace_back(std::forward<decltype(args)>(args)...);
-                    return value.back();
-                }));
-        }
-    });
-}
-
-template <typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<std::vector<bool>>,
-                               Priority<1>,
-                               InvokeContext& invoke_context,
-                               Input&& input,
-                               ReadDest&& read_dest)
-{
-    return read_dest.update([&](auto& value) {
-        auto data = input.get();
-        value.clear();
-        value.reserve(data.size());
-        for (auto item : data) {
-            value.push_back(ReadField(TypeList<bool>(), invoke_context, Make<ValueField>(item), ReadDestTemp<bool>()));
-        }
-    });
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_VECTOR_H
diff --git a/src/ipc/libmultiprocess/include/mp/type-void.h b/src/ipc/libmultiprocess/include/mp/type-void.h
deleted file mode 100644
index ed733985b29b..000000000000
--- a/src/ipc/libmultiprocess/include/mp/type-void.h
+++ /dev/null
@@ -1,23 +0,0 @@
-// 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 MP_PROXY_TYPE_VOID_H
-#define MP_PROXY_TYPE_VOID_H
-
-#include <mp/util.h>
-
-namespace mp {
-template <typename Value>
-::capnp::Void BuildPrimitive(InvokeContext& invoke_context, Value&&, TypeList<::capnp::Void>)
-{
-    return {};
-}
-
-template <typename LocalType, typename Output>
-void CustomBuildField(TypeList<LocalType>, Priority<1>, InvokeContext& invoke_context, ::capnp::Void, Output&& output)
-{
-}
-} // namespace mp
-
-#endif // MP_PROXY_TYPE_VOID_H
diff --git a/src/ipc/libmultiprocess/include/mp/util.h b/src/ipc/libmultiprocess/include/mp/util.h
deleted file mode 100644
index a3db1282bbcf..000000000000
--- a/src/ipc/libmultiprocess/include/mp/util.h
+++ /dev/null
@@ -1,342 +0,0 @@
-// 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 MP_UTIL_H
-#define MP_UTIL_H
-
-#include <capnp/schema.h>
-#include <cassert>
-#include <cstddef>
-#include <cstring>
-#include <exception>
-#include <functional>
-#include <kj/string-tree.h>
-#include <mutex>
-#include <string>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <variant>
-#include <vector>
-
-namespace mp {
-
-//! Generic utility functions used by capnp code.
-
-//! Type holding a list of types.
-//!
-//! Example:
-//!   TypeList<int, bool, void>
-template <typename... Types>
-struct TypeList
-{
-    static constexpr size_t size = sizeof...(Types);
-};
-
-//! Construct a template class value by deducing template arguments from the
-//! types of constructor arguments, so they don't need to be specified manually.
-//!
-//! Uses of this can go away with class template deduction in C++17
-//! (https://en.cppreference.com/w/cpp/language/class_template_argument_deduction)
-//!
-//! Example:
-//!   Make<std::pair>(5, true) // Constructs std::pair<int, bool>(5, true);
-template <template <typename...> class Class, typename... Types, typename... Args>
-Class<Types..., std::remove_reference_t<Args>...> Make(Args&&... args)
-{
-    return Class<Types..., std::remove_reference_t<Args>...>{std::forward<Args>(args)...};
-}
-
-//! Type helper splitting a TypeList into two halves at position index.
-//!
-//! Example:
-//!   is_same<TypeList<int, double>, Split<2, TypeList<int, double, float, bool>>::First>
-//!   is_same<TypeList<float, bool>, Split<2, TypeList<int, double, float, bool>>::Second>
-template <std::size_t index, typename List, typename _First = TypeList<>, bool done = index == 0>
-struct Split;
-
-//! Specialization of above (base case)
-template <typename _Second, typename _First>
-struct Split<0, _Second, _First, true>
-{
-    using First = _First;
-    using Second = _Second;
-};
-
-//! Specialization of above (recursive case)
-template <std::size_t index, typename Type, typename... _Second, typename... _First>
-struct Split<index, TypeList<Type, _Second...>, TypeList<_First...>, false>
-{
-    using _Next = Split<index - 1, TypeList<_Second...>, TypeList<_First..., Type>>;
-    using First = typename _Next::First;
-    using Second = typename _Next::Second;
-};
-
-//! Type helper giving return type of a callable type.
-template <typename Callable>
-using ResultOf = decltype(std::declval<Callable>()());
-
-//! Substitutue for std::remove_cvref_t
-template <typename T>
-using RemoveCvRef = std::remove_cv_t<std::remove_reference_t<T>>;
-
-//! Type helper abbreviating std::decay.
-template <typename T>
-using Decay = std::decay_t<T>;
-
-//! SFINAE helper, see using Require below.
-template <typename SfinaeExpr, typename Result_>
-struct _Require
-{
-    using Result = Result_;
-};
-
-//! SFINAE helper, basically the same as to C++17's void_t, but allowing types other than void to be returned.
-template <typename SfinaeExpr, typename Result = void>
-using Require = typename _Require<SfinaeExpr, Result>::Result;
-
-//! Function parameter type for prioritizing overloaded function calls that
-//! would otherwise be ambiguous.
-//!
-//! Example:
-//!   auto foo(Priority<1>) -> std::enable_if<>;
-//!   auto foo(Priority<0>) -> void;
-//!
-//!   foo(Priority<1>());   // Calls higher priority overload if enabled.
-template <int priority>
-struct Priority : Priority<priority - 1>
-{
-};
-
-//! Specialization of above (base case)
-template <>
-struct Priority<0>
-{
-};
-
-//! Return capnp type name with filename prefix removed.
-template <typename T>
-const char* TypeName()
-{
-    // DisplayName string looks like
-    // "interfaces/capnp/common.capnp:ChainNotifications.resendWalletTransactions$Results"
-    // This discards the part of the string before the first ':' character.
-    // Another alternative would be to use the displayNamePrefixLength field,
-    // but this discards everything before the last '.' character, throwing away
-    // the object name, which is useful.
-    const char* display_name = ::capnp::Schema::from<T>().getProto().getDisplayName().cStr();
-    const char* short_name = strchr(display_name, ':');
-    return short_name ? short_name + 1 : display_name;
-}
-
-//! Convenient wrapper around std::variant<T*, T>
-template <typename T>
-struct PtrOrValue {
-    std::variant<T*, T> data;
-
-    template <typename... Args>
-    PtrOrValue(T* ptr, Args&&... args) : data(ptr ? ptr : std::variant<T*, T>{std::in_place_type<T>, std::forward<Args>(args)...}) {}
-
-    T& operator*() { return data.index() ? std::get<T>(data) : *std::get<T*>(data); }
-    T* operator->() { return &**this; }
-    T& operator*() const { return data.index() ? std::get<T>(data) : *std::get<T*>(data); }
-    T* operator->() const { return &**this; }
-};
-
-// Annotated mutex and lock class (https://clang.llvm.org/docs/ThreadSafetyAnalysis.html)
-#if defined(__clang__) && (!defined(SWIG))
-#define MP_TSA(x)   __attribute__((x))
-#else
-#define MP_TSA(x)   // no-op
-#endif
-
-#define MP_CAPABILITY(x)        MP_TSA(capability(x))
-#define MP_SCOPED_CAPABILITY    MP_TSA(scoped_lockable)
-#define MP_REQUIRES(x)          MP_TSA(requires_capability(x))
-#define MP_ACQUIRE(...)         MP_TSA(acquire_capability(__VA_ARGS__))
-#define MP_RELEASE(...)         MP_TSA(release_capability(__VA_ARGS__))
-#define MP_ASSERT_CAPABILITY(x) MP_TSA(assert_capability(x))
-#define MP_GUARDED_BY(x)        MP_TSA(guarded_by(x))
-#define MP_NO_TSA               MP_TSA(no_thread_safety_analysis)
-
-class MP_CAPABILITY("mutex") Mutex {
-public:
-    void lock() MP_ACQUIRE() { m_mutex.lock(); }
-    void unlock() MP_RELEASE() { m_mutex.unlock(); }
-
-    std::mutex m_mutex;
-};
-
-class MP_SCOPED_CAPABILITY Lock {
-public:
-    explicit Lock(Mutex& m) MP_ACQUIRE(m) : m_lock(m.m_mutex) {}
-    ~Lock() MP_RELEASE() = default;
-    void unlock() MP_RELEASE() { m_lock.unlock(); }
-    void lock() MP_ACQUIRE() { m_lock.lock(); }
-    void assert_locked(Mutex& mutex) MP_ASSERT_CAPABILITY() MP_ASSERT_CAPABILITY(mutex)
-    {
-        assert(m_lock.mutex() == &mutex.m_mutex);
-        assert(m_lock);
-    }
-
-    std::unique_lock<std::mutex> m_lock;
-};
-
-template<typename T>
-struct GuardedRef
-{
-    Mutex& mutex;
-    T& ref MP_GUARDED_BY(mutex);
-};
-
-// CTAD for Clang 16: GuardedRef{mutex, x} -> GuardedRef<decltype(x)>
-template <class U>
-GuardedRef(Mutex&, U&) -> GuardedRef<U>;
-
-//! Analog to std::lock_guard that unlocks instead of locks.
-template <typename Lock>
-struct UnlockGuard
-{
-    UnlockGuard(Lock& lock) : m_lock(lock) { m_lock.unlock(); }
-    ~UnlockGuard() { m_lock.lock(); }
-    Lock& m_lock;
-};
-
-template <typename Lock, typename Callback>
-void Unlock(Lock& lock, Callback&& callback)
-{
-    const UnlockGuard<Lock> unlock(lock);
-    callback();
-}
-
-//! Invoke a function and run a follow-up action before returning the original
-//! result.
-//!
-//! This can be used similarly to KJ_DEFER to run cleanup code, but works better
-//! if the cleanup function can throw because it avoids clang bug
-//! https://github.com/llvm/llvm-project/issues/12658 which skips calling
-//! destructors in that case and can lead to memory leaks. Also, if both
-//! functions throw, this lets one exception take precedence instead of
-//! terminating due to having two active exceptions.
-template <typename Fn, typename After>
-decltype(auto) TryFinally(Fn&& fn, After&& after)
-{
-    bool success{false};
-    using R = std::invoke_result_t<Fn>;
-    try {
-        if constexpr (std::is_void_v<R>) {
-            std::forward<Fn>(fn)();
-            success = true;
-            std::forward<After>(after)();
-            return;
-        } else {
-            decltype(auto) result = std::forward<Fn>(fn)();
-            success = true;
-            std::forward<After>(after)();
-            return result;
-        }
-    } catch (...) {
-        if (!success) std::forward<After>(after)();
-        throw;
-    }
-}
-
-//! Format current thread name as "{exe_name}-{$pid}/{thread_name}-{$tid}".
-std::string ThreadName(const char* exe_name);
-
-//! Escape binary string for use in log so it doesn't trigger unicode decode
-//! errors in python unit tests.
-std::string LogEscape(const kj::StringTree& string, size_t max_size);
-
-//! Callback type used by SpawnProcess below.
-using FdToArgsFn = std::function<std::vector<std::string>(int fd)>;
-
-//! Spawn a new process that communicates with the current process over a socket
-//! pair. Returns pid through an output argument, and file descriptor for the
-//! local side of the socket.
-//! The fd_to_args callback is invoked in the parent process before fork().
-//! It must not rely on child pid/state, and must return the command line
-//! arguments that should be used to execute the process. Embed the remote file
-//! descriptor number in whatever format the child process expects.
-int SpawnProcess(int& pid, FdToArgsFn&& fd_to_args);
-
-//! Call execvp with vector args.
-//! Not safe to call in a post-fork child of a multi-threaded process.
-//! Currently only used by mpgen at build time.
-void ExecProcess(const std::vector<std::string>& args);
-
-//! Wait for a process to exit and return its exit code.
-int WaitProcess(int pid);
-
-inline char* CharCast(char* c) { return c; }
-inline char* CharCast(unsigned char* c) { return (char*)c; }
-inline const char* CharCast(const char* c) { return c; }
-inline const char* CharCast(const unsigned char* c) { return (const char*)c; }
-
-//! Exception thrown from code executing an IPC call that is interrupted.
-struct InterruptException final : std::exception {
-    explicit InterruptException(std::string message) : m_message(std::move(message)) {}
-    const char* what() const noexcept override { return m_message.c_str(); }
-    std::string m_message;
-};
-
-class CancelProbe;
-
-//! Helper class that detects when a promise is canceled. Used to detect
-//! canceled requests and prevent potential crashes on unclean disconnects.
-//!
-//! In the future, this could also be used to support a way for wrapped C++
-//! methods to detect cancellation (like approach #4 in
-//! https://github.com/bitcoin/bitcoin/issues/33575).
-class CancelMonitor
-{
-public:
-    inline ~CancelMonitor();
-    inline void promiseDestroyed(CancelProbe& probe);
-
-    bool m_canceled{false};
-    std::function<void()> m_on_cancel;
-    CancelProbe* m_probe{nullptr};
-};
-
-//! Helper object to attach to a promise and update a CancelMonitor.
-class CancelProbe
-{
-public:
-    CancelProbe(CancelMonitor& monitor) : m_monitor(&monitor)
-    {
-        assert(!monitor.m_probe);
-        monitor.m_probe = this;
-    }
-    ~CancelProbe()
-    {
-        if (m_monitor) m_monitor->promiseDestroyed(*this);
-    }
-    CancelMonitor* m_monitor;
-};
-
-CancelMonitor::~CancelMonitor()
-{
-    if (m_probe) {
-        assert(m_probe->m_monitor == this);
-        m_probe->m_monitor = nullptr;
-        m_probe = nullptr;
-    }
-}
-
-void CancelMonitor::promiseDestroyed(CancelProbe& probe)
-{
-    // If promise is being destroyed, assume the promise has been canceled. In
-    // theory this method could be called when a promise was fulfilled or
-    // rejected rather than canceled, but it's safe to assume that's not the
-    // case because the CancelMonitor class is meant to be used inside code
-    // fulfilling or rejecting the promise and destroyed before doing so.
-    assert(m_probe == &probe);
-    m_canceled = true;
-    if (m_on_cancel) m_on_cancel();
-    m_probe = nullptr;
-}
-} // namespace mp
-
-#endif // MP_UTIL_H
diff --git a/src/ipc/libmultiprocess/include/mp/version.h b/src/ipc/libmultiprocess/include/mp/version.h
deleted file mode 100644
index 964667a98fb6..000000000000
--- a/src/ipc/libmultiprocess/include/mp/version.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// 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 MP_VERSION_H
-#define MP_VERSION_H
-
-//! @file
-//! @brief Major and minor version numbers
-//!
-//! Versioning uses a cruder form of SemVer where the major number is
-//! incremented with all significant changes, regardless of whether they are
-//! backward compatible, and the minor number is treated like a patch level and
-//! only incremented when a fix or backport is applied to an old branch.
-
-//! Major version number. Should be incremented after any release or external
-//! usage of the library (like a subtree update) so the previous number
-//! identifies that release. Should also be incremented before any change that
-//! breaks backward compatibility or introduces nontrivial features, so
-//! downstream code can use it to detect compatibility.
-//!
-//! Each time this is incremented, a new stable branch should be created. E.g.
-//! when this is incremented to 8, a "v7" stable branch should be created
-//! pointing at the prior merge commit. The /doc/versions.md file should also be
-//! updated, noting any significant or incompatible changes made since the
-//! previous version.
-#define MP_MAJOR_VERSION 10
-
-//! Minor version number. Should be incremented in stable branches after
-//! backporting changes. The /doc/versions.md file should also be updated to
-//! list the new minor version.
-#define MP_MINOR_VERSION 0
-
-#endif // MP_VERSION_H
diff --git a/src/ipc/libmultiprocess/include/mpgen.mk b/src/ipc/libmultiprocess/include/mpgen.mk
deleted file mode 100644
index 2af7e9985a2b..000000000000
--- a/src/ipc/libmultiprocess/include/mpgen.mk
+++ /dev/null
@@ -1,4 +0,0 @@
-%.capnp:
-	@:
-%.capnp.c++ %.capnp.h %.capnp.proxy-client.c++ %.capnp.proxy-types.h %.capnp.proxy-server.c++ %.capnp.proxy-types.c++ %.capnp.proxy.h: %.capnp
-	$(AM_V_GEN) $(MPGEN_PREFIX)/bin/mpgen '$(srcdir)' '$(srcdir)' $<
diff --git a/src/ipc/libmultiprocess/pkgconfig/libmultiprocess.pc.in b/src/ipc/libmultiprocess/pkgconfig/libmultiprocess.pc.in
deleted file mode 100644
index 2d780f1ec4e4..000000000000
--- a/src/ipc/libmultiprocess/pkgconfig/libmultiprocess.pc.in
+++ /dev/null
@@ -1,12 +0,0 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-exec_prefix=${prefix}
-libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@
-includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
-capnp_prefix=@capnp_PREFIX@
-
-Name: libmultiprocess
-Description: Multiprocess IPC library
-Version: 0.0
-
-Libs: -L${libdir} -lmultiprocess -L${capnp_prefix}/lib -lcapnp-rpc -lcapnp -lkj-async -lkj -pthread -lpthread
-Cflags: -I${includedir} -I${capnp_prefix}/include -pthread
diff --git a/src/ipc/libmultiprocess/shell.nix b/src/ipc/libmultiprocess/shell.nix
deleted file mode 100644
index 9ebbc0a034e9..000000000000
--- a/src/ipc/libmultiprocess/shell.nix
+++ /dev/null
@@ -1,84 +0,0 @@
-{ pkgs ? import <nixpkgs> {}
-, crossPkgs ? import <nixpkgs> {}
-, enableLibcxx ? false # Whether to use libc++ toolchain and libraries instead of libstdc++
-, minimal ? false # Whether to create minimal shell without extra tools (faster when cross compiling)
-, capnprotoVersion ? null
-, capnprotoSanitizers ? null # Optional sanitizers to build cap'n proto with
-, cmakeVersion ? null
-, libcxxSanitizers ? null # Optional LLVM_USE_SANITIZER value to use for libc++, see https://llvm.org/docs/CMake.html
-}:
-
-let
-  lib  = pkgs.lib;
-  llvmBase = crossPkgs.llvmPackages_21;
-  llvm = llvmBase // lib.optionalAttrs (libcxxSanitizers != null) {
-    libcxx = llvmBase.libcxx.override {
-      devExtraCmakeFlags = [ "-DLLVM_USE_SANITIZER=${libcxxSanitizers}" ];
-    };
-  };
-  capnprotoHashes = {
-    "0.7.0" = "sha256-Y/7dUOQPDHjniuKNRw3j8dG1NI9f/aRWpf8V0WzV9k8=";
-    "0.7.1" = "sha256-3cBpVmpvCXyqPUXDp12vCFCk32ZXWpkdOliNH37UwWE=";
-    "0.8.0" = "sha256-rfiqN83begjJ9eYjtr21/tk1GJBjmeVfa3C3dZBJ93w=";
-    "0.8.1" = "sha256-OZqNVYdyszro5rIe+w6YN00g6y8U/1b8dKYc214q/2o=";
-    "0.9.0" = "sha256-yhbDcWUe6jp5PbIXzn5EoKabXiWN8lnS08hyfxUgEQ0=";
-    "0.9.2" = "sha256-BspWOPZcP5nCTvmsDE62Zutox+aY5pw42d6hpH3v4cM=";
-    "0.10.0" = "sha256-++F4l54OMTDnJ+FO3kV/Y/VLobKVRk461dopanuU3IQ=";
-    "0.10.4" = "sha256-45sxnVyyYIw9i3sbFZ1naBMoUzkpP21WarzR5crg4X8=";
-    "1.0.0" = "sha256-NLTFJdeOzqhk4ATvkc17Sh6g/junzqYBBEoXYGH/czo=";
-    "1.0.2" = "sha256-LVdkqVBTeh8JZ1McdVNtRcnFVwEJRNjt0JV2l7RkuO8=";
-    "1.1.0" = "sha256-gxkko7LFyJNlxpTS+CWOd/p9x/778/kNIXfpDGiKM2A=";
-    "1.2.0" = "sha256-aDcn4bLZGq8915/NPPQsN5Jv8FRWd8cAspkG3078psc=";
-  };
-  capnprotoBase = if capnprotoVersion == null then crossPkgs.capnproto else crossPkgs.capnproto.overrideAttrs (old: {
-    version = capnprotoVersion;
-    src = crossPkgs.fetchFromGitHub {
-      owner = "capnproto";
-      repo  = "capnproto";
-      rev   = "v${capnprotoVersion}";
-      hash  = lib.attrByPath [capnprotoVersion] "" capnprotoHashes;
-    };
-    patches = lib.optionals (lib.versionAtLeast capnprotoVersion "0.9.0" && lib.versionOlder capnprotoVersion "0.10.4") [ ./ci/patches/spaceship.patch ];
-  } // (lib.optionalAttrs (lib.versionOlder capnprotoVersion "0.10") {
-    env = { }; # Drop -std=c++20 flag forced by nixpkgs
-  }));
-  capnproto = (capnprotoBase.overrideAttrs (old: lib.optionalAttrs (capnprotoSanitizers != null) {
-    env = (old.env or { }) // {
-      CXXFLAGS =
-        lib.concatStringsSep " " [
-          (old.env.CXXFLAGS or "")
-          "-fsanitize=${capnprotoSanitizers}"
-          "-fno-omit-frame-pointer"
-          "-g"
-        ];
-    };
-  })).override (lib.optionalAttrs enableLibcxx { clangStdenv = llvm.libcxxStdenv; });
-  clang = if enableLibcxx then llvm.libcxxClang else llvm.clang;
-  clang-tools = llvm.clang-tools.override { inherit enableLibcxx; };
-  cmakeHashes = {
-    "3.12.4" = "sha256-UlVYS/0EPrcXViz/iULUcvHA5GecSUHYS6raqbKOMZQ=";
-  };
-  cmakeBuild = if cmakeVersion == null then pkgs.cmake else (pkgs.cmake.overrideAttrs (old: {
-    version = cmakeVersion;
-    src = pkgs.fetchurl {
-      url = "https://cmake.org/files/v${lib.versions.majorMinor cmakeVersion}/cmake-${cmakeVersion}.tar.gz";
-      hash = lib.attrByPath [cmakeVersion] "" cmakeHashes;
-    };
-    patches = [];
-  })).override { isMinimalBuild = true; };
-in crossPkgs.mkShell {
-  buildInputs = [
-    capnproto
-  ];
-  nativeBuildInputs = with pkgs; [
-    cmakeBuild
-    include-what-you-use
-    ninja
-  ] ++ lib.optionals (!minimal) [
-    clang
-    clang-tools
-  ];
-
-  # Tell IWYU where its libc++ mapping lives
-  IWYU_MAPPING_FILE = if enableLibcxx then "${llvm.libcxx.dev}/include/c++/v1/libcxx.imp" else null;
-}
diff --git a/src/ipc/libmultiprocess/src/mp/gen.cpp b/src/ipc/libmultiprocess/src/mp/gen.cpp
deleted file mode 100644
index 603f9ccb7206..000000000000
--- a/src/ipc/libmultiprocess/src/mp/gen.cpp
+++ /dev/null
@@ -1,711 +0,0 @@
-// 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 <mp/config.h>
-#include <mp/util.h>
-
-#include <algorithm>
-#include <capnp/schema.h>
-#include <capnp/schema-parser.h>
-#include <cerrno>
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <fstream>
-#include <functional>
-#include <initializer_list>
-#include <iostream>
-#include <kj/array.h>
-#include <kj/common.h>
-#include <kj/filesystem.h>
-#include <kj/memory.h>
-#include <kj/string.h>
-#include <map>
-#include <set>
-#include <sstream>
-#include <stdexcept>
-#include <string>
-#include <system_error>
-#include <unistd.h>
-#include <utility>
-#include <vector>
-
-#define PROXY_BIN "mpgen"
-#define PROXY_DECL "mp/proxy.h"
-#define PROXY_TYPES "mp/proxy-types.h"
-
-constexpr uint64_t NAMESPACE_ANNOTATION_ID = 0xb9c6f99ebf805f2cull; // From c++.capnp
-constexpr uint64_t INCLUDE_ANNOTATION_ID = 0xb899f3c154fdb458ull;   // From proxy.capnp
-constexpr uint64_t INCLUDE_TYPES_ANNOTATION_ID = 0xbcec15648e8a0cf1ull; // From proxy.capnp
-constexpr uint64_t WRAP_ANNOTATION_ID = 0xe6f46079b7b1405eull;      // From proxy.capnp
-constexpr uint64_t COUNT_ANNOTATION_ID = 0xd02682b319f69b38ull;     // From proxy.capnp
-constexpr uint64_t EXCEPTION_ANNOTATION_ID = 0x996a183200992f88ull; // From proxy.capnp
-constexpr uint64_t NAME_ANNOTATION_ID = 0xb594888f63f4dbb9ull;      // From proxy.capnp
-constexpr uint64_t SKIP_ANNOTATION_ID = 0x824c08b82695d8ddull;      // From proxy.capnp
-
-template <typename Reader>
-static bool AnnotationExists(const Reader& reader, uint64_t id)
-{
-    for (const auto annotation : reader.getAnnotations()) {
-        if (annotation.getId() == id) {
-            return true;
-        }
-    }
-    return false;
-}
-
-template <typename Reader>
-static bool GetAnnotationText(const Reader& reader, uint64_t id, kj::StringPtr* result)
-{
-    for (const auto annotation : reader.getAnnotations()) {
-        if (annotation.getId() == id) {
-            *result = annotation.getValue().getText();
-            return true;
-        }
-    }
-    return false;
-}
-
-template <typename Reader>
-static bool GetAnnotationInt32(const Reader& reader, uint64_t id, int32_t* result)
-{
-    for (const auto annotation : reader.getAnnotations()) {
-        if (annotation.getId() == id) {
-            *result = annotation.getValue().getInt32();
-            return true;
-        }
-    }
-    return false;
-}
-
-static void ForEachMethod(const capnp::InterfaceSchema& interface, const std::function<void(const capnp::InterfaceSchema& interface, const capnp::InterfaceSchema::Method)>& callback) // NOLINT(misc-no-recursion)
-{
-    for (const auto super : interface.getSuperclasses()) {
-        ForEachMethod(super, callback);
-    }
-    for (const auto method : interface.getMethods()) {
-        callback(interface, method);
-    }
-}
-
-using CharSlice = kj::ArrayPtr<const char>;
-
-// Overload for any type with a string .begin(), like kj::StringPtr and kj::ArrayPtr<char>.
-template <class OutputStream, class Array, const char* Enable = decltype(std::declval<Array>().begin())()>
-static OutputStream& operator<<(OutputStream& os, const Array& array)
-{
-    os.write(array.begin(), array.size());
-    return os;
-}
-
-struct Format
-{
-    template <typename Value>
-    Format& operator<<(Value&& value)
-    {
-        m_os << value;
-        return *this;
-    }
-    operator std::string() const { return m_os.str(); }
-    std::ostringstream m_os;
-};
-
-static std::string Cap(kj::StringPtr str)
-{
-    std::string result = str;
-    if (!result.empty() && 'a' <= result[0] && result[0] <= 'z') result[0] -= 'a' - 'A';
-    return result;
-}
-
-static bool BoxedType(const ::capnp::Type& type)
-{
-    return !(type.isVoid() || type.isBool() || type.isInt8() || type.isInt16() || type.isInt32() || type.isInt64() ||
-             type.isUInt8() || type.isUInt16() || type.isUInt32() || type.isUInt64() || type.isFloat32() ||
-             type.isFloat64() || type.isEnum());
-}
-
-// src_file is path to .capnp file to generate stub code from.
-//
-// src_prefix can be used to generate outputs in a different directory than the
-// source directory. For example if src_file is "/a/b/c/d/file.canp", and
-// src_prefix is "/a/b", then output files will be "c/d/file.capnp.h"
-// "c/d/file.capnp.cxx" "c/d/file.capnp.proxy.h", etc. This is equivalent to
-// the capnp "--src-prefix" option (see "capnp help compile").
-//
-// include_prefix can be used to control relative include paths used in
-// generated files. For example if src_file is "/a/b/c/d/file.canp" and
-// include_prefix is "/a/b/c" include lines like
-// "#include <d/file.capnp.proxy.h>", "#include <d/file.capnp.proxy-types.h>"
-// will be generated.
-static void Generate(kj::StringPtr src_prefix,
-    kj::StringPtr include_prefix,
-    kj::StringPtr src_file,
-    const std::vector<kj::StringPtr>& import_paths,
-    const kj::ReadableDirectory& src_dir,
-    const std::vector<kj::Own<const kj::ReadableDirectory>>& import_dirs)
-{
-    std::string output_path;
-    if (src_prefix == kj::StringPtr{"."}) {
-        output_path = src_file;
-    } else if (!src_file.startsWith(src_prefix) || src_file.size() <= src_prefix.size() ||
-               src_file[src_prefix.size()] != '/') {
-        throw std::runtime_error("src_prefix is not src_file prefix");
-    } else {
-        output_path = src_file.slice(src_prefix.size() + 1);
-    }
-
-    std::string include_path;
-    if (include_prefix == kj::StringPtr{"."}) {
-        include_path = src_file;
-    } else if (!src_file.startsWith(include_prefix) || src_file.size() <= include_prefix.size() ||
-               src_file[include_prefix.size()] != '/') {
-        throw std::runtime_error("include_prefix is not src_file prefix");
-    } else {
-        include_path = src_file.slice(include_prefix.size() + 1);
-    }
-
-    std::string include_base = include_path;
-    const std::string::size_type p = include_base.rfind('.');
-    if (p != std::string::npos) include_base.erase(p);
-
-    std::vector<std::string> args;
-    args.emplace_back(capnp_PREFIX "/bin/capnp");
-    args.emplace_back("compile");
-    args.emplace_back("--src-prefix=");
-    args.back().append(src_prefix.cStr(), src_prefix.size());
-    for (const auto& import_path : import_paths) {
-        args.emplace_back("--import-path=");
-        args.back().append(import_path.cStr(), import_path.size());
-    }
-    args.emplace_back("--output=" capnp_PREFIX "/bin/capnpc-c++");
-    args.emplace_back(src_file);
-    const int pid = fork();
-    if (pid == -1) {
-        throw std::system_error(errno, std::system_category(), "fork");
-    }
-    if (!pid) {
-        mp::ExecProcess(args);
-    }
-    const int status = mp::WaitProcess(pid);
-    if (status) {
-        throw std::runtime_error("Invoking " capnp_PREFIX "/bin/capnp failed");
-    }
-
-    const capnp::SchemaParser parser;
-    auto directory_pointers = kj::heapArray<const kj::ReadableDirectory*>(import_dirs.size());
-    for (size_t i = 0; i < import_dirs.size(); ++i) {
-        directory_pointers[i] = import_dirs[i].get();
-    }
-    auto file_schema = parser.parseFromDirectory(src_dir, kj::Path::parse(output_path), directory_pointers);
-
-    std::ofstream cpp_server(output_path + ".proxy-server.c++");
-    cpp_server << "// Generated by " PROXY_BIN " from " << src_file << "\n\n";
-    cpp_server << "// IWYU pragma: no_include <kj/memory.h>\n";
-    cpp_server << "// IWYU pragma: no_include <memory>\n";
-    cpp_server << "// IWYU pragma: begin_keep\n";
-    cpp_server << "#include <" << include_path << ".proxy.h>\n";
-    cpp_server << "#include <" << include_path << ".proxy-types.h>\n";
-    cpp_server << "#include <capnp/generated-header-support.h>\n";
-    cpp_server << "#include <cstring>\n";
-    cpp_server << "#include <kj/async.h>\n";
-    cpp_server << "#include <kj/common.h>\n";
-    cpp_server << "#include <kj/exception.h>\n";
-    cpp_server << "#include <kj/tuple.h>\n";
-    cpp_server << "#include <mp/proxy.h>\n";
-    cpp_server << "#include <mp/util.h>\n";
-    cpp_server << "#include <" << PROXY_TYPES << ">\n";
-    cpp_server << "// IWYU pragma: end_keep\n\n";
-    cpp_server << "namespace mp {\n";
-
-    std::ofstream cpp_client(output_path + ".proxy-client.c++");
-    cpp_client << "// Generated by " PROXY_BIN " from " << src_file << "\n\n";
-    cpp_client << "// IWYU pragma: no_include <kj/memory.h>\n";
-    cpp_client << "// IWYU pragma: no_include <memory>\n";
-    cpp_client << "// IWYU pragma: begin_keep\n";
-    cpp_client << "#include <" << include_path << ".h>\n";
-    cpp_client << "#include <" << include_path << ".proxy.h>\n";
-    cpp_client << "#include <" << include_path << ".proxy-types.h>\n";
-    cpp_client << "#include <capnp/generated-header-support.h>\n";
-    cpp_client << "#include <cstring>\n";
-    cpp_client << "#include <vector>\n";
-    cpp_client << "#include <kj/common.h>\n";
-    cpp_client << "#include <mp/proxy.h>\n";
-    cpp_client << "#include <mp/util.h>\n";
-    cpp_client << "#include <" << PROXY_TYPES << ">\n";
-    cpp_client << "// IWYU pragma: end_keep\n\n";
-    cpp_client << "namespace mp {\n";
-
-    std::ofstream cpp_types(output_path + ".proxy-types.c++");
-    cpp_types << "// Generated by " PROXY_BIN " from " << src_file << "\n\n";
-    cpp_types << "// IWYU pragma: no_include \"mp/proxy.h\"\n";
-    cpp_types << "// IWYU pragma: no_include \"mp/proxy-io.h\"\n";
-    cpp_types << "#include <" << include_path << ".proxy.h>\n";
-    cpp_types << "#include <" << include_path << ".proxy-types.h> // IWYU pragma: keep\n";
-    cpp_types << "#include <" << PROXY_TYPES << ">\n\n";
-    cpp_types << "namespace mp {\n";
-
-    std::string guard = output_path;
-    std::ranges::transform(guard, guard.begin(), [](unsigned char c) -> unsigned char {
-        if ('0' <= c && c <= '9') return c;
-        if ('A' <= c && c <= 'Z') return c;
-        if ('a' <= c && c <= 'z') return c - 'a' + 'A';
-        return '_';
-    });
-
-    std::ofstream inl(output_path + ".proxy-types.h");
-    inl << "// Generated by " PROXY_BIN " from " << src_file << "\n\n";
-    inl << "#ifndef " << guard << "_PROXY_TYPES_H\n";
-    inl << "#define " << guard << "_PROXY_TYPES_H\n\n";
-    inl << "// IWYU pragma: no_include \"mp/proxy.h\"\n";
-    inl << "#include <mp/proxy.h> // IWYU pragma: keep\n";
-    inl << "#include <" << include_path << ".proxy.h> // IWYU pragma: keep\n";
-    for (const auto annotation : file_schema.getProto().getAnnotations()) {
-        if (annotation.getId() == INCLUDE_TYPES_ANNOTATION_ID) {
-            inl << "#include \"" << annotation.getValue().getText() << "\" // IWYU pragma: export\n";
-        }
-    }
-    inl << "namespace mp {\n";
-
-    std::ofstream h(output_path + ".proxy.h");
-    h << "// Generated by " PROXY_BIN " from " << src_file << "\n\n";
-    h << "#ifndef " << guard << "_PROXY_H\n";
-    h << "#define " << guard << "_PROXY_H\n\n";
-    h << "#include <" << include_path << ".h> // IWYU pragma: keep\n";
-    for (const auto annotation : file_schema.getProto().getAnnotations()) {
-        if (annotation.getId() == INCLUDE_ANNOTATION_ID) {
-            h << "#include \"" << annotation.getValue().getText() << "\" // IWYU pragma: export\n";
-        }
-    }
-    h << "#include <" << PROXY_DECL << ">\n\n";
-    h << "#if defined(__GNUC__)\n";
-    h << "#pragma GCC diagnostic push\n";
-    h << "#if !defined(__has_warning)\n";
-    h << "#pragma GCC diagnostic ignored \"-Wsuggest-override\"\n";
-    h << "#elif __has_warning(\"-Wsuggest-override\")\n";
-    h << "#pragma GCC diagnostic ignored \"-Wsuggest-override\"\n";
-    h << "#endif\n";
-    h << "#endif\n";
-    h << "namespace mp {\n";
-
-    kj::StringPtr message_namespace;
-    GetAnnotationText(file_schema.getProto(), NAMESPACE_ANNOTATION_ID, &message_namespace);
-
-    std::string base_name = include_base;
-    const size_t output_slash = base_name.rfind('/');
-    if (output_slash != std::string::npos) {
-        base_name.erase(0, output_slash + 1);
-    }
-
-    std::ostringstream methods;
-    std::set<kj::StringPtr> accessors_done;
-    std::ostringstream accessors;
-    std::ostringstream dec;
-    std::ostringstream def_server;
-    std::ostringstream def_client;
-    std::ostringstream int_client;
-    std::ostringstream def_types;
-
-    auto add_accessor = [&](kj::StringPtr name) {
-        if (!accessors_done.insert(name).second) return;
-        const std::string cap = Cap(name);
-        accessors << "struct " << cap << "\n";
-        accessors << "{\n";
-        accessors << "    template<typename S> static auto get(S&& s) -> decltype(s.get" << cap << "()) { return s.get" << cap << "(); }\n";
-        accessors << "    template<typename S> static bool has(S&& s) { return s.has" << cap << "(); }\n";
-        accessors << "    template<typename S, typename A> static void set(S&& s, A&& a) { s.set" << cap
-                  << "(std::forward<A>(a)); }\n";
-        accessors << "    template<typename S, typename... A> static decltype(auto) init(S&& s, A&&... a) { return s.init"
-                  << cap << "(std::forward<A>(a)...); }\n";
-        accessors << "    template<typename S> static bool getWant(S&& s) { return s.getWant" << cap << "(); }\n";
-        accessors << "    template<typename S> static void setWant(S&& s) { s.setWant" << cap << "(true); }\n";
-        accessors << "    template<typename S> static bool getHas(S&& s) { return s.getHas" << cap << "(); }\n";
-        accessors << "    template<typename S> static void setHas(S&& s) { s.setHas" << cap << "(true); }\n";
-        accessors << "};\n";
-    };
-
-    for (const auto node_nested : file_schema.getProto().getNestedNodes()) {
-        kj::StringPtr node_name = node_nested.getName();
-        const auto& node = file_schema.getNested(node_name);
-        kj::StringPtr proxied_class_type;
-        GetAnnotationText(node.getProto(), WRAP_ANNOTATION_ID, &proxied_class_type);
-
-        if (node.getProto().isStruct()) {
-            const auto& struc = node.asStruct();
-            std::ostringstream generic_name;
-            generic_name << node_name;
-            dec << "template<";
-            bool first_param = true;
-            for (const auto param : node.getProto().getParameters()) {
-                if (first_param) {
-                    first_param = false;
-                    generic_name << "<";
-                } else {
-                    dec << ", ";
-                    generic_name << ", ";
-                }
-                dec << "typename " << param.getName();
-                generic_name << "" << param.getName();
-            }
-            if (!first_param) generic_name << ">";
-            dec << ">\n";
-            dec << "struct ProxyStruct<" << message_namespace << "::" << generic_name.str() << ">\n";
-            dec << "{\n";
-            dec << "    using Struct = " << message_namespace << "::" << generic_name.str() << ";\n";
-            for (const auto field : struc.getFields()) {
-                auto field_name = field.getProto().getName();
-                add_accessor(field_name);
-                dec << "    using " << Cap(field_name) << "Accessor = Accessor<" << base_name
-                    << "_fields::" << Cap(field_name) << ", FIELD_IN | FIELD_OUT";
-                if (BoxedType(field.getType())) dec << " | FIELD_BOXED";
-                dec << ">;\n";
-            }
-            dec << "    using Accessors = std::tuple<";
-            size_t i = 0;
-            for (const auto field : struc.getFields()) {
-                if (AnnotationExists(field.getProto(), SKIP_ANNOTATION_ID)) {
-                    continue;
-                }
-                if (i) dec << ", ";
-                dec << Cap(field.getProto().getName()) << "Accessor";
-                ++i;
-            }
-            dec << ">;\n";
-            dec << "    static constexpr size_t fields = " << i << ";\n";
-            dec << "};\n";
-
-            if (proxied_class_type.size()) {
-                inl << "template<>\n";
-                inl << "struct ProxyType<" << proxied_class_type << ">\n";
-                inl << "{\n";
-                inl << "public:\n";
-                inl << "    using Struct = " << message_namespace << "::" << node_name << ";\n";
-                size_t i = 0;
-                for (const auto field : struc.getFields()) {
-                    if (AnnotationExists(field.getProto(), SKIP_ANNOTATION_ID)) {
-                        continue;
-                    }
-                    auto field_name = field.getProto().getName();
-                    auto member_name = field_name;
-                    GetAnnotationText(field.getProto(), NAME_ANNOTATION_ID, &member_name);
-                    inl << "    static decltype(auto) get(std::integral_constant<size_t, " << i << ">) { return "
-                        << "&" << proxied_class_type << "::" << member_name << "; }\n";
-                    ++i;
-                }
-                inl << "    static constexpr size_t fields = " << i << ";\n";
-                inl << "};\n";
-            }
-        }
-
-        if (proxied_class_type.size() && node.getProto().isInterface()) {
-            const auto& interface = node.asInterface();
-
-            std::ostringstream client;
-            client << "template<>\nstruct ProxyClient<" << message_namespace << "::" << node_name << "> final : ";
-            client << "public ProxyClientCustom<" << message_namespace << "::" << node_name << ", "
-                   << proxied_class_type << ">\n{\n";
-            client << "public:\n";
-            client << "    using ProxyClientCustom::ProxyClientCustom;\n";
-            client << "    ~ProxyClient();\n";
-
-            std::ostringstream server;
-            server << "template<>\nstruct ProxyServer<" << message_namespace << "::" << node_name << "> : public "
-                   << "ProxyServerCustom<" << message_namespace << "::" << node_name << ", " << proxied_class_type
-                   << ">\n{\n";
-            server << "public:\n";
-            server << "    using ProxyServerCustom::ProxyServerCustom;\n";
-            server << "    ~ProxyServer();\n";
-
-            const std::ostringstream client_construct;
-            const std::ostringstream client_destroy;
-
-            int method_ordinal = 0;
-            ForEachMethod(interface, [&] (const capnp::InterfaceSchema& method_interface, const capnp::InterfaceSchema::Method& method) {
-                const kj::StringPtr method_name = method.getProto().getName();
-                kj::StringPtr proxied_method_name = method_name;
-                GetAnnotationText(method.getProto(), NAME_ANNOTATION_ID, &proxied_method_name);
-
-                const std::string method_prefix = Format() << message_namespace << "::" << method_interface.getShortDisplayName()
-                                                           << "::" << Cap(method_name);
-                const bool is_construct = method_name == kj::StringPtr{"construct"};
-                const bool is_destroy = method_name == kj::StringPtr{"destroy"};
-
-                struct Field
-                {
-                    ::capnp::StructSchema::Field param;
-                    bool param_is_set = false;
-                    ::capnp::StructSchema::Field result;
-                    bool result_is_set = false;
-                    int args = 0;
-                    bool retval = false;
-                    bool optional = false;
-                    bool requested = false;
-                    bool skip = false;
-                    kj::StringPtr exception;
-                };
-
-                std::vector<Field> fields;
-                std::map<kj::StringPtr, int> field_idx; // name -> args index
-                bool has_result = false;
-
-                auto add_field = [&](const ::capnp::StructSchema::Field& schema_field, bool param) {
-                    if (AnnotationExists(schema_field.getProto(), SKIP_ANNOTATION_ID)) {
-                        return;
-                    }
-
-                    auto field_name = schema_field.getProto().getName();
-                    auto inserted = field_idx.emplace(field_name, fields.size());
-                    if (inserted.second) {
-                        fields.emplace_back();
-                    }
-                    auto& field = fields[inserted.first->second];
-                    if (param) {
-                        field.param = schema_field;
-                        field.param_is_set = true;
-                    } else {
-                        field.result = schema_field;
-                        field.result_is_set = true;
-                    }
-
-                    if (!param && field_name == kj::StringPtr{"result"}) {
-                        field.retval = true;
-                        has_result = true;
-                    }
-
-                    GetAnnotationText(schema_field.getProto(), EXCEPTION_ANNOTATION_ID, &field.exception);
-
-                    int32_t count = 1;
-                    if (!GetAnnotationInt32(schema_field.getProto(), COUNT_ANNOTATION_ID, &count)) {
-                        if (schema_field.getType().isStruct()) {
-                            GetAnnotationInt32(schema_field.getType().asStruct().getProto(),
-                                    COUNT_ANNOTATION_ID, &count);
-                        } else if (schema_field.getType().isInterface()) {
-                            GetAnnotationInt32(schema_field.getType().asInterface().getProto(),
-                                    COUNT_ANNOTATION_ID, &count);
-                        }
-                    }
-
-
-                    if (inserted.second && !field.retval && !field.exception.size()) {
-                        field.args = count;
-                    }
-                };
-
-                for (const auto schema_field : method.getParamType().getFields()) {
-                    add_field(schema_field, true);
-                }
-                for (const auto schema_field : method.getResultType().getFields()) {
-                    add_field(schema_field, false);
-                }
-                for (auto& field : field_idx) {
-                    auto has_field = field_idx.find("has" + Cap(field.first));
-                    if (has_field != field_idx.end()) {
-                        fields[has_field->second].skip = true;
-                        fields[field.second].optional = true;
-                    }
-                    auto want_field = field_idx.find("want" + Cap(field.first));
-                    if (want_field != field_idx.end() && fields[want_field->second].param_is_set) {
-                        fields[want_field->second].skip = true;
-                        fields[field.second].requested = true;
-                    }
-                }
-
-                if (!is_construct && !is_destroy && (&method_interface == &interface)) {
-                    methods << "template<>\n";
-                    methods << "struct ProxyMethod<" << method_prefix << "Params>\n";
-                    methods << "{\n";
-                    methods << "    static constexpr auto impl = &" << proxied_class_type
-                            << "::" << proxied_method_name << ";\n";
-                    methods << "};\n\n";
-                }
-
-                std::ostringstream client_args;
-                std::ostringstream client_invoke;
-                std::ostringstream server_invoke_start;
-                std::ostringstream server_invoke_end;
-                int argc = 0;
-                for (const auto& field : fields) {
-                    if (field.skip) continue;
-
-                    const auto& f = field.param_is_set ? field.param : field.result;
-                    auto field_name = f.getProto().getName();
-                    auto field_type = f.getType();
-
-                    std::ostringstream field_flags;
-                    if (!field.param_is_set) {
-                        field_flags << "FIELD_OUT";
-                    } else if (field.result_is_set) {
-                        field_flags << "FIELD_IN | FIELD_OUT";
-                    } else {
-                        field_flags << "FIELD_IN";
-                    }
-                    if (field.optional) field_flags << " | FIELD_OPTIONAL";
-                    if (field.requested) field_flags << " | FIELD_REQUESTED";
-                    if (BoxedType(field_type)) field_flags << " | FIELD_BOXED";
-
-                    add_accessor(field_name);
-
-                    std::ostringstream fwd_args;
-                    for (int i = 0; i < field.args; ++i) {
-                        if (argc > 0) client_args << ",";
-
-                        // Add to client method parameter list.
-                        client_args << "M" << method_ordinal << "::Param<" << argc << "> " << field_name;
-                        if (field.args > 1) client_args << i;
-
-                        // Add to MakeClientParam argument list using Fwd helper for perfect forwarding.
-                        if (i > 0) fwd_args << ", ";
-                        fwd_args << "M" << method_ordinal << "::Fwd<" << argc << ">(" << field_name;
-                        if (field.args > 1) fwd_args << i;
-                        fwd_args << ")";
-
-                        ++argc;
-                    }
-                    client_invoke << ", ";
-
-                    if (field.exception.size()) {
-                        client_invoke << "ClientException<" << field.exception << ", ";
-                    } else {
-                        client_invoke << "MakeClientParam<";
-                    }
-
-                    client_invoke << "Accessor<" << base_name << "_fields::" << Cap(field_name) << ", "
-                                  << field_flags.str() << ">>(";
-
-                    if (field.retval) {
-                        client_invoke << field_name;
-                    } else {
-                        client_invoke << fwd_args.str();
-                    }
-                    client_invoke << ")";
-
-                    if (field.exception.size()) {
-                        server_invoke_start << "Make<ServerExcept, " << field.exception;
-                    } else if (field.retval) {
-                        server_invoke_start << "Make<ServerRet";
-                    } else {
-                        server_invoke_start << "MakeServerField<" << field.args;
-                    }
-                    server_invoke_start << ", Accessor<" << base_name << "_fields::" << Cap(field_name) << ", "
-                                        << field_flags.str() << ">>(";
-                    server_invoke_end << ")";
-                }
-
-                const std::string static_str{is_construct || is_destroy ? "static " : ""};
-                const std::string super_str{is_construct || is_destroy ? "Super& super" : ""};
-                const std::string self_str{is_construct || is_destroy ? "super" : "*this"};
-
-                client << "    using M" << method_ordinal << " = ProxyClientMethodTraits<" << method_prefix
-                       << "Params>;\n";
-                client << "    " << static_str << "typename M" << method_ordinal << "::Result " << method_name << "("
-                       << super_str << client_args.str() << ")";
-                client << ";\n";
-                def_client << "ProxyClient<" << message_namespace << "::" << node_name << ">::M" << method_ordinal
-                           << "::Result ProxyClient<" << message_namespace << "::" << node_name << ">::" << method_name
-                           << "(" << super_str << client_args.str() << ") {\n";
-                if (has_result) {
-                    def_client << "    typename M" << method_ordinal << "::Result result;\n";
-                }
-                def_client << "    clientInvoke(" << self_str << ", &" << message_namespace << "::" << node_name
-                           << "::Client::" << method_name << "Request" << client_invoke.str() << ");\n";
-                if (has_result) def_client << "    return result;\n";
-                def_client << "}\n";
-
-                server << "    kj::Promise<void> " << method_name << "(" << Cap(method_name)
-                       << "Context call_context) override;\n";
-
-                def_server << "kj::Promise<void> ProxyServer<" << message_namespace << "::" << node_name
-                           << ">::" << method_name << "(" << Cap(method_name)
-                           << "Context call_context) {\n"
-                              "    return serverInvoke(*this, call_context, "
-                           << server_invoke_start.str();
-                if (is_destroy) {
-                    def_server << "ServerDestroy()";
-                } else {
-                    def_server << "ServerCall()";
-                }
-                def_server << server_invoke_end.str() << ");\n}\n";
-                ++method_ordinal;
-            });
-
-            client << "};\n";
-            server << "};\n";
-            dec << "\n" << client.str() << "\n" << server.str() << "\n";
-            KJ_IF_MAYBE(bracket, proxied_class_type.findFirst('<')) {
-              // Skip ProxyType definition for complex type expressions which
-              // could lead to duplicate definitions. They can be defined
-              // manually if actually needed.
-            } else {
-              dec << "template<>\nstruct ProxyType<" << proxied_class_type << ">\n{\n";
-              dec << "    using Type = " << proxied_class_type << ";\n";
-              dec << "    using Message = " << message_namespace << "::" << node_name << ";\n";
-              dec << "    using Client = ProxyClient<Message>;\n";
-              dec << "    using Server = ProxyServer<Message>;\n";
-              dec << "};\n";
-              int_client << "ProxyTypeRegister t" << node_nested.getId() << "{TypeList<" << proxied_class_type << ">{}};\n";
-            }
-            def_types << "ProxyClient<" << message_namespace << "::" << node_name
-                      << ">::~ProxyClient() { clientDestroy(*this); " << client_destroy.str() << " }\n";
-            def_types << "ProxyServer<" << message_namespace << "::" << node_name
-                      << ">::~ProxyServer() { serverDestroy(*this); }\n";
-        }
-    }
-
-    h << methods.str() << "namespace " << base_name << "_fields {\n"
-      << accessors.str() << "} // namespace " << base_name << "_fields\n"
-      << dec.str();
-
-    cpp_server << def_server.str();
-    cpp_server << "} // namespace mp\n";
-
-    cpp_client << def_client.str();
-    cpp_client << "namespace {\n" << int_client.str() << "} // namespace\n";
-    cpp_client << "} // namespace mp\n";
-
-    cpp_types << def_types.str();
-    cpp_types << "} // namespace mp\n";
-
-    inl << "} // namespace mp\n";
-    inl << "#endif\n";
-
-    h << "} // namespace mp\n";
-    h << "#if defined(__GNUC__)\n";
-    h << "#pragma GCC diagnostic pop\n";
-    h << "#endif\n";
-    h << "#endif\n";
-}
-
-int main(int argc, char** argv)
-{
-    if (argc < 3) {
-        std::cerr << "Usage: " << PROXY_BIN << " SRC_PREFIX INCLUDE_PREFIX SRC_FILE [IMPORT_PATH...]\n";
-        exit(1);
-    }
-    std::vector<kj::StringPtr> import_paths;
-    std::vector<kj::Own<const kj::ReadableDirectory>> import_dirs;
-    auto fs = kj::newDiskFilesystem();
-    auto cwd = fs->getCurrentPath();
-    kj::Own<const kj::ReadableDirectory> src_dir;
-    KJ_IF_MAYBE(dir, fs->getRoot().tryOpenSubdir(cwd.evalNative(argv[1]))) {
-        src_dir = kj::mv(*dir);
-    } else {
-        throw std::runtime_error(std::string("Failed to open src_prefix prefix directory: ") + argv[1]);
-    }
-    for (int i = 4; i < argc; ++i) {
-        KJ_IF_MAYBE(dir, fs->getRoot().tryOpenSubdir(cwd.evalNative(argv[i]))) {
-            import_paths.emplace_back(argv[i]);
-            import_dirs.emplace_back(kj::mv(*dir));
-        } else {
-            throw std::runtime_error(std::string("Failed to open import directory: ") + argv[i]);
-        }
-    }
-    for (const char* path : {CMAKE_INSTALL_PREFIX "/include", capnp_PREFIX "/include"}) {
-        KJ_IF_MAYBE(dir, fs->getRoot().tryOpenSubdir(cwd.evalNative(path))) {
-            import_paths.emplace_back(path);
-            import_dirs.emplace_back(kj::mv(*dir));
-        }
-        // No exception thrown if _PREFIX directories do not exist
-    }
-    Generate(argv[1], argv[2], argv[3], import_paths, *src_dir, import_dirs);
-    return 0;
-}
diff --git a/src/ipc/libmultiprocess/src/mp/proxy.cpp b/src/ipc/libmultiprocess/src/mp/proxy.cpp
deleted file mode 100644
index d24208dbfd89..000000000000
--- a/src/ipc/libmultiprocess/src/mp/proxy.cpp
+++ /dev/null
@@ -1,453 +0,0 @@
-// 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 <mp/proxy.h>
-
-#include <mp/proxy-io.h>
-#include <mp/proxy-types.h>
-#include <mp/proxy.capnp.h>
-#include <mp/type-threadmap.h>
-#include <mp/util.h>
-
-#include <atomic>
-#include <capnp/capability.h>
-#include <capnp/common.h> // IWYU pragma: keep
-#include <capnp/rpc.h>
-#include <condition_variable>
-#include <functional>
-#include <future>
-#include <kj/async.h>
-#include <kj/async-io.h>
-#include <kj/async-prelude.h>
-#include <kj/common.h>
-#include <kj/debug.h>
-#include <kj/function.h>
-#include <kj/memory.h>
-#include <kj/string.h>
-#include <map>
-#include <memory>
-#include <optional>
-#include <stdexcept>
-#include <string>
-#include <sys/socket.h>
-#include <thread>
-#include <tuple>
-#include <unistd.h>
-#include <utility>
-
-namespace mp {
-
-thread_local ThreadContext g_thread_context; // NOLINT(bitcoin-nontrivial-threadlocal)
-
-void LoggingErrorHandler::taskFailed(kj::Exception&& exception)
-{
-    KJ_LOG(ERROR, "Uncaught exception in daemonized task.", exception);
-    MP_LOG(m_loop, Log::Error) << "Uncaught exception in daemonized task.";
-}
-
-EventLoopRef::EventLoopRef(EventLoop& loop, Lock* lock) : m_loop(&loop), m_lock(lock)
-{
-    auto loop_lock{PtrOrValue{m_lock, m_loop->m_mutex}};
-    loop_lock->assert_locked(m_loop->m_mutex);
-    m_loop->m_num_clients += 1;
-}
-
-// Due to the conditionals in this function, MP_NO_TSA is required to avoid
-// error "error: mutex 'loop_lock' is not held on every path through here
-// [-Wthread-safety-analysis]"
-void EventLoopRef::reset(bool relock) MP_NO_TSA
-{
-    if (auto* loop{m_loop}) {
-        m_loop = nullptr;
-        auto loop_lock{PtrOrValue{m_lock, loop->m_mutex}};
-        loop_lock->assert_locked(loop->m_mutex);
-        assert(loop->m_num_clients > 0);
-        loop->m_num_clients -= 1;
-        if (loop->done()) {
-            loop->m_cv.notify_all();
-            int post_fd{loop->m_post_fd};
-            loop_lock->unlock();
-            char buffer = 0;
-            KJ_SYSCALL(write(post_fd, &buffer, 1)); // NOLINT(bugprone-suspicious-semicolon)
-            // By default, do not try to relock `loop_lock` after writing,
-            // because the event loop could wake up and destroy itself and the
-            // mutex might no longer exist.
-            if (relock) loop_lock->lock();
-        }
-    }
-}
-
-ProxyContext::ProxyContext(Connection* connection) : connection(connection), loop{*connection->m_loop} {}
-
-Connection::~Connection()
-{
-    // Connection destructor is always called on the event loop thread. If this
-    // is a local disconnect, it will trigger I/O, so this needs to run on the
-    // event loop thread, and if there was a remote disconnect, this is called
-    // by an onDisconnect callback directly from the event loop thread.
-    assert(std::this_thread::get_id() == m_loop->m_thread_id);
-
-    // Try to cancel any calls that may be executing.
-    m_canceler.cancel("Interrupted by disconnect");
-
-    // Shut down RPC system first, since this will garbage collect any
-    // ProxyServer objects that were not freed before the connection was closed.
-    // Typically all ProxyServer objects associated with this connection will be
-    // freed before this call returns. However that will not be the case if
-    // there are asynchronous IPC calls over this connection still currently
-    // executing. In that case, Cap'n Proto will destroy the ProxyServer objects
-    // after the calls finish.
-    m_rpc_system.reset();
-
-    // ProxyClient cleanup handlers are in sync list, and ProxyServer cleanup
-    // handlers are in the async list.
-    //
-    // The ProxyClient cleanup handlers are synchronous because they are fast
-    // and don't do anything besides release capnp resources and reset state so
-    // future calls to client methods immediately throw exceptions instead of
-    // trying to communicate across the socket. The synchronous callbacks set
-    // ProxyClient capability pointers to null, so new method calls on client
-    // objects fail without triggering i/o or relying on event loop which may go
-    // out of scope or trigger obscure capnp i/o errors.
-    //
-    // The ProxyServer cleanup handlers call user defined destructors on the server
-    // object, which can run arbitrary blocking bitcoin code so they have to run
-    // asynchronously in a different thread. The asynchronous cleanup functions
-    // intentionally aren't started until after the synchronous cleanup
-    // functions run, so client objects are fully disconnected before bitcoin
-    // code in the destructors are run. This way if the bitcoin code tries to
-    // make client requests the requests will just fail immediately instead of
-    // sending i/o or accessing the event loop.
-    //
-    // The context where Connection objects are destroyed and this destructor is invoked
-    // is different depending on whether this is an outgoing connection being used
-    // to make an Init.makeX call() (e.g. Init.makeNode or Init.makeWalletClient) or an incoming
-    // connection implementing the Init interface and handling the Init.makeX() calls.
-    //
-    // Either way when a connection is closed, capnp behavior is to call all
-    // ProxyServer object destructors first, and then trigger an onDisconnect
-    // callback.
-    //
-    // On incoming side of the connection, the onDisconnect callback is written
-    // to delete the Connection object from the m_incoming_connections and call
-    // this destructor which calls Connection::disconnect.
-    //
-    // On the outgoing side, the Connection object is owned by top level client
-    // object client, which onDisconnect handler doesn't have ready access to,
-    // so onDisconnect handler just calls Connection::disconnect directly
-    // instead.
-    //
-    // Either way disconnect code runs in the event loop thread and called both
-    // on clean and unclean shutdowns. In unclean shutdown case when the
-    // connection is broken, sync and async cleanup lists will be filled with
-    // callbacks. In the clean shutdown case both lists will be empty.
-    Lock lock{m_loop->m_mutex};
-    while (!m_sync_cleanup_fns.empty()) {
-        CleanupList fn;
-        fn.splice(fn.begin(), m_sync_cleanup_fns, m_sync_cleanup_fns.begin());
-        Unlock(lock, fn.front());
-    }
-}
-
-CleanupIt Connection::addSyncCleanup(std::function<void()> fn)
-{
-    const Lock lock(m_loop->m_mutex);
-    // Add cleanup callbacks to the front of list, so sync cleanup functions run
-    // in LIFO order. This is a good approach because sync cleanup functions are
-    // added as client objects are created, and it is natural to clean up
-    // objects in the reverse order they were created. In practice, however,
-    // order should not be significant because the cleanup callbacks run
-    // synchronously in a single batch when the connection is broken, and they
-    // only reset the connection pointers in the client objects without actually
-    // deleting the client objects.
-    return m_sync_cleanup_fns.emplace(m_sync_cleanup_fns.begin(), std::move(fn));
-}
-
-void Connection::removeSyncCleanup(CleanupIt it)
-{
-    // Require cleanup functions to be removed on the event loop thread to avoid
-    // needing to deal with them being removed in the middle of a disconnect.
-    assert(std::this_thread::get_id() == m_loop->m_thread_id);
-    const Lock lock(m_loop->m_mutex);
-    m_sync_cleanup_fns.erase(it);
-}
-
-void EventLoop::addAsyncCleanup(std::function<void()> fn)
-{
-    const Lock lock(m_mutex);
-    // Add async cleanup callbacks to the back of the list. Unlike the sync
-    // cleanup list, this list order is more significant because it determines
-    // the order server objects are destroyed when there is a sudden disconnect,
-    // and it is possible objects may need to be destroyed in a certain order.
-    // This function is called in ProxyServerBase destructors, and since capnp
-    // destroys ProxyServer objects in LIFO order, we should preserve this
-    // order, and add cleanup callbacks to the end of the list so they can be
-    // run starting from the beginning of the list.
-    //
-    // In bitcoin core, running these callbacks in the right order is
-    // particularly important for the wallet process, because it uses blocking
-    // shared_ptrs and requires Chain::Notification pointers owned by the node
-    // process to be destroyed before the WalletLoader objects owned by the node
-    // process, otherwise shared pointer counts of the CWallet objects (which
-    // inherit from Chain::Notification) will not be 1 when WalletLoader
-    // destructor runs and it will wait forever for them to be released.
-    m_async_fns->emplace_back(std::move(fn));
-    startAsyncThread();
-}
-
-EventLoop::EventLoop(const char* exe_name, LogOptions log_opts, void* context)
-    : m_exe_name(exe_name),
-      m_io_context(kj::setupAsyncIo()),
-      m_task_set(new kj::TaskSet(m_error_handler)),
-      m_log_opts(std::move(log_opts)),
-      m_context(context)
-{
-    int fds[2];
-    KJ_SYSCALL(socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
-    m_wait_fd = fds[0];
-    m_post_fd = fds[1];
-}
-
-EventLoop::~EventLoop()
-{
-    if (m_async_thread.joinable()) m_async_thread.join();
-    const Lock lock(m_mutex);
-    KJ_ASSERT(m_post_fn == nullptr);
-    KJ_ASSERT(!m_async_fns);
-    KJ_ASSERT(m_wait_fd == -1);
-    KJ_ASSERT(m_post_fd == -1);
-    KJ_ASSERT(m_num_clients == 0);
-
-    // Spin event loop. wait for any promises triggered by RPC shutdown.
-    // auto cleanup = kj::evalLater([]{});
-    // cleanup.wait(m_io_context.waitScope);
-}
-
-void EventLoop::loop()
-{
-    assert(!g_thread_context.loop_thread);
-    g_thread_context.loop_thread = true;
-    KJ_DEFER(g_thread_context.loop_thread = false);
-
-    {
-        const Lock lock(m_mutex);
-        assert(!m_async_fns);
-        m_async_fns.emplace();
-    }
-
-    kj::Own<kj::AsyncIoStream> wait_stream{
-        m_io_context.lowLevelProvider->wrapSocketFd(m_wait_fd, kj::LowLevelAsyncIoProvider::TAKE_OWNERSHIP)};
-    int post_fd{m_post_fd};
-    char buffer = 0;
-    for (;;) {
-        const size_t read_bytes = wait_stream->read(&buffer, 0, 1).wait(m_io_context.waitScope);
-        if (read_bytes != 1) throw std::logic_error("EventLoop wait_stream closed unexpectedly");
-        Lock lock(m_mutex);
-        if (m_post_fn) {
-            Unlock(lock, *m_post_fn);
-            m_post_fn = nullptr;
-            m_cv.notify_all();
-        } else if (done()) {
-            // Intentionally do not break if m_post_fn was set, even if done()
-            // would return true, to ensure that the EventLoopRef write(post_fd)
-            // call always succeeds and the loop does not exit between the time
-            // that the done condition is set and the write call is made.
-            break;
-        }
-    }
-    MP_LOG(*this, Log::Info) << "EventLoop::loop done, cancelling event listeners.";
-    m_task_set.reset();
-    MP_LOG(*this, Log::Info) << "EventLoop::loop bye.";
-    wait_stream = nullptr;
-    KJ_SYSCALL(::close(post_fd));
-    const Lock lock(m_mutex);
-    m_wait_fd = -1;
-    m_post_fd = -1;
-    m_async_fns.reset();
-    m_cv.notify_all();
-}
-
-void EventLoop::post(kj::Function<void()> fn)
-{
-    if (std::this_thread::get_id() == m_thread_id) {
-        fn();
-        return;
-    }
-    Lock lock(m_mutex);
-    EventLoopRef ref(*this, &lock);
-    m_cv.wait(lock.m_lock, [this]() MP_REQUIRES(m_mutex) { return m_post_fn == nullptr; });
-    m_post_fn = &fn;
-    int post_fd{m_post_fd};
-    Unlock(lock, [&] {
-        char buffer = 0;
-        KJ_SYSCALL(write(post_fd, &buffer, 1));
-    });
-    m_cv.wait(lock.m_lock, [this, &fn]() MP_REQUIRES(m_mutex) { return m_post_fn != &fn; });
-}
-
-void EventLoop::startAsyncThread()
-{
-    assert (std::this_thread::get_id() == m_thread_id);
-    if (m_async_thread.joinable()) {
-        // Notify to wake up the async thread if it is already running.
-        m_cv.notify_all();
-    } else if (!m_async_fns->empty()) {
-        m_async_thread = std::thread([this] {
-            Lock lock(m_mutex);
-            while (m_async_fns) {
-                if (!m_async_fns->empty()) {
-                    EventLoopRef ref{*this, &lock};
-                    const std::function<void()> fn = std::move(m_async_fns->front());
-                    m_async_fns->pop_front();
-                    Unlock(lock, fn);
-                    // Important to relock because of the wait() call below.
-                    ref.reset(/*relock=*/true);
-                    // Continue without waiting in case there are more async_fns
-                    continue;
-                }
-                m_cv.wait(lock.m_lock);
-            }
-        });
-    }
-}
-
-bool EventLoop::done() const
-{
-    assert(m_num_clients >= 0);
-    return m_num_clients == 0 && m_async_fns->empty();
-}
-
-std::tuple<ConnThread, bool> SetThread(GuardedRef<ConnThreads> threads, Connection* connection, const std::function<Thread::Client()>& make_thread)
-{
-    assert(std::this_thread::get_id() == connection->m_loop->m_thread_id);
-    ConnThread thread;
-    bool inserted;
-    {
-        const Lock lock(threads.mutex);
-        std::tie(thread, inserted) = threads.ref.try_emplace(connection);
-    }
-    if (inserted) {
-        thread->second.emplace(make_thread(), connection, /* destroy_connection= */ false);
-        thread->second->m_disconnect_cb = connection->addSyncCleanup([threads, thread] {
-            // Note: it is safe to use the `thread` iterator in this cleanup
-            // function, because the iterator would only be invalid if the map entry
-            // was removed, and if the map entry is removed the ProxyClient<Thread>
-            // destructor unregisters the cleanup.
-
-            // Connection is being destroyed before thread client is, so reset
-            // thread client m_disconnect_cb member so thread client destructor does not
-            // try to unregister this callback after connection is destroyed.
-            thread->second->m_disconnect_cb.reset();
-
-            // Remove connection pointer about to be destroyed from the map
-            const Lock lock(threads.mutex);
-            threads.ref.erase(thread);
-        });
-    }
-    return {thread, inserted};
-}
-
-ProxyClient<Thread>::~ProxyClient()
-{
-    // If thread is being destroyed before connection is destroyed, remove the
-    // cleanup callback that was registered to handle the connection being
-    // destroyed before the thread being destroyed.
-    if (m_disconnect_cb) {
-        // Remove disconnect callback on the event loop thread with
-        // loop->sync(), so if the connection is broken there is not a race
-        // between this thread trying to remove the callback and the disconnect
-        // handler attempting to call it.
-        m_context.loop->sync([&]() {
-            if (m_disconnect_cb) {
-                m_context.connection->removeSyncCleanup(*m_disconnect_cb);
-            }
-        });
-    }
-}
-
-ProxyServer<Thread>::ProxyServer(Connection& connection, ThreadContext& thread_context, std::thread&& thread)
-    : m_loop{*connection.m_loop}, m_thread_context(thread_context), m_thread(std::move(thread))
-{
-    assert(m_thread_context.waiter.get() != nullptr);
-}
-
-ProxyServer<Thread>::~ProxyServer()
-{
-    if (!m_thread.joinable()) return;
-    // Stop async thread and wait for it to exit. Need to wait because the
-    // m_thread handle needs to outlive the thread to avoid "terminate called
-    // without an active exception" error. An alternative to waiting would be
-    // detach the thread, but this would introduce nondeterminism which could
-    // make code harder to debug or extend.
-    assert(m_thread_context.waiter.get());
-    std::unique_ptr<Waiter> waiter;
-    {
-        const Lock lock(m_thread_context.waiter->m_mutex);
-        //! Reset thread context waiter pointer, as shutdown signal for done
-        //! lambda passed as waiter->wait() argument in makeThread code below.
-        waiter = std::move(m_thread_context.waiter);
-        //! Assert waiter is idle. This destructor shouldn't be getting called if it is busy.
-        assert(!waiter->m_fn);
-        // Clear client maps now to avoid deadlock in m_thread.join() call
-        // below. The maps contain Thread::Client objects that need to be
-        // destroyed from the event loop thread (this thread), which can't
-        // happen if this thread is busy calling join.
-        m_thread_context.request_threads.clear();
-        m_thread_context.callback_threads.clear();
-        //! Ping waiter.
-        waiter->m_cv.notify_all();
-    }
-    m_thread.join();
-}
-
-kj::Promise<void> ProxyServer<Thread>::getName(GetNameContext context)
-{
-    context.getResults().setResult(m_thread_context.thread_name);
-    return kj::READY_NOW;
-}
-
-ProxyServer<ThreadMap>::ProxyServer(Connection& connection) : m_connection(connection) {}
-
-kj::Promise<void> ProxyServer<ThreadMap>::makeThread(MakeThreadContext context)
-{
-    EventLoop& loop{*m_connection.m_loop};
-    if (loop.testing_hook_makethread) loop.testing_hook_makethread();
-    const std::string from = context.getParams().getName();
-    std::promise<ThreadContext*> thread_context;
-    std::thread thread([&loop, &thread_context, from]() {
-        g_thread_context.thread_name = ThreadName(loop.m_exe_name) + " (from " + from + ")";
-        g_thread_context.waiter = std::make_unique<Waiter>();
-        Lock lock(g_thread_context.waiter->m_mutex);
-        thread_context.set_value(&g_thread_context);
-        if (loop.testing_hook_makethread_created) loop.testing_hook_makethread_created();
-        // Wait for shutdown signal from ProxyServer<Thread> destructor (signal
-        // is just waiter getting set to null.)
-        g_thread_context.waiter->wait(lock, [] { return !g_thread_context.waiter; });
-    });
-    auto thread_server = kj::heap<ProxyServer<Thread>>(m_connection, *thread_context.get_future().get(), std::move(thread));
-    auto thread_client = m_connection.m_threads.add(kj::mv(thread_server));
-    context.getResults().setResult(kj::mv(thread_client));
-    return kj::READY_NOW;
-}
-
-std::atomic<int> server_reqs{0};
-
-std::string LongThreadName(const char* exe_name)
-{
-    return g_thread_context.thread_name.empty() ? ThreadName(exe_name) : g_thread_context.thread_name;
-}
-
-kj::StringPtr KJ_STRINGIFY(Log v)
-{
-    switch (v) {
-        case Log::Trace:   return "Trace";
-        case Log::Debug:   return "Debug";
-        case Log::Info:    return "Info";
-        case Log::Warning: return "Warning";
-        case Log::Error:   return "Error";
-        case Log::Raise:   return "Raise";
-    }
-    return "<Log?>";
-}
-} // namespace mp
diff --git a/src/ipc/libmultiprocess/src/mp/util.cpp b/src/ipc/libmultiprocess/src/mp/util.cpp
deleted file mode 100644
index 463947b9bbb8..000000000000
--- a/src/ipc/libmultiprocess/src/mp/util.cpp
+++ /dev/null
@@ -1,195 +0,0 @@
-// 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 <mp/config.h>
-#include <mp/util.h>
-
-#include <cerrno>
-#include <cstdio>
-#include <filesystem>
-#include <iostream>
-#include <kj/common.h>
-#include <kj/string-tree.h>
-#include <pthread.h>
-#include <sstream>
-#include <string>
-#include <sys/types.h>
-#include <sys/resource.h>
-#include <sys/socket.h>
-#include <sys/wait.h>
-#include <system_error>
-#include <thread> // NOLINT(misc-include-cleaner) // IWYU pragma: keep
-#include <unistd.h>
-#include <utility>
-#include <vector>
-
-#ifdef __linux__
-#include <sys/syscall.h>
-#endif
-
-#ifdef HAVE_PTHREAD_GETTHREADID_NP
-#include <pthread_np.h>
-#endif // HAVE_PTHREAD_GETTHREADID_NP
-
-namespace fs = std::filesystem;
-
-namespace mp {
-namespace {
-
-std::vector<char*> MakeArgv(const std::vector<std::string>& args)
-{
-    std::vector<char*> argv;
-    argv.reserve(args.size() + 1);
-    for (const auto& arg : args) {
-        argv.push_back(const_cast<char*>(arg.c_str()));
-    }
-    argv.push_back(nullptr);
-    return argv;
-}
-
-//! Return highest possible file descriptor.
-size_t MaxFd()
-{
-    struct rlimit nofile;
-    if (getrlimit(RLIMIT_NOFILE, &nofile) == 0) {
-        return nofile.rlim_cur - 1;
-    } else {
-        return 1023;
-    }
-}
-
-} // namespace
-
-std::string ThreadName(const char* exe_name)
-{
-    char thread_name[16] = {0};
-#ifdef HAVE_PTHREAD_GETNAME_NP
-    pthread_getname_np(pthread_self(), thread_name, sizeof(thread_name));
-#endif // HAVE_PTHREAD_GETNAME_NP
-
-    std::ostringstream buffer;
-    buffer << (exe_name ? exe_name : "") << "-" << getpid() << "/";
-
-    if (thread_name[0] != '\0') {
-        buffer << thread_name << "-";
-    }
-
-    // Prefer platform specific thread ids over the standard C++11 ones because
-    // the former are shorter and are the same as what gdb prints "LWP ...".
-#ifdef __linux__
-    buffer << syscall(SYS_gettid);
-#elif defined(HAVE_PTHREAD_THREADID_NP)
-    uint64_t tid = 0;
-    pthread_threadid_np(nullptr, &tid);
-    buffer << tid;
-#elif defined(HAVE_PTHREAD_GETTHREADID_NP)
-    buffer << pthread_getthreadid_np();
-#else
-    buffer << std::this_thread::get_id();
-#endif
-
-    return std::move(buffer).str();
-}
-
-std::string LogEscape(const kj::StringTree& string, size_t max_size)
-{
-    std::string result;
-    string.visit([&](const kj::ArrayPtr<const char>& piece) {
-        if (result.size() > max_size) return;
-        for (const char c : piece) {
-            if (c == '\\') {
-                result.append("\\\\");
-            } else if (c < 0x20 || c > 0x7e) {
-                char escape[4];
-                snprintf(escape, sizeof(escape), "\\%02x", static_cast<unsigned char>(c));
-                result.append(escape);
-            } else {
-                result.push_back(c);
-            }
-            if (result.size() > max_size) {
-                result += "...";
-                break;
-            }
-        }
-    });
-    return result;
-}
-
-int SpawnProcess(int& pid, FdToArgsFn&& fd_to_args)
-{
-    int fds[2];
-    if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) != 0) {
-        throw std::system_error(errno, std::system_category(), "socketpair");
-    }
-
-    // Evaluate the callback and build the argv array before forking.
-    //
-    // The parent process may be multi-threaded and holding internal library
-    // locks at fork time. In that case, running code that allocates memory or
-    // takes locks in the child between fork() and exec() can deadlock
-    // indefinitely. Precomputing arguments in the parent avoids this.
-    const std::vector<std::string> args{fd_to_args(fds[0])};
-    const std::vector<char*> argv{MakeArgv(args)};
-
-    pid = fork();
-    if (pid == -1) {
-        throw std::system_error(errno, std::system_category(), "fork");
-    }
-    // Parent process closes the descriptor for socket 0, child closes the
-    // descriptor for socket 1. On failure, the parent throws, but the child
-    // must _exit(126) (post-fork child must not throw).
-    if (close(fds[pid ? 0 : 1]) != 0) {
-        if (pid) {
-            (void)close(fds[1]);
-            throw std::system_error(errno, std::system_category(), "close");
-        }
-        static constexpr char msg[] = "SpawnProcess(child): close(fds[1]) failed\n";
-        const ssize_t writeResult = ::write(STDERR_FILENO, msg, sizeof(msg) - 1);
-        (void)writeResult;
-        _exit(126);
-    }
-
-    if (!pid) {
-        // Child process must close all potentially open descriptors, except
-        // socket 0. Do not throw, allocate, or do non-fork-safe work here.
-        const int maxFd = MaxFd();
-        for (int fd = 3; fd < maxFd; ++fd) {
-            if (fd != fds[0]) {
-                close(fd);
-            }
-        }
-
-        execvp(argv[0], argv.data());
-        // NOTE: perror() is not async-signal-safe; calling it here in a
-        // post-fork child may deadlock in multithreaded parents.
-        // TODO: Report errors to the parent via a pipe (e.g. write errno)
-        // so callers can get diagnostics without relying on perror().
-        perror("execvp failed");
-        _exit(127);
-    }
-    return fds[1];
-}
-
-void ExecProcess(const std::vector<std::string>& args)
-{
-    const std::vector<char*> argv{MakeArgv(args)};
-    if (execvp(argv[0], argv.data()) != 0) {
-        perror("execvp failed");
-        if (errno == ENOENT && !args.empty()) {
-            std::cerr << "Missing executable: " << fs::weakly_canonical(args.front()) << '\n';
-        }
-        _exit(1);
-    }
-}
-
-int WaitProcess(int pid)
-{
-    int status;
-    if (::waitpid(pid, &status, /*options=*/0) != pid) {
-        throw std::system_error(errno, std::system_category(), "waitpid");
-    }
-    return status;
-}
-
-} // namespace mp
diff --git a/src/ipc/libmultiprocess/test/CMakeLists.txt b/src/ipc/libmultiprocess/test/CMakeLists.txt
deleted file mode 100644
index 1f21ba44ca04..000000000000
--- a/src/ipc/libmultiprocess/test/CMakeLists.txt
+++ /dev/null
@@ -1,40 +0,0 @@
-# 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.
-
-# Custom test targets for convenience, based on
-# https://gitlab.kitware.com/cmake/community/-/wikis/doc/tutorials/EmulateMakeCheck.
-#
-# CTest already provides a "make test" target, but it just runs existing tests
-# that were previously built, without building anything itself. Define "make
-# tests" here as a custom target to build all available tests and "make check"
-# as a custom target to build and run them.
-add_custom_target(mptests)
-add_custom_target(mpcheck COMMAND ${CMAKE_CTEST_COMMAND} DEPENDS mptests)
-
-# Only add more convenient tests and check targets if project is being built
-# standalone, to prevent clashes with external projects.
-if (MP_STANDALONE)
-  add_custom_target(tests DEPENDS mptests)
-  add_custom_target(check DEPENDS mpcheck)
-endif()
-
-if(BUILD_TESTING AND TARGET CapnProto::kj-test)
-  set_property(SOURCE ${MP_PROXY_HDRS} PROPERTY GENERATED 1)
-
-  add_executable(mptest
-    ${MP_PROXY_HDRS}
-    mp/test/foo-types.h
-    mp/test/foo.h
-    mp/test/spawn_tests.cpp
-    mp/test/test.cpp
-  )
-  include(${PROJECT_SOURCE_DIR}/cmake/TargetCapnpSources.cmake)
-  target_capnp_sources(mptest ${CMAKE_CURRENT_SOURCE_DIR} mp/test/foo.capnp)
-  target_include_directories(mptest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
-  target_link_libraries(mptest PRIVATE CapnProto::kj-test)
-  target_link_libraries(mptest PRIVATE Threads::Threads)
-
-  add_dependencies(mptests mptest)
-  add_test(NAME mptest COMMAND mptest)
-endif()
diff --git a/src/ipc/libmultiprocess/test/mp/test/foo-types.h b/src/ipc/libmultiprocess/test/mp/test/foo-types.h
deleted file mode 100644
index 735adb7689c9..000000000000
--- a/src/ipc/libmultiprocess/test/mp/test/foo-types.h
+++ /dev/null
@@ -1,109 +0,0 @@
-// 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 MP_TEST_FOO_TYPES_H
-#define MP_TEST_FOO_TYPES_H
-
-#include <mp/proxy.h>
-#include <mp/proxy-types.h>
-
-// IWYU pragma: begin_exports
-#include <capnp/common.h>
-#include <cstddef>
-#include <mp/test/foo.capnp.h>
-#include <mp/type-context.h>
-#include <mp/type-data.h>
-#include <mp/type-decay.h>
-#include <mp/type-function.h>
-#include <mp/type-interface.h>
-#include <mp/type-map.h>
-#include <mp/type-message.h>
-#include <mp/type-number.h>
-#include <mp/type-pointer.h>
-#include <mp/type-set.h>
-#include <mp/type-string.h>
-#include <mp/type-struct.h>
-#include <mp/type-threadmap.h>
-#include <mp/type-vector.h>
-#include <string>
-#include <type_traits>
-// IWYU pragma: end_exports
-
-namespace mp {
-namespace test {
-namespace messages {
-struct ExtendedCallback; // IWYU pragma: export
-struct FooCallback; // IWYU pragma: export
-struct FooFn; // IWYU pragma: export
-struct FooInterface; // IWYU pragma: export
-} // namespace messages
-
-template <typename Output>
-void CustomBuildField(TypeList<FooCustom>, Priority<1>, InvokeContext& invoke_context, const FooCustom& value, Output&& output)
-{
-    BuildField(TypeList<std::string>(), invoke_context, output, value.v1);
-    output.setV2(value.v2);
-}
-
-template <typename Input, typename ReadDest>
-decltype(auto) CustomReadField(TypeList<FooCustom>, Priority<1>, InvokeContext& invoke_context, Input&& input, ReadDest&& read_dest)
-{
-    messages::FooCustom::Reader custom = input.get();
-    return read_dest.update([&](FooCustom& value) {
-        value.v1 = ReadField(TypeList<std::string>(), invoke_context, mp::Make<mp::ValueField>(custom.getV1()), ReadDestTemp<std::string>());
-        value.v2 = custom.getV2();
-    });
-}
-
-} // namespace test
-
-template <typename Input>
-bool CustomHasField(TypeList<test::FooData>, InvokeContext& invoke_context, const Input& input)
-{
-    // Cap'n Proto C++ cannot distinguish null vs empty Data in List(Data), so
-    // interpret empty Data as null for this specific type.
-    return input.get().size() != 0;
-}
-
-inline void CustomBuildMessage(InvokeContext& invoke_context,
-                        const test::FooMessage& src,
-                        test::messages::FooMessage::Builder&& builder)
-{
-    builder.setMessage(src.message + " build");
-}
-
-inline void CustomReadMessage(InvokeContext& invoke_context,
-                       const test::messages::FooMessage::Reader& reader,
-                       test::FooMessage& dest)
-{
-    dest.message = std::string{reader.getMessage()} + " read";
-}
-
-inline void CustomBuildMessage(InvokeContext& invoke_context,
-                        const test::FooMutable& src,
-                        test::messages::FooMutable::Builder&& builder)
-{
-    builder.setMessage(src.message + " build");
-}
-
-inline void CustomReadMessage(InvokeContext& invoke_context,
-                       const test::messages::FooMutable::Reader& reader,
-                       test::FooMutable& dest)
-{
-    dest.message = std::string{reader.getMessage()} + " read";
-}
-
-inline void CustomPassMessage(InvokeContext& invoke_context,
-                       const test::messages::FooMutable::Reader& reader,
-                       test::messages::FooMutable::Builder builder,
-                       std::function<void(test::FooMutable&)>&& fn)
-{
-    test::FooMutable mut;
-    mut.message = std::string{reader.getMessage()} + " pass";
-    fn(mut);
-    builder.setMessage(mut.message + " return");
-}
-} // namespace mp
-
-#endif // MP_TEST_FOO_TYPES_H
diff --git a/src/ipc/libmultiprocess/test/mp/test/foo.capnp b/src/ipc/libmultiprocess/test/mp/test/foo.capnp
deleted file mode 100644
index 5bdee2575b5a..000000000000
--- a/src/ipc/libmultiprocess/test/mp/test/foo.capnp
+++ /dev/null
@@ -1,79 +0,0 @@
-# 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.
-
-@0xe102a54b33a43a20;
-
-using Cxx = import "/capnp/c++.capnp";
-$Cxx.namespace("mp::test::messages");
-
-using Proxy = import "/mp/proxy.capnp";
-$Proxy.include("mp/test/foo.h");
-$Proxy.includeTypes("mp/test/foo-types.h");
-
-interface FooInterface $Proxy.wrap("mp::test::FooImplementation") {
-    add @0 (a :Int32, b :Int32) -> (result :Int32);
-    addOut @19 (a :Int32, b :Int32) -> (ret :Int32);
-    addInOut @20 (x :Int32, sum :Int32) -> (sum :Int32);
-    mapSize @1 (map :List(Pair(Text, Text))) -> (result :Int32);
-    pass @2 (arg :FooStruct) -> (result :FooStruct);
-    raise @3 (arg :FooStruct) -> (error :FooStruct $Proxy.exception("mp::test::FooStruct"));
-    initThreadMap @4 (threadMap: Proxy.ThreadMap) -> (threadMap :Proxy.ThreadMap);
-    callback @5 (context :Proxy.Context, callback :FooCallback, arg: Int32) -> (result :Int32);
-    callbackUnique @6 (context :Proxy.Context, callback :FooCallback, arg: Int32) -> (result :Int32);
-    callbackShared @7 (context :Proxy.Context, callback :FooCallback, arg: Int32) -> (result :Int32);
-    saveCallback @8 (context :Proxy.Context, callback :FooCallback) -> ();
-    callbackSaved @9 (context :Proxy.Context, arg: Int32) -> (result :Int32);
-    callbackExtended @10 (context :Proxy.Context, callback :ExtendedCallback, arg: Int32) -> (result :Int32);
-    passCustom @11 (arg :FooCustom) -> (result :FooCustom);
-    passEmpty @12 (arg :FooEmpty) -> (result :FooEmpty);
-    passMessage @13 (arg :FooMessage) -> (result :FooMessage);
-    passMutable @14 (arg :FooMutable) -> (arg :FooMutable);
-    passEnum @15 (arg :Int32) -> (result :Int32);
-    passFn @16 (context :Proxy.Context, fn :FooFn) -> (result :Int32);
-    callFn @17 () -> ();
-    callFnAsync @18 (context :Proxy.Context) -> ();
-    callIntFnAsync @21 (context :Proxy.Context, arg :Int32) -> (result :Int32);
-    passDataPointers @22 (arg :List(Data)) -> (result :List(Data));
-}
-
-interface FooCallback $Proxy.wrap("mp::test::FooCallback") {
-    destroy @0 (context :Proxy.Context) -> ();
-    call @1 (context :Proxy.Context, arg :Int32) -> (result :Int32);
-}
-
-interface ExtendedCallback extends(FooCallback) $Proxy.wrap("mp::test::ExtendedCallback") {
-    callExtended @0 (context :Proxy.Context, arg :Int32) -> (result :Int32);
-}
-
-interface FooFn $Proxy.wrap("ProxyCallback<std::function<int()>>") {
-    destroy @0 (context :Proxy.Context) -> ();
-    call @1 (context :Proxy.Context) -> (result :Int32);
-}
-
-struct FooStruct $Proxy.wrap("mp::test::FooStruct") {
-    name @0 :Text;
-    setint @1 :List(Int32);
-    vbool @2 :List(Bool);
-}
-
-struct FooCustom $Proxy.wrap("mp::test::FooCustom") {
-    v1 @0 :Text;
-    v2 @1 :Int32;
-}
-
-struct FooEmpty $Proxy.wrap("mp::test::FooEmpty") {
-}
-
-struct FooMessage {
-    message @0 :Text;
-}
-
-struct FooMutable {
-    message @0 :Text;
-}
-
-struct Pair(T1, T2) {
-    first @0 :T1;
-    second @1 :T2;
-}
diff --git a/src/ipc/libmultiprocess/test/mp/test/foo.h b/src/ipc/libmultiprocess/test/mp/test/foo.h
deleted file mode 100644
index 317af025eb63..000000000000
--- a/src/ipc/libmultiprocess/test/mp/test/foo.h
+++ /dev/null
@@ -1,98 +0,0 @@
-// 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 MP_TEST_FOO_H
-#define MP_TEST_FOO_H
-
-#include <cassert>
-#include <functional>
-#include <map>
-#include <memory>
-#include <string>
-#include <set>
-#include <vector>
-
-namespace mp {
-namespace test {
-
-struct FooStruct
-{
-    std::string name;
-    std::set<int> setint;
-    std::vector<bool> vbool;
-};
-
-enum class FooEnum : uint8_t { ONE = 1, TWO = 2, };
-
-struct FooCustom
-{
-    std::string v1;
-    int v2;
-};
-
-struct FooEmpty
-{
-};
-
-struct FooMessage
-{
-    std::string message;
-};
-
-struct FooMutable
-{
-    std::string message;
-};
-
-using FooData = std::vector<char>;
-using FooDataRef = std::shared_ptr<const FooData>;
-
-class FooCallback
-{
-public:
-    virtual ~FooCallback() = default;
-    virtual int call(int arg) = 0;
-};
-
-class ExtendedCallback : public FooCallback
-{
-public:
-    virtual int callExtended(int arg) = 0;
-};
-
-class FooImplementation
-{
-public:
-    int add(int a, int b) { return a + b; }
-    void addOut(int a, int b, int& out) { out = a + b; }
-    void addInOut(int x, int& sum) { sum += x; }
-    int mapSize(const std::map<std::string, std::string>& map) { return map.size(); }
-    FooStruct pass(FooStruct foo) { return foo; }
-    void raise(FooStruct foo) { throw foo; }
-    void initThreadMap() {}
-    int callback(FooCallback& callback, int arg) { return callback.call(arg); }
-    int callbackUnique(std::unique_ptr<FooCallback> callback, int arg) { return callback->call(arg); }
-    int callbackShared(std::shared_ptr<FooCallback> callback, int arg) { return callback->call(arg); } // NOLINT(performance-unnecessary-value-param)
-    void saveCallback(std::shared_ptr<FooCallback> callback) { m_callback = std::move(callback); }
-    int callbackSaved(int arg) { return m_callback->call(arg); }
-    int callbackExtended(ExtendedCallback& callback, int arg) { return callback.callExtended(arg); }
-    FooCustom passCustom(FooCustom foo) { return foo; }
-    FooEmpty passEmpty(FooEmpty foo) { return foo; }
-    FooMessage passMessage(FooMessage foo) { foo.message += " call"; return foo; }
-    void passMutable(FooMutable& foo) { foo.message += " call"; }
-    FooEnum passEnum(FooEnum foo) { return foo; }
-    int passFn(std::function<int()> fn) { return fn(); }
-    std::vector<FooDataRef> passDataPointers(std::vector<FooDataRef> values) { return values; }
-    std::shared_ptr<FooCallback> m_callback;
-    void callFn() { assert(m_fn); m_fn(); }
-    void callFnAsync() { assert(m_fn); m_fn(); }
-    int callIntFnAsync(int arg) { assert(m_int_fn); return m_int_fn(arg); }
-    std::function<void()> m_fn;
-    std::function<int(int)> m_int_fn;
-};
-
-} // namespace test
-} // namespace mp
-
-#endif // MP_TEST_FOO_H
diff --git a/src/ipc/libmultiprocess/test/mp/test/spawn_tests.cpp b/src/ipc/libmultiprocess/test/mp/test/spawn_tests.cpp
deleted file mode 100644
index a14e50e2a30f..000000000000
--- a/src/ipc/libmultiprocess/test/mp/test/spawn_tests.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-// 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 <mp/util.h>
-
-#include <kj/test.h>
-
-#include <chrono>
-#include <compare>
-#include <condition_variable>
-#include <csignal>
-#include <cstdlib>
-#include <mutex>
-#include <string>
-#include <sys/wait.h>
-#include <thread>
-#include <unistd.h>
-#include <vector>
-
-namespace {
-
-constexpr auto FAILURE_TIMEOUT = std::chrono::seconds{30};
-
-// Poll for child process exit using waitpid(..., WNOHANG) until the child exits
-// or timeout expires. Returns true if the child exited and status_out was set.
-// Returns false on timeout or error.
-static bool WaitPidWithTimeout(int pid, std::chrono::milliseconds timeout, int& status_out)
-{
-    const auto deadline = std::chrono::steady_clock::now() + timeout;
-    while (std::chrono::steady_clock::now() < deadline) {
-        const int r = ::waitpid(pid, &status_out, WNOHANG);
-        if (r == pid) return true;
-        if (r == 0) {
-            std::this_thread::sleep_for(std::chrono::milliseconds{1});
-            continue;
-        }
-        // waitpid error
-        return false;
-    }
-    return false;
-}
-
-} // namespace
-
-KJ_TEST("SpawnProcess does not run callback in child")
-{
-    // This test is designed to fail deterministically if fd_to_args is invoked
-    // in the post-fork child: a mutex held by another parent thread at fork
-    // time appears locked forever in the child.
-    std::mutex target_mutex;
-    std::mutex control_mutex;
-    std::condition_variable control_cv;
-    bool locked{false};
-    bool release{false};
-
-    // Holds target_mutex until the releaser thread updates release
-    std::thread locker([&] {
-        std::unique_lock<std::mutex> target_lock(target_mutex);
-        {
-            std::lock_guard<std::mutex> g(control_mutex);
-            locked = true;
-        }
-        control_cv.notify_one();
-
-        std::unique_lock<std::mutex> control_lock(control_mutex);
-        control_cv.wait(control_lock, [&] { return release; });
-    });
-
-    // Wait for target_mutex to be held by the locker thread.
-    {
-        std::unique_lock<std::mutex> l(control_mutex);
-        control_cv.wait(l, [&] { return locked; });
-    }
-
-    // Release the lock shortly after SpawnProcess starts.
-    std::thread releaser([&] {
-        // In the unlikely event a CI machine overshoots this delay, a
-        // regression could be missed. This is preferable to spurious
-        // test failures.
-        std::this_thread::sleep_for(std::chrono::milliseconds{50});
-        {
-            std::lock_guard<std::mutex> g(control_mutex);
-            release = true;
-        }
-        control_cv.notify_one();
-    });
-
-    int pid{-1};
-    const int fd{mp::SpawnProcess(pid, [&](int child_fd) -> std::vector<std::string> {
-        // If this callback runs in the post-fork child, target_mutex appears
-        // locked forever (the owning thread does not exist), so this deadlocks.
-        std::lock_guard<std::mutex> g(target_mutex);
-        return {"true", std::to_string(child_fd)};
-    })};
-    ::close(fd);
-
-    int status{0};
-    // Give the child some time to exit. If it does not, terminate it and
-    // reap it to avoid leaving a zombie behind.
-    const bool exited{WaitPidWithTimeout(pid, FAILURE_TIMEOUT, status)};
-    if (!exited) {
-        ::kill(pid, SIGKILL);
-        ::waitpid(pid, &status, /*options=*/0);
-    }
-
-    releaser.join();
-    locker.join();
-
-    KJ_EXPECT(exited, "Timeout waiting for child process to exit");
-    KJ_EXPECT(WIFEXITED(status) && WEXITSTATUS(status) == 0);
-}
diff --git a/src/ipc/libmultiprocess/test/mp/test/test.cpp b/src/ipc/libmultiprocess/test/mp/test/test.cpp
deleted file mode 100644
index d91edb40dce4..000000000000
--- a/src/ipc/libmultiprocess/test/mp/test/test.cpp
+++ /dev/null
@@ -1,485 +0,0 @@
-// 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 <mp/test/foo.capnp.h>
-#include <mp/test/foo.capnp.proxy.h>
-
-#include <atomic>
-#include <capnp/capability.h>
-#include <capnp/rpc.h>
-#include <cassert>
-#include <chrono>
-#include <condition_variable>
-#include <cstdint>
-#include <cstring>
-#include <functional>
-#include <future>
-#include <kj/async.h>
-#include <kj/async-io.h>
-#include <kj/common.h>
-#include <kj/debug.h>
-#include <kj/memory.h>
-#include <kj/test.h>
-#include <memory>
-#include <mp/proxy.h>
-#include <mp/proxy.capnp.h>
-#include <mp/proxy-io.h>
-#include <mp/util.h>
-#include <mp/version.h>
-#include <optional>
-#include <set>
-#include <stdexcept>
-#include <string>
-#include <string_view>
-#include <thread>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-namespace mp {
-namespace test {
-
-/** Check version.h header values */
-constexpr auto kMP_MAJOR_VERSION{MP_MAJOR_VERSION};
-constexpr auto kMP_MINOR_VERSION{MP_MINOR_VERSION};
-static_assert(std::is_integral_v<decltype(kMP_MAJOR_VERSION)>, "MP_MAJOR_VERSION must be an integral constant");
-static_assert(std::is_integral_v<decltype(kMP_MINOR_VERSION)>, "MP_MINOR_VERSION must be an integral constant");
-
-/**
- * Test setup class creating a two way connection between a
- * ProxyServer<FooInterface> object and a ProxyClient<FooInterface>.
- *
- * Provides disconnection lambdas that can be used to trigger
- * disconnects and test handling of broken and closed connections.
- *
- * Accepts a client_owns_connection option to test different ProxyClient
- * destroy_connection values and control whether destroying the ProxyClient
- * object destroys the client Connection object. Normally it makes sense for
- * this to be true to simplify shutdown and avoid needing to call
- * client_disconnect manually, but false allows testing more ProxyClient
- * behavior and the "IPC client method called after disconnect" code path.
- */
-class TestSetup
-{
-public:
-    std::function<void()> server_disconnect;
-    std::function<void()> server_disconnect_later;
-    std::function<void()> client_disconnect;
-    std::promise<std::unique_ptr<ProxyClient<messages::FooInterface>>> client_promise;
-    std::unique_ptr<ProxyClient<messages::FooInterface>> client;
-    ProxyServer<messages::FooInterface>* server{nullptr};
-    //! Thread variable should be after other struct members so the thread does
-    //! not start until the other members are initialized.
-    std::thread thread;
-
-    TestSetup(bool client_owns_connection = true)
-        : thread{[&] {
-              EventLoop loop("mptest", [](mp::LogMessage log) {
-                  // Info logs are not printed by default, but will be shown with `mptest --verbose`
-                  KJ_LOG(INFO, log.level, log.message);
-                  if (log.level == mp::Log::Raise) throw std::runtime_error(log.message);
-              });
-              auto pipe = loop.m_io_context.provider->newTwoWayPipe();
-
-              auto server_connection =
-                  std::make_unique<Connection>(loop, kj::mv(pipe.ends[0]), [&](Connection& connection) {
-                      auto server_proxy = kj::heap<ProxyServer<messages::FooInterface>>(
-                          std::make_shared<FooImplementation>(), connection);
-                      server = server_proxy;
-                      return capnp::Capability::Client(kj::mv(server_proxy));
-                  });
-              server_disconnect = [&] { loop.sync([&] { server_connection.reset(); }); };
-              server_disconnect_later = [&] {
-                  assert(std::this_thread::get_id() == loop.m_thread_id);
-                  loop.m_task_set->add(kj::evalLater([&] { server_connection.reset(); }));
-              };
-              // Set handler to destroy the server when the client disconnects. This
-              // is ignored if server_disconnect() is called instead.
-              server_connection->onDisconnect([&] { server_connection.reset(); });
-
-              auto client_connection = std::make_unique<Connection>(loop, kj::mv(pipe.ends[1]));
-              auto client_proxy = std::make_unique<ProxyClient<messages::FooInterface>>(
-                  client_connection->m_rpc_system->bootstrap(ServerVatId().vat_id).castAs<messages::FooInterface>(),
-                  client_connection.get(), /* destroy_connection= */ client_owns_connection);
-              if (client_owns_connection) {
-                  (void)client_connection.release();
-              } else {
-                  client_disconnect = [&] { loop.sync([&] { client_connection.reset(); }); };
-              }
-
-              client_promise.set_value(std::move(client_proxy));
-              loop.loop();
-          }}
-    {
-        client = client_promise.get_future().get();
-    }
-
-    ~TestSetup()
-    {
-        // Test that client cleanup_fns are executed.
-        bool destroyed = false;
-        client->m_context.cleanup_fns.emplace_front([&destroyed] { destroyed = true; });
-        client.reset();
-        KJ_EXPECT(destroyed);
-
-        thread.join();
-    }
-};
-
-KJ_TEST("Call FooInterface methods")
-{
-    TestSetup setup;
-    ProxyClient<messages::FooInterface>* foo = setup.client.get();
-
-    KJ_EXPECT(foo->add(1, 2) == 3);
-    int ret;
-    foo->addOut(3, 4, ret);
-    KJ_EXPECT(ret == 7);
-    foo->addInOut(3, ret);
-    KJ_EXPECT(ret == 10);
-
-    FooStruct in;
-    in.name = "name";
-    in.setint.insert(2);
-    in.setint.insert(1);
-    in.vbool.push_back(false);
-    in.vbool.push_back(true);
-    in.vbool.push_back(false);
-    FooStruct out = foo->pass(in);
-    KJ_EXPECT(in.name == out.name);
-    KJ_EXPECT(in.setint.size() == out.setint.size());
-    for (auto init{in.setint.begin()}, outit{out.setint.begin()}; init != in.setint.end() && outit != out.setint.end(); ++init, ++outit) {
-        KJ_EXPECT(*init == *outit);
-    }
-    KJ_EXPECT(in.vbool.size() == out.vbool.size());
-    for (size_t i = 0; i < in.vbool.size(); ++i) {
-        KJ_EXPECT(in.vbool[i] == out.vbool[i]);
-    }
-
-    FooStruct err;
-    try {
-        foo->raise(in);
-    } catch (const FooStruct& e) {
-        err = e;
-    }
-    KJ_EXPECT(in.name == err.name);
-
-    class Callback : public ExtendedCallback
-    {
-    public:
-        Callback(int expect, int ret) : m_expect(expect), m_ret(ret) {}
-        int call(int arg) override
-        {
-            KJ_EXPECT(arg == m_expect);
-            return m_ret;
-        }
-        int callExtended(int arg) override
-        {
-            KJ_EXPECT(arg == m_expect + 10);
-            return m_ret + 10;
-        }
-        int m_expect, m_ret;
-    };
-
-    foo->initThreadMap();
-    Callback callback(1, 2);
-    KJ_EXPECT(foo->callback(callback, 1) == 2);
-    KJ_EXPECT(foo->callbackUnique(std::make_unique<Callback>(3, 4), 3) == 4);
-    KJ_EXPECT(foo->callbackShared(std::make_shared<Callback>(5, 6), 5) == 6);
-    auto saved = std::make_shared<Callback>(7, 8);
-    KJ_EXPECT(saved.use_count() == 1);
-    foo->saveCallback(saved);
-    KJ_EXPECT(saved.use_count() == 2);
-    foo->callbackSaved(7);
-    KJ_EXPECT(foo->callbackSaved(7) == 8);
-    foo->saveCallback(nullptr);
-    KJ_EXPECT(saved.use_count() == 1);
-    KJ_EXPECT(foo->callbackExtended(callback, 11) == 12);
-
-    FooCustom custom_in;
-    custom_in.v1 = "v1";
-    custom_in.v2 = 5;
-    FooCustom custom_out = foo->passCustom(custom_in);
-    KJ_EXPECT(custom_in.v1 == custom_out.v1);
-    KJ_EXPECT(custom_in.v2 == custom_out.v2);
-
-    foo->passEmpty(FooEmpty{});
-
-    FooMessage message1;
-    message1.message = "init";
-    FooMessage message2{foo->passMessage(message1)};
-    KJ_EXPECT(message2.message == "init build read call build read");
-
-    FooMutable mut;
-    mut.message = "init";
-    foo->passMutable(mut);
-    KJ_EXPECT(mut.message == "init build pass call return read");
-
-    KJ_EXPECT(foo->passFn([]{ return 10; }) == 10);
-
-    std::vector<FooDataRef> data_in;
-    data_in.push_back(std::make_shared<FooData>(FooData{'H', 'i'}));
-    data_in.push_back(nullptr);
-    std::vector<FooDataRef> data_out{foo->passDataPointers(data_in)};
-    KJ_EXPECT(data_out.size() == 2);
-    KJ_REQUIRE(data_out[0] != nullptr);
-    KJ_EXPECT(*data_out[0] == *data_in[0]);
-    KJ_EXPECT(!data_out[1]);
-}
-
-KJ_TEST("Call IPC method after client connection is closed")
-{
-    TestSetup setup{/*client_owns_connection=*/false};
-    ProxyClient<messages::FooInterface>* foo = setup.client.get();
-    KJ_EXPECT(foo->add(1, 2) == 3);
-    setup.client_disconnect();
-
-    bool disconnected{false};
-    try {
-        foo->add(1, 2);
-    } catch (const std::runtime_error& e) {
-        KJ_EXPECT(std::string_view{e.what()} == "IPC client method called after disconnect.");
-        disconnected = true;
-    }
-    KJ_EXPECT(disconnected);
-}
-
-KJ_TEST("Calling IPC method after server connection is closed")
-{
-    TestSetup setup;
-    ProxyClient<messages::FooInterface>* foo = setup.client.get();
-    KJ_EXPECT(foo->add(1, 2) == 3);
-    setup.server_disconnect();
-
-    bool disconnected{false};
-    try {
-        foo->add(1, 2);
-    } catch (const std::runtime_error& e) {
-        KJ_EXPECT(std::string_view{e.what()} == "IPC client method call interrupted by disconnect.");
-        disconnected = true;
-    }
-    KJ_EXPECT(disconnected);
-}
-
-KJ_TEST("Calling IPC method and disconnecting during the call")
-{
-    TestSetup setup{/*client_owns_connection=*/false};
-    ProxyClient<messages::FooInterface>* foo = setup.client.get();
-    KJ_EXPECT(foo->add(1, 2) == 3);
-
-    // Set m_fn to initiate client disconnect when server is in the middle of
-    // handling the callFn call to make sure this case is handled cleanly.
-    setup.server->m_impl->m_fn = setup.client_disconnect;
-
-    bool disconnected{false};
-    try {
-        foo->callFn();
-    } catch (const std::runtime_error& e) {
-        KJ_EXPECT(std::string_view{e.what()} == "IPC client method call interrupted by disconnect.");
-        disconnected = true;
-    }
-    KJ_EXPECT(disconnected);
-}
-
-KJ_TEST("Calling IPC method, disconnecting and blocking during the call")
-{
-    // This test is similar to last test, except that instead of letting the IPC
-    // call return immediately after triggering a disconnect, make it disconnect
-    // & wait so server is forced to deal with having a disconnection and call
-    // in flight at the same time.
-    //
-    // Test uses callFnAsync() instead of callFn() to implement this. Both of
-    // these methods have the same implementation, but the callFnAsync() capnp
-    // method declaration takes an mp.Context argument so the method executes on
-    // an asynchronous thread instead of executing in the event loop thread, so
-    // it is able to block without deadlocking the event lock thread.
-    //
-    // This test adds important coverage because it causes the server Connection
-    // object to be destroyed before ProxyServer object, which is not a
-    // condition that usually happens because the m_rpc_system.reset() call in
-    // the ~Connection destructor usually would immediately free all remaining
-    // ProxyServer objects associated with the connection. Having an in-progress
-    // RPC call requires keeping the ProxyServer longer.
-
-    std::promise<void> signal;
-    TestSetup setup{/*client_owns_connection=*/false};
-    ProxyClient<messages::FooInterface>* foo = setup.client.get();
-    KJ_EXPECT(foo->add(1, 2) == 3);
-
-    foo->initThreadMap();
-    setup.server->m_impl->m_fn = [&] {
-        EventLoopRef loop{*setup.server->m_context.loop};
-        setup.client_disconnect();
-        signal.get_future().get();
-    };
-
-    bool disconnected{false};
-    try {
-        foo->callFnAsync();
-    } catch (const std::runtime_error& e) {
-        KJ_EXPECT(std::string_view{e.what()} == "IPC client method call interrupted by disconnect.");
-        disconnected = true;
-    }
-    KJ_EXPECT(disconnected);
-
-    // Now that the disconnect has been detected, set signal allowing the
-    // callFnAsync() IPC call to return. Since signalling may not wake up the
-    // thread right away, it is important for the signal variable to be declared
-    // *before* the TestSetup variable so is not destroyed while
-    // signal.get_future().get() is called.
-    signal.set_value();
-}
-
-KJ_TEST("Worker thread destroyed before it is initialized")
-{
-    // Regression test for bitcoin/bitcoin#34711, bitcoin/bitcoin#34756 where a
-    // worker thread is destroyed before it starts waiting for work.
-    //
-    // The test uses the `makethread` hook to trigger a disconnect as soon as
-    // ProxyServer<ThreadMap>::makeThread is called, so without the bugfix,
-    // ProxyServer<Thread>::~ProxyServer would run and destroy the waiter before
-    // the worker thread started waiting, causing a SIGSEGV when it did start.
-    TestSetup setup;
-    ProxyClient<messages::FooInterface>* foo = setup.client.get();
-    foo->initThreadMap();
-    setup.server->m_impl->m_fn = [] {};
-
-    EventLoop& loop = *setup.server->m_context.connection->m_loop;
-    loop.testing_hook_makethread = [&] {
-        // Use disconnect_later to queue the disconnect, because the makethread
-        // hook is called on the event loop thread. The disconnect should happen
-        // as soon as the event loop is idle.
-        setup.server_disconnect_later();
-    };
-    loop.testing_hook_makethread_created = [&] {
-        // Sleep to allow event loop to run and process the queued disconnect
-        // before the worker thread starts waiting.
-        std::this_thread::sleep_for(std::chrono::milliseconds(10));
-    };
-
-    bool disconnected{false};
-    try {
-        foo->callFnAsync();
-    } catch (const std::runtime_error& e) {
-        KJ_EXPECT(std::string_view{e.what()} == "IPC client method call interrupted by disconnect.");
-        disconnected = true;
-    }
-    KJ_EXPECT(disconnected);
-}
-
-KJ_TEST("Calling async IPC method, with server disconnect racing the call")
-{
-    // Regression test for bitcoin/bitcoin#34777 heap-use-after-free where
-    // an async request is canceled before it starts to execute.
-    //
-    // Use testing_hook_async_request_start to trigger a disconnect from the
-    // worker thread as soon as it begins to execute an async request. Without
-    // the bugfix, the worker thread would trigger a SIGSEGV after this by
-    // calling call_context.getParams().
-    TestSetup setup;
-    ProxyClient<messages::FooInterface>* foo = setup.client.get();
-    foo->initThreadMap();
-    setup.server->m_impl->m_fn = [] {};
-
-    EventLoop& loop = *setup.server->m_context.connection->m_loop;
-    loop.testing_hook_async_request_start = [&] {
-        setup.server_disconnect();
-        // Sleep is necessary to let the event loop fully clean up after the
-        // disconnect and trigger the SIGSEGV.
-        std::this_thread::sleep_for(std::chrono::milliseconds(10));
-    };
-
-    try {
-        foo->callFnAsync();
-        KJ_EXPECT(false);
-    } catch (const std::runtime_error& e) {
-        KJ_EXPECT(std::string_view{e.what()} == "IPC client method call interrupted by disconnect.");
-    }
-}
-
-KJ_TEST("Calling async IPC method, with server disconnect after cleanup")
-{
-    // Regression test for bitcoin/bitcoin#34782 stack-use-after-return where
-    // an async request is canceled after it finishes executing but before the
-    // response is sent.
-    //
-    // Use testing_hook_async_request_done to trigger a disconnect from the
-    // worker thread after it executes an async request but before it returns.
-    // Without the bugfix, the m_on_cancel callback would be called at this
-    // point, accessing the cancel_mutex stack variable that had gone out of
-    // scope.
-    TestSetup setup;
-    ProxyClient<messages::FooInterface>* foo = setup.client.get();
-    foo->initThreadMap();
-    setup.server->m_impl->m_fn = [] {};
-
-    EventLoop& loop = *setup.server->m_context.connection->m_loop;
-    loop.testing_hook_async_request_done = [&] {
-        setup.server_disconnect();
-    };
-
-    try {
-        foo->callFnAsync();
-        KJ_EXPECT(false);
-    } catch (const std::runtime_error& e) {
-        KJ_EXPECT(std::string_view{e.what()} == "IPC client method call interrupted by disconnect.");
-    }
-}
-
-KJ_TEST("Make simultaneous IPC calls on single remote thread")
-{
-    TestSetup setup;
-    ProxyClient<messages::FooInterface>* foo = setup.client.get();
-    std::promise<void> signal;
-
-    foo->initThreadMap();
-    // Use callFnAsync() to get the client to set up the request_thread
-    // that will be used for the test.
-    setup.server->m_impl->m_fn = [&] {};
-    foo->callFnAsync();
-    ThreadContext& tc{g_thread_context};
-    Thread::Client *callback_thread, *request_thread;
-    foo->m_context.loop->sync([&] {
-        Lock lock(tc.waiter->m_mutex);
-        callback_thread = &tc.callback_threads.at(foo->m_context.connection)->m_client;
-        request_thread = &tc.request_threads.at(foo->m_context.connection)->m_client;
-    });
-
-    // Call callIntFnAsync 3 times with n=100, 200, 300
-    std::atomic<int> expected = 100;
-
-    setup.server->m_impl->m_int_fn = [&](int n) {
-        assert(n == expected);
-        expected += 100;
-        return n;
-    };
-
-    auto client{foo->m_client};
-    std::atomic<size_t> running{3};
-    foo->m_context.loop->sync([&]
-    {
-        for (size_t i = 0; i < running; i++)
-        {
-            auto request{client.callIntFnAsyncRequest()};
-            auto context{request.initContext()};
-            context.setCallbackThread(*callback_thread);
-            context.setThread(*request_thread);
-            request.setArg(100 * (i+1));
-            foo->m_context.loop->m_task_set->add(request.send().then(
-                [&running, &tc, i](auto&& results) {
-                    assert(results.getResult() == static_cast<int32_t>(100 * (i+1)));
-                    running -= 1;
-                    tc.waiter->m_cv.notify_all();
-                }));
-        }
-    });
-    {
-        Lock lock(tc.waiter->m_mutex);
-        tc.waiter->wait(lock, [&running] { return running == 0; });
-    }
-    KJ_EXPECT(expected == 400);
-}
-
-} // namespace test
-} // namespace mp
diff --git a/test/lint/lint_ignore_dirs.py b/test/lint/lint_ignore_dirs.py
index 60637832309a..c3a033fb6aff 100644
--- a/test/lint/lint_ignore_dirs.py
+++ b/test/lint/lint_ignore_dirs.py
@@ -8,6 +8,5 @@
                  "src/crc32c/",
                  "src/secp256k1/",
                  "src/minisketch/",
-                 "src/ipc/libmultiprocess/",
                  "src/crypto/ctaes/",
                 ]
diff --git a/test/lint/test_runner/src/lint_cpp.rs b/test/lint/test_runner/src/lint_cpp.rs
index 727c87584df4..4523b658b797 100644
--- a/test/lint/test_runner/src/lint_cpp.rs
+++ b/test/lint/test_runner/src/lint_cpp.rs
@@ -103,7 +103,6 @@ pub fn lint_std_filesystem() -> LintResult {
             "std::filesystem",
             "--",
             "./src/",
-            ":(exclude)src/ipc/libmultiprocess/",
             ":(exclude)src/util/fs.h",
             ":(exclude)src/bitcoin-chainstate.cpp",
         ])

From 077a323ca340211ea6eb33e2827a3089b60ecb11 Mon Sep 17 00:00:00 2001
From: josibake <josibake@protonmail.com>
Date: Thu, 11 Jun 2026 06:05:58 +0100
Subject: [PATCH 3/3] doc: update ipc docs for native capnp

---
 doc/dependencies.md        |  2 -
 doc/design/multiprocess.md | 91 +++++++++++++++++++-------------------
 doc/developer-notes.md     | 14 ------
 doc/multiprocess.md        |  9 ++--
 src/interfaces/README.md   |  6 +--
 5 files changed, 53 insertions(+), 69 deletions(-)

diff --git a/doc/dependencies.md b/doc/dependencies.md
index 005b6d285b36..393a51907d73 100644
--- a/doc/dependencies.md
+++ b/doc/dependencies.md
@@ -24,7 +24,6 @@ Bitcoin Core requires one of the following compilers.
 | [Boost](../depends/packages/boost.mk) | [link](https://www.boost.org/users/download/) | [1.74.0](https://github.com/bitcoin/bitcoin/pull/34107) |
 | [Cap'n Proto](../depends/packages/native_capnp.mk) ([IPC](multiprocess.md)) | [link](https://capnproto.org/) | [0.7.1](https://github.com/bitcoin/bitcoin/pull/33241) |
 | CMake | [link](https://cmake.org/) | [3.22](https://github.com/bitcoin/bitcoin/pull/30454) |
-| [libmultiprocess](../depends/packages/native_libmultiprocess.mk) ([IPC](multiprocess.md)) | [link](https://github.com/bitcoin-core/libmultiprocess/tags) | [v7.0-pre1](https://github.com/bitcoin/bitcoin/pull/33517) |
 
 ### Runtime
 
@@ -40,4 +39,3 @@ Bitcoin Core requires one of the following compilers.
 | --- | --- | --- |
 | Python (scripts, tests) | [link](https://www.python.org) | [3.10](https://github.com/bitcoin/bitcoin/pull/30527) |
 | [systemtap](../depends/packages/systemtap.mk) ([tracing](tracing.md)) | [link](https://sourceware.org/systemtap/) | N/A |
-
diff --git a/doc/design/multiprocess.md b/doc/design/multiprocess.md
index f87e9c02b867..a5b7396d1ded 100644
--- a/doc/design/multiprocess.md
+++ b/doc/design/multiprocess.md
@@ -40,32 +40,31 @@ This section describes the major components of the Inter-Process Communication (
   compatibility with Cap'n Proto.
 
 ### Cap’n Proto Files in [`src/ipc/capnp/`](../../src/ipc/capnp/)
-- Corresponding to each abstract class, there are `.capnp` files within the [`src/ipc/capnp/`](../../src/ipc/capnp/) directory. These files are used as input to the `mpgen` tool (described below) to generate C++ code.
-- These Cap’n Proto files ([learn more about Cap'n Proto RPC](https://capnproto.org/rpc.html)) define the structure and format of messages that are exchanged over IPC. They serve as blueprints for generating C++ code that bridges the gap between high-level C++ interfaces and low-level socket communication.
+- Corresponding to each abstract class, there are `.capnp` files within the [`src/ipc/capnp/`](../../src/ipc/capnp/) directory. These files are used as input to Cap'n Proto's C++ compiler to generate low-level RPC classes.
+- These Cap’n Proto files ([learn more about Cap'n Proto RPC](https://capnproto.org/rpc.html)) define the structure and format of messages that are exchanged over IPC. The native bridge in [`src/ipc/capnp/protocol.cpp`](../../src/ipc/capnp/protocol.cpp) adapts those generated classes to the high-level C++ interfaces.
 
-### The `mpgen` Code Generation Tool
-- A central component of the IPC framework is the `mpgen` tool which is part of the [`libmultiprocess` project](https://github.com/bitcoin-core/libmultiprocess). This tool takes the `.capnp` files as input and generates C++ code.
-- The generated code handles IPC communication, translating interface calls into socket reads and writes.
+### Cap'n Proto Code Generation
+- Cap'n Proto's `capnp` and `capnpc-c++` tools generate the C++ RPC types from the `.capnp` files at build time.
+- Generated files are build outputs. Hand-written code in [`src/ipc/capnp/`](../../src/ipc/capnp/) owns the policy for mapping Bitcoin Core interfaces, cancellation handlers, callbacks, and domain types to those generated RPC types.
 
-### C++ Client Subclasses in Generated Code
-- In the generated code, we have C++ client subclasses that inherit from the abstract classes in [`src/interfaces/`](../../src/interfaces/). These subclasses are the workhorses of the IPC mechanism.
+### C++ Client Subclasses
+- The native IPC bridge provides C++ client subclasses that inherit from the abstract classes in [`src/interfaces/`](../../src/interfaces/). These subclasses are the workhorses of the IPC mechanism.
 - They implement all the methods of the interface, marshalling arguments into a structured format, sending them as requests to the IPC server via a UNIX socket, and handling the responses.
 - These subclasses effectively mask the complexity of IPC, presenting a familiar C++ interface to developers.
-- Internally, the client subclasses generated by the `mpgen` tool wrap [client classes generated by Cap'n Proto](https://capnproto.org/cxxrpc.html#clients), and use them to send IPC requests. The Cap'n Proto client classes are low-level, with non-blocking methods that use asynchronous I/O and pass request and response objects, while mpgen client subclasses provide normal C++ methods that block while executing and convert between request/response objects and arguments/return values.
+- Internally, the client subclasses wrap [client classes generated by Cap'n Proto](https://capnproto.org/cxxrpc.html#clients), and use them to send IPC requests. Synchronous interface methods block on the Cap'n Proto event loop, while async interface methods schedule RPC promises and return cancellation handlers before completion callbacks can run.
 
-### C++ Server Classes in Generated Code
-- On the server side, corresponding generated C++ classes receive IPC requests. These server classes are responsible for unmarshalling method arguments, invoking the corresponding methods in the local [`src/interfaces/`](../../src/interfaces/) objects, and creating the IPC response.
-- The server classes ensure that return values (including output argument values and thrown exceptions) are marshalled and sent back to the client, completing the communication cycle.
-- Internally, the server subclasses generated by the `mpgen` tool inherit from [server classes generated by Cap'n Proto](https://capnproto.org/cxxrpc.html#servers), and use them to process IPC requests.
+### C++ Server Classes
+- On the server side, hand-written server classes inherit from [server classes generated by Cap'n Proto](https://capnproto.org/cxxrpc.html#servers). These server classes are responsible for unmarshalling method arguments, invoking the corresponding methods in the local [`src/interfaces/`](../../src/interfaces/) objects, and creating the IPC response.
+- The server classes ensure that return values and translated errors are marshalled and sent back to the client, completing the communication cycle.
 
-### The `libmultiprocess` Runtime Library
-- **Core Functionality**: The `libmultiprocess` runtime library's primary function is to instantiate the generated client and server classes as needed.
-- **Bootstrapping IPC Connections**: It provides functions for starting new IPC connections, specifically binding generated client and server classes for an initial `interfaces::Init` interface (defined in [`src/interfaces/init.h`](../../src/interfaces/init.h)) to a UNIX socket. This initial interface has methods returning other interfaces that different Bitcoin Core modules use to communicate after the bootstrapping phase.
-- **Asynchronous I/O and Thread Management**: The library is also responsible for managing I/O and threading. Particularly, it ensures that IPC requests never block each other and that new threads on either side of a connection can always make client calls. It also manages worker threads on the server side of calls, ensuring that calls from the same client thread always execute on the same server thread (to avoid locking issues and support nested callbacks).
+### The Native Cap'n Proto Runtime
+- **Core Functionality**: The native runtime in [`src/ipc/capnp/protocol.cpp`](../../src/ipc/capnp/protocol.cpp) instantiates client and server adapters for the generated Cap'n Proto capabilities.
+- **Bootstrapping IPC Connections**: It starts new IPC connections by binding an initial `interfaces::Init` interface (defined in [`src/interfaces/init.h`](../../src/interfaces/init.h)) to a UNIX socket. This initial interface has methods returning other interfaces that different Bitcoin Core modules use to communicate after the bootstrapping phase.
+- **Asynchronous I/O and Thread Management**: The runtime owns the Cap'n Proto event loop thread for each client connection, schedules asynchronous calls on that thread, and dispatches completion callbacks on a separate callback executor so interface callbacks do not re-enter before cancellation handlers are returned.
 
-### Type Hooks in [`src/ipc/capnp/*-types.h`](../../src/ipc/capnp/)
-- **Custom Type Conversions**: In [`src/ipc/capnp/*-types.h`](../../src/ipc/capnp/), function overloads of `libmultiprocess` C++ functions, `mp::CustomReadField`, `mp::CustomBuildField`, `mp::CustomReadMessage` and `mp::CustomBuildMessage`, are defined. These overloads are used for customizing the conversion of specific C++ types to and from Cap’n Proto types.
-- **Handling Special Cases**: The `mpgen` tool and `libmultiprocess` library can convert most C++ types to and from Cap’n Proto types automatically, including interface types, primitive C++ types, standard C++ types like `std::vector`, `std::set`, `std::map`, `std::tuple`, and `std::function`, as well as simple C++ structs that consist of aforementioned types and whose fields correspond 1:1 with Cap’n Proto struct fields. For other types, `*-types.h` files provide custom code to convert between C++ and Cap’n Proto data representations.
+### Type Conversion Helpers
+- **Custom Type Conversions**: [`src/ipc/capnp/common-types.h`](../../src/ipc/capnp/common-types.h) provides serialization helpers for Bitcoin Core types that are sent as Cap'n Proto `Data` fields.
+- **Handling Special Cases**: Interface capabilities, callbacks, cancellation watches, and option-presence semantics are mapped explicitly in the native bridge instead of being inferred by a separate code generator.
 
 ### Protocol-Agnostic IPC Code in [`src/ipc/`](../../src/ipc/)
 - **Broad Applicability**: Unlike the Cap’n Proto-specific code in [`src/ipc/capnp/`](../../src/ipc/capnp/), the code in the [`src/ipc/`](../../src/ipc/) directory is protocol-agnostic. This enables potential support for other protocols, such as gRPC or a custom protocol in the future.
@@ -76,17 +75,16 @@ This section describes the major components of the Inter-Process Communication (
 
 ```mermaid
 flowchart TD
-    capnpFile[ipc/capnp/chain.capnp] -->|Input to| mpgenTool([mpgen Tool])
-    mpgenTool -->|Generates| proxyTypesH[ipc/capnp/chain.capnp.proxy-types.h]
-    mpgenTool --> proxyClientCpp[ipc/capnp/chain.capnp.proxy-client.c++]
-    mpgenTool --> proxyServerCpp[ipc/capnp/chain.capnp.proxy-server.c++]
-    proxyTypesH -.->|Includes| interfaces/chain.h
-    proxyClientCpp -.-> interfaces/chain.h
-    proxyServerCpp -.-> interfaces/chain.h
+    capnpFile[ipc/capnp/init.capnp] -->|Input to| capnpc([capnpc-c++])
+    capnpc -->|Generates| capnpH[ipc/capnp/init.capnp.h]
+    capnpc --> capnpCpp[ipc/capnp/init.capnp.c++]
+    capnpH -.-> protocolCpp[ipc/capnp/protocol.cpp]
+    capnpCpp -.-> protocolCpp
+    protocolCpp -.-> interfaces/init.h
 ```
 
 </td></tr><tr><td>
-Diagram showing generated source files and includes.
+Diagram showing generated Cap'n Proto files and the native bridge.
 </td></tr></table>
 
 ## Design Considerations
@@ -102,7 +100,11 @@ The IPC mechanism is deliberately isolated from the rest of the codebase so less
 
 Building Bitcoin Core with IPC support is optional. The build system also ensures Cap’n Proto library headers can only be used within the [`src/ipc/capnp/`](../../src/ipc/capnp/) directory, not in other parts of the codebase.
 
-The libmultiprocess runtime is designed to place as few constraints as possible on IPC interfaces and to make IPC calls act like normal function calls. Method arguments, return values, and exceptions are automatically serialized and sent between processes. Object references and `std::function` arguments are tracked to allow invoked code to call back into invoking code at any time. And there is a 1:1 threading model where every client thread has a corresponding server thread responsible for executing incoming calls from that thread (there can be multiple calls from the same thread due to callbacks) without blocking, and holding the same thread-local variables and locks so behavior is the same whether IPC is used or not.
+The native runtime is designed to keep IPC concerns inside `src/ipc/`. The
+high-level interfaces expose ordinary C++ values, capabilities, callbacks, and
+cancellation handlers. The Cap'n Proto bridge translates those to generated RPC
+requests and promises, while the node layer remains independent of Cap'n Proto
+headers.
 
 ### Interface Definition Maintenance
 
@@ -120,7 +122,12 @@ The currently defined IPC interfaces are unstable, and can change freely with no
 
 ## Security Considerations
 
-The integration of [Cap’n Proto](https://capnproto.org/) and [libmultiprocess](https://github.com/bitcoin-core/libmultiprocess) into the Bitcoin Core architecture increases its potential attack surface. Cap’n Proto, being a complex and substantial new dependency, introduces potential sources of vulnerability, particularly through the creation of new UNIX sockets. The inclusion of libmultiprocess, while a smaller external dependency, also contributes to this risk. However, plans are underway to incorporate libmultiprocess as a git subtree, aligning it more closely with the project's well-reviewed internal libraries. While adopting these multiprocess features does introduce some risk, it's worth noting that they can be disabled, allowing builds without these new dependencies. This flexibility ensures that users can balance functionality with security considerations as needed.
+The integration of [Cap’n Proto](https://capnproto.org/) into the Bitcoin Core
+architecture increases its potential attack surface. Cap’n Proto introduces
+potential sources of vulnerability, particularly through the creation of new UNIX
+sockets and bidirectional RPC capabilities. While adopting these multiprocess
+features does introduce some risk, IPC support can be disabled so users and
+builders can balance functionality with security considerations as needed.
 
 ## Example Use Cases and Flows
 
@@ -157,20 +164,19 @@ sequenceDiagram
    - The client process calls the `getBlockHash` method on a `Chain` object. This method is defined as a virtual method in [`src/interfaces/chain.h`](../../src/interfaces/chain.h).
 
 2. **Translation to Cap’n Proto RPC**
-   - The `Chain::getBlockHash` virtual method is overridden by the `Chain` [client subclass](#c-client-subclasses-in-generated-code) to translate the method call into a Cap’n Proto RPC call.
-   - The client subclass is automatically generated by the `mpgen` tool from the [`chain.capnp`](https://github.com/ryanofsky/bitcoin/blob/pr/ipc/src/ipc/capnp/chain.capnp) file in [`src/ipc/capnp/`](../../src/ipc/capnp/).
+   - The `Chain::getBlockHash` virtual method is overridden by the `Chain` [client subclass](#c-client-subclasses) to translate the method call into a Cap’n Proto RPC call.
+   - The client subclass is implemented in the native bridge under [`src/ipc/capnp/`](../../src/ipc/capnp/) and uses Cap'n Proto generated client classes.
 
 3. **Request Preparation and Dispatch**
-   - The `getBlockHash` method of the generated `Chain` client subclass in the client process populates a Cap’n Proto request with the `height` parameter, sends it to `bitcoin-node` process, and waits for a response.
+   - The `getBlockHash` method of the native `Chain` client subclass in the client process populates a Cap’n Proto request with the `height` parameter, sends it to `bitcoin-node` process, and waits for a response.
 
 4. **Handling in bitcoin-node**
-   - Upon receiving the request, the Cap'n Proto dispatching code in the `bitcoin-node` process calls the `getBlockHash` method of the `Chain` [server class](#c-server-classes-in-generated-code).
-   - The server class is automatically generated by the `mpgen` tool from the [`chain.capnp`](https://github.com/ryanofsky/bitcoin/blob/pr/ipc/src/ipc/capnp/chain.capnp) file in [`src/ipc/capnp/`](../../src/ipc/capnp/).
-   - The `getBlockHash` method of the generated `Chain` server subclass in `bitcoin-node` receives a Cap’n Proto request object with the `height` parameter, and calls the `getBlockHash` method on its local `Chain` object with the provided `height`.
+   - Upon receiving the request, the Cap'n Proto dispatching code in the `bitcoin-node` process calls the `getBlockHash` method of the `Chain` [server class](#c-server-classes).
+   - The native server class in [`src/ipc/capnp/`](../../src/ipc/capnp/) receives a Cap’n Proto request object with the `height` parameter, and calls the `getBlockHash` method on its local `Chain` object with the provided `height`.
    - When the call returns, it encapsulates the return value in a Cap’n Proto response, which it sends back to the client process.
 
 5. **Response and Return**
-   - The `getBlockHash` method of the generated `Chain` client subclass in the client process which sent the request now receives the response.
+   - The `getBlockHash` method of the native `Chain` client subclass in the client process which sent the request now receives the response.
    - It extracts the block hash value from the response, and returns it to the original caller.
 
 ## Future Enhancements
@@ -181,7 +187,7 @@ Further improvements are possible such as:
 - Automatically generating `.capnp` files from C++ interface definitions (see [Interface Definition Maintenance](#interface-definition-maintenance)).
 - Simplifying and stabilizing interfaces (see [Interface Stability](#interface-stability)).
 - Adding sandbox features, restricting subprocess access to resources and data (see [https://eklitzke.org/multiprocess-bitcoin](https://eklitzke.org/multiprocess-bitcoin)).
-- Using Cap'n Proto's support for [other languages](https://capnproto.org/otherlang.html), such as [Rust](https://github.com/capnproto/capnproto-rust), to allow code written in other languages to call Bitcoin Core C++ code, and vice versa (see [How to rustify libmultiprocess? #56](https://github.com/bitcoin-core/libmultiprocess/issues/56)).
+- Using Cap'n Proto's support for [other languages](https://capnproto.org/otherlang.html), such as [Rust](https://github.com/capnproto/capnproto-rust), to allow code written in other languages to call Bitcoin Core C++ code.
 
 ## Conclusion
 
@@ -201,23 +207,19 @@ This modularization represents an advancement in Bitcoin Core's architecture, of
 
 - **Cap’n Proto struct**: A structured data format used in Cap’n Proto, similar to structs in C++, for organizing and transporting data across different processes.
 
-- **client class (in generated code)**: A C++ class generated from a Cap’n Proto interface which inherits from a Bitcoin Core abstract class, and implements each virtual method to send IPC requests to another process. (see also [components section](#c-client-subclasses-in-generated-code))
+- **client class**: A C++ class in the native bridge which inherits from a Bitcoin Core abstract class, and implements each virtual method to send IPC requests to another process. (see also [components section](#c-client-subclasses))
 
 - **IPC (inter-process communication)**: Mechanisms that enable processes to exchange requests and data.
 
 - **ipc::Exception class**: A class within Bitcoin Core's protocol-agnostic IPC code that is thrown by client class methods when there is an IPC error.
 
-- **libmultiprocess**: A custom library and code generation tool used for creating IPC interfaces and managing IPC connections.
-
 - **marshalling**: Transforming an object’s memory representation for transmission.
 
-- **mpgen tool**: A tool within the `libmultiprocess` suite that generates C++ code from Cap’n Proto files, facilitating IPC.
-
 - **protocol-agnostic code**: Generic IPC code in [`src/ipc/`](../../src/ipc/) that does not rely on Cap’n Proto and could be used with other protocols. Distinct from code in [`src/ipc/capnp/`](../../src/ipc/capnp/) which relies on Cap’n Proto.
 
 - **RPC (remote procedure call)**: A protocol that enables a program to request a service from another program in a different address space or network. Bitcoin Core uses [JSON-RPC](https://en.wikipedia.org/wiki/JSON-RPC) for RPC.
 
-- **server class (in generated code)**: A C++ class generated from a Cap’n Proto interface which handles requests sent by a _client class_ in another process. The request handled by calling a local Bitcoin Core interface method, and the return values (if any) are sent back in a response. (see also: [components section](#c-server-classes-in-generated-code))
+- **server class**: A C++ class in the native bridge which handles requests sent by a _client class_ in another process. The request is handled by calling a local Bitcoin Core interface method, and the return values (if any) are sent back in a response. (see also: [components section](#c-server-classes))
 
 - **unix socket**: Communication endpoint which is a filesystem path, used for exchanging data between processes running on the same host.
 
@@ -226,8 +228,7 @@ This modularization represents an advancement in Bitcoin Core's architecture, of
 ## References
 
 - **Cap’n Proto RPC protocol description**: https://capnproto.org/rpc.html
-- **libmultiprocess project page**: https://github.com/bitcoin-core/libmultiprocess
 
 ## Acknowledgements
 
-This design doc was written by @ryanofsky, who is grateful to all the reviewers who gave feedback and tested [multiprocess PRs](https://github.com/bitcoin/bitcoin/pull/28722), and everyone else who's helped with this project. Particular thanks to @ariard who deeply reviewed IPC code and improved the design of the IPC library and initialization process. @jnewbery who championed the early refactoring PRs and helped guide them through development and review. @sjors who has reviewed and repeatedly tested multiprocess code, reporting many issues and helping debug them. @hebasto, @fanquake, and @maflcko who made significant improvements to the build system and fixed countless build issues. @vasild and @jamesob who were brave contributors to the libmultiprocess library. And Chaincode Labs for making this work possible. Also thanks to ChatGPT, who actually wrote most of this document (not @ryanofsky).
+This design doc was written by @ryanofsky, who is grateful to all the reviewers who gave feedback and tested [multiprocess PRs](https://github.com/bitcoin/bitcoin/pull/28722), and everyone else who's helped with this project. Particular thanks to @ariard who deeply reviewed IPC code and improved the design of the IPC library and initialization process. @jnewbery who championed the early refactoring PRs and helped guide them through development and review. @sjors who has reviewed and repeatedly tested multiprocess code, reporting many issues and helping debug them. @hebasto, @fanquake, and @maflcko who made significant improvements to the build system and fixed countless build issues. And Chaincode Labs for making this work possible. Also thanks to ChatGPT, who actually wrote most of this document (not @ryanofsky).
diff --git a/doc/developer-notes.md b/doc/developer-notes.md
index f3bbf6add1a3..2d8c3611b361 100644
--- a/doc/developer-notes.md
+++ b/doc/developer-notes.md
@@ -1139,19 +1139,6 @@ to check a subtree directory for consistency with its upstream repository.
 
 The tool instructions also include a list of the subtrees managed by Bitcoin Core.
 
-To fully verify or update a subtree, add it as a remote:
-
-```sh
-git remote add libmultiprocess https://github.com/bitcoin-core/libmultiprocess.git
-```
-
-To update the subtree:
-
-```sh
-git fetch libmultiprocess
-git subtree pull --prefix=src/ipc/libmultiprocess libmultiprocess master --squash
-```
-
 The ultimate upstream of the few externally managed subtrees are:
 
 - src/leveldb
@@ -1410,7 +1397,6 @@ there are [`interfaces::Chain`](../src/interfaces/chain.h), used to
 access the node's latest chain state,
 [`interfaces::Node`](../src/interfaces/node.h), used to control the
 node, and [`interfaces::Mining`](../src/interfaces/mining.h),
->>>>>>> acdcd09526 (nuke: wallet + psbt + external-signer (src, build, deps, ci, tests, docs))
 used by RPC to generate block templates. There are also more specialized interface
 types like [`interfaces::Handler`](../src/interfaces/handler.h) passed to and from
 various interface methods.
diff --git a/doc/multiprocess.md b/doc/multiprocess.md
index 4d599f678107..64168624fc28 100644
--- a/doc/multiprocess.md
+++ b/doc/multiprocess.md
@@ -26,11 +26,10 @@ build/bin/bitcoin -m node -regtest -printtoconsole -debug=ipc
 
 ### Cross-compiling
 
-When cross-compiling and not using depends, native code generation tools from [libmultiprocess](https://github.com/bitcoin-core/libmultiprocess) and [Cap'n Proto](https://capnproto.org/) are required. They can be passed to the cmake build by specifying `-DMPGEN_EXECUTABLE=/path/to/mpgen -DCAPNP_EXECUTABLE=/path/to/capnp -DCAPNPC_CXX_EXECUTABLE=/path/to/capnpc-c++` options.
-
-### External libmultiprocess installation
-
-By default the libmultiprocess sources at [../src/ipc/libmultiprocess/](../src/ipc/libmultiprocess/) are built as part of the bitcoin cmake build, but alternately an external [libmultiprocess](https://github.com/bitcoin-core/libmultiprocess/) cmake package can be used instead by following its [installation instructions](https://github.com/bitcoin-core/libmultiprocess/blob/master/doc/install.md) and specifying `-DWITH_EXTERNAL_LIBMULTIPROCESS=ON` to the bitcoin build, so it will use the external package instead of the sources. This can be useful when making changes to the upstream project. If libmultiprocess is not installed in a default system location it is possible to specify the [`CMAKE_PREFIX_PATH`](https://cmake.org/cmake/help/latest/envvar/CMAKE_PREFIX_PATH.html) environment variable to point to the installation prefix where libmultiprocess is installed.
+When cross-compiling and not using depends, native code generation tools from
+[Cap'n Proto](https://capnproto.org/) are required. They can be passed to the
+cmake build by specifying `-DCAPNP_EXECUTABLE=/path/to/capnp
+-DCAPNPC_CXX_EXECUTABLE=/path/to/capnpc-c++` options.
 
 ## Usage
 
diff --git a/src/interfaces/README.md b/src/interfaces/README.md
index c9f33a5fb5f8..72fe20a0653a 100644
--- a/src/interfaces/README.md
+++ b/src/interfaces/README.md
@@ -10,8 +10,8 @@ The following interfaces are defined here:
 
 * [`Handler`](handler.h) — returned by `handleEvent` methods on interfaces above and used to manage lifetimes of event handlers.
 
-* [`Init`](init.h) — used by multiprocess code to access interfaces above on startup. Added in [#19160](https://github.com/bitcoin/bitcoin/pull/19160).
+* [`Init`](init.h) — used by IPC code to access interfaces above on startup. Added in [#19160](https://github.com/bitcoin/bitcoin/pull/19160).
 
-* [`Ipc`](ipc.h) — used by multiprocess code to access `Init` interface across processes. Added in [#19160](https://github.com/bitcoin/bitcoin/pull/19160).
+* [`Ipc`](ipc.h) — used by IPC code to access `Init` interface across processes. Added in [#19160](https://github.com/bitcoin/bitcoin/pull/19160).
 
-The interfaces above define boundaries between major components of bitcoin code (node, wallet, and gui), making it possible for them to run in [different processes](../../doc/multiprocess.md), and be tested, developed, and understood independently. These interfaces are not currently designed to be stable or to be used externally.
+The interfaces above define boundaries between major components of bitcoin code (node, wallet, and gui), making it possible for them to run in different processes and be tested, developed, and understood independently. These interfaces are not currently designed to be stable or to be used externally.