Merge #6143: backport: bitcoin#19160, #21663, #21669, #21732, #21738, #21750, #21775, #21812

f4cb0fbfe1 fix: no need to relay quorum commitment in case of block undo (Konstantin Akimov) 0431a33919 fix: follow-up changes for bitcoin#14193. (Konstantin Akimov) 86b76d19b6 Merge bitcoin/bitcoin#21812: ci: Enable D_GLIBCXX_DEBUG for multiprocess task (fanquake) 334496ea7e Merge bitcoin/bitcoin#21775: p2p: Limit m_block_inv_mutex (MarcoFalke) 23b83109ea Merge bitcoin/bitcoin#21750: net: remove unnecessary check of CNode::cs_vSend (MarcoFalke) b34514191f Merge bitcoin/bitcoin#21738: test: Use clang-12 for ASAN, Add missing suppression (fanquake) 3411577473 Merge bitcoin/bitcoin#19160: multiprocess: Add basic spawn and IPC support (W. J. van der Laan) 970048d917 fix: missing changes from bitcoin#19267 - run multiprocess on CI (Konstantin Akimov) f2b7ee73db fix: follow-up bitcoin#15402 - removed dead code (Konstantin Akimov) 274068cdbc fix: follow-up bitcoin/bitcoin#21732 - minor missing typo (MarcoFalke) e9450a8b36 Merge #21669: test: Remove spurious double lock tsan suppressions by bumping to clang-12 (MarcoFalke) ef92c3065c Merge #21663: ci: Fix macOS brew install command (W. J. van der Laan) Pull request description: ## Issue being fixed or feature implemented Just regular backports from v22 ## What was done? See commits for backports. Also there're 2 bugs are fixed which became visible after backporting bitcoin#21775 - both are related to possible deadlocks in net_processing ## How Has This Been Tested? Run unit and functional tests. Enabled multiprocess builds on CI ## Breaking Changes N/A ## Checklist: - [x] I have performed a self-review of my own code - [ ] I have commented my code, particularly in hard-to-understand areas - [ ] I have added or updated relevant unit/integration/functional/e2e tests - [ ] I have made corresponding changes to the documentation - [x] I have assigned this pull request to a milestone ACKs for top commit: UdjinM6: utACK f4cb0fbfe1 PastaPastaPasta: utACK f4cb0fbfe1 Tree-SHA512: 3204c2aa243fa4834ccf4ff4672d183cf9b35f87b857df8543572cd685729e15fca39f85b27194233e57cbc1746e36b556efab95ce20d0aa0a7d4476a9f3c6c0
2024-12-24 19:42:46 +01:00 · 2024-08-10 19:11:37 +07:00 · 2024-08-10 19:11:37 +07:00 · efe4c2d6eb
commit efe4c2d6eb
parent 7cc99c43c3 f4cb0fbfe1
42 changed files with 985 additions and 224 deletions
--- a/.cirrus.yml
+++ b/.cirrus.yml
@ -87,7 +87,7 @@ task:
    FILE_ENV: "./ci/test/00_setup_env_i686_centos.sh"

 task:
-  name: '[previous releases, uses qt5 dev package and some depends packages] [unsigned char] [focal]'
+  name: '[previous releases, uses qt5 dev package and some depends packages, DEBUG] [unsigned char] [focal]'
  # For faster CI feedback, immediately schedule a task that compiles most modules
  << : *CREDITS_TEMPLATE
  << : *GLOBAL_TASK_TEMPLATE
@ -116,10 +116,10 @@ task:
    FILE_ENV: "./ci/test/00_setup_env_native_msan.sh"

 task:
-  name: '[no depends, sanitizers: address/leak (ASan + LSan) + undefined (UBSan) + integer] [focal]'
+  name: '[no depends, sanitizers: address/leak (ASan + LSan) + undefined (UBSan) + integer] [hirsute]'
  << : *GLOBAL_TASK_TEMPLATE
  container:
-    image: ubuntu:focal
+    image: ubuntu:hirsute
  env:
    FILE_ENV: "./ci/test/00_setup_env_native_asan.sh"

@ -132,7 +132,7 @@ task:
    FILE_ENV: "./ci/test/00_setup_env_native_fuzz.sh"

 task:
-  name: '[multiprocess] [focal]'
+  name: '[multiprocess, DEBUG] [focal]'
  << : *GLOBAL_TASK_TEMPLATE
  container:
    image: ubuntu:focal
@ -157,8 +157,9 @@ task:

 task:
  name: 'macOS 11 native [gui] [no depends]'
-  macos_brew_addon_script:
-    - brew install boost libevent berkeley-db4 qt miniupnpc ccache zeromq qrencode sqlite libtool automake pkg-config gnu-getopt
+  brew_install_script:
+    - brew update
+    - brew install boost libevent berkeley-db4 qt@5 miniupnpc ccache zeromq qrencode sqlite libtool automake pkg-config gnu-getopt
  << : *GLOBAL_TASK_TEMPLATE
  macos_instance:
    # Use latest image, but hardcode version to avoid silent upgrades (and breaks)
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -203,16 +203,13 @@ x86_64-pc-linux-gnu-nowallet:
    HOST: x86_64-pc-linux-gnu
    DEP_OPTS: "NO_WALLET=1"

-## TODO: # Skip on non-depends, non-multiprocess PRs
-## if: type != pull_request OR commit_message =~ /depends:|multiprocess:/
-#x86_64-pc-linux-gnu-multiprocess:
-#  extends:
-#    - .build-depends-template
-#    - .skip-in-fast-mode-template
-#  variables:
-#    HOST: x86_64-pc-linux-gnu
-#    DEP_OPTS: "MULTIPROCESS=1"
-#
+x86_64-pc-linux-gnu-multiprocess:
+  extends:
+    - .build-depends-template
+    - .skip-in-fast-mode-template
+  variables:
+    HOST: x86_64-pc-linux-gnu
+    DEP_OPTS: "MULTIPROCESS=1"

 x86_64-apple-darwin:
  extends:
@ -309,14 +306,14 @@ linux64_nowallet-build:
  variables:
    BUILD_TARGET: linux64_nowallet

-#linux64_multiprocess-build:
-#  extends:
-#    - .build-template
-#    - .skip-in-fast-mode-template
-#  needs:
-#    - x86_64-pc-linux-gnu-multiprocess
-#  variables:
-#    BUILD_TARGET: linux64_multiprocess
+linux64_multiprocess-build:
+  extends:
+    - .build-template
+    - .skip-in-fast-mode-template
+  needs:
+    - x86_64-pc-linux-gnu-multiprocess
+  variables:
+    BUILD_TARGET: linux64_multiprocess

 #linux64_valgrind-build:
 #  extends:
@ -381,16 +378,14 @@ linux64_ubsan-test:
  variables:
    BUILD_TARGET: linux64_ubsan

-# TODO: enable multiprocess back in CI once it has any value
-# or in case if any new backports to test
-#linux64_multiprocess-test:
-#  extends:
-#    - .test-template
-#    - .skip-in-fast-mode-template
-#  needs:
-#    - linux64_multiprocess-build
-#  variables:
-#    BUILD_TARGET: linux64_multiprocess
+linux64_multiprocess-test:
+  extends:
+    - .test-template
+    - .skip-in-fast-mode-template
+  needs:
+    - linux64_multiprocess-build
+  variables:
+    BUILD_TARGET: linux64_multiprocess

 #linux64_valgrind-test:
 #  extends:
--- a/ci/test/00_setup_env_native_multiprocess.sh
+++ b/ci/test/00_setup_env_native_multiprocess.sh
@ -7,8 +7,8 @@
 export LC_ALL=C.UTF-8

 export CONTAINER_NAME=ci_native_multiprocess
-export PACKAGES="cmake python3"
-export DEP_OPTS="MULTIPROCESS=1"
+export PACKAGES="cmake python3 llvm clang"
+export DEP_OPTS="DEBUG=1 MULTIPROCESS=1"
 export GOAL="install"
-export BITCOIN_CONFIG="--with-boost-process"
+export BITCOIN_CONFIG="--with-boost-process --enable-debug CC=clang CXX=clang++" # Use clang to avoid OOM
 export TEST_RUNNER_ENV="BITCOIND=dash-node"
--- a/depends/packages/native_libmultiprocess.mk
+++ b/depends/packages/native_libmultiprocess.mk
@ -1,8 +1,8 @@
 package=native_libmultiprocess
-$(package)_version=5741d750a04e644a03336090d8979c6d033e32c0
+$(package)_version=d576d975debdc9090bd2582f83f49c76c0061698
 $(package)_download_path=https://github.com/chaincodelabs/libmultiprocess/archive
 $(package)_file_name=$($(package)_version).tar.gz
-$(package)_sha256_hash=ac848db49a6ed53e423c62d54bd87f1f08cbb0326254a8667e10bbfe5bf032a4
+$(package)_sha256_hash=9f8b055c8bba755dc32fe799b67c20b91e7b13e67cadafbc54c0f1def057a370
 $(package)_dependencies=native_capnp

 define $(package)_config_cmds
--- a/doc/multiprocess.md
+++ b/doc/multiprocess.md
@ -15,7 +15,7 @@ Specific next steps after backporting [bitcoin#10102](https://github.com/bitcoin

 ## Debugging

-After backporting [bitcoin#10102](https://github.com/bitcoin/bitcoin/pull/10102), the `-debug=ipc` command line option can be used to see requests and responses between processes.
+The `-debug=ipc` command line option can be used to see requests and responses between processes.

 ## Installation

@ -33,3 +33,40 @@ DASHD=dash-node test/functional/test_runner.py
 The configure script will pick up settings and library locations from the depends directory, so there is no need to pass `--enable-multiprocess` as a separate flag when using the depends system (it's controlled by the `MULTIPROCESS=1` option).

 Alternately, you can install [Cap'n Proto](https://capnproto.org/) and [libmultiprocess](https://github.com/chaincodelabs/libmultiprocess) packages on your system, and just run `./configure --enable-multiprocess` without using the depends system. The configure script will be able to locate the installed packages via [pkg-config](https://www.freedesktop.org/wiki/Software/pkg-config/). See [Installation](https://github.com/chaincodelabs/libmultiprocess#installation) section of the libmultiprocess readme for install steps. See [build-unix.md](build-unix.md) and [build-osx.md](build-osx.md) for information about installing dependencies in general.
+
+## IPC implementation details
+
+Cross process Node, Wallet, and Chain interfaces are defined in
+[`src/interfaces/`](../src/interfaces/). These are C++ classes which follow
+[conventions](developer-notes.md#internal-interface-guidelines), like passing
+serializable arguments so they can be called from different processes, and
+making methods pure virtual so they can have proxy implementations that forward
+calls between processes.
+
+When Wallet, Node, and Chain code is running in the same process, calling any
+interface method invokes the implementation directly. When code is running in
+different processes, calling an interface method invokes a proxy interface
+implementation that communicates with a remote process and invokes the real
+implementation in the remote process. The
+[libmultiprocess](https://github.com/chaincodelabs/libmultiprocess) code
+generation tool internally generates proxy client classes and proxy server
+classes for this purpose that are thin wrappers around Cap'n Proto
+[client](https://capnproto.org/cxxrpc.html#clients) and
+[server](https://capnproto.org/cxxrpc.html#servers) classes, which handle the
+actual serialization and socket communication.
+
+As much as possible, calls between processes are meant to work the same as
+calls within a single process without adding limitations or requiring extra
+implementation effort. Processes communicate with each other by calling regular
+[C++ interface methods](../src/interfaces/README.md). Method arguments and
+return values are automatically serialized and sent between processes. Object
+references and `std::function` arguments are automatically tracked and mapped
+to allow invoked code to call back into invoking code at any time, and there is
+a 1:1 threading model where any thread invoking a method in another process has
+a corresponding thread in the invoked process responsible for executing all
+method calls from the source thread, without blocking I/O or holding up another
+call, and using the same thread local variables, locks, and callbacks between
+calls. The forwarding, tracking, and threading is implemented inside the
+[libmultiprocess](https://github.com/chaincodelabs/libmultiprocess) library
+which has the design goal of making calls between processes look like calls in
+the same process to the extent possible.
--- a/src/Makefile.am
+++ b/src/Makefile.am
@ -94,6 +94,7 @@ EXTRA_LIBRARIES += \
  $(LIBBITCOIN_CONSENSUS) \
  $(LIBBITCOIN_SERVER) \
  $(LIBBITCOIN_CLI) \
+  $(LIBBITCOIN_IPC) \
  $(LIBBITCOIN_WALLET) \
  $(LIBBITCOIN_WALLET_TOOL) \
  $(LIBBITCOIN_ZMQ)
@ -219,7 +220,10 @@ BITCOIN_CORE_H = \
  init/common.h \
  interfaces/chain.h \
  interfaces/coinjoin.h \
+  interfaces/echo.h \
  interfaces/handler.h \
+  interfaces/init.h \
+  interfaces/ipc.h \
  interfaces/node.h \
  interfaces/wallet.h \
  key.h \
@ -406,6 +410,8 @@ obj/build.h: FORCE
 	  "$(abs_top_srcdir)"
 libbitcoin_util_a-clientversion.$(OBJEXT): obj/build.h

+ipc/capnp/libbitcoin_ipc_a-ipc.$(OBJEXT): $(libbitcoin_ipc_mpgen_input:=.h)
+
 # server: shared between dashd and dash-qt
 # Contains code accessing mempool and chain state that is meant to be separated
 # from wallet and gui code (see node/README.md). Shared code should go in
@ -772,7 +778,9 @@ libbitcoin_util_a_SOURCES = \
  clientversion.cpp \
  compat/strnlen.cpp \
  fs.cpp \
+  interfaces/echo.cpp \
  interfaces/handler.cpp \
+  interfaces/init.cpp \
  logging.cpp \
  messagesigner.cpp \
  random.cpp \
@ -851,17 +859,17 @@ bitcoin_bin_ldadd = \

 bitcoin_bin_ldadd += $(BACKTRACE_LIB) $(BOOST_LIBS) $(BDB_LIBS) $(MINIUPNPC_LIBS) $(NATPMP_LIBS) $(SQLITE_LIBS) $(EVENT_PTHREADS_LIBS) $(EVENT_LIBS) $(ZMQ_LIBS) $(GMP_LIBS)

-dashd_SOURCES = $(bitcoin_daemon_sources)
+dashd_SOURCES = $(bitcoin_daemon_sources) init/bitcoind.cpp
 dashd_CPPFLAGS = $(bitcoin_bin_cppflags)
 dashd_CXXFLAGS = $(bitcoin_bin_cxxflags)
 dashd_LDFLAGS = $(bitcoin_bin_ldflags)
 dashd_LDADD = $(LIBBITCOIN_SERVER) $(bitcoin_bin_ldadd)

-dash_node_SOURCES = $(bitcoin_daemon_sources)
+dash_node_SOURCES = $(bitcoin_daemon_sources) init/bitcoin-node.cpp
 dash_node_CPPFLAGS = $(bitcoin_bin_cppflags)
 dash_node_CXXFLAGS = $(bitcoin_bin_cxxflags)
 dash_node_LDFLAGS = $(bitcoin_bin_ldflags)
-dash_node_LDADD = $(LIBBITCOIN_SERVER) $(bitcoin_bin_ldadd)
+dash_node_LDADD = $(LIBBITCOIN_SERVER) $(bitcoin_bin_ldadd) $(LIBBITCOIN_IPC) $(LIBMULTIPROCESS_LIBS)

 # dash-cli binary #
 dash_cli_SOURCES = bitcoin-cli.cpp
@ -1001,6 +1009,39 @@ endif
 osx_debug: $(bin_PROGRAMS)
 	for i in $(bin_PROGRAMS); do mkdir -p $$i.dSYM/Contents/Resources/DWARF && $(DSYMUTIL_FLAT) -o $$i.dSYM/Contents/Resources/DWARF/$$(basename $$i) $$i &> /dev/null ; done

+libbitcoin_ipc_mpgen_input = \
+  ipc/capnp/echo.capnp \
+  ipc/capnp/init.capnp
+EXTRA_DIST += $(libbitcoin_ipc_mpgen_input)
+%.capnp:
+
+if BUILD_MULTIPROCESS
+LIBBITCOIN_IPC=libbitcoin_ipc.a
+libbitcoin_ipc_a_SOURCES = \
+  ipc/capnp/init-types.h \
+  ipc/capnp/protocol.cpp \
+  ipc/capnp/protocol.h \
+  ipc/exception.h \
+  ipc/interfaces.cpp \
+  ipc/process.cpp \
+  ipc/process.h \
+  ipc/protocol.h
+libbitcoin_ipc_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
+libbitcoin_ipc_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS) $(LIBMULTIPROCESS_CFLAGS)
+
+include $(MPGEN_PREFIX)/include/mpgen.mk
+libbitcoin_ipc_mpgen_output = \
+  $(libbitcoin_ipc_mpgen_input:=.c++) \
+  $(libbitcoin_ipc_mpgen_input:=.h) \
+  $(libbitcoin_ipc_mpgen_input:=.proxy-client.c++) \
+  $(libbitcoin_ipc_mpgen_input:=.proxy-server.c++) \
+  $(libbitcoin_ipc_mpgen_input:=.proxy-types.c++) \
+  $(libbitcoin_ipc_mpgen_input:=.proxy-types.h) \
+  $(libbitcoin_ipc_mpgen_input:=.proxy.h)
+nodist_libbitcoin_ipc_a_SOURCES = $(libbitcoin_ipc_mpgen_output)
+CLEANFILES += $(libbitcoin_ipc_mpgen_output)
+endif
+
 include Makefile.crc32c.include
 include Makefile.leveldb.include
 include Makefile.test_util.include
--- a/src/bitcoind.cpp
+++ b/src/bitcoind.cpp
@ -13,6 +13,7 @@
 #include <compat.h>
 #include <init.h>
 #include <interfaces/chain.h>
+#include <interfaces/init.h>
 #include <node/context.h>
 #include <node/ui_interface.h>
 #include <noui.h>
@ -109,10 +110,8 @@ int fork_daemon(bool nochdir, bool noclose, TokenPipeEnd& endpoint)

 #endif

-static bool AppInit(int argc, char* argv[])
+static bool AppInit(NodeContext& node, int argc, char* argv[])
 {
-    NodeContext node;
-
    bool fRet = false;

    util::ThreadSetInternalName("init");
@ -264,10 +263,18 @@ MAIN_FUNCTION
    util::WinCmdLineArgs winArgs;
    std::tie(argc, argv) = winArgs.get();
 #endif
+
+    NodeContext node;
+    int exit_status;
+    std::unique_ptr<interfaces::Init> init = interfaces::MakeNodeInit(node, argc, argv, exit_status);
+    if (!init) {
+        return exit_status;
+    }
+
    SetupEnvironment();

    // Connect dashd signal handlers
    noui_connect();

-    return (AppInit(argc, argv) ? EXIT_SUCCESS : EXIT_FAILURE);
+    return (AppInit(node, argc, argv) ? EXIT_SUCCESS : EXIT_FAILURE);
 }
--- a/src/init.cpp
+++ b/src/init.cpp
@ -721,7 +721,7 @@ void SetupServerArgs(NodeContext& node)
    argsman.AddArg("-disablegovernance", strprintf("Disable governance validation (0-1, default: %u)", 0), ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
    argsman.AddArg("-maxsigcachesize=<n>", strprintf("Limit sum of signature cache and script execution cache sizes to <n> MiB (default: %u)", DEFAULT_MAX_SIG_CACHE_SIZE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
    argsman.AddArg("-maxtipage=<n>", strprintf("Maximum tip age in seconds to consider node in initial block download (default: %u)", DEFAULT_MAX_TIP_AGE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
-    argsman.AddArg("-mocktime=<n>", "Replace actual time with " + UNIX_EPOCH_TIME + "(default: 0)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
+    argsman.AddArg("-mocktime=<n>", "Replace actual time with " + UNIX_EPOCH_TIME + " (default: 0)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
    argsman.AddArg("-minsporkkeys=<n>", "Overrides minimum spork signers to change spork value. Only useful for regtest and devnet. Using this on mainnet or testnet will ban you.", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
    argsman.AddArg("-printpriority", strprintf("Log transaction fee per kB when mining blocks (default: %u)", DEFAULT_PRINTPRIORITY), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
    argsman.AddArg("-pushversion", "Protocol version to report to other nodes", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
--- a/src/init/bitcoin-node.cpp
+++ b/src/init/bitcoin-node.cpp
@ -0,0 +1,45 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <interfaces/echo.h>
+#include <interfaces/init.h>
+#include <interfaces/ipc.h>
+#include <node/context.h>
+
+#include <memory>
+
+namespace init {
+namespace {
+const char* EXE_NAME = "dash-node";
+
+class BitcoinNodeInit : public interfaces::Init
+{
+public:
+    BitcoinNodeInit(NodeContext& node, const char* arg0)
+        : m_node(node),
+          m_ipc(interfaces::MakeIpc(EXE_NAME, arg0, *this))
+    {
+        m_node.init = this;
+    }
+    std::unique_ptr<interfaces::Echo> makeEcho() override { return interfaces::MakeEcho(); }
+    interfaces::Ipc* ipc() override { return m_ipc.get(); }
+    NodeContext& m_node;
+    std::unique_ptr<interfaces::Ipc> m_ipc;
+};
+} // namespace
+} // namespace init
+
+namespace interfaces {
+std::unique_ptr<Init> MakeNodeInit(NodeContext& node, int argc, char* argv[], int& exit_status)
+{
+    auto init = std::make_unique<init::BitcoinNodeInit>(node, argc > 0 ? argv[0] : "");
+    // Check if bitcoin-node is being invoked as an IPC server. If so, then
+    // bypass normal execution and just respond to requests over the IPC
+    // channel and return null.
+    if (init->m_ipc->startSpawnedProcess(argc, argv, exit_status)) {
+        return nullptr;
+    }
+    return init;
+}
+} // namespace interfaces
--- a/src/init/bitcoind.cpp
+++ b/src/init/bitcoind.cpp
@ -0,0 +1,29 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <interfaces/init.h>
+#include <node/context.h>
+
+#include <memory>
+
+namespace init {
+namespace {
+class BitcoindInit : public interfaces::Init
+{
+public:
+    BitcoindInit(NodeContext& node) : m_node(node)
+    {
+        m_node.init = this;
+    }
+    NodeContext& m_node;
+};
+} // namespace
+} // namespace init
+
+namespace interfaces {
+std::unique_ptr<Init> MakeNodeInit(NodeContext& node, int argc, char* argv[], int& exit_status)
+{
+    return std::make_unique<init::BitcoindInit>(node);
+}
+} // namespace interfaces
--- a/src/init/common.cpp
+++ b/src/init/common.cpp
@ -12,7 +12,6 @@
 #include <key.h>
 #include <logging.h>
 #include <node/ui_interface.h>
-#include <pubkey.h>
 #include <random.h>
 #include <util/system.h>
 #include <util/time.h>
--- a/src/interfaces/README.md
+++ b/src/interfaces/README.md
@ -12,6 +12,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 [#10102](https://github.com/bitcoin/bitcoin/pull/10102).
+* [`Init`](init.h) — used by multiprocess code to access interfaces above on startup. Added in [#6143](https://github.com/dashpay/dash/pull/6143).

-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.
+* [`Ipc`](ipc.h) — used by multiprocess code to access `Init` interface across processes. Added in [#6143](https://github.com/dashpay/dash/pull/6143).
+
+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.
--- a/src/interfaces/echo.cpp
+++ b/src/interfaces/echo.cpp
@ -0,0 +1,18 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <interfaces/echo.h>
+
+#include <memory>
+
+namespace interfaces {
+namespace {
+class EchoImpl : public Echo
+{
+public:
+    std::string echo(const std::string& echo) override { return echo; }
+};
+} // namespace
+std::unique_ptr<Echo> MakeEcho() { return std::make_unique<EchoImpl>(); }
+} // namespace interfaces
--- a/src/interfaces/echo.h
+++ b/src/interfaces/echo.h
@ -0,0 +1,26 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_INTERFACES_ECHO_H
+#define BITCOIN_INTERFACES_ECHO_H
+
+#include <memory>
+#include <string>
+
+namespace interfaces {
+//! Simple string echoing interface for testing.
+class Echo
+{
+public:
+    virtual ~Echo() {}
+
+    //! Echo provided string.
+    virtual std::string echo(const std::string& echo) = 0;
+};
+
+//! Return implementation of Echo interface.
+std::unique_ptr<Echo> MakeEcho();
+} // namespace interfaces
+
+#endif // BITCOIN_INTERFACES_ECHO_H
--- a/src/interfaces/init.cpp
+++ b/src/interfaces/init.cpp
@ -0,0 +1,17 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <interfaces/chain.h>
+#include <interfaces/echo.h>
+#include <interfaces/init.h>
+#include <interfaces/node.h>
+#include <interfaces/wallet.h>
+
+namespace interfaces {
+std::unique_ptr<Node> Init::makeNode() { return {}; }
+std::unique_ptr<Chain> Init::makeChain() { return {}; }
+std::unique_ptr<WalletLoader> Init::makeWalletLoader(Chain& chain) { return {}; }
+std::unique_ptr<Echo> Init::makeEcho() { return {}; }
+Ipc* Init::ipc() { return nullptr; }
+} // namespace interfaces
--- a/src/interfaces/init.h
+++ b/src/interfaces/init.h
@ -0,0 +1,52 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_INTERFACES_INIT_H
+#define BITCOIN_INTERFACES_INIT_H
+
+#include <memory>
+
+struct NodeContext;
+
+namespace interfaces {
+class Chain;
+class Echo;
+class Ipc;
+class Node;
+class WalletLoader;
+
+//! Initial interface created when a process is first started, and used to give
+//! and get access to other interfaces (Node, Chain, Wallet, etc).
+//!
+//! There is a different Init interface implementation for each process
+//! (bitcoin-gui, bitcoin-node, bitcoin-wallet, bitcoind, bitcoin-qt) and each
+//! implementation can implement the make methods for interfaces it supports.
+//! The default make methods all return null.
+class Init
+{
+public:
+    virtual ~Init() = default;
+    virtual std::unique_ptr<Node> makeNode();
+    virtual std::unique_ptr<Chain> makeChain();
+    virtual std::unique_ptr<WalletLoader> makeWalletLoader(Chain& chain);
+    virtual std::unique_ptr<Echo> makeEcho();
+    virtual Ipc* ipc();
+};
+
+//! Return implementation of Init interface for the node process. If the argv
+//! indicates that this is a child process spawned to handle requests from a
+//! parent process, this blocks and handles requests, then returns null and a
+//! status code to exit with. If this returns non-null, the caller can start up
+//! normally and use the Init object to spawn and connect to other processes
+//! while it is running.
+std::unique_ptr<Init> MakeNodeInit(NodeContext& node, int argc, char* argv[], int& exit_status);
+
+//! Return implementation of Init interface for the wallet process.
+std::unique_ptr<Init> MakeWalletInit(int argc, char* argv[], int& exit_status);
+
+//! Return implementation of Init interface for the gui process.
+std::unique_ptr<Init> MakeGuiInit(int argc, char* argv[]);
+} // namespace interfaces
+
+#endif // BITCOIN_INTERFACES_INIT_H
--- a/src/interfaces/ipc.h
+++ b/src/interfaces/ipc.h
@ -0,0 +1,71 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_INTERFACES_IPC_H
+#define BITCOIN_INTERFACES_IPC_H
+
+#include <functional>
+#include <memory>
+#include <typeindex>
+
+namespace interfaces {
+class Init;
+
+//! Interface providing access to interprocess-communication (IPC)
+//! functionality. The IPC implementation is responsible for establishing
+//! connections between a controlling process and a process being controlled.
+//! When a connection is established, the process being controlled returns an
+//! interfaces::Init pointer to the controlling process, which the controlling
+//! process can use to get access to other interfaces and functionality.
+//!
+//! When spawning a new process, the steps are:
+//!
+//! 1. The controlling process calls interfaces::Ipc::spawnProcess(), which
+//!    calls ipc::Process::spawn(), which spawns a new process and returns a
+//!    socketpair file descriptor for communicating with it.
+//!    interfaces::Ipc::spawnProcess() then calls ipc::Protocol::connect()
+//!    passing the socketpair descriptor, which returns a local proxy
+//!    interfaces::Init implementation calling remote interfaces::Init methods.
+//! 2. The spawned process calls interfaces::Ipc::startSpawnProcess(), which
+//!    calls ipc::Process::checkSpawned() to read command line arguments and
+//!    determine whether it is a spawned process and what socketpair file
+//!    descriptor it should use. It then calls ipc::Protocol::serve() to handle
+//!    incoming requests from the socketpair and invoke interfaces::Init
+//!    interface methods, and exit when the socket is closed.
+//! 3. The controlling process calls local proxy interfaces::Init object methods
+//!    to make other proxy objects calling other remote interfaces. It can also
+//!    destroy the initial interfaces::Init object to close the connection and
+//!    shut down the spawned process.
+class Ipc
+{
+public:
+    virtual ~Ipc() = default;
+
+    //! Spawn a child process returning pointer to its Init interface.
+    virtual std::unique_ptr<Init> spawnProcess(const char* exe_name) = 0;
+
+    //! If this is a spawned process, block and handle requests from the parent
+    //! process by forwarding them to this process's Init interface, then return
+    //! true. If this is not a spawned child process, return false.
+    virtual bool startSpawnedProcess(int argc, char* argv[], int& exit_status) = 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));
+    }
+
+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.
+std::unique_ptr<Ipc> MakeIpc(const char* exe_name, const char* process_argv0, Init& init);
+} // namespace interfaces
+
+#endif // BITCOIN_INTERFACES_IPC_H
--- a/src/ipc/capnp/.gitignore
+++ b/src/ipc/capnp/.gitignore
@ -0,0 +1,2 @@
+# capnp generated files
+*.capnp.*
--- a/src/ipc/capnp/echo.capnp
+++ b/src/ipc/capnp/echo.capnp
@ -0,0 +1,17 @@
+# Copyright (c) 2021 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+@0x888b4f7f51e691f7;
+
+using Cxx = import "/capnp/c++.capnp";
+$Cxx.namespace("ipc::capnp::messages");
+
+using Proxy = import "/mp/proxy.capnp";
+$Proxy.include("interfaces/echo.h");
+$Proxy.include("ipc/capnp/echo.capnp.h");
+
+interface Echo $Proxy.wrap("interfaces::Echo") {
+    destroy @0 (context :Proxy.Context) -> ();
+    echo @1 (context :Proxy.Context, echo: Text) -> (result :Text);
+}
--- a/src/ipc/capnp/init-types.h
+++ b/src/ipc/capnp/init-types.h
@ -0,0 +1,10 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_IPC_CAPNP_INIT_TYPES_H
+#define BITCOIN_IPC_CAPNP_INIT_TYPES_H
+
+#include <ipc/capnp/echo.capnp.proxy-types.h>
+
+#endif // BITCOIN_IPC_CAPNP_INIT_TYPES_H
--- a/src/ipc/capnp/init.capnp
+++ b/src/ipc/capnp/init.capnp
@ -0,0 +1,20 @@
+# Copyright (c) 2021 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+@0xf2c5cfa319406aa6;
+
+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.includeTypes("ipc/capnp/init-types.h");
+
+using Echo = import "echo.capnp";
+
+interface Init $Proxy.wrap("interfaces::Init") {
+    construct @0 (threadMap: Proxy.ThreadMap) -> (threadMap :Proxy.ThreadMap);
+    makeEcho @1 (context :Proxy.Context) -> (result :Echo.Echo);
+}
--- a/src/ipc/capnp/protocol.cpp
+++ b/src/ipc/capnp/protocol.cpp
@ -0,0 +1,90 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <interfaces/init.h>
+#include <ipc/capnp/init.capnp.h>
+#include <ipc/capnp/init.capnp.proxy.h>
+#include <ipc/capnp/protocol.h>
+#include <ipc/exception.h>
+#include <ipc/protocol.h>
+#include <kj/async.h>
+#include <logging.h>
+#include <mp/proxy-io.h>
+#include <mp/proxy-types.h>
+#include <mp/util.h>
+#include <util/threadnames.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <future>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <thread>
+
+namespace ipc {
+namespace capnp {
+namespace {
+void IpcLogFn(bool raise, std::string message)
+{
+    LogPrint(BCLog::IPC, "%s\n", message);
+    if (raise) throw Exception(message);
+}
+
+class CapnpProtocol : public Protocol
+{
+public:
+    ~CapnpProtocol() noexcept(true)
+    {
+        if (m_loop) {
+            std::unique_lock<std::mutex> lock(m_loop->m_mutex);
+            m_loop->removeClient(lock);
+        }
+        if (m_loop_thread.joinable()) m_loop_thread.join();
+        assert(!m_loop);
+    };
+    std::unique_ptr<interfaces::Init> connect(int fd, const char* exe_name) override
+    {
+        startLoop(exe_name);
+        return mp::ConnectStream<messages::Init>(*m_loop, fd);
+    }
+    void serve(int fd, const char* exe_name, interfaces::Init& init) override
+    {
+        assert(!m_loop);
+        mp::g_thread_context.thread_name = mp::ThreadName(exe_name);
+        m_loop.emplace(exe_name, &IpcLogFn, nullptr);
+        mp::ServeStream<messages::Init>(*m_loop, fd, init);
+        m_loop->loop();
+        m_loop.reset();
+    }
+    void addCleanup(std::type_index type, void* iface, std::function<void()> cleanup) override
+    {
+        mp::ProxyTypeRegister::types().at(type)(iface).cleanup.emplace_back(std::move(cleanup));
+    }
+    void startLoop(const char* exe_name)
+    {
+        if (m_loop) return;
+        std::promise<void> promise;
+        m_loop_thread = std::thread([&] {
+            util::ThreadRename("capnp-loop");
+            m_loop.emplace(exe_name, &IpcLogFn, nullptr);
+            {
+                std::unique_lock<std::mutex> lock(m_loop->m_mutex);
+                m_loop->addClient(lock);
+            }
+            promise.set_value();
+            m_loop->loop();
+            m_loop.reset();
+        });
+        promise.get_future().wait();
+    }
+    std::thread m_loop_thread;
+    std::optional<mp::EventLoop> m_loop;
+};
+} // namespace
+
+std::unique_ptr<Protocol> MakeCapnpProtocol() { return std::make_unique<CapnpProtocol>(); }
+} // namespace capnp
+} // namespace ipc
--- a/src/ipc/capnp/protocol.h
+++ b/src/ipc/capnp/protocol.h
@ -0,0 +1,17 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_IPC_CAPNP_PROTOCOL_H
+#define BITCOIN_IPC_CAPNP_PROTOCOL_H
+
+#include <memory>
+
+namespace ipc {
+class Protocol;
+namespace capnp {
+std::unique_ptr<Protocol> MakeCapnpProtocol();
+} // namespace capnp
+} // namespace ipc
+
+#endif // BITCOIN_IPC_CAPNP_PROTOCOL_H
--- a/src/ipc/exception.h
+++ b/src/ipc/exception.h
@ -0,0 +1,20 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_IPC_EXCEPTION_H
+#define BITCOIN_IPC_EXCEPTION_H
+
+#include <stdexcept>
+
+namespace ipc {
+//! Exception class thrown when a call to remote method fails due to an IPC
+//! error, like a socket getting disconnected.
+class Exception : public std::runtime_error
+{
+public:
+    using std::runtime_error::runtime_error;
+};
+} // namespace ipc
+
+#endif // BITCOIN_IPC_EXCEPTION_H
--- a/src/ipc/interfaces.cpp
+++ b/src/ipc/interfaces.cpp
@ -0,0 +1,77 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <fs.h>
+#include <interfaces/init.h>
+#include <interfaces/ipc.h>
+#include <ipc/capnp/protocol.h>
+#include <ipc/process.h>
+#include <ipc/protocol.h>
+#include <logging.h>
+#include <tinyformat.h>
+#include <util/system.h>
+
+#include <functional>
+#include <memory>
+#include <stdexcept>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <string>
+#include <unistd.h>
+#include <utility>
+#include <vector>
+
+namespace ipc {
+namespace {
+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())
+    {
+    }
+    std::unique_ptr<interfaces::Init> spawnProcess(const char* new_exe_name) override
+    {
+        int pid;
+        int fd = m_process->spawn(new_exe_name, m_process_argv0, pid);
+        LogPrint(::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] {
+            int status = m_process->waitSpawned(pid);
+            LogPrint(::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
+    {
+        exit_status = EXIT_FAILURE;
+        int32_t fd = -1;
+        if (!m_process->checkSpawned(argc, argv, fd)) {
+            return false;
+        }
+        m_protocol->serve(fd, m_exe_name, m_init);
+        exit_status = EXIT_SUCCESS;
+        return true;
+    }
+    void addCleanup(std::type_index type, void* iface, std::function<void()> cleanup) override
+    {
+        m_protocol->addCleanup(type, iface, std::move(cleanup));
+    }
+    const char* m_exe_name;
+    const char* m_process_argv0;
+    interfaces::Init& m_init;
+    std::unique_ptr<Protocol> m_protocol;
+    std::unique_ptr<Process> m_process;
+};
+} // namespace
+} // namespace ipc
+
+namespace interfaces {
+std::unique_ptr<Ipc> MakeIpc(const char* exe_name, const char* process_argv0, Init& init)
+{
+    return std::make_unique<ipc::IpcImpl>(exe_name, process_argv0, init);
+}
+} // namespace interfaces
--- a/src/ipc/process.cpp
+++ b/src/ipc/process.cpp
@ -0,0 +1,61 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <fs.h>
+#include <ipc/process.h>
+#include <ipc/protocol.h>
+#include <mp/util.h>
+#include <tinyformat.h>
+#include <util/strencodings.h>
+
+#include <cstdint>
+#include <exception>
+#include <iostream>
+#include <stdexcept>
+#include <stdlib.h>
+#include <string.h>
+#include <system_error>
+#include <unistd.h>
+#include <utility>
+#include <vector>
+
+namespace ipc {
+namespace {
+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.append(new_exe_name);
+            return std::vector<std::string>{path.string(), "-ipcfd", strprintf("%i", fd)};
+        });
+    }
+    int waitSpawned(int pid) override { return mp::WaitProcess(pid); }
+    bool checkSpawned(int argc, char* argv[], int& fd) override
+    {
+        // If this process was not started with a single -ipcfd argument, it is
+        // not a process spawned by the spawn() call above, so return false and
+        // do not try to serve requests.
+        if (argc != 3 || strcmp(argv[1], "-ipcfd") != 0) {
+            return false;
+        }
+        // If a single -ipcfd argument was provided, return true and get the
+        // file descriptor so Protocol::serve() can be called to handle
+        // requests from the parent process. The -ipcfd argument is not valid
+        // in combination with other arguments because the parent process
+        // should be able to control the child process through the IPC protocol
+        // without passing information out of band.
+        if (!ParseInt32(argv[2], &fd)) {
+            throw std::runtime_error(strprintf("Invalid -ipcfd number '%s'", argv[2]));
+        }
+        return true;
+    }
+};
+} // namespace
+
+std::unique_ptr<Process> MakeProcess() { return std::make_unique<ProcessImpl>(); }
+} // namespace ipc
--- a/src/ipc/process.h
+++ b/src/ipc/process.h
@ -0,0 +1,42 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_IPC_PROCESS_H
+#define BITCOIN_IPC_PROCESS_H
+
+#include <memory>
+#include <string>
+
+namespace ipc {
+class Protocol;
+
+//! IPC process interface for spawning bitcoin processes and serving requests
+//! in processes that have been spawned.
+//!
+//! There will be different implementations of this interface depending on the
+//! platform (e.g. unix, windows).
+class Process
+{
+public:
+    virtual ~Process() = default;
+
+    //! Spawn process and return socket file descriptor for communicating with
+    //! it.
+    virtual int spawn(const std::string& new_exe_name, const fs::path& argv0_path, int& pid) = 0;
+
+    //! Wait for spawned process to exit and return its exit code.
+    virtual int waitSpawned(int pid) = 0;
+
+    //! Parse command line and determine if current process is a spawned child
+    //! process. If so, return true and a file descriptor for communicating
+    //! with the parent process.
+    virtual bool checkSpawned(int argc, char* argv[], int& fd) = 0;
+};
+
+//! Constructor for Process interface. Implementation will vary depending on
+//! the platform (unix or windows).
+std::unique_ptr<Process> MakeProcess();
+} // namespace ipc
+
+#endif // BITCOIN_IPC_PROCESS_H
--- a/src/ipc/protocol.h
+++ b/src/ipc/protocol.h
@ -0,0 +1,39 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_IPC_PROTOCOL_H
+#define BITCOIN_IPC_PROTOCOL_H
+
+#include <interfaces/init.h>
+
+#include <functional>
+#include <memory>
+#include <typeindex>
+
+namespace ipc {
+//! IPC protocol interface for calling IPC methods over sockets.
+//!
+//! There may be different implementations of this interface for different IPC
+//! protocols (e.g. Cap'n Proto, gRPC, JSON-RPC, or custom protocols).
+class Protocol
+{
+public:
+    virtual ~Protocol() = default;
+
+    //! Return Init interface that forwards requests over given socket descriptor.
+    //! Socket communication is handled on a background thread.
+    virtual std::unique_ptr<interfaces::Init> connect(int fd, const char* exe_name) = 0;
+
+    //! Handle requests on provided socket descriptor, forwarding them to the
+    //! provided Init interface. Socket communication is handled on the
+    //! current thread, and this call blocks until the socket is closed.
+    virtual void serve(int fd, const char* exe_name, interfaces::Init& init) = 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;
+};
+} // namespace ipc
+
+#endif // BITCOIN_IPC_PROTOCOL_H
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@ -138,7 +138,7 @@ PeerMsgRet CQuorumBlockProcessor::ProcessMessage(const CNode& peer, std::string_
    LogPrint(BCLog::LLMQ, "CQuorumBlockProcessor::%s -- received commitment for quorum %s:%d, validMembers=%d, signers=%d, peer=%d\n", __func__,
             qc.quorumHash.ToString(), ToUnderlying(qc.llmqType), qc.CountValidMembers(), qc.CountSigners(), peer.GetId());

-    AddMineableCommitment(qc);
+    AddMineableCommitmentAndRelay(qc);
    return {};
 }

@ -636,7 +636,7 @@ bool CQuorumBlockProcessor::HasMineableCommitment(const uint256& hash) const
    return minableCommitments.count(hash) != 0;
 }

-void CQuorumBlockProcessor::AddMineableCommitment(const CFinalCommitment& fqc)
+std::optional<uint256> CQuorumBlockProcessor::AddMineableCommitment(const CFinalCommitment& fqc)
 {
    const uint256 commitmentHash = ::SerializeHash(fqc);

@ -662,9 +662,15 @@ void CQuorumBlockProcessor::AddMineableCommitment(const CFinalCommitment& fqc)
        return false;
    }();

+    return relay ? std::make_optional(commitmentHash) : std::nullopt;
+}
+
+void CQuorumBlockProcessor::AddMineableCommitmentAndRelay(const CFinalCommitment& fqc)
+{
+    const auto commitmentHashOpt = AddMineableCommitment(fqc);
    // We only relay the new commitment if it's new or better then the old one
-    if (relay) {
-        CInv inv(MSG_QUORUM_FINAL_COMMITMENT, commitmentHash);
+    if (commitmentHashOpt) {
+        CInv inv(MSG_QUORUM_FINAL_COMMITMENT, *commitmentHashOpt);
        Assert(m_peerman)->RelayInv(inv);
    }
 }
--- a/src/llmq/blockprocessor.h
+++ b/src/llmq/blockprocessor.h
@ -59,7 +59,7 @@ public:
    bool ProcessBlock(const CBlock& block, gsl::not_null<const CBlockIndex*> pindex, BlockValidationState& state, bool fJustCheck, bool fBLSChecks) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    bool UndoBlock(const CBlock& block, gsl::not_null<const CBlockIndex*> pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

-    void AddMineableCommitment(const CFinalCommitment& fqc);
+    void AddMineableCommitmentAndRelay(const CFinalCommitment& fqc);
    bool HasMineableCommitment(const uint256& hash) const;
    bool GetMineableCommitmentByHash(const uint256& commitmentHash, CFinalCommitment& ret) const;
    std::optional<std::vector<CFinalCommitment>> GetMineableCommitments(const Consensus::LLMQParams& llmqParams, int nHeight) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
@ -74,6 +74,8 @@ public:
    std::vector<std::pair<int, const CBlockIndex*>> GetLastMinedCommitmentsPerQuorumIndexUntilBlock(Consensus::LLMQType llmqType, const CBlockIndex* pindex, size_t cycle) const;
    std::optional<const CBlockIndex*> GetLastMinedCommitmentsByQuorumIndexUntilBlock(Consensus::LLMQType llmqType, const CBlockIndex* pindex, int quorumIndex, size_t cycle) const;
 private:
+    //! it returns hash of commitment if it should be relay, otherwise nullopt
+    std::optional<uint256> AddMineableCommitment(const CFinalCommitment& fqc);
    static bool GetCommitmentsFromBlock(const CBlock& block, gsl::not_null<const CBlockIndex*> pindex, std::multimap<Consensus::LLMQType, CFinalCommitment>& ret, BlockValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    bool ProcessCommitment(int nHeight, const uint256& blockHash, const CFinalCommitment& qc, BlockValidationState& state, bool fJustCheck, bool fBLSChecks) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    static bool IsMiningPhase(const Consensus::LLMQParams& llmqParams, const CChain& active_chain, int nHeight) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
--- a/src/llmq/dkgsessionhandler.cpp
+++ b/src/llmq/dkgsessionhandler.cpp
@ -570,7 +570,7 @@ void CDKGSessionHandler::HandleDKGRound()

    auto finalCommitments = curSession->FinalizeCommitments();
    for (const auto& fqc : finalCommitments) {
-        quorumBlockProcessor.AddMineableCommitment(fqc);
+        quorumBlockProcessor.AddMineableCommitmentAndRelay(fqc);
    }
 }

--- a/src/logging.cpp
+++ b/src/logging.cpp
@ -159,6 +159,7 @@ const CLogCategoryDesc LogCategories[] =
    {BCLog::LEVELDB, "leveldb"},
    {BCLog::VALIDATION, "validation"},
    {BCLog::I2P, "i2p"},
+    {BCLog::IPC, "ipc"},
    {BCLog::LOCK, "lock"},
    {BCLog::ALL, "1"},
    {BCLog::ALL, "all"},
--- a/src/logging.h
+++ b/src/logging.h
@ -60,6 +60,7 @@ namespace BCLog {
        LEVELDB     = (1 << 20),
        VALIDATION  = (1 << 21),
        I2P         = (1 << 22),
+        IPC         = (1 << 23),
        LOCK        = (1 << 24),

        //Start Dash
--- a/src/net.cpp
+++ b/src/net.cpp
@ -1562,21 +1562,11 @@ void CConnman::DisconnectNodes()
        for (auto it = m_nodes_disconnected.begin(); it != m_nodes_disconnected.end(); )
        {
            CNode* pnode = *it;
-            // wait until threads are done using it
-            bool fDelete = false;
+            // Destroy the object only after other threads have stopped using it.
            if (pnode->GetRefCount() <= 0) {
-                {
-                    TRY_LOCK(pnode->cs_vSend, lockSend);
-                    if (lockSend) {
-                        fDelete = true;
-                    }
-                }
-                if (fDelete) {
-                    it = m_nodes_disconnected.erase(it);
-                    DeleteNode(pnode);
-                }
-            }
-            if (!fDelete) {
+                it = m_nodes_disconnected.erase(it);
+                DeleteNode(pnode);
+            } else {
                ++it;
            }
        }
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@ -5824,7 +5824,7 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
        //
        std::vector<CInv> vInv;
        {
-            LOCK2(m_mempool.cs, peer->m_block_inv_mutex);
+            LOCK(peer->m_block_inv_mutex);

            size_t reserve = INVENTORY_BROADCAST_MAX_PER_1MB_BLOCK * MaxBlockSize() / 1000000;
            if (!pto->IsBlockOnlyConn()) {
@ -5844,155 +5844,154 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                }
            }
            peer->m_blocks_for_inv_relay.clear();
+        }

-            auto queueAndMaybePushInv = [this, pto, peer, &vInv, &msgMaker](const CInv& invIn) {
-                AssertLockHeld(peer->m_tx_relay->m_tx_inventory_mutex);
-                peer->m_tx_relay->m_tx_inventory_known_filter.insert(invIn.hash);
-                LogPrint(BCLog::NET, "SendMessages -- queued inv: %s  index=%d peer=%d\n", invIn.ToString(), vInv.size(), pto->GetId());
-                // Responses to MEMPOOL requests bypass the m_recently_announced_invs filter.
-                vInv.push_back(invIn);
-                if (vInv.size() == MAX_INV_SZ) {
-                    LogPrint(BCLog::NET, "SendMessages -- pushing invs: count=%d peer=%d\n", vInv.size(), pto->GetId());
-                    m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::INV, vInv));
-                    vInv.clear();
+        auto queueAndMaybePushInv = [this, pto, peer, &vInv, &msgMaker](const CInv& invIn) {
+            AssertLockHeld(peer->m_tx_relay->m_tx_inventory_mutex);
+            peer->m_tx_relay->m_tx_inventory_known_filter.insert(invIn.hash);
+            LogPrint(BCLog::NET, "SendMessages -- queued inv: %s  index=%d peer=%d\n", invIn.ToString(), vInv.size(), pto->GetId());
+            // Responses to MEMPOOL requests bypass the m_recently_announced_invs filter.
+            vInv.push_back(invIn);
+            if (vInv.size() == MAX_INV_SZ) {
+                LogPrint(BCLog::NET, "SendMessages -- pushing invs: count=%d peer=%d\n", vInv.size(), pto->GetId());
+                m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::INV, vInv));
+                vInv.clear();
+            }
+        };
+
+        if (!pto->IsBlockOnlyConn()) {
+            LOCK(peer->m_tx_relay->m_tx_inventory_mutex);
+            // Check whether periodic sends should happen
+            // Note: If this node is running in a Masternode mode, it makes no sense to delay outgoing txes
+            // because we never produce any txes ourselves i.e. no privacy is lost in this case.
+            bool fSendTrickle = pto->HasPermission(NetPermissionFlags::NoBan) || is_masternode;
+            if (peer->m_tx_relay->m_next_inv_send_time < current_time) {
+                fSendTrickle = true;
+                if (pto->IsInboundConn()) {
+                    peer->m_tx_relay->m_next_inv_send_time = m_connman.PoissonNextSendInbound(current_time, INBOUND_INVENTORY_BROADCAST_INTERVAL);
+                } else {
+                    // Use half the delay for Masternode outbound peers, as there is less privacy concern for them.
+                    peer->m_tx_relay->m_next_inv_send_time = pto->GetVerifiedProRegTxHash().IsNull() ?
+                                                     PoissonNextSend(current_time, OUTBOUND_INVENTORY_BROADCAST_INTERVAL) :
+                                                     PoissonNextSend(current_time, OUTBOUND_INVENTORY_BROADCAST_INTERVAL / 2);
                }
-            };
+            }

-            if (!pto->IsBlockOnlyConn()) {
-                LOCK(peer->m_tx_relay->m_tx_inventory_mutex);
-                // Check whether periodic sends should happen
-                // Note: If this node is running in a Masternode mode, it makes no sense to delay outgoing txes
-                // because we never produce any txes ourselves i.e. no privacy is lost in this case.
-                bool fSendTrickle = pto->HasPermission(NetPermissionFlags::NoBan) || is_masternode;
-                if (peer->m_tx_relay->m_next_inv_send_time < current_time) {
-                    fSendTrickle = true;
-                    if (pto->IsInboundConn()) {
-                        peer->m_tx_relay->m_next_inv_send_time = m_connman.PoissonNextSendInbound(current_time, INBOUND_INVENTORY_BROADCAST_INTERVAL);
-                    } else {
-                        // Use half the delay for Masternode outbound peers, as there is less privacy concern for them.
-                        peer->m_tx_relay->m_next_inv_send_time = pto->GetVerifiedProRegTxHash().IsNull() ?
-                                                         PoissonNextSend(current_time, OUTBOUND_INVENTORY_BROADCAST_INTERVAL) :
-                                                         PoissonNextSend(current_time, OUTBOUND_INVENTORY_BROADCAST_INTERVAL / 2);
-                    }
+            // Time to send but the peer has requested we not relay transactions.
+            if (fSendTrickle) {
+                LOCK(peer->m_tx_relay->m_bloom_filter_mutex);
+                if (!peer->m_tx_relay->m_relay_txs) peer->m_tx_relay->m_tx_inventory_to_send.clear();
+            }
+
+            // Respond to BIP35 mempool requests
+            if (fSendTrickle && peer->m_tx_relay->m_send_mempool) {
+                auto vtxinfo = m_mempool.infoAll();
+                peer->m_tx_relay->m_send_mempool = false;
+
+                LOCK(peer->m_tx_relay->m_bloom_filter_mutex);
+
+                // Send invs for txes and corresponding IS-locks
+                for (const auto& txinfo : vtxinfo) {
+                    const uint256& hash = txinfo.tx->GetHash();
+                    peer->m_tx_relay->m_tx_inventory_to_send.erase(hash);
+                    if (peer->m_tx_relay->m_bloom_filter && !peer->m_tx_relay->m_bloom_filter->IsRelevantAndUpdate(*txinfo.tx)) continue;
+
+                    int nInvType = m_cj_ctx->dstxman->GetDSTX(hash) ? MSG_DSTX : MSG_TX;
+                    queueAndMaybePushInv(CInv(nInvType, hash));
+
+                    const auto islock = m_llmq_ctx->isman->GetInstantSendLockByTxid(hash);
+                    if (islock == nullptr) continue;
+                    if (pto->nVersion < ISDLOCK_PROTO_VERSION) continue;
+                    queueAndMaybePushInv(CInv(MSG_ISDLOCK, ::SerializeHash(*islock)));
                }

-                // Time to send but the peer has requested we not relay transactions.
-                if (fSendTrickle) {
-                    LOCK(peer->m_tx_relay->m_bloom_filter_mutex);
-                    if (!peer->m_tx_relay->m_relay_txs) peer->m_tx_relay->m_tx_inventory_to_send.clear();
+                // Send an inv for the best ChainLock we have
+                const auto& clsig = m_llmq_ctx->clhandler->GetBestChainLock();
+                if (!clsig.IsNull()) {
+                    uint256 chainlockHash = ::SerializeHash(clsig);
+                    queueAndMaybePushInv(CInv(MSG_CLSIG, chainlockHash));
                }
+                peer->m_tx_relay->m_last_mempool_req = std::chrono::duration_cast<std::chrono::seconds>(current_time);
+            }

-                // Respond to BIP35 mempool requests
-                if (fSendTrickle && peer->m_tx_relay->m_send_mempool) {
-                    auto vtxinfo = m_mempool.infoAll();
-                    peer->m_tx_relay->m_send_mempool = false;
+            // Determine transactions to relay
+            if (fSendTrickle) {
+                LOCK(peer->m_tx_relay->m_bloom_filter_mutex);

-                    LOCK(peer->m_tx_relay->m_bloom_filter_mutex);
-
-                    // Send invs for txes and corresponding IS-locks
-                    for (const auto& txinfo : vtxinfo) {
-                        const uint256& hash = txinfo.tx->GetHash();
-                        peer->m_tx_relay->m_tx_inventory_to_send.erase(hash);
-                        if (peer->m_tx_relay->m_bloom_filter && !peer->m_tx_relay->m_bloom_filter->IsRelevantAndUpdate(*txinfo.tx)) continue;
-
-                        int nInvType = m_cj_ctx->dstxman->GetDSTX(hash) ? MSG_DSTX : MSG_TX;
-                        queueAndMaybePushInv(CInv(nInvType, hash));
-
-                        const auto islock = m_llmq_ctx->isman->GetInstantSendLockByTxid(hash);
-                        if (islock == nullptr) continue;
-                        if (pto->nVersion < ISDLOCK_PROTO_VERSION) continue;
-                        queueAndMaybePushInv(CInv(MSG_ISDLOCK, ::SerializeHash(*islock)));
-                    }
-
-                    // Send an inv for the best ChainLock we have
-                    const auto& clsig = m_llmq_ctx->clhandler->GetBestChainLock();
-                    if (!clsig.IsNull()) {
-                        uint256 chainlockHash = ::SerializeHash(clsig);
-                        queueAndMaybePushInv(CInv(MSG_CLSIG, chainlockHash));
-                    }
-                    peer->m_tx_relay->m_last_mempool_req = std::chrono::duration_cast<std::chrono::seconds>(current_time);
+                // Produce a vector with all candidates for sending
+                std::vector<std::set<uint256>::iterator> vInvTx;
+                vInvTx.reserve(peer->m_tx_relay->m_tx_inventory_to_send.size());
+                for (std::set<uint256>::iterator it = peer->m_tx_relay->m_tx_inventory_to_send.begin(); it != peer->m_tx_relay->m_tx_inventory_to_send.end(); it++) {
+                    vInvTx.push_back(it);
                }
+                // Topologically and fee-rate sort the inventory we send for privacy and priority reasons.
+                // A heap is used so that not all items need sorting if only a few are being sent.
+                CompareInvMempoolOrder compareInvMempoolOrder(&m_mempool);
+                std::make_heap(vInvTx.begin(), vInvTx.end(), compareInvMempoolOrder);
+                // No reason to drain out at many times the network's capacity,
+                // especially since we have many peers and some will draw much shorter delays.
+                unsigned int nRelayedTransactions = 0;
+                size_t broadcast_max{INVENTORY_BROADCAST_MAX_PER_1MB_BLOCK * MaxBlockSize() / 1000000 + (peer->m_tx_relay->m_tx_inventory_to_send.size()/1000)*5};
+                broadcast_max = std::min<size_t>(1000, broadcast_max);

-                // Determine transactions to relay
-                if (fSendTrickle) {
-                    LOCK(peer->m_tx_relay->m_bloom_filter_mutex);
-
-                    // Produce a vector with all candidates for sending
-                    std::vector<std::set<uint256>::iterator> vInvTx;
-                    vInvTx.reserve(peer->m_tx_relay->m_tx_inventory_to_send.size());
-                    for (std::set<uint256>::iterator it = peer->m_tx_relay->m_tx_inventory_to_send.begin(); it != peer->m_tx_relay->m_tx_inventory_to_send.end(); it++) {
-                        vInvTx.push_back(it);
+                while (!vInvTx.empty() && nRelayedTransactions < broadcast_max) {
+                    // Fetch the top element from the heap
+                    std::pop_heap(vInvTx.begin(), vInvTx.end(), compareInvMempoolOrder);
+                    std::set<uint256>::iterator it = vInvTx.back();
+                    vInvTx.pop_back();
+                    uint256 hash = *it;
+                    // Remove it from the to-be-sent set
+                    peer->m_tx_relay->m_tx_inventory_to_send.erase(it);
+                    // Check if not in the filter already
+                    if (peer->m_tx_relay->m_tx_inventory_known_filter.contains(hash)) {
+                        continue;
                    }
-                    // Topologically and fee-rate sort the inventory we send for privacy and priority reasons.
-                    // A heap is used so that not all items need sorting if only a few are being sent.
-                    CompareInvMempoolOrder compareInvMempoolOrder(&m_mempool);
-                    std::make_heap(vInvTx.begin(), vInvTx.end(), compareInvMempoolOrder);
-                    // No reason to drain out at many times the network's capacity,
-                    // especially since we have many peers and some will draw much shorter delays.
-                    unsigned int nRelayedTransactions = 0;
-                    size_t broadcast_max{INVENTORY_BROADCAST_MAX_PER_1MB_BLOCK * MaxBlockSize() / 1000000 + (peer->m_tx_relay->m_tx_inventory_to_send.size()/1000)*5};
-                    broadcast_max = std::min<size_t>(1000, broadcast_max);
-
-                    while (!vInvTx.empty() && nRelayedTransactions < broadcast_max) {
-                        // Fetch the top element from the heap
-                        std::pop_heap(vInvTx.begin(), vInvTx.end(), compareInvMempoolOrder);
-                        std::set<uint256>::iterator it = vInvTx.back();
-                        vInvTx.pop_back();
-                        uint256 hash = *it;
-                        // Remove it from the to-be-sent set
-                        peer->m_tx_relay->m_tx_inventory_to_send.erase(it);
-                        // Check if not in the filter already
-                        if (peer->m_tx_relay->m_tx_inventory_known_filter.contains(hash)) {
-                            continue;
-                        }
-                        // Not in the mempool anymore? don't bother sending it.
-                        auto txinfo = m_mempool.info(hash);
-                        if (!txinfo.tx) {
-                            continue;
-                        }
-                        if (peer->m_tx_relay->m_bloom_filter && !peer->m_tx_relay->m_bloom_filter->IsRelevantAndUpdate(*txinfo.tx)) continue;
-                        // Send
-                        State(pto->GetId())->m_recently_announced_invs.insert(hash);
-                        nRelayedTransactions++;
+                    // Not in the mempool anymore? don't bother sending it.
+                    auto txinfo = m_mempool.info(hash);
+                    if (!txinfo.tx) {
+                        continue;
+                    }
+                    if (peer->m_tx_relay->m_bloom_filter && !peer->m_tx_relay->m_bloom_filter->IsRelevantAndUpdate(*txinfo.tx)) continue;
+                    // Send
+                    State(pto->GetId())->m_recently_announced_invs.insert(hash);
+                    nRelayedTransactions++;
+                    {
+                        // Expire old relay messages
+                        while (!g_relay_expiration.empty() && g_relay_expiration.front().first < current_time)
                        {
-                            // Expire old relay messages
-                            while (!g_relay_expiration.empty() && g_relay_expiration.front().first < current_time)
-                            {
-                                mapRelay.erase(g_relay_expiration.front().second);
-                                g_relay_expiration.pop_front();
-                            }
-
-                            auto ret = mapRelay.emplace(hash, std::move(txinfo.tx));
-                            if (ret.second) {
-                                g_relay_expiration.emplace_back(current_time + RELAY_TX_CACHE_TIME, ret.first);
-                            }
+                            mapRelay.erase(g_relay_expiration.front().second);
+                            g_relay_expiration.pop_front();
+                        }
+
+                        auto ret = mapRelay.emplace(hash, std::move(txinfo.tx));
+                        if (ret.second) {
+                            g_relay_expiration.emplace_back(current_time + RELAY_TX_CACHE_TIME, ret.first);
                        }
-                        int nInvType = m_cj_ctx->dstxman->GetDSTX(hash) ? MSG_DSTX : MSG_TX;
-                        queueAndMaybePushInv(CInv(nInvType, hash));
                    }
+                    int nInvType = m_cj_ctx->dstxman->GetDSTX(hash) ? MSG_DSTX : MSG_TX;
+                    queueAndMaybePushInv(CInv(nInvType, hash));
                }
            }
+        }
+        {
+            // Send non-tx/non-block inventory items
+            LOCK2(peer->m_tx_relay->m_tx_inventory_mutex, peer->m_tx_relay->m_bloom_filter_mutex);

-            {
-                // Send non-tx/non-block inventory items
-                LOCK2(peer->m_tx_relay->m_tx_inventory_mutex, peer->m_tx_relay->m_bloom_filter_mutex);
+            bool fSendIS = peer->m_tx_relay->m_relay_txs && !pto->IsBlockRelayOnly();

-                bool fSendIS = peer->m_tx_relay->m_relay_txs && !pto->IsBlockRelayOnly();
-
-                for (const auto& inv : peer->m_tx_relay->vInventoryOtherToSend) {
-                    if (!peer->m_tx_relay->m_relay_txs && NetMessageViolatesBlocksOnly(inv.GetCommand())) {
-                        continue;
-                    }
-                    if (peer->m_tx_relay->m_tx_inventory_known_filter.contains(inv.hash)) {
-                        continue;
-                    }
-                    if (!fSendIS && inv.type == MSG_ISDLOCK) {
-                        continue;
-                    }
-                    queueAndMaybePushInv(inv);
+            for (const auto& inv : peer->m_tx_relay->vInventoryOtherToSend) {
+                if (!peer->m_tx_relay->m_relay_txs && NetMessageViolatesBlocksOnly(inv.GetCommand())) {
+                    continue;
                }
-                peer->m_tx_relay->vInventoryOtherToSend.clear();
+                if (peer->m_tx_relay->m_tx_inventory_known_filter.contains(inv.hash)) {
+                    continue;
+                }
+                if (!fSendIS && inv.type == MSG_ISDLOCK) {
+                    continue;
+                }
+                queueAndMaybePushInv(inv);
            }
+            peer->m_tx_relay->vInventoryOtherToSend.clear();
        }
        if (!vInv.empty())
            m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::INV, vInv));
--- a/src/node/context.h
+++ b/src/node/context.h
@ -36,6 +36,7 @@ struct LLMQContext;
 namespace interfaces {
 class Chain;
 class ChainClient;
+class Init;
 class WalletLoader;
 namespace CoinJoin {
 class Loader;
@ -53,6 +54,8 @@ class Loader;
 //! any member functions. It should just be a collection of references that can
 //! be used without pulling in unwanted dependencies or functionality.
 struct NodeContext {
+    //! Init interface for initializing current process and connecting to other processes.
+    interfaces::Init* init{nullptr};
    std::unique_ptr<AddrMan> addrman;
    std::unique_ptr<CConnman> connman;
    std::unique_ptr<CTxMemPool> mempool;
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@ -15,6 +15,9 @@
 #include <index/txindex.h>
 #include <init.h>
 #include <interfaces/chain.h>
+#include <interfaces/echo.h>
+#include <interfaces/init.h>
+#include <interfaces/ipc.h>
 #include <key_io.h>
 #include <net.h>
 #include <node/context.h>
@ -1465,6 +1468,43 @@ static RPCHelpMan getindexinfo()
 static RPCHelpMan echo() { return echo("echo"); }
 static RPCHelpMan echojson() { return echo("echojson"); }

+static RPCHelpMan echoipc()
+{
+    return RPCHelpMan{
+        "echoipc",
+        "\nEcho back the input argument, passing it through a spawned process in a multiprocess build.\n"
+        "This command is for testing.\n",
+        {{"arg", RPCArg::Type::STR, RPCArg::Optional::NO, "The string to echo",}},
+        RPCResult{RPCResult::Type::STR, "echo", "The echoed string."},
+        RPCExamples{HelpExampleCli("echo", "\"Hello world\"") +
+                    HelpExampleRpc("echo", "\"Hello world\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            std::unique_ptr<interfaces::Echo> echo;
+            if (interfaces::Ipc* ipc = Assert(EnsureAnyNodeContext(request.context).init)->ipc()) {
+                // Spawn a new bitcoin-node process and call makeEcho to get a
+                // client pointer to a interfaces::Echo instance running in
+                // that process. This is just for testing. A slightly more
+                // realistic test spawning a different executable instead of
+                // the same executable would add a new bitcoin-echo executable,
+                // and spawn bitcoin-echo below instead of bitcoin-node. But
+                // using bitcoin-node avoids the need to build and install a
+                // new executable just for this one test.
+                auto init = ipc->spawnProcess("dash-node");
+                echo = init->makeEcho();
+                ipc->addCleanup(*echo, [init = init.release()] { delete init; });
+            } else {
+                // IPC support is not available because this is a bitcoind
+                // process not a bitcoind-node process, so just create a local
+                // interfaces::Echo object and return it so the `echoipc` RPC
+                // method will work, and the python test calling `echoipc`
+                // can expect the same result.
+                echo = interfaces::MakeEcho();
+            }
+            return echo->echo(request.params[0].get_str());
+        },
+    };
+}
+
 void RegisterMiscRPCCommands(CRPCTable &t)
 {
 static const CRPCCommand commands[] =
@ -1499,6 +1539,7 @@ static const CRPCCommand commands[] =
    { "hidden",             &mockscheduler,           },
    { "hidden",             &echo,                    },
    { "hidden",             &echojson,                },
+    { "hidden",             &echoipc,                 },
    { "hidden",             &mnauth,                  },
 };
 // clang-format on
--- a/src/validation.h
+++ b/src/validation.h
@ -721,9 +721,6 @@ private:
    //! Mark a block as conflicting
    bool MarkConflictingBlock(BlockValidationState& state, CBlockIndex* pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

-    //! Mark a block as not having block data
-    void EraseBlockData(CBlockIndex* index) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-
    void CheckForkWarningConditions() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    void InvalidChainFound(CBlockIndex* pindexNew) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    void ConflictingChainFound(CBlockIndex* pindexNew) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
--- a/test/functional/rpc_misc.py
+++ b/test/functional/rpc_misc.py
@ -57,7 +57,7 @@ class RpcMiscTest(BitcoinTestFramework):
        self.log.info("test logging rpc and help")

        # Test logging RPC returns the expected number of logging categories.
-        assert_equal(len(node.logging()), 37)
+        assert_equal(len(node.logging()), 38)

        # Test toggling a logging category on/off/on with the logging RPC.
        assert_equal(node.logging()['qt'], True)
@ -75,6 +75,9 @@ class RpcMiscTest(BitcoinTestFramework):
        logging_help = self.nodes[0].help('logging')
        assert f"valid logging categories are: {categories}" in logging_help

+        self.log.info("test echoipc (testing spawned process in multiprocess build)")
+        assert_equal(node.echoipc("hello"), "hello")
+
        self.log.info("test getindexinfo")
        self.restart_node(0, ["-txindex=0"])
        # Without any indices running the RPC returns an empty object
--- a/test/lint/lint-include-guards.sh
+++ b/test/lint/lint-include-guards.sh
@ -15,7 +15,7 @@ REGEXP_EXCLUDE_FILES_WITH_PREFIX="src/(crypto/ctaes/|dashbls/|immer/|leveldb/|cr
 EXIT_CODE=0
 for HEADER_FILE in $(git ls-files -- "*.h" | grep -vE "^${REGEXP_EXCLUDE_FILES_WITH_PREFIX}")
 do
-    HEADER_ID_BASE=$(cut -f2- -d/ <<< "${HEADER_FILE}" | sed "s/\.h$//g" | tr / _ | tr "[:lower:]" "[:upper:]" | tr - _)
+    HEADER_ID_BASE=$(cut -f2- -d/ <<< "${HEADER_FILE}" | sed "s/\.h$//g" | tr / _ | tr - _ | tr "[:lower:]" "[:upper:]")
    HEADER_ID="${HEADER_ID_PREFIX}${HEADER_ID_BASE}${HEADER_ID_SUFFIX}"
    if [[ $(grep -cE "^#(ifndef|define) ${HEADER_ID}" "${HEADER_FILE}") != 2 ]]; then
        echo "${HEADER_FILE} seems to be missing the expected include guard:"
--- a/test/sanitizer_suppressions/tsan
+++ b/test/sanitizer_suppressions/tsan
@ -6,30 +6,12 @@
 # Data races from zmq namespace
 race:zmq::*

-# double locks (TODO fix)
-mutex:g_genesis_wait_mutex
-mutex:Interrupt
-mutex:CThreadInterrupt
-mutex:CConnman::Interrupt
-mutex:CConnman::WakeMessageHandler
-mutex:CConnman::ThreadOpenConnections
-mutex:CConnman::ThreadOpenAddedConnections
-mutex:CConnman::SocketHandler
-mutex:UpdateTip
-mutex:PeerLogicValidation::UpdatedBlockTip
-mutex:g_best_block_mutex
 # race (TODO fix)
-race:CConnman::WakeMessageHandler
-race:CConnman::ThreadMessageHandler
-race:fHaveGenesis
-race:ProcessNewBlock
-race:ThreadImport
 race:LoadWallet
 race:WalletBatch::WriteHDChain
 race:BerkeleyBatch
 race:BerkeleyDatabase
 race:DatabaseBatch
-race:leveldb::DBImpl::DeleteObsoleteFiles
 race:zmq::*
 race:bitcoin-qt
 # deadlock (TODO fix)
--- a/test/sanitizer_suppressions/ubsan
+++ b/test/sanitizer_suppressions/ubsan
@ -96,6 +96,7 @@ implicit-unsigned-integer-truncation:test/fuzz/crypto_diff_fuzz_chacha20.cpp
 # std::variant warning fixed in https://github.com/gcc-mirror/gcc/commit/074436cf8cdd2a9ce75cadd36deb8301f00e55b9
 implicit-unsigned-integer-truncation:std::__detail::__variant::_Variant_storage
 shift-base:xoroshiro128plusplus.h
+shift-base:nanobench.h
 shift-base:*/include/c++/
 shift-base:arith_uint256.cpp
 shift-base:crypto/