diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 434b5e16718e..4f54497acb36 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -19,7 +19,6 @@ concurrency:
 
 env:
   CI_FAILFAST_TEST_LEAVE_DANGLING: 1  # GHA does not care about dangling processes and setting this variable avoids killing the CI script itself on error
-  REPO_USE_WARP_RUNNERS: 'bitcoin/bitcoin' # Use warp runners for this repo, instead of falling back to the slow GHA runners
 
 defaults:
   run:
@@ -28,12 +27,16 @@ defaults:
     shell: bash
 
 jobs:
-  runners:
-    name: '[meta] determine runners'
-    runs-on: ubuntu-slim
-    outputs:
-      provider: ${{ steps.runners.outputs.provider }}
+  test-each-commit:
+    name: 'test ancestor commits'
+    runs-on: ${{ github.repository == 'bitcoin/bitcoin' && 'warp-ubuntu-latest-x64-8x' || 'ubuntu-latest' }}
+    env:
+      TEST_RUNNER_PORT_MIN: "14000"  # Use a larger port range to avoid colliding with other CI services.
+    if: github.event_name == 'pull_request' && github.event.pull_request.commits != 1
+    timeout-minutes: 360  # Use maximum time, see https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions#jobsjob_idtimeout-minutes.
     steps:
+      - name: Determine fetch depth
+        run: echo "FETCH_DEPTH=$((${{ github.event.pull_request.commits }} + 2))" >> "$GITHUB_ENV"
       - &ANNOTATION_PR_NUMBER
         name: Annotate with pull request number
         # This annotation is machine-readable and can be used to assign a check
@@ -44,28 +47,6 @@ jobs:
           if [ "${{ github.event_name }}" = "pull_request" ]; then
             echo "::notice title=debug_pull_request_number_str::${{ github.event.number }}"
           fi
-      - id: runners
-        run: |
-          if [[ "${REPO_USE_WARP_RUNNERS}" == "${{ github.repository }}" ]]; then
-            echo "provider=warp" >> "$GITHUB_OUTPUT"
-            echo "::notice title=Runner Selection::Using Warp Runners"
-          else
-            echo "provider=gha" >> "$GITHUB_OUTPUT"
-            echo "::notice title=Runner Selection::Using GitHub-hosted runners"
-          fi
-
-  test-each-commit:
-    name: 'test ancestor commits'
-    needs: runners
-    runs-on: ${{ needs.runners.outputs.provider == 'warp' && 'warp-ubuntu-latest-x64-8x' || 'ubuntu-latest' }}
-    env:
-      TEST_RUNNER_PORT_MIN: "14000"  # Use a larger port range to avoid colliding with other CI services.
-    if: github.event_name == 'pull_request' && github.event.pull_request.commits != 1
-    timeout-minutes: 360  # Use maximum time, see https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions#jobsjob_idtimeout-minutes.
-    steps:
-      - name: Determine fetch depth
-        run: echo "FETCH_DEPTH=$((${{ github.event.pull_request.commits }} + 2))" >> "$GITHUB_ENV"
-      - *ANNOTATION_PR_NUMBER
       - uses: actions/checkout@v6
         with:
           ref: ${{ github.event.pull_request.head.sha }}
@@ -324,8 +305,8 @@ jobs:
 
   windows-cross:
     name: 'Windows-cross to x86_64, ${{ matrix.crt }}'
-    needs: [runners, record-frozen-commit]
-    runs-on: ${{ needs.runners.outputs.provider == 'warp' && 'warp-ubuntu-latest-x64-4x' || 'ubuntu-latest' }}
+    needs: record-frozen-commit
+    runs-on: ${{ github.repository == 'bitcoin/bitcoin' && 'warp-ubuntu-latest-x64-4x' || 'ubuntu-latest' }}
     if: ${{ vars.SKIP_BRANCH_PUSH != 'true' || github.event_name == 'pull_request' }}
 
     strategy:
@@ -359,7 +340,7 @@ jobs:
         id: restore-cache
         uses: ./.github/actions/cache/restore
         with:
-          provider: ${{ needs.runners.outputs.provider }}
+          provider: ${{ github.repository == 'bitcoin/bitcoin' && 'warp' || 'gha' }}
 
       - name: Configure Docker
         uses: ./.github/actions/configure-docker
@@ -372,7 +353,7 @@ jobs:
       - name: Save caches
         uses: ./.github/actions/cache/save
         with:
-          provider: ${{ needs.runners.outputs.provider }}
+          provider: ${{ github.repository == 'bitcoin/bitcoin' && 'warp' || 'gha' }}
 
       - name: Upload built executables
         uses: actions/upload-artifact@v7
@@ -439,8 +420,7 @@ jobs:
 
   ci-matrix:
     name: ${{ matrix.name }}
-    needs: runners
-    runs-on: ${{ needs.runners.outputs.provider == 'warp' && matrix.warp-runner || matrix.fallback-runner }}
+    runs-on: ${{ github.repository == 'bitcoin/bitcoin' && matrix.warp-runner || matrix.fallback-runner }}
     if: ${{ vars.SKIP_BRANCH_PUSH != 'true' || github.event_name == 'pull_request' }}
     timeout-minutes: ${{ matrix.timeout-minutes }}
 
@@ -534,7 +514,7 @@ jobs:
           - name: 'MSan, fuzz'
             warp-runner: 'warp-ubuntu-latest-x64-8x'
             fallback-runner: 'ubuntu-latest'
-            timeout-minutes: 150
+            timeout-minutes: 180
             file-env: './ci/test/00_setup_env_native_fuzz_with_msan.sh'
 
           - name: 'MSan'
@@ -555,7 +535,7 @@ jobs:
         id: restore-cache
         uses: ./.github/actions/cache/restore
         with:
-          provider: ${{ matrix.provider || needs.runners.outputs.provider }}
+          provider: ${{ matrix.provider || (github.repository == 'bitcoin/bitcoin' && 'warp' || 'gha') }}
 
       - name: Configure Docker
         uses: ./.github/actions/configure-docker
@@ -563,7 +543,7 @@ jobs:
           provider: ${{ matrix.provider || needs.runners.outputs.provider }}
 
       - name: Clear unnecessary files
-        if: ${{ needs.runners.outputs.provider == 'gha' && true || false }} # Only needed on GHA runners
+        if: ${{ github.repository != 'bitcoin/bitcoin' || matrix.provider == 'gha' }} # Only needed on GHA runners
         uses: ./.github/actions/clear-files
 
       - name: Enable bpfcc script
@@ -583,12 +563,11 @@ jobs:
       - name: Save caches
         uses: ./.github/actions/cache/save
         with:
-          provider: ${{ matrix.provider || needs.runners.outputs.provider }}
+          provider: ${{ matrix.provider || (github.repository == 'bitcoin/bitcoin' && 'warp' || 'gha') }}
 
   lint:
     name: 'lint'
-    needs: runners
-    runs-on: ${{ needs.runners.outputs.provider == 'warp' && 'warp-ubuntu-latest-x64-2x' || 'ubuntu-latest' }}
+    runs-on: ${{ github.repository == 'bitcoin/bitcoin' && 'warp-ubuntu-latest-x64-2x' || 'ubuntu-latest' }}
     if: ${{ vars.SKIP_BRANCH_PUSH != 'true' || github.event_name == 'pull_request' }}
     timeout-minutes: 20
     env:
diff --git a/ci/README.md b/ci/README.md
index 0b6a34460ca1..33c623dc2afa 100644
--- a/ci/README.md
+++ b/ci/README.md
@@ -97,5 +97,5 @@ To configure the primary repository, follow these steps:
 When used in a fork the CI will run on GitHub's free hosted runners by default.
 In this case, GitHub's cache size limitations may cause caches to be frequently evicted and missed, but the workflows will run (slowly).
 
-It is also possible to use your own WarpBuild Runners in your own fork with an appropriate patch to the `REPO_USE_WARP_RUNNERS` variable in ../.github/workflows/ci.yml
+It is also possible to use your own WarpBuild Runners in your own fork by replacing the references to `bitcoin/bitcoin` in `../.github/workflows/ci.yml` with the name of your fork (e.g. `your-org/bitcoin`).
 NB that WarpBuild Runners only work at an organisation level, therefore in order to use your own WarpBuild Runners, *the fork must be within your own organisation*.
diff --git a/ci/test/00_setup_env_arm.sh b/ci/test/00_setup_env_arm.sh
index f4ad97d2cc2b..71b519dab189 100755
--- a/ci/test/00_setup_env_arm.sh
+++ b/ci/test/00_setup_env_arm.sh
@@ -8,7 +8,8 @@ export LC_ALL=C.UTF-8
 
 export HOST=arm-linux-gnueabihf
 export DPKG_ADD_ARCH="armhf"
-export PACKAGES="python3-zmq g++-arm-linux-gnueabihf libc6:armhf libstdc++6:armhf libfontconfig1:armhf libxcb1:armhf"
+export PACKAGES="python3-pip python3-zmq g++-arm-linux-gnueabihf libc6:armhf libstdc++6:armhf libfontconfig1:armhf libxcb1:armhf"
+export PIP_PACKAGES="--break-system-packages pycapnp"
 export CONTAINER_NAME=ci_arm_linux
 export CI_IMAGE_NAME_TAG="mirror.gcr.io/debian:trixie"  # Check that https://packages.debian.org/trixie/g++-arm-linux-gnueabihf (version 14.x, similar to guix) can cross-compile
 export CI_IMAGE_PLATFORM="linux/arm64"
diff --git a/ci/test/00_setup_env_freebsd_cross.sh b/ci/test/00_setup_env_freebsd_cross.sh
index da7304d1d26d..1be28a22c643 100755
--- a/ci/test/00_setup_env_freebsd_cross.sh
+++ b/ci/test/00_setup_env_freebsd_cross.sh
@@ -7,7 +7,7 @@
 export LC_ALL=C.UTF-8
 
 export CONTAINER_NAME=ci_freebsd_cross
-export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:24.04"
+export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:26.04"
 export APT_LLVM_V="22"
 export FREEBSD_VERSION=15.0
 export PACKAGES="clang-${APT_LLVM_V} llvm-${APT_LLVM_V} lld"
diff --git a/ci/test/00_setup_env_i686_no_ipc.sh b/ci/test/00_setup_env_i686_no_ipc.sh
index 93d5ab744604..d8df8100fe56 100755
--- a/ci/test/00_setup_env_i686_no_ipc.sh
+++ b/ci/test/00_setup_env_i686_no_ipc.sh
@@ -8,10 +8,10 @@ export LC_ALL=C.UTF-8
 
 export HOST=i686-pc-linux-gnu
 export CONTAINER_NAME=ci_i686_no_multiprocess
-export CI_IMAGE_NAME_TAG="mirror.gcr.io/debian:trixie"
+export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:26.04"
 export CI_IMAGE_PLATFORM="linux/amd64"
 export CI_CONTAINER_CAP="--security-opt seccomp=unconfined"
-export PACKAGES="llvm clang g++-multilib"
+export PACKAGES="g++-multilib"
 export DEP_OPTS="DEBUG=1 NO_IPC=1"
 export GOAL="install"
 export CI_LIMIT_STACK_SIZE=1
@@ -19,7 +19,5 @@ export BITCOIN_CONFIG="\
  --preset=dev-mode \
  -DENABLE_IPC=OFF \
  -DCMAKE_BUILD_TYPE=Debug \
- -DCMAKE_C_COMPILER='clang;-m32' \
- -DCMAKE_CXX_COMPILER='clang++;-m32' \
  -DAPPEND_CPPFLAGS='-DBOOST_MULTI_INDEX_ENABLE_SAFE_MODE' \
 "
diff --git a/ci/test/00_setup_env_native_alpine_musl.sh b/ci/test/00_setup_env_native_alpine_musl.sh
index 3bad08d68538..3801dfec403c 100755
--- a/ci/test/00_setup_env_native_alpine_musl.sh
+++ b/ci/test/00_setup_env_native_alpine_musl.sh
@@ -7,7 +7,7 @@
 export LC_ALL=C.UTF-8
 
 export CONTAINER_NAME=ci_native_alpine_musl
-export CI_IMAGE_NAME_TAG="mirror.gcr.io/alpine:3.23"
+export CI_IMAGE_NAME_TAG="mirror.gcr.io/alpine:3.24"
 export CI_BASE_PACKAGES="build-base musl-dev pkgconf curl ccache make ninja git python3-dev py3-pip which patch xz procps rsync util-linux bison e2fsprogs cmake dash linux-headers"
 export PIP_PACKAGES="--break-system-packages pyzmq pycapnp"
 export DEP_OPTS="DEBUG=1"
diff --git a/ci/test/00_setup_env_native_asan.sh b/ci/test/00_setup_env_native_asan.sh
index 2465c70bb487..58be89fa1041 100755
--- a/ci/test/00_setup_env_native_asan.sh
+++ b/ci/test/00_setup_env_native_asan.sh
@@ -9,7 +9,7 @@ export LC_ALL=C.UTF-8
 export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:24.04"
 
 # Only install BCC tracing packages in CI. Container has to match the host for BCC to work.
-if [[ "${INSTALL_BCC_TRACING_TOOLS}" == "true" ]]; then
+if [[ "${INSTALL_BCC_TRACING_TOOLS:-}" == "true" ]]; then
   # Required for USDT functional tests to run
   BPFCC_PACKAGE="bpfcc-tools linux-headers-$(uname --kernel-release)"
   export CI_CONTAINER_CAP="--privileged -v /sys/kernel:/sys/kernel:rw"
diff --git a/ci/test/00_setup_env_native_fuzz.sh b/ci/test/00_setup_env_native_fuzz.sh
index cdfe2a0d35b3..276ce08d056e 100755
--- a/ci/test/00_setup_env_native_fuzz.sh
+++ b/ci/test/00_setup_env_native_fuzz.sh
@@ -6,7 +6,7 @@
 
 export LC_ALL=C.UTF-8
 
-export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:24.04"
+export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:26.04"
 export CONTAINER_NAME=ci_native_fuzz
 export APT_LLVM_V="22"
 export PACKAGES="clang-${APT_LLVM_V} llvm-${APT_LLVM_V} libclang-rt-${APT_LLVM_V}-dev libevent-dev libboost-dev libsqlite3-dev libcapnp-dev capnproto"
diff --git a/ci/test/00_setup_env_native_fuzz_with_msan.sh b/ci/test/00_setup_env_native_fuzz_with_msan.sh
index 82d9044a8d70..c35a93622df8 100755
--- a/ci/test/00_setup_env_native_fuzz_with_msan.sh
+++ b/ci/test/00_setup_env_native_fuzz_with_msan.sh
@@ -6,7 +6,7 @@
 
 export LC_ALL=C.UTF-8
 
-export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:24.04"
+export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:26.04"
 export APT_LLVM_V="22"
 LIBCXX_DIR="/cxx_build/"
 export MSAN_FLAGS="-fsanitize=memory -fsanitize-memory-track-origins=2 -fno-omit-frame-pointer -g -O1 -fno-optimize-sibling-calls"
diff --git a/ci/test/00_setup_env_native_fuzz_with_valgrind.sh b/ci/test/00_setup_env_native_fuzz_with_valgrind.sh
index ed84ae84cf35..8020ea43da7a 100755
--- a/ci/test/00_setup_env_native_fuzz_with_valgrind.sh
+++ b/ci/test/00_setup_env_native_fuzz_with_valgrind.sh
@@ -6,7 +6,7 @@
 
 export LC_ALL=C.UTF-8
 
-export CI_IMAGE_NAME_TAG="mirror.gcr.io/debian:trixie"
+export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:26.04"
 export CONTAINER_NAME=ci_native_fuzz_valgrind
 export PACKAGES="clang llvm libclang-rt-dev libevent-dev libboost-dev libsqlite3-dev valgrind libcapnp-dev capnproto"
 export NO_DEPENDS=1
diff --git a/ci/test/00_setup_env_native_iwyu.sh b/ci/test/00_setup_env_native_iwyu.sh
index 27b1e02b6db8..3a26be56e7ea 100755
--- a/ci/test/00_setup_env_native_iwyu.sh
+++ b/ci/test/00_setup_env_native_iwyu.sh
@@ -6,7 +6,7 @@
 
 export LC_ALL=C.UTF-8
 
-export CI_IMAGE_NAME_TAG="mirror.gcr.io/debian:trixie"  # To build codegen, CMake must be 3.31 or newer.
+export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:26.04"  # To build codegen, CMake must be 3.31 or newer.
 export CONTAINER_NAME=ci_native_iwyu
 export IWYU_LLVM_V="22"
 export APT_LLVM_V="${IWYU_LLVM_V}"
diff --git a/ci/test/00_setup_env_native_msan.sh b/ci/test/00_setup_env_native_msan.sh
index 4a10bf96eabc..1d005abbd605 100755
--- a/ci/test/00_setup_env_native_msan.sh
+++ b/ci/test/00_setup_env_native_msan.sh
@@ -6,7 +6,7 @@
 
 export LC_ALL=C.UTF-8
 
-export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:24.04"
+export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:26.04"
 export APT_LLVM_V="22"
 LIBCXX_DIR="/cxx_build/"
 export MSAN_FLAGS="-fsanitize=memory -fsanitize-memory-track-origins=2 -fno-omit-frame-pointer -g -O1 -fno-optimize-sibling-calls"
diff --git a/ci/test/00_setup_env_native_tidy.sh b/ci/test/00_setup_env_native_tidy.sh
index b3cda17e8eed..5cebb8cd8ca6 100755
--- a/ci/test/00_setup_env_native_tidy.sh
+++ b/ci/test/00_setup_env_native_tidy.sh
@@ -6,7 +6,7 @@
 
 export LC_ALL=C.UTF-8
 
-export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:24.04"
+export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:26.04"
 export CONTAINER_NAME=ci_native_tidy
 export TIDY_LLVM_V="22"
 export APT_LLVM_V="${TIDY_LLVM_V}"
diff --git a/ci/test/00_setup_env_native_valgrind.sh b/ci/test/00_setup_env_native_valgrind.sh
index 0ca02f77824c..ba9d5b404aae 100755
--- a/ci/test/00_setup_env_native_valgrind.sh
+++ b/ci/test/00_setup_env_native_valgrind.sh
@@ -6,7 +6,7 @@
 
 export LC_ALL=C.UTF-8
 
-export CI_IMAGE_NAME_TAG="mirror.gcr.io/debian:trixie"
+export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:26.04"
 export CONTAINER_NAME=ci_native_valgrind
 export PACKAGES="clang llvm libclang-rt-dev valgrind python3-zmq libevent-dev libboost-dev libzmq3-dev libsqlite3-dev libcapnp-dev capnproto python3-pip"
 export PIP_PACKAGES="--break-system-packages pycapnp"
diff --git a/ci/test/00_setup_env_s390x.sh b/ci/test/00_setup_env_s390x.sh
index d1e34070ca99..a7c59d769635 100755
--- a/ci/test/00_setup_env_s390x.sh
+++ b/ci/test/00_setup_env_s390x.sh
@@ -9,7 +9,7 @@ export LC_ALL=C.UTF-8
 export HOST=s390x-linux-gnu
 export PACKAGES="python3-zmq"
 export CONTAINER_NAME=ci_s390x
-export CI_IMAGE_NAME_TAG="mirror.gcr.io/debian:trixie"
+export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:26.04"
 export CI_IMAGE_PLATFORM="linux/s390x"
 # bind tests excluded for now, see https://github.com/bitcoin/bitcoin/issues/17765#issuecomment-602068547
 export TEST_RUNNER_EXTRA="--exclude rpc_bind --exclude feature_bind_extra"
diff --git a/ci/test/01_base_install.sh b/ci/test/01_base_install.sh
index 512d1a32e87c..54dafbe8fd40 100755
--- a/ci/test/01_base_install.sh
+++ b/ci/test/01_base_install.sh
@@ -62,10 +62,13 @@ if [ -n "$PIP_PACKAGES" ]; then
 fi
 
 if [[ -n "${USE_INSTRUMENTED_LIBCPP}" ]]; then
-  ${CI_RETRY_EXE} git clone --depth=1 https://github.com/llvm/llvm-project -b "llvmorg-22.1.3" /llvm-project
+  ${CI_RETRY_EXE} git clone --depth=1 https://github.com/llvm/llvm-project -b "llvmorg-22.1.7" /llvm-project
 
+# LLVM is configured with LIBCXXABI_USE_LLVM_UNWINDER=OFF,
+# because libunwind doesn't handle exceptions under MSAN.
+# https://github.com/llvm/llvm-project/issues/84348
   cmake -G Ninja -B /cxx_build/ \
-    -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi;libunwind" \
+    -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi" \
     -DCMAKE_BUILD_TYPE=Release \
     -DLLVM_USE_SANITIZER="${USE_INSTRUMENTED_LIBCPP}" \
     -DCMAKE_C_COMPILER=clang \
@@ -86,7 +89,10 @@ fi
 
 if [[ "${RUN_IWYU}" == true ]]; then
   ${CI_RETRY_EXE} git clone --depth=1 https://github.com/include-what-you-use/include-what-you-use -b clang_"${IWYU_LLVM_V}" /include-what-you-use
-  (cd /include-what-you-use && patch -p1 < /ci_container_base/ci/test/01_iwyu.patch)
+  pushd /include-what-you-use
+  patch -p1 < /ci_container_base/ci/test/01_iwyu.patch
+  patch -p1 < /ci_container_base/ci/test/02_iwyu_hash.patch
+  popd
   cmake -B /iwyu-build/ -G 'Unix Makefiles' -DCMAKE_PREFIX_PATH=/usr/lib/llvm-"${IWYU_LLVM_V}" -S /include-what-you-use
   make -C /iwyu-build/ install "$MAKEJOBS"
 fi
diff --git a/ci/test/02_iwyu_hash.patch b/ci/test/02_iwyu_hash.patch
new file mode 100644
index 000000000000..12df7a04ed5c
--- /dev/null
+++ b/ci/test/02_iwyu_hash.patch
@@ -0,0 +1,44 @@
+Map std::hash to its providing standard headers.
+Backport of https://github.com/include-what-you-use/include-what-you-use/pull/2013
+(commit 52f85e1f4d990f55fc6556d543eb051d79364a16) to the clang_22 release
+branch. Drop once the upstream fix lands in the IWYU branch tracked by
+ci/test/00_setup_env_native_iwyu.sh.
+
+--- a/std_symbol_map.inc
++++ b/std_symbol_map.inc
+@@ -1054,12 +1054,27 @@
+ { "std::has_unique_object_representations_v", kPrivate, "<type_traits>", kPublic },
+ { "std::has_virtual_destructor", kPrivate, "<type_traits>", kPublic },
+ { "std::has_virtual_destructor_v", kPrivate, "<type_traits>", kPublic },
++{ "std::hash", kPrivate, "<functional>", kPublic },
++{ "std::hash", kPrivate, "<bitset>", kPublic },
++{ "std::hash", kPrivate, "<coroutine>", kPublic },
++{ "std::hash", kPrivate, "<filesystem>", kPublic },
++{ "std::hash", kPrivate, "<memory>", kPublic },
++{ "std::hash", kPrivate, "<optional>", kPublic },
++{ "std::hash", kPrivate, "<stacktrace>", kPublic },
++{ "std::hash", kPrivate, "<string>", kPublic },
++{ "std::hash", kPrivate, "<string_view>", kPublic },
++{ "std::hash", kPrivate, "<system_error>", kPublic },
++{ "std::hash", kPrivate, "<thread>", kPublic },
++{ "std::hash", kPrivate, "<typeindex>", kPublic },
++{ "std::hash", kPrivate, "<variant>", kPublic },
++{ "std::hash", kPrivate, "<vector>", kPublic },
+ { "std::hash<std::basic_stacktrace<:0>>", kPrivate, "<stacktrace>", kPublic },
+ { "std::hash<std::basic_string<char, std::char_traits<char>, :0>>", kPrivate, "<string>", kPublic },
+ { "std::hash<std::basic_string<char16_t, std::char_traits<char16_t>, :0>>", kPrivate, "<string>", kPublic },
+ { "std::hash<std::basic_string<char32_t, std::char_traits<char32_t>, :0>>", kPrivate, "<string>", kPublic },
+ { "std::hash<std::basic_string<char8_t, std::char_traits<char8_t>, :0>>", kPrivate, "<string>", kPublic },
+ { "std::hash<std::basic_string<wchar_t, std::char_traits<wchar_t>, :0>>", kPrivate, "<string>", kPublic },
++{ "std::hash<std::bitset<:0>>", kPrivate, "<bitset>", kPublic },
+ { "std::hash<std::coroutine_handle<:0>>", kPrivate, "<coroutine>", kPublic },
+ { "std::hash<std::error_code>", kPrivate, "<system_error>", kPublic },
+ { "std::hash<std::error_condition>", kPrivate, "<system_error>", kPublic },
+@@ -1069,6 +1084,7 @@
+ { "std::hash<std::shared_ptr<:0>>", kPrivate, "<memory>", kPublic },
+ { "std::hash<std::stacktrace_entry>", kPrivate, "<stacktrace>", kPublic },
+ { "std::hash<std::string_view>", kPrivate, "<string_view>", kPublic },
++{ "std::hash<std::thread::id>", kPrivate, "<thread>", kPublic },
+ { "std::hash<std::type_index>", kPrivate, "<typeindex>", kPublic },
+ { "std::hash<std::u16string_view>", kPrivate, "<string_view>", kPublic },
+ { "std::hash<std::u32string_view>", kPrivate, "<string_view>", kPublic },
diff --git a/ci/test/03_test_script.sh b/ci/test/03_test_script.sh
index 980583d00b56..c55f44301637 100755
--- a/ci/test/03_test_script.sh
+++ b/ci/test/03_test_script.sh
@@ -168,7 +168,7 @@ if [ -n "${CI_LIMIT_STACK_SIZE}" ]; then
 fi
 
 if [ -n "$USE_VALGRIND" ]; then
-  "${BASE_ROOT_DIR}/ci/test/wrap-valgrind.sh"
+  "${BASE_ROOT_DIR}/ci/test/wrap-valgrind.py"
 fi
 
 if [ "$RUN_CHECK_DEPS" = "true" ]; then
@@ -229,7 +229,7 @@ fi
 
 if [[ "${RUN_IWYU}" == true ]]; then
   # TODO: Consider enforcing IWYU across the entire codebase.
-  FILES_WITH_ENFORCED_IWYU="/src/(((crypto|index|kernel|primitives|script|univalue/(lib|test)|util|zmq)/.*|bench/(block_assemble|connectblock)|common/license_info|node/(blockstorage|interfaces|miner|mining_args|utxo_snapshot)|rpc/mining|clientversion|core_io|signet|init)\\.cpp)"
+  FILES_WITH_ENFORCED_IWYU="/src/(((bench|crypto|index|kernel|primitives|script|univalue/(lib|test)|util|zmq)/.*|common/license_info|node/(blockstorage|interfaces|miner|mining_args|utxo_snapshot)|rpc/mining|clientversion|core_io|signet|init)\\.cpp)"
   jq --arg patterns "$FILES_WITH_ENFORCED_IWYU" 'map(select(.file | test($patterns)))' "${BASE_BUILD_DIR}/compile_commands.json" > "${BASE_BUILD_DIR}/compile_commands_iwyu_errors.json"
   jq --arg patterns "$FILES_WITH_ENFORCED_IWYU" 'map(select(.file | test($patterns) | not))' "${BASE_BUILD_DIR}/compile_commands.json" > "${BASE_BUILD_DIR}/compile_commands_iwyu_warnings.json"
 
diff --git a/ci/test/wrap-valgrind.py b/ci/test/wrap-valgrind.py
new file mode 100755
index 000000000000..6a79f2aaae1d
--- /dev/null
+++ b/ci/test/wrap-valgrind.py
@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+# Copyright (c) The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or https://opensource.org/license/mit/.
+
+import os
+import shlex
+from pathlib import Path
+
+
+def main():
+    base_root = Path(os.environ["BASE_ROOT_DIR"])
+    base_out = Path(os.environ["BASE_OUTDIR"])
+    suppressions_file = base_root / "test" / "sanitizer_suppressions" / "valgrind.supp"
+    target_names = {b.name for b in (base_out / "bin").iterdir()}
+
+    for exe in base_root.rglob("*"):
+        if exe.name in target_names and exe.is_file() and os.access(exe, os.X_OK):
+            print(f"Wrap {exe} ...")
+            original_path = exe.with_name(f"{exe.name}_orig")
+            exe.rename(original_path)
+            exe.write_text(
+                "#!/usr/bin/env bash\n"
+                "exec valgrind --gen-suppressions=all --quiet --error-exitcode=1 "
+                f"--suppressions={shlex.quote(str(suppressions_file))} "
+                f'{shlex.quote(str(original_path))} "$@"\n'
+            )
+            exe.chmod(exe.stat().st_mode | 0o111)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ci/test/wrap-valgrind.sh b/ci/test/wrap-valgrind.sh
deleted file mode 100755
index 4ed3f2d66c54..000000000000
--- a/ci/test/wrap-valgrind.sh
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/usr/bin/env bash
-#
-# Copyright (c) 2018-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.
-
-export LC_ALL=C.UTF-8
-
-for b_name in "${BASE_OUTDIR}/bin"/*; do
-    # shellcheck disable=SC2044
-    for b in $(find "${BASE_ROOT_DIR}" -executable -type f -name "$(basename "$b_name")"); do
-      echo "Wrap $b ..."
-      mv "$b" "${b}_orig"
-      echo '#!/usr/bin/env bash' > "$b"
-      echo "exec valgrind --gen-suppressions=all --quiet --error-exitcode=1 --suppressions=${BASE_ROOT_DIR}/test/sanitizer_suppressions/valgrind.supp \"${b}_orig\" \"\$@\"" >> "$b"
-      chmod +x "$b"
-    done
-done
diff --git a/ci/test_imagefile b/ci/test_imagefile
index 908e9a0f5ab4..dac6b5531564 100644
--- a/ci/test_imagefile
+++ b/ci/test_imagefile
@@ -16,7 +16,8 @@ ENV BASE_ROOT_DIR=${BASE_ROOT_DIR}
 
 # Make retry available in PATH, needed for CI_RETRY_EXE
 COPY ./ci/retry/retry /usr/bin/retry
-COPY ./ci/test/00_setup_env.sh ./${FILE_ENV} ./ci/test/01_base_install.sh ./ci/test/01_iwyu.patch /ci_container_base/ci/test/
+COPY ./ci/test/00_setup_env.sh ./${FILE_ENV} ./ci/test/01_base_install.sh /ci_container_base/ci/test/
+COPY ./ci/test/*.patch /ci_container_base/ci/test/
 
 # Bash is required, so install it when missing
 RUN sh -c "bash -c 'true' || ( apk update && apk add --no-cache bash )"
diff --git a/contrib/guix/libexec/build.sh b/contrib/guix/libexec/build.sh
index 51354273efae..0ec058b8de32 100755
--- a/contrib/guix/libexec/build.sh
+++ b/contrib/guix/libexec/build.sh
@@ -5,73 +5,13 @@
 export LC_ALL=C
 set -e -o pipefail
 
-# Environment variables for determinism
-export TAR_OPTIONS="--no-same-owner --owner=0 --group=0 --numeric-owner --mtime='@${SOURCE_DATE_EPOCH}' --sort=name"
-export TZ=UTC
-
-# Although Guix _does_ set umask when building its own packages (in our case,
-# this is all packages in manifest.scm), it does not set it for `guix
-# shell`. It does make sense for at least `guix shell --container`
-# to set umask, so if that change gets merged upstream and we bump the
-# time-machine to a commit which includes the aforementioned change, we can
-# remove this line.
-#
-# This line should be placed before any commands which creates files.
-umask 0022
-
-if [ -n "$V" ]; then
-    # Print both unexpanded (-v) and expanded (-x) forms of commands as they are
-    # read from this file.
-    set -vx
-    # Set VERBOSE for CMake-based builds
-    export VERBOSE="$V"
-fi
-
-# Check that required environment variables are set
-cat << EOF
-Required environment variables as seen inside the container:
-    DIST_ARCHIVE_BASE: ${DIST_ARCHIVE_BASE:?not set}
-    DISTNAME: ${DISTNAME:?not set}
-    HOST: ${HOST:?not set}
-    SOURCE_DATE_EPOCH: ${SOURCE_DATE_EPOCH:?not set}
-    JOBS: ${JOBS:?not set}
-    DISTSRC: ${DISTSRC:?not set}
-    OUTDIR: ${OUTDIR:?not set}
-EOF
-
-ACTUAL_OUTDIR="${OUTDIR}"
-OUTDIR="${DISTSRC}/output"
-
-#####################
-# Environment Setup #
-#####################
-
-# The depends folder also serves as a base-prefix for depends packages for
-# $HOSTs after successfully building.
-BASEPREFIX="${PWD}/depends"
-
-# Given a package name and an output name, return the path of that output in our
-# current guix environment
-store_path() {
-    grep --extended-regexp "/[^-]{32}-${1}-[^-]+${2:+-${2}}" "${GUIX_ENVIRONMENT}/manifest" \
-        | head --lines=1 \
-        | sed --expression='s|\x29*$||' \
-              --expression='s|^[[:space:]]*"||' \
-              --expression='s|"[[:space:]]*$||'
-}
-
+# shellcheck source=setup.sh
+source "$(dirname "${BASH_SOURCE[0]}")/setup.sh"
 
 # Set environment variables to point the NATIVE toolchain to the right
 # includes/libs
 NATIVE_GCC="$(store_path gcc-toolchain)"
 
-unset LIBRARY_PATH
-unset CPATH
-unset C_INCLUDE_PATH
-unset CPLUS_INCLUDE_PATH
-unset OBJC_INCLUDE_PATH
-unset OBJCPLUS_INCLUDE_PATH
-
 # Set native toolchain
 build_CC="${NATIVE_GCC}/bin/gcc -isystem ${NATIVE_GCC}/include"
 build_CXX="${NATIVE_GCC}/bin/g++ -isystem ${NATIVE_GCC}/include/c++ -isystem ${NATIVE_GCC}/include"
@@ -134,15 +74,6 @@ for p in "${PATHS[@]}"; do
     fi
 done
 
-# Disable Guix ld auto-rpath behavior
-export GUIX_LD_WRAPPER_DISABLE_RPATH=yes
-
-# Make /usr/bin if it doesn't exist
-[ -e /usr/bin ] || mkdir -p /usr/bin
-
-# Symlink env to a conventional path
-[ -e /usr/bin/env ]  || ln -s --no-dereference "$(command -v env)"  /usr/bin/env
-
 # Determine the correct value for -Wl,--dynamic-linker for the current $HOST
 case "$HOST" in
     *linux*)
@@ -186,20 +117,6 @@ case "$HOST" in
         ;;
 esac
 
-###########################
-# Source Tarball Building #
-###########################
-
-GIT_ARCHIVE="${DIST_ARCHIVE_BASE}/${DISTNAME}.tar.gz"
-
-# Create the source tarball if not already there
-if [ ! -e "$GIT_ARCHIVE" ]; then
-    mkdir -p "$(dirname "$GIT_ARCHIVE")"
-    git archive --prefix="${DISTNAME}/" --output="$GIT_ARCHIVE" HEAD
-fi
-
-mkdir -p "$OUTDIR"
-
 ###########################
 # Binary Tarball Building #
 ###########################
@@ -249,17 +166,17 @@ mkdir -p "$DISTSRC"
           -DWITH_CCACHE=OFF \
           -Werror=dev \
           ${CONFIGFLAGS} \
-          "${CMAKE_EXE_LINKER_FLAGS}"
+          ${CMAKE_EXE_LINKER_FLAGS+"$CMAKE_EXE_LINKER_FLAGS"}
 
     # Build Bitcoin Core
-    cmake --build build -j "$JOBS" ${V:+--verbose}
+    cmake --build build -j "$JOBS"
 
     mkdir -p "$OUTDIR"
 
     # Make the os-specific installers
     case "$HOST" in
         *mingw*)
-            cmake --build build -j "$JOBS" -t deploy ${V:+--verbose}
+            cmake --build build -j "$JOBS" -t deploy
             mv build/bitcoin-win64-setup.exe "${OUTDIR}/${DISTNAME}-win64-setup-unsigned.exe"
             ;;
     esac
@@ -267,15 +184,14 @@ mkdir -p "$DISTSRC"
     # Setup the directory where our Bitcoin Core build for HOST will be
     # installed. This directory will also later serve as the input for our
     # binary tarballs.
-    INSTALLPATH="${PWD}/installed/${DISTNAME}"
     mkdir -p "${INSTALLPATH}"
     # Install built Bitcoin Core to $INSTALLPATH
     case "$HOST" in
         *darwin*)
-            cmake --install build --strip --prefix "${INSTALLPATH}" ${V:+--verbose}
+            cmake --install build --strip --prefix "${INSTALLPATH}"
             ;;
         *)
-            cmake --install build --prefix "${INSTALLPATH}" ${V:+--verbose}
+            cmake --install build --prefix "${INSTALLPATH}"
             ;;
     esac
 
@@ -285,126 +201,7 @@ mkdir -p "$DISTSRC"
     # Check that executables only contain allowed version symbols.
     echo "Running symbol and dynamic library checks on installed executables..."
     python3 "${DISTSRC}/contrib/guix/symbol-check.py" "${INSTALLPATH}/bin/"* "${INSTALLPATH}/libexec/"*
-
-    (
-        cd installed
-
-        case "$HOST" in
-            *darwin*) ;;
-            *)
-                # Split binaries from their debug symbols
-                {
-                    find "${DISTNAME}/bin" "${DISTNAME}/libexec" -type f -executable -print0
-                } | xargs -0 -P"$JOBS" -I{} "${DISTSRC}/build/split-debug.sh" {} {} {}.dbg
-                ;;
-        esac
-
-        case "$HOST" in
-            *mingw*)
-                cp "${DISTSRC}/doc/README_windows.txt" "${DISTNAME}/readme.txt"
-                ;;
-            *linux*)
-                cp "${DISTSRC}/README.md" "${DISTNAME}/"
-                cp "${DISTSRC}/doc/INSTALL_linux.md" "${DISTNAME}/INSTALL.md"
-                ;;
-        esac
-
-        # copy over the example bitcoin.conf file. if contrib/devtools/gen-bitcoin-conf.sh
-        # has not been run before buildling, this file will be a stub
-        cp "${DISTSRC}/share/examples/bitcoin.conf" "${DISTNAME}/"
-
-        cp -r "${DISTSRC}/share/rpcauth" "${DISTNAME}/share/"
-
-        # Deterministically produce {non-,}debug binary tarballs ready
-        # for release
-        case "$HOST" in
-            *mingw*)
-                find "${DISTNAME}" -not -name "*.dbg" -print0 \
-                    | xargs -0r touch --no-dereference --date="@${SOURCE_DATE_EPOCH}"
-                find "${DISTNAME}" -not -name "*.dbg" \
-                    | sort \
-                    | zip -X@ "${OUTDIR}/${DISTNAME}-${HOST//x86_64-w64-mingw32/win64}-unsigned.zip" \
-                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST//x86_64-w64-mingw32/win64}-unsigned.zip" && exit 1 )
-                find "${DISTNAME}" -name "*.dbg" -print0 \
-                    | xargs -0r touch --no-dereference --date="@${SOURCE_DATE_EPOCH}"
-                find "${DISTNAME}" -name "*.dbg" \
-                    | sort \
-                    | zip -X@ "${OUTDIR}/${DISTNAME}-${HOST//x86_64-w64-mingw32/win64}-debug.zip" \
-                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST//x86_64-w64-mingw32/win64}-debug.zip" && exit 1 )
-                ;;
-            *linux*)
-                find "${DISTNAME}" -not -name "*.dbg" -print0 \
-                    | sort --zero-terminated \
-                    | tar --create --no-recursion --mode='u+rw,go+r-w,a+X' --null --files-from=- \
-                    | gzip -9n > "${OUTDIR}/${DISTNAME}-${HOST}.tar.gz" \
-                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST}.tar.gz" && exit 1 )
-                find "${DISTNAME}" -name "*.dbg" -print0 \
-                    | sort --zero-terminated \
-                    | tar --create --no-recursion --mode='u+rw,go+r-w,a+X' --null --files-from=- \
-                    | gzip -9n > "${OUTDIR}/${DISTNAME}-${HOST}-debug.tar.gz" \
-                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST}-debug.tar.gz" && exit 1 )
-                ;;
-            *darwin*)
-                find "${DISTNAME}" -print0 \
-                    | sort --zero-terminated \
-                    | tar --create --no-recursion --mode='u+rw,go+r-w,a+X' --null --files-from=- \
-                    | gzip -9n > "${OUTDIR}/${DISTNAME}-${HOST}-unsigned.tar.gz" \
-                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST}-unsigned.tar.gz" && exit 1 )
-                ;;
-        esac
-    )  # $DISTSRC/installed
-
-    # Finally make tarballs for codesigning
-    case "$HOST" in
-        *mingw*)
-            cp -rf --target-directory=. contrib/windeploy
-            (
-                cd ./windeploy
-                mkdir -p unsigned
-                cp --target-directory=unsigned/ "${OUTDIR}/${DISTNAME}-win64-setup-unsigned.exe"
-                cp -r --target-directory=unsigned/ "${INSTALLPATH}"
-                find unsigned/ -name "*.dbg" -print0 \
-                    | xargs -0r rm
-                find . -print0 \
-                    | sort --zero-terminated \
-                    | tar --create --no-recursion --mode='u+rw,go+r-w,a+X' --null --files-from=- \
-                    | gzip -9n > "${OUTDIR}/${DISTNAME}-win64-codesigning.tar.gz" \
-                    || ( rm -f "${OUTDIR}/${DISTNAME}-win64-codesigning.tar.gz" && exit 1 )
-            )
-            ;;
-        *darwin*)
-            cmake --build build --target deploy ${V:+--verbose}
-            mv build/dist/bitcoin-macos-app.zip "${OUTDIR}/${DISTNAME}-${HOST}-unsigned.zip"
-            mkdir -p "unsigned-app-${HOST}"
-            cp  --target-directory="unsigned-app-${HOST}" \
-                contrib/macdeploy/detached-sig-create.sh
-            mv --target-directory="unsigned-app-${HOST}" build/dist
-            cp -r --target-directory="unsigned-app-${HOST}" "${INSTALLPATH}"
-            (
-                cd "unsigned-app-${HOST}"
-                find . -print0 \
-                    | sort --zero-terminated \
-                    | tar --create --no-recursion --mode='u+rw,go+r-w,a+X' --null --files-from=- \
-                    | gzip -9n > "${OUTDIR}/${DISTNAME}-${HOST}-codesigning.tar.gz" \
-                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST}-codesigning.tar.gz" && exit 1 )
-            )
-            ;;
-    esac
 )  # $DISTSRC
 
-rm -rf "$ACTUAL_OUTDIR"
-mv --no-target-directory "$OUTDIR" "$ACTUAL_OUTDIR" \
-    || ( rm -rf "$ACTUAL_OUTDIR" && exit 1 )
-
-(
-    tmp="$(mktemp)"
-    cd /outdir-base
-    {
-        echo "$GIT_ARCHIVE"
-        find "$ACTUAL_OUTDIR" -type f
-    } | xargs realpath --relative-base="$PWD" \
-        | xargs sha256sum \
-        | sort -k2 \
-        > "$tmp";
-    mv "$tmp" "$ACTUAL_OUTDIR"/SHA256SUMS.part
-)
+# shellcheck source=package.sh
+source "$(dirname "${BASH_SOURCE[0]}")/package.sh"
diff --git a/contrib/guix/libexec/package.sh b/contrib/guix/libexec/package.sh
new file mode 100755
index 000000000000..7228346abe7a
--- /dev/null
+++ b/contrib/guix/libexec/package.sh
@@ -0,0 +1,133 @@
+#!/usr/bin/env bash
+# Copyright (c) The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or https://opensource.org/license/mit.
+export LC_ALL=C
+set -e -o pipefail
+
+(
+    cd "$DISTSRC"
+
+    (
+        cd installed
+
+        case "$HOST" in
+            *darwin*) ;;
+            *)
+                # Split binaries from their debug symbols
+                {
+                    find "${DISTNAME}/bin" "${DISTNAME}/libexec" -type f -executable -print0
+                } | xargs -0 -P"$JOBS" -I{} "${DISTSRC}/build/split-debug.sh" {} {} {}.dbg
+                ;;
+        esac
+
+        case "$HOST" in
+            *mingw*)
+                cp "${DISTSRC}/doc/README_windows.txt" "${DISTNAME}/readme.txt"
+                ;;
+            *linux*)
+                cp "${DISTSRC}/README.md" "${DISTNAME}/"
+                cp "${DISTSRC}/doc/INSTALL_linux.md" "${DISTNAME}/INSTALL.md"
+                ;;
+        esac
+
+        # copy over the example bitcoin.conf file. if contrib/devtools/gen-bitcoin-conf.sh
+        # has not been run before buildling, this file will be a stub
+        cp "${DISTSRC}/share/examples/bitcoin.conf" "${DISTNAME}/"
+
+        cp -r "${DISTSRC}/share/rpcauth" "${DISTNAME}/share/"
+
+        # Deterministically produce {non-,}debug binary tarballs ready
+        # for release
+        case "$HOST" in
+            *mingw*)
+                find "${DISTNAME}" -not -name "*.dbg" -print0 \
+                    | xargs -0r touch --no-dereference --date="@${SOURCE_DATE_EPOCH}"
+                find "${DISTNAME}" -not -name "*.dbg" \
+                    | sort \
+                    | zip -X@ "${OUTDIR}/${DISTNAME}-${HOST//x86_64-w64-mingw32/win64}-unsigned.zip" \
+                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST//x86_64-w64-mingw32/win64}-unsigned.zip" && exit 1 )
+                find "${DISTNAME}" -name "*.dbg" -print0 \
+                    | xargs -0r touch --no-dereference --date="@${SOURCE_DATE_EPOCH}"
+                find "${DISTNAME}" -name "*.dbg" \
+                    | sort \
+                    | zip -X@ "${OUTDIR}/${DISTNAME}-${HOST//x86_64-w64-mingw32/win64}-debug.zip" \
+                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST//x86_64-w64-mingw32/win64}-debug.zip" && exit 1 )
+                ;;
+            *linux*)
+                find "${DISTNAME}" -not -name "*.dbg" -print0 \
+                    | sort --zero-terminated \
+                    | tar --create --no-recursion --mode='u+rw,go+r-w,a+X' --null --files-from=- \
+                    | gzip -9n > "${OUTDIR}/${DISTNAME}-${HOST}.tar.gz" \
+                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST}.tar.gz" && exit 1 )
+                find "${DISTNAME}" -name "*.dbg" -print0 \
+                    | sort --zero-terminated \
+                    | tar --create --no-recursion --mode='u+rw,go+r-w,a+X' --null --files-from=- \
+                    | gzip -9n > "${OUTDIR}/${DISTNAME}-${HOST}-debug.tar.gz" \
+                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST}-debug.tar.gz" && exit 1 )
+                ;;
+            *darwin*)
+                find "${DISTNAME}" -print0 \
+                    | sort --zero-terminated \
+                    | tar --create --no-recursion --mode='u+rw,go+r-w,a+X' --null --files-from=- \
+                    | gzip -9n > "${OUTDIR}/${DISTNAME}-${HOST}-unsigned.tar.gz" \
+                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST}-unsigned.tar.gz" && exit 1 )
+                ;;
+        esac
+    )  # $DISTSRC/installed
+
+    # Finally make tarballs for codesigning
+    case "$HOST" in
+        *mingw*)
+            cp -rf --target-directory=. contrib/windeploy
+            (
+                cd ./windeploy
+                mkdir -p unsigned
+                cp --target-directory=unsigned/ "${OUTDIR}/${DISTNAME}-win64-setup-unsigned.exe"
+                cp -r --target-directory=unsigned/ "${INSTALLPATH}"
+                find unsigned/ -name "*.dbg" -print0 \
+                    | xargs -0r rm
+                find . -print0 \
+                    | sort --zero-terminated \
+                    | tar --create --no-recursion --mode='u+rw,go+r-w,a+X' --null --files-from=- \
+                    | gzip -9n > "${OUTDIR}/${DISTNAME}-win64-codesigning.tar.gz" \
+                    || ( rm -f "${OUTDIR}/${DISTNAME}-win64-codesigning.tar.gz" && exit 1 )
+            )
+            ;;
+        *darwin*)
+            cmake --build build --target deploy
+            mv build/dist/bitcoin-macos-app.zip "${OUTDIR}/${DISTNAME}-${HOST}-unsigned.zip"
+            mkdir -p "unsigned-app-${HOST}"
+            cp  --target-directory="unsigned-app-${HOST}" \
+                contrib/macdeploy/detached-sig-create.sh
+            mv --target-directory="unsigned-app-${HOST}" build/dist
+            cp -r --target-directory="unsigned-app-${HOST}" "${INSTALLPATH}"
+            (
+                cd "unsigned-app-${HOST}"
+                find . -print0 \
+                    | sort --zero-terminated \
+                    | tar --create --no-recursion --mode='u+rw,go+r-w,a+X' --null --files-from=- \
+                    | gzip -9n > "${OUTDIR}/${DISTNAME}-${HOST}-codesigning.tar.gz" \
+                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST}-codesigning.tar.gz" && exit 1 )
+            )
+            ;;
+    esac
+
+) # $DISTSRC
+
+rm -rf "$ACTUAL_OUTDIR"
+mv --no-target-directory "$OUTDIR" "$ACTUAL_OUTDIR" \
+    || ( rm -rf "$ACTUAL_OUTDIR" && exit 1 )
+
+(
+    tmp="$(mktemp)"
+    cd /outdir-base
+    {
+        echo "$GIT_ARCHIVE"
+        find "$ACTUAL_OUTDIR" -type f
+    } | xargs realpath --relative-base="$PWD" \
+        | xargs sha256sum \
+        | sort -k2 \
+        > "$tmp";
+    mv "$tmp" "$ACTUAL_OUTDIR"/SHA256SUMS.part
+)
diff --git a/contrib/guix/libexec/setup.sh b/contrib/guix/libexec/setup.sh
new file mode 100755
index 000000000000..37388f985538
--- /dev/null
+++ b/contrib/guix/libexec/setup.sh
@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+# Copyright (c) The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or https://opensource.org/license/mit.
+export LC_ALL=C
+set -e -o pipefail
+
+# Environment variables for determinism
+export TAR_OPTIONS="--no-same-owner --owner=0 --group=0 --numeric-owner --mtime='@${SOURCE_DATE_EPOCH}' --sort=name"
+export TZ=UTC
+
+# Although Guix _does_ set umask when building its own packages (in our case,
+# this is all packages in manifest.scm), it does not set it for `guix
+# shell`. It does make sense for at least `guix shell --container`
+# to set umask, so if that change gets merged upstream and we bump the
+# time-machine to a commit which includes the aforementioned change, we can
+# remove this line.
+#
+# This line should be placed before any commands which creates files.
+umask 0022
+
+if [ -n "$V" ]; then
+    # Print both unexpanded (-v) and expanded (-x) forms of commands as they are
+    # read from this file.
+    set -vx
+    # Set VERBOSE for CMake-based builds
+    export VERBOSE="$V"
+fi
+
+# Check that required environment variables are set
+cat << EOF
+Required environment variables as seen inside the container:
+    DIST_ARCHIVE_BASE: ${DIST_ARCHIVE_BASE:?not set}
+    DISTNAME: ${DISTNAME:?not set}
+    HOST: ${HOST:?not set}
+    SOURCE_DATE_EPOCH: ${SOURCE_DATE_EPOCH:?not set}
+    JOBS: ${JOBS:?not set}
+    DISTSRC: ${DISTSRC:?not set}
+    OUTDIR: ${OUTDIR:?not set}
+EOF
+
+export ACTUAL_OUTDIR="${OUTDIR}"
+export OUTDIR="${DISTSRC}/output"
+export INSTALLPATH="${DISTSRC}/installed/${DISTNAME}"
+
+#####################
+# Environment Setup #
+#####################
+
+# The depends folder also serves as a base-prefix for depends packages for
+# $HOSTs after successfully building.
+export BASEPREFIX="${PWD}/depends"
+
+# Given a package name and an output name, return the path of that output in our
+# current guix environment
+store_path() {
+    grep --extended-regexp "/[^-]{32}-${1}-[^-]+${2:+-${2}}" "${GUIX_ENVIRONMENT}/manifest" \
+        | head --lines=1 \
+        | sed --expression='s|\x29*$||' \
+              --expression='s|^[[:space:]]*"||' \
+              --expression='s|"[[:space:]]*$||'
+}
+
+# Disable Guix ld auto-rpath behavior
+export GUIX_LD_WRAPPER_DISABLE_RPATH=yes
+
+# Make /usr/bin if it doesn't exist
+[ -e /usr/bin ] || mkdir -p /usr/bin
+
+# Symlink env to a conventional path
+[ -e /usr/bin/env ]  || ln -s --no-dereference "$(command -v env)"  /usr/bin/env
+
+###########################
+# Source Tarball Building #
+###########################
+
+GIT_ARCHIVE="${DIST_ARCHIVE_BASE}/${DISTNAME}.tar.gz"
+
+# Create the source tarball if not already there
+if [ ! -e "$GIT_ARCHIVE" ]; then
+    mkdir -p "$(dirname "$GIT_ARCHIVE")"
+    git archive --prefix="${DISTNAME}/" --output="$GIT_ARCHIVE" HEAD
+fi
+
+mkdir -p "$OUTDIR"
+
+unset LIBRARY_PATH
+unset CPATH
+unset C_INCLUDE_PATH
+unset CPLUS_INCLUDE_PATH
+unset OBJC_INCLUDE_PATH
+unset OBJCPLUS_INCLUDE_PATH
diff --git a/depends/funcs.mk b/depends/funcs.mk
index 60e7889a4ec5..f6221ef18f8c 100644
--- a/depends/funcs.mk
+++ b/depends/funcs.mk
@@ -222,7 +222,7 @@ $(1)_cmake=env CC="$$($(1)_cc)" \
                -DCMAKE_AR=`which $$($(1)_ar)` \
                -DCMAKE_NM=`which $$($(1)_nm)` \
                -DCMAKE_RANLIB=`which $$($(1)_ranlib)` \
-               -DCMAKE_INSTALL_LIBDIR=lib/ \
+               -DCMAKE_INSTALL_LIBDIR=lib \
                -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
                -DCMAKE_VERBOSE_MAKEFILE:BOOL=$(V) \
                -DCMAKE_EXPORT_NO_PACKAGE_REGISTRY:BOOL=TRUE \
diff --git a/doc/bips.md b/doc/bips.md
index ebf6b8fcd7d7..6f9b322e33da 100644
--- a/doc/bips.md
+++ b/doc/bips.md
@@ -79,3 +79,4 @@ BIPs that are implemented by Bitcoin Core:
 * [`BIP 390`](https://github.com/bitcoin/bips/blob/master/bip-0390.mediawiki): MuSig2 Descriptor parsing is implemented in **v30.0** ([PR 31244](https://github.com/bitcoin/bitcoin/pull/31244)) and signing in **v31.0** ([PR 29675](https://github.com/bitcoin/bitcoin/pull/29675))
 * [`BIP 431`](https://github.com/bitcoin/bips/blob/master/bip-0431.mediawiki): transactions with nVersion=3 are standard and treated as Topologically Restricted Until Confirmation as of **v28.0** ([PR 29496](https://github.com/bitcoin/bitcoin/pull/29496)).
 * [`BIP 433`](https://github.com/bitcoin/bips/blob/master/bip-0433.mediawiki): Spending of Pay to Anchor (P2A) outputs is standard as of **v28.0** ([PR 30352](https://github.com/bitcoin/bitcoin/pull/30352)).
+* [`BIP 434`](https://github.com/bitcoin/bips/blob/master/bip-0434.md): Peer Feature Negotiation as of **v32.0** ([PR 35221](https://github.com/bitcoin/bitcoin/pull/35221)).
diff --git a/doc/developer-notes.md b/doc/developer-notes.md
index e44a4b91093a..962e8851187c 100644
--- a/doc/developer-notes.md
+++ b/doc/developer-notes.md
@@ -562,9 +562,8 @@ For IWYU pragmas, prefer adding a nearby source comment that explains why the an
 
 Profiling is a good way to get a precise idea of where time is being spent in
 code. One tool for doing profiling on Linux platforms is called
-[`perf`](https://www.brendangregg.com/perf.html), and has been integrated into
-the functional test framework. Perf can observe a running process and sample
-(at some frequency) where its execution is.
+[`perf`](https://www.brendangregg.com/perf.html). It can observe a running
+process and sample (at some frequency) where its execution is.
 
 Perf installation is contingent on which kernel version you're running; see
 [this thread](https://askubuntu.com/questions/50145/how-to-install-perf-monitoring-tool)
@@ -599,8 +598,6 @@ perf report --stdio | c++filt | less
 
 or using a graphical tool like [Hotspot](https://github.com/KDAB/hotspot).
 
-See the functional test documentation for how to invoke perf within tests.
-
 ### Valgrind
 
 Valgrind is a programming tool for memory debugging, memory leak detection, and
@@ -702,16 +699,16 @@ and its `cs_KeyStore` lock for example).
   : Performs various loading tasks that are part of init but shouldn't block the node from being started: external block import,
    reindex, reindex-chainstate, main chain activation, spawn indexes background sync threads and mempool load.
 
-- [CCheckQueue::Loop (`b-scriptch.x`)](https://doxygen.bitcoincore.org/class_c_check_queue.html#checkqueue)
+- [CCheckQueue::Loop (`b-scriptch.xx`)](https://doxygen.bitcoincore.org/class_c_check_queue.html#checkqueue)
   : Parallel script validation threads for transactions in blocks.
 
 - [ThreadHTTP (`b-http`)](https://doxygen.bitcoincore.org/httpserver_8cpp.html#http)
   : Libevent thread to listen for RPC and REST connections.
 
-- [HTTP worker threads (`b-http_pool_x`)](https://doxygen.bitcoincore.org/httpserver_8cpp.html#http_pool)
+- [HTTP worker threads (`b-http.xx`)](https://doxygen.bitcoincore.org/httpserver_8cpp.html#http_pool)
   : Threads to service RPC and REST requests.
 
-- [Indexer threads (`b-txindex`, etc)](https://doxygen.bitcoincore.org/class_base_index.html#index_sync)
+- [Indexer threads (`b-txidx`, `b-blkfltbscidx`, `b-coinstatsidx`, `b-txospenderidx`)](https://doxygen.bitcoincore.org/class_base_index.html#index_sync)
   : One thread per indexer.
 
 - [SchedulerThread (`b-scheduler`)](https://doxygen.bitcoincore.org/class_c_scheduler.html#scheduler)
diff --git a/doc/release-notes-35267.md b/doc/release-notes-35267.md
new file mode 100644
index 000000000000..ff9ad4550ef9
--- /dev/null
+++ b/doc/release-notes-35267.md
@@ -0,0 +1,4 @@
+RPC
+---
+
+The `getprivatebroadcastinfo` and `abortprivatebroadcast` RPCs now return an error `-32601`, "Method not found", when `-privatebroadcast` is not enabled at startup.
diff --git a/src/addrman.cpp b/src/addrman.cpp
index 92178f30089b..3050beb7968c 100644
--- a/src/addrman.cpp
+++ b/src/addrman.cpp
@@ -11,6 +11,7 @@
 #include <hash.h>
 #include <logging/timer.h>
 #include <netaddress.h>
+#include <netgroup.h>
 #include <protocol.h>
 #include <random.h>
 #include <serialize.h>
diff --git a/src/addrman.h b/src/addrman.h
index 94e7d3e65379..f714338610c1 100644
--- a/src/addrman.h
+++ b/src/addrman.h
@@ -7,18 +7,22 @@
 #define BITCOIN_ADDRMAN_H
 
 #include <netaddress.h>
-#include <netgroup.h>
 #include <protocol.h>
-#include <streams.h>
 #include <util/time.h>
 
+#include <cstddef>
 #include <cstdint>
+#include <ios>
 #include <memory>
 #include <optional>
+#include <string>
+#include <tuple>
 #include <unordered_set>
 #include <utility>
 #include <vector>
 
+class NetGroupManager;
+
 /** Over how many buckets entries with tried addresses from a single group (/16 for IPv4) are spread */
 static constexpr uint32_t ADDRMAN_TRIED_BUCKETS_PER_GROUP{8};
 /** Over how many buckets entries with new addresses originating from a single group are spread */
diff --git a/src/base58.h b/src/base58.h
index f258163bc3da..1656cbe1d394 100644
--- a/src/base58.h
+++ b/src/base58.h
@@ -14,8 +14,7 @@
 #ifndef BITCOIN_BASE58_H
 #define BITCOIN_BASE58_H
 
-#include <span.h>
-
+#include <span>
 #include <string>
 #include <vector>
 
diff --git a/src/bech32.h b/src/bech32.h
index ba4c79bb8695..9a43a58f396c 100644
--- a/src/bech32.h
+++ b/src/bech32.h
@@ -14,8 +14,10 @@
 #ifndef BITCOIN_BECH32_H
 #define BITCOIN_BECH32_H
 
+#include <cstddef>
 #include <cstdint>
 #include <string>
+#include <utility>
 #include <vector>
 
 namespace bech32
diff --git a/src/bench/addrman.cpp b/src/bench/addrman.cpp
index 703b4d245db4..5ce7893d5365 100644
--- a/src/bench/addrman.cpp
+++ b/src/bench/addrman.cpp
@@ -10,13 +10,13 @@
 #include <netgroup.h>
 #include <protocol.h>
 #include <random.h>
-#include <span.h>
 #include <uint256.h>
 #include <util/check.h>
 #include <util/time.h>
 
 #include <cstring>
 #include <optional>
+#include <span>
 #include <vector>
 
 /* A "source" is a source address from which we have received a bunch of other addresses. */
diff --git a/src/bench/asmap.cpp b/src/bench/asmap.cpp
index e834ea04a278..92b048f746e3 100644
--- a/src/bench/asmap.cpp
+++ b/src/bench/asmap.cpp
@@ -8,10 +8,10 @@
 #include <node/data/ip_asn.dat.h>
 #include <random.h>
 #include <util/asmap.h>
+#include <util/check.h>
 
 #include <algorithm>
 #include <array>
-#include <cassert>
 #include <span>
 #include <string>
 
diff --git a/src/bench/base58.cpp b/src/bench/base58.cpp
index 0be16439c3c1..ed36dc32cfb9 100644
--- a/src/bench/base58.cpp
+++ b/src/bench/base58.cpp
@@ -4,7 +4,6 @@
 
 #include <base58.h>
 #include <bench/bench.h>
-#include <span.h>
 
 #include <array>
 #include <cstring>
diff --git a/src/bench/bech32.cpp b/src/bench/bech32.cpp
index c5e864aed03e..1147bd6d2f6c 100644
--- a/src/bench/bech32.cpp
+++ b/src/bench/bech32.cpp
@@ -6,6 +6,7 @@
 #include <bench/bench.h>
 #include <util/strencodings.h>
 
+#include <array>
 #include <vector>
 
 using namespace util::hex_literals;
diff --git a/src/bench/bench.cpp b/src/bench/bench.cpp
index 45d1b360f659..4d1f4da03290 100644
--- a/src/bench/bench.cpp
+++ b/src/bench/bench.cpp
@@ -7,19 +7,18 @@
 #include <test/util/setup_common.h> // IWYU pragma: keep
 #include <util/check.h>
 #include <util/fs.h>
+#include <util/time.h>
 
-#include <chrono>
 #include <compare>
 #include <fstream>
 #include <functional>
 #include <iostream>
 #include <regex>
 #include <string>
+#include <string_view>
 #include <utility>
 #include <vector>
 
-using namespace std::chrono_literals;
-
 /**
  * Retrieves the available test setup command line arguments that may be used
  * in the benchmark. They will be used only if the benchmark utilizes a
@@ -68,9 +67,9 @@ BenchRunner::BenchmarkMap& BenchRunner::benchmarks()
     return benchmarks_map;
 }
 
-BenchRunner::BenchRunner(std::string name, BenchFunction func)
+BenchRunner::BenchRunner(std::string_view name, BenchFunction func)
 {
-    Assert(benchmarks().try_emplace(std::move(name), std::move(func)).second);
+    Assert(benchmarks().try_emplace(std::string{name}, std::move(func)).second);
 }
 
 void BenchRunner::RunAll(const Args& args)
diff --git a/src/bench/bench.h b/src/bench/bench.h
index f7df42a30384..54c75bc21cab 100644
--- a/src/bench/bench.h
+++ b/src/bench/bench.h
@@ -8,11 +8,12 @@
 #include <bench/nanobench.h> // IWYU pragma: export
 #include <util/fs.h>
 #include <util/macros.h>
+#include <util/time.h>
 
-#include <chrono>
 #include <functional>
 #include <map>
 #include <string>
+#include <string_view>
 #include <vector>
 
 /*
@@ -58,7 +59,7 @@ class BenchRunner
     static BenchmarkMap& benchmarks();
 
 public:
-    BenchRunner(std::string name, BenchFunction func);
+    BenchRunner(std::string_view name, BenchFunction func);
 
     static void RunAll(const Args& args);
 };
diff --git a/src/bench/bench_bitcoin.cpp b/src/bench/bench_bitcoin.cpp
index 987523a128b5..fa0c170f93f4 100644
--- a/src/bench/bench_bitcoin.cpp
+++ b/src/bench/bench_bitcoin.cpp
@@ -3,19 +3,19 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <bench/bench.h>
-#include <common/args.h>
 #include <crypto/sha256.h>
+#include <test/util/setup_common.h>
 #include <tinyformat.h>
 #include <util/fs.h>
-#include <util/string.h>
-#include <test/util/setup_common.h>
+#include <util/time.h>
 
-#include <chrono>
 #include <cstdint>
 #include <cstdlib>
 #include <exception>
 #include <iostream>
+#include <optional>
 #include <sstream>
+#include <string>
 #include <vector>
 
 static const char* DEFAULT_BENCH_FILTER = ".*";
diff --git a/src/bench/bip324_ecdh.cpp b/src/bench/bip324_ecdh.cpp
index 65deb8b74e9e..c8d3a35efc53 100644
--- a/src/bench/bip324_ecdh.cpp
+++ b/src/bench/bip324_ecdh.cpp
@@ -11,6 +11,7 @@
 #include <algorithm>
 #include <array>
 #include <cstddef>
+#include <span>
 
 static void BIP324_ECDH(benchmark::Bench& bench)
 {
diff --git a/src/bench/block_assemble.cpp b/src/bench/block_assemble.cpp
index be03917417e6..45052ecf71cd 100644
--- a/src/bench/block_assemble.cpp
+++ b/src/bench/block_assemble.cpp
@@ -12,13 +12,12 @@
 #include <test/util/mining.h>
 #include <test/util/script.h>
 #include <test/util/setup_common.h>
+#include <util/check.h>
 #include <validation.h>
 
 #include <array>
-#include <cassert>
 #include <cstddef>
 #include <memory>
-#include <string>
 #include <vector>
 
 using node::BlockCreateOptions;
diff --git a/src/bench/blockencodings.cpp b/src/bench/blockencodings.cpp
index ce968dbc6516..274474d498cd 100644
--- a/src/bench/blockencodings.cpp
+++ b/src/bench/blockencodings.cpp
@@ -7,15 +7,23 @@
 #include <consensus/amount.h>
 #include <kernel/cs_main.h>
 #include <net_processing.h>
+#include <primitives/block.h>
 #include <primitives/transaction.h>
+#include <random.h>
 #include <script/script.h>
 #include <sync.h>
 #include <test/util/setup_common.h>
 #include <test/util/txmempool.h>
 #include <txmempool.h>
+#include <uint256.h>
 #include <util/check.h>
 
+#include <algorithm>
+#include <array>
+#include <cstddef>
 #include <memory>
+#include <span>
+#include <utility>
 #include <vector>
 
 
diff --git a/src/bench/ccoins_caching.cpp b/src/bench/ccoins_caching.cpp
index 12ea07608010..ec44e6631dd3 100644
--- a/src/bench/ccoins_caching.cpp
+++ b/src/bench/ccoins_caching.cpp
@@ -5,14 +5,16 @@
 #include <bench/bench.h>
 #include <coins.h>
 #include <consensus/amount.h>
+#include <consensus/validation.h>
 #include <key.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <script/signingprovider.h>
 #include <test/util/transaction_utils.h>
+#include <util/check.h>
 
-#include <cassert>
+#include <span>
 #include <vector>
 
 // Microbenchmark for simple accesses to a CCoinsViewCache database. Note from
diff --git a/src/bench/chacha20.cpp b/src/bench/chacha20.cpp
index b5a333d00268..cc2b57ebbeb8 100644
--- a/src/bench/chacha20.cpp
+++ b/src/bench/chacha20.cpp
@@ -2,15 +2,16 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-
 #include <bench/bench.h>
 #include <crypto/chacha20.h>
 #include <crypto/chacha20poly1305.h>
-#include <span.h>
-#include <util/byte_units.h>
+// IWYU incorrectly suggests removing this header.
+// See https://github.com/include-what-you-use/include-what-you-use/issues/2014.
+#include <util/byte_units.h> // IWYU pragma: keep
 
 #include <cstddef>
 #include <cstdint>
+#include <span>
 #include <vector>
 
 /* Number of bytes to process per iteration */
diff --git a/src/bench/checkblock.cpp b/src/bench/checkblock.cpp
index b943dc0f82b3..e041159e1d58 100644
--- a/src/bench/checkblock.cpp
+++ b/src/bench/checkblock.cpp
@@ -5,13 +5,17 @@
 #include <bench/bench.h>
 #include <bench/data/block413567.raw.h>
 #include <consensus/validation.h>
+#include <kernel/chainparams.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
+#include <serialize.h>
 #include <streams.h>
+#include <util/check.h>
 #include <validation.h>
 
-#include <cassert>
-#include <cstddef>
+#include <memory>
+#include <span>
+#include <vector>
 
 // These are the two major time-sinks which happen after we have fully received
 // a block off the wire, but before we can relay the block on to peers using
@@ -40,9 +44,8 @@ static void CheckBlockTest(benchmark::Bench& bench)
             assert(block.vtx.size() == 1557);
         })
         .run([&] {
-            BlockValidationState validationState;
-            const bool checked{CheckBlock(block, validationState, chain_params->GetConsensus())};
-            assert(checked);
+            BlockValidationState validationState{CheckBlock(block, chain_params->GetConsensus())};
+            assert(validationState.IsValid());
         });
 }
 
diff --git a/src/bench/checkqueue.cpp b/src/bench/checkqueue.cpp
index 2c9126dd6628..20f3094b8586 100644
--- a/src/bench/checkqueue.cpp
+++ b/src/bench/checkqueue.cpp
@@ -12,6 +12,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <optional>
 #include <utility>
 #include <vector>
 
diff --git a/src/bench/cluster_linearize.cpp b/src/bench/cluster_linearize.cpp
index 0799cc2c2e9d..6d4c8382e09d 100644
--- a/src/bench/cluster_linearize.cpp
+++ b/src/bench/cluster_linearize.cpp
@@ -4,13 +4,18 @@
 
 #include <bench/bench.h>
 #include <cluster_linearize.h>
+#include <serialize.h>
+#include <streams.h>
 #include <test/util/cluster_linearize.h>
+#include <tinyformat.h>
 #include <util/bitset.h>
+#include <util/check.h>
 #include <util/strencodings.h>
 
-#include <algorithm>
-#include <cassert>
 #include <cstdint>
+#include <span>
+#include <string>
+#include <tuple>
 #include <vector>
 
 using namespace cluster_linearize;
diff --git a/src/bench/coin_selection.cpp b/src/bench/coin_selection.cpp
index ff682720ab0d..4f203fe8618b 100644
--- a/src/bench/coin_selection.cpp
+++ b/src/bench/coin_selection.cpp
@@ -4,8 +4,6 @@
 
 #include <bench/bench.h>
 #include <consensus/amount.h>
-#include <interfaces/chain.h>
-#include <node/context.h>
 #include <outputtype.h>
 #include <policy/feerate.h>
 #include <policy/policy.h>
@@ -13,19 +11,21 @@
 #include <random.h>
 #include <sync.h>
 #include <test/util/setup_common.h>
+#include <util/check.h>
 #include <util/result.h>
 #include <wallet/coinselection.h>
-#include <wallet/context.h>
+#include <wallet/db.h>
 #include <wallet/spend.h>
 #include <wallet/test/util.h>
 #include <wallet/transaction.h>
 #include <wallet/wallet.h>
 
-#include <cassert>
+#include <cstddef>
+#include <cstdint>
 #include <map>
 #include <memory>
 #include <optional>
-#include <set>
+#include <string>
 #include <utility>
 #include <vector>
 
diff --git a/src/bench/connectblock.cpp b/src/bench/connectblock.cpp
index 0c7470b56c8c..5d530a5ac643 100644
--- a/src/bench/connectblock.cpp
+++ b/src/bench/connectblock.cpp
@@ -17,13 +17,12 @@
 #include <script/script.h>
 #include <sync.h>
 #include <test/util/setup_common.h>
+#include <util/check.h>
 #include <validation.h>
 
-#include <cassert>
 #include <cstddef>
 #include <memory>
 #include <optional>
-#include <string>
 #include <utility>
 #include <vector>
 
diff --git a/src/bench/crypto_hash.cpp b/src/bench/crypto_hash.cpp
index 666ff3c053c9..4d0660db5806 100644
--- a/src/bench/crypto_hash.cpp
+++ b/src/bench/crypto_hash.cpp
@@ -2,7 +2,6 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-
 #include <bench/bench.h>
 #include <crypto/muhash.h>
 #include <crypto/ripemd160.h>
@@ -12,11 +11,12 @@
 #include <crypto/sha512.h>
 #include <crypto/siphash.h>
 #include <random.h>
-#include <span.h>
 #include <tinyformat.h>
 #include <uint256.h>
 
 #include <cstdint>
+#include <span>
+#include <string>
 #include <vector>
 
 /* Number of bytes to hash per iteration */
diff --git a/src/bench/descriptors.cpp b/src/bench/descriptors.cpp
index c375d31211ba..af5dc46b0588 100644
--- a/src/bench/descriptors.cpp
+++ b/src/bench/descriptors.cpp
@@ -7,8 +7,8 @@
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/signingprovider.h>
+#include <util/check.h>
 
-#include <cassert>
 #include <cstdint>
 #include <memory>
 #include <string>
diff --git a/src/bench/disconnected_transactions.cpp b/src/bench/disconnected_transactions.cpp
index 4dd5de42ca25..1ab2ec6cd6ef 100644
--- a/src/bench/disconnected_transactions.cpp
+++ b/src/bench/disconnected_transactions.cpp
@@ -8,13 +8,12 @@
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <test/util/setup_common.h>
+#include <util/check.h>
 
 #include <algorithm>
-#include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
-#include <memory>
 #include <vector>
 
 constexpr size_t BLOCK_VTX_COUNT{4000};
diff --git a/src/bench/duplicate_inputs.cpp b/src/bench/duplicate_inputs.cpp
index 5b1ca5f552f7..370b403410ce 100644
--- a/src/bench/duplicate_inputs.cpp
+++ b/src/bench/duplicate_inputs.cpp
@@ -16,9 +16,9 @@
 #include <sync.h>
 #include <test/util/setup_common.h>
 #include <uint256.h>
+#include <util/check.h>
 #include <validation.h>
 
-#include <cassert>
 #include <cstdint>
 #include <memory>
 #include <string>
@@ -70,8 +70,8 @@ static void DuplicateInputs(benchmark::Bench& bench)
     block.hashMerkleRoot = BlockMerkleRoot(block);
 
     bench.run([&] {
-        BlockValidationState cvstate{};
-        assert(!CheckBlock(block, cvstate, chainparams.GetConsensus(), false, false));
+        BlockValidationState cvstate{CheckBlock(block, chainparams.GetConsensus(), false, false)};
+        assert(!cvstate.IsValid());
         assert(cvstate.GetRejectReason() == "bad-txns-inputs-duplicate");
     });
 }
diff --git a/src/bench/ellswift.cpp b/src/bench/ellswift.cpp
index 2daf1a9e9e89..2951ca9b7ffc 100644
--- a/src/bench/ellswift.cpp
+++ b/src/bench/ellswift.cpp
@@ -8,9 +8,10 @@
 #include <random.h>
 #include <span.h>
 #include <uint256.h>
+#include <util/check.h>
 
 #include <algorithm>
-#include <cassert>
+#include <span>
 
 static void EllSwiftCreate(benchmark::Bench& bench)
 {
diff --git a/src/bench/index_blockfilter.cpp b/src/bench/index_blockfilter.cpp
index 805ad050bfcc..a945754f2ce7 100644
--- a/src/bench/index_blockfilter.cpp
+++ b/src/bench/index_blockfilter.cpp
@@ -13,16 +13,16 @@
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <script/script.h>
-#include <span.h>
 #include <sync.h>
 #include <test/util/setup_common.h>
+#include <test/util/time.h>
 #include <uint256.h>
+#include <util/check.h>
 #include <util/strencodings.h>
-#include <util/time.h>
 #include <validation.h>
 
-#include <cassert>
 #include <memory>
+#include <span>
 #include <vector>
 
 using namespace util::hex_literals;
@@ -39,7 +39,7 @@ static void BlockFilterIndexSync(benchmark::Bench& bench)
     std::vector<CMutableTransaction> noTxns;
     for (int i = 0; i < CHAIN_SIZE - 100; i++) {
         test_setup->CreateAndProcessBlock(noTxns, script);
-        SetMockTime(GetTime() + 1);
+        test_setup->m_clock += 1s;
     }
     assert(WITH_LOCK(::cs_main, return test_setup->m_node.chainman->ActiveHeight() == CHAIN_SIZE));
 
diff --git a/src/bench/load_external.cpp b/src/bench/load_external.cpp
index 8e7201eaa520..77c229f1fea5 100644
--- a/src/bench/load_external.cpp
+++ b/src/bench/load_external.cpp
@@ -7,7 +7,6 @@
 #include <chainparams.h>
 #include <flatfile.h>
 #include <node/blockstorage.h>
-#include <span.h>
 #include <streams.h>
 #include <test/util/setup_common.h>
 #include <uint256.h>
@@ -18,8 +17,8 @@
 #include <cstdio>
 #include <map>
 #include <memory>
+#include <span>
 #include <stdexcept>
-#include <vector>
 
 /**
  * The LoadExternalBlockFile() function is used during -reindex and -loadblock.
diff --git a/src/bench/lockedpool.cpp b/src/bench/lockedpool.cpp
index 61b35cce2bbf..0a924a729bfa 100644
--- a/src/bench/lockedpool.cpp
+++ b/src/bench/lockedpool.cpp
@@ -4,10 +4,12 @@
 
 #include <bench/bench.h>
 #include <support/lockedpool.h>
+// IWYU incorrectly suggests removing this header.
+// See https://github.com/include-what-you-use/include-what-you-use/issues/2014.
+#include <util/byte_units.h> // IWYU pragma: keep
 
 #include <cstddef>
 #include <cstdint>
-#include <util/byte_units.h>
 #include <vector>
 
 #define ASIZE 2048
diff --git a/src/bench/mempool_ephemeral_spends.cpp b/src/bench/mempool_ephemeral_spends.cpp
index 1c0692878bd5..f88643c5b1a9 100644
--- a/src/bench/mempool_ephemeral_spends.cpp
+++ b/src/bench/mempool_ephemeral_spends.cpp
@@ -4,9 +4,10 @@
 
 #include <bench/bench.h>
 #include <consensus/amount.h>
+#include <consensus/validation.h>
 #include <kernel/cs_main.h>
 #include <policy/ephemeral_policy.h>
-#include <policy/policy.h>
+#include <policy/feerate.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <sync.h>
@@ -15,6 +16,7 @@
 #include <txmempool.h>
 #include <util/check.h>
 
+#include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <vector>
diff --git a/src/bench/mempool_stress.cpp b/src/bench/mempool_stress.cpp
index 1f582081ea9c..ab1146e1dc96 100644
--- a/src/bench/mempool_stress.cpp
+++ b/src/bench/mempool_stress.cpp
@@ -4,7 +4,6 @@
 
 #include <bench/bench.h>
 #include <consensus/amount.h>
-#include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <script/script.h>
@@ -17,6 +16,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <memory>
+#include <optional>
 #include <vector>
 
 class CCoinsViewCache;
diff --git a/src/bench/merkle_root.cpp b/src/bench/merkle_root.cpp
index 17f7fa8691ca..d80ddb21d684 100644
--- a/src/bench/merkle_root.cpp
+++ b/src/bench/merkle_root.cpp
@@ -6,8 +6,10 @@
 #include <consensus/merkle.h>
 #include <random.h>
 #include <uint256.h>
+#include <util/check.h>
 
-#include <cassert>
+#include <initializer_list>
+#include <utility>
 #include <vector>
 
 static void MerkleRoot(benchmark::Bench& bench)
diff --git a/src/bench/nanobench.h b/src/bench/nanobench.h
index 79a384aa56f6..785129086834 100644
--- a/src/bench/nanobench.h
+++ b/src/bench/nanobench.h
@@ -41,10 +41,19 @@
 
 #include <chrono>        // high_resolution_clock
 #include <cassert>       // assert
+#include <cstdint>
 #include <cstring>       // memcpy
+// IWYU will only see this header with ANKERL_NANOBENCH_IMPLEMENT defined, which
+// makes it suggest removing forward declarations for the Input/output library.
+// IWYU pragma: begin_keep
 #include <iosfwd>        // for std::ostream* custom output target in Config
+// IWYU pragma: end_keep
+#include <limits>
+#include <ratio>
 #include <string>        // all names
+#include <type_traits>
 #include <unordered_map> // holds context information of results
+#include <utility>
 #include <vector>        // holds all results
 
 #define ANKERL_NANOBENCH(x) ANKERL_NANOBENCH_PRIVATE_##x()
@@ -127,6 +136,11 @@
 
 // declarations ///////////////////////////////////////////////////////////////////////////////////
 
+// As definitions follow these declarations within this
+// header, IWYU considers some of them redundant and
+// suggests removing them. Disable this IWYU behavior.
+// IWYU pragma: begin_keep
+
 namespace ankerl {
 namespace nanobench {
 
@@ -370,6 +384,8 @@ class LinuxPerformanceCounters;
 } // namespace nanobench
 } // namespace ankerl
 
+// IWYU pragma: end_keep
+
 // definitions ////////////////////////////////////////////////////////////////////////////////////
 
 namespace ankerl {
@@ -1359,12 +1375,15 @@ void doNotOptimizeAway(T const& val) {
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #    include <algorithm> // sort, reverse
-#    include <atomic>    // compare_exchange_strong in loop overhead
+#    include <cmath>
+#    include <compare>
 #    include <cstdlib>   // getenv
-#    include <cstring>   // strstr, strncmp
 #    include <fstream>   // ifstream to parse proc files
+#    include <functional>
 #    include <iomanip>   // setw, setprecision
 #    include <iostream>  // cout
+#    include <iterator>
+#    include <locale>
 #    include <numeric>   // accumulate
 #    include <random>    // random_device
 #    include <sstream>   // to_s in Number
@@ -1379,18 +1398,22 @@ void doNotOptimizeAway(T const& val) {
 #        include <linux/perf_event.h>
 #        include <sys/ioctl.h>
 #        include <sys/syscall.h>
+#        include <sys/types.h>
 #    endif
 
 // declarations ///////////////////////////////////////////////////////////////////////////////////
 
+// As definitions follow these declarations within this
+// header, IWYU considers some of them redundant and
+// suggests removing them. Disable this IWYU behavior.
+// IWYU pragma: begin_keep
+
 namespace ankerl {
 namespace nanobench {
 
 // helper stuff that is only intended to be used internally
 namespace detail {
 
-struct TableInfo;
-
 // formatting utilities
 namespace fmt {
 
@@ -1405,6 +1428,8 @@ class MarkDownCode;
 } // namespace nanobench
 } // namespace ankerl
 
+// IWYU pragma: end_keep
+
 // definitions ////////////////////////////////////////////////////////////////////////////////////
 
 namespace ankerl {
diff --git a/src/bench/obfuscation.cpp b/src/bench/obfuscation.cpp
index c7392e038540..1587b7349857 100644
--- a/src/bench/obfuscation.cpp
+++ b/src/bench/obfuscation.cpp
@@ -7,6 +7,7 @@
 #include <util/obfuscation.h>
 
 #include <cstddef>
+#include <span>
 #include <vector>
 
 static void ObfuscationBench(benchmark::Bench& bench)
diff --git a/src/bench/parse_hex.cpp b/src/bench/parse_hex.cpp
index 928176bdc1c9..846009a3980e 100644
--- a/src/bench/parse_hex.cpp
+++ b/src/bench/parse_hex.cpp
@@ -4,11 +4,12 @@
 
 #include <bench/bench.h>
 #include <random.h>
+#include <util/check.h>
 #include <util/strencodings.h>
 
-#include <cassert>
 #include <cstddef>
 #include <optional>
+#include <string>
 #include <vector>
 
 std::string generateHexString(size_t length) {
diff --git a/src/bench/peer_eviction.cpp b/src/bench/peer_eviction.cpp
index 24b78e3179cf..b9c1c9b33743 100644
--- a/src/bench/peer_eviction.cpp
+++ b/src/bench/peer_eviction.cpp
@@ -7,8 +7,8 @@
 #include <node/eviction.h>
 #include <random.h>
 #include <test/util/net.h>
+#include <util/time.h>
 
-#include <chrono>
 #include <functional>
 #include <vector>
 
diff --git a/src/bench/poly1305.cpp b/src/bench/poly1305.cpp
index ef5a573d9b4a..a3d0f94b72cb 100644
--- a/src/bench/poly1305.cpp
+++ b/src/bench/poly1305.cpp
@@ -2,14 +2,15 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-
 #include <bench/bench.h>
 #include <crypto/poly1305.h>
-#include <span.h>
-#include <util/byte_units.h>
+// IWYU incorrectly suggests removing this header.
+// See https://github.com/include-what-you-use/include-what-you-use/issues/2014.
+#include <util/byte_units.h> // IWYU pragma: keep
 
 #include <cstddef>
 #include <cstdint>
+#include <span>
 #include <vector>
 
 /* Number of bytes to process per iteration */
diff --git a/src/bench/prevector.cpp b/src/bench/prevector.cpp
index e842aec4ed25..2b5544fe0544 100644
--- a/src/bench/prevector.cpp
+++ b/src/bench/prevector.cpp
@@ -9,6 +9,7 @@
 #include <serialize.h>
 #include <streams.h>
 
+#include <span>
 #include <type_traits>
 #include <vector>
 
diff --git a/src/bench/readwriteblock.cpp b/src/bench/readwriteblock.cpp
index b8e226c6eb96..984936dbd48a 100644
--- a/src/bench/readwriteblock.cpp
+++ b/src/bench/readwriteblock.cpp
@@ -9,15 +9,16 @@
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <serialize.h>
-#include <span.h>
 #include <streams.h>
+#include <sync.h>
 #include <test/util/setup_common.h>
+#include <uint256.h>
+#include <util/check.h>
 #include <validation.h>
 
-#include <cassert>
-#include <cstdint>
 #include <memory>
-#include <vector>
+#include <optional>
+#include <span>
 
 static CBlock CreateTestBlock()
 {
@@ -32,6 +33,7 @@ static void WriteBlockBench(benchmark::Bench& bench)
     auto& blockman{testing_setup->m_node.chainman->m_blockman};
     const CBlock block{CreateTestBlock()};
     bench.run([&] {
+        LOCK(::cs_main);
         const auto pos{blockman.WriteBlock(block, 413'567)};
         assert(!pos.IsNull());
     });
@@ -43,7 +45,7 @@ static void ReadBlockBench(benchmark::Bench& bench)
     auto& blockman{testing_setup->m_node.chainman->m_blockman};
     const auto& test_block{CreateTestBlock()};
     const auto& expected_hash{test_block.GetHash()};
-    const auto& pos{blockman.WriteBlock(test_block, 413'567)};
+    const auto& pos{WITH_LOCK(::cs_main, return blockman.WriteBlock(test_block, 413'567))};
     bench.run([&] {
         CBlock block;
         const auto success{blockman.ReadBlock(block, pos, expected_hash)};
@@ -55,7 +57,7 @@ static void ReadRawBlockBench(benchmark::Bench& bench)
 {
     const auto testing_setup{MakeNoLogFileContext<const TestingSetup>(ChainType::MAIN)};
     auto& blockman{testing_setup->m_node.chainman->m_blockman};
-    const auto pos{blockman.WriteBlock(CreateTestBlock(), 413'567)};
+    const auto pos{WITH_LOCK(::cs_main, return blockman.WriteBlock(CreateTestBlock(), 413'567))};
     bench.run([&] {
         const auto res{blockman.ReadRawBlock(pos)};
         assert(res);
diff --git a/src/bench/rollingbloom.cpp b/src/bench/rollingbloom.cpp
index 8331eb6a7c90..0f9bc9e8969b 100644
--- a/src/bench/rollingbloom.cpp
+++ b/src/bench/rollingbloom.cpp
@@ -2,13 +2,12 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-
 #include <bench/bench.h>
 #include <common/bloom.h>
 #include <crypto/common.h>
-#include <span.h>
 
 #include <cstdint>
+#include <span>
 #include <vector>
 
 static void RollingBloom(benchmark::Bench& bench)
diff --git a/src/bench/rpc_blockchain.cpp b/src/bench/rpc_blockchain.cpp
index fe83c4a26f7a..b09eae6424eb 100644
--- a/src/bench/rpc_blockchain.cpp
+++ b/src/bench/rpc_blockchain.cpp
@@ -5,21 +5,22 @@
 #include <bench/bench.h>
 #include <bench/data/block413567.raw.h>
 #include <chain.h>
+#include <consensus/params.h>
 #include <core_io.h>
+#include <kernel/chainparams.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <rpc/blockchain.h>
 #include <serialize.h>
-#include <span.h>
 #include <streams.h>
 #include <test/util/setup_common.h>
 #include <uint256.h>
 #include <univalue.h>
 #include <validation.h>
 
-#include <cstddef>
 #include <memory>
-#include <vector>
+#include <span>
+#include <string>
 
 namespace {
 
diff --git a/src/bench/sign_transaction.cpp b/src/bench/sign_transaction.cpp
index 63a5d97f5190..38955595c882 100644
--- a/src/bench/sign_transaction.cpp
+++ b/src/bench/sign_transaction.cpp
@@ -8,17 +8,17 @@
 #include <key.h>
 #include <primitives/transaction.h>
 #include <pubkey.h>
+#include <random.h>
 #include <script/interpreter.h>
 #include <script/script.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
-#include <span.h>
-#include <test/util/random.h>
 #include <uint256.h>
+#include <util/check.h>
 #include <util/translation.h>
 
-#include <cassert>
 #include <map>
+#include <span>
 #include <vector>
 
 enum class InputType {
diff --git a/src/bench/streams_findbyte.cpp b/src/bench/streams_findbyte.cpp
index c9ea486c697e..456f5aef9b2c 100644
--- a/src/bench/streams_findbyte.cpp
+++ b/src/bench/streams_findbyte.cpp
@@ -5,11 +5,13 @@
 #include <bench/bench.h>
 #include <streams.h>
 #include <test/util/setup_common.h>
+#include <util/check.h>
 #include <util/fs.h>
 
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
+#include <memory>
 
 static void FindByte(benchmark::Bench& bench)
 {
diff --git a/src/bench/strencodings.cpp b/src/bench/strencodings.cpp
index c00de181b544..4b52b7444492 100644
--- a/src/bench/strencodings.cpp
+++ b/src/bench/strencodings.cpp
@@ -6,9 +6,10 @@
 #include <consensus/consensus.h>
 #include <crypto/hex_base.h>
 #include <random.h>
-#include <span.h>
-#include <util/strencodings.h>
 
+#include <cstddef>
+#include <span>
+#include <string>
 #include <vector>
 
 static void HexStrBench(benchmark::Bench& bench)
diff --git a/src/bench/txgraph.cpp b/src/bench/txgraph.cpp
index c56a284aa25d..57081dd9edbe 100644
--- a/src/bench/txgraph.cpp
+++ b/src/bench/txgraph.cpp
@@ -5,10 +5,17 @@
 #include <bench/bench.h>
 #include <random.h>
 #include <txgraph.h>
+#include <util/check.h>
 #include <util/feefrac.h>
 
-#include <cassert>
+#include <algorithm>
+#include <compare>
+#include <cstddef>
 #include <cstdint>
+#include <functional>
+#include <memory>
+#include <utility>
+#include <vector>
 
 namespace {
 
diff --git a/src/bench/txorphanage.cpp b/src/bench/txorphanage.cpp
index 1f94553bc4d3..8765a7b9f5d4 100644
--- a/src/bench/txorphanage.cpp
+++ b/src/bench/txorphanage.cpp
@@ -3,19 +3,24 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <bench/bench.h>
-#include <consensus/amount.h>
+#include <consensus/consensus.h>
+#include <consensus/validation.h>
 #include <net.h>
 #include <policy/policy.h>
+#include <primitives/block.h>
 #include <primitives/transaction.h>
-#include <pubkey.h>
-#include <script/sign.h>
-#include <test/util/setup_common.h>
 #include <node/txorphanage.h>
-#include <util/check.h>
+#include <random.h>
 #include <test/util/transaction_utils.h>
+#include <threadsafety.h>
+#include <util/check.h>
 
+#include <algorithm>
+#include <cstddef>
 #include <cstdint>
 #include <memory>
+#include <numeric>
+#include <vector>
 
 static constexpr node::TxOrphanage::Usage TINY_TX_WEIGHT{240};
 static constexpr int64_t APPROX_WEIGHT_PER_INPUT{200};
diff --git a/src/bench/util_time.cpp b/src/bench/util_time.cpp
index 19ffd0e04985..0079549c0d1f 100644
--- a/src/bench/util_time.cpp
+++ b/src/bench/util_time.cpp
@@ -15,7 +15,7 @@ static void BenchTimeDeprecated(benchmark::Bench& bench)
 
 static void BenchTimeMock(benchmark::Bench& bench)
 {
-    NodeClockContext clock_ctx{111s};
+    FakeNodeClock clock{111s};
     bench.run([&] {
         (void)GetTime<std::chrono::seconds>();
     });
diff --git a/src/bench/verify_script.cpp b/src/bench/verify_script.cpp
index 63a9544ad981..b6d73b8679ac 100644
--- a/src/bench/verify_script.cpp
+++ b/src/bench/verify_script.cpp
@@ -11,14 +11,19 @@
 #include <pubkey.h>
 #include <script/interpreter.h>
 #include <script/script.h>
+#include <script/script_error.h>
+#include <script/sign.h>
+#include <script/signingprovider.h>
+#include <script/verify_flags.h>
 #include <span.h>
 #include <test/util/transaction_utils.h>
 #include <uint256.h>
+#include <util/check.h>
 #include <util/translation.h>
 
-#include <array>
-#include <cassert>
-#include <cstdint>
+#include <cstddef>
+#include <map>
+#include <span>
 #include <vector>
 
 enum class ScriptType {
diff --git a/src/bench/wallet_balance.cpp b/src/bench/wallet_balance.cpp
index 07fd46a9fca0..958044e2e407 100644
--- a/src/bench/wallet_balance.cpp
+++ b/src/bench/wallet_balance.cpp
@@ -4,6 +4,7 @@
 
 #include <bench/bench.h>
 #include <interfaces/chain.h>
+#include <interfaces/handler.h>
 #include <kernel/chainparams.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
@@ -12,14 +13,14 @@
 #include <test/util/setup_common.h>
 #include <test/util/time.h>
 #include <uint256.h>
-#include <util/time.h>
+#include <util/check.h>
 #include <validation.h>
+#include <wallet/db.h>
 #include <wallet/receive.h>
 #include <wallet/test/util.h>
 #include <wallet/wallet.h>
 #include <wallet/walletutil.h>
 
-#include <cassert>
 #include <memory>
 #include <optional>
 #include <string>
@@ -33,7 +34,7 @@ static void WalletBalance(benchmark::Bench& bench, const bool set_dirty, const b
 
     // Set clock to genesis block, so the descriptors/keys creation time don't interfere with the blocks scanning process.
     // The reason is 'generatetoaddress', which creates a chain with deterministic timestamps in the past.
-    NodeClockContext clock_ctx{test_setup->m_node.chainman->GetParams().GenesisBlock().Time()};
+    FakeNodeClock clock{test_setup->m_node.chainman->GetParams().GenesisBlock().Time()};
     CWallet wallet{test_setup->m_node.chain.get(), "", CreateMockableWalletDatabase()};
     {
         LOCK(wallet.cs_wallet);
diff --git a/src/bench/wallet_create.cpp b/src/bench/wallet_create.cpp
index 11244fe84442..13e8ee148312 100644
--- a/src/bench/wallet_create.cpp
+++ b/src/bench/wallet_create.cpp
@@ -4,9 +4,9 @@
 
 #include <bench/bench.h>
 #include <random.h>
-#include <support/allocators/secure.h>
 #include <test/util/setup_common.h>
 #include <uint256.h>
+#include <util/check.h>
 #include <util/fs.h>
 #include <util/translation.h>
 #include <wallet/context.h>
@@ -14,7 +14,6 @@
 #include <wallet/wallet.h>
 #include <wallet/walletutil.h>
 
-#include <cassert>
 #include <memory>
 #include <optional>
 #include <string>
diff --git a/src/bench/wallet_create_tx.cpp b/src/bench/wallet_create_tx.cpp
index 11125e26fed0..394f21ce187d 100644
--- a/src/bench/wallet_create_tx.cpp
+++ b/src/bench/wallet_create_tx.cpp
@@ -9,7 +9,6 @@
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
 #include <consensus/merkle.h>
-#include <interfaces/chain.h>
 #include <kernel/chain.h>
 #include <kernel/types.h>
 #include <node/blockstorage.h>
@@ -22,22 +21,24 @@
 #include <test/util/setup_common.h>
 #include <test/util/time.h>
 #include <uint256.h>
+#include <util/check.h>
 #include <util/result.h>
-#include <util/time.h>
 #include <validation.h>
 #include <versionbits.h>
 #include <wallet/coincontrol.h>
 #include <wallet/coinselection.h>
+#include <wallet/db.h>
 #include <wallet/spend.h>
 #include <wallet/test/util.h>
+#include <wallet/types.h>
 #include <wallet/wallet.h>
 #include <wallet/walletutil.h>
 
-#include <cassert>
 #include <cstdint>
 #include <map>
 #include <memory>
 #include <optional>
+#include <string>
 #include <utility>
 #include <vector>
 
@@ -118,7 +119,7 @@ static void WalletCreateTx(benchmark::Bench& bench, const OutputType output_type
     const auto test_setup = MakeNoLogFileContext<const TestingSetup>();
 
     // Set clock to genesis block, so the descriptors/keys creation time don't interfere with the blocks scanning process.
-    NodeClockContext clock_ctx{test_setup->m_node.chainman->GetParams().GenesisBlock().Time()};
+    FakeNodeClock clock{test_setup->m_node.chainman->GetParams().GenesisBlock().Time()};
     CWallet wallet{test_setup->m_node.chain.get(), "", CreateMockableWalletDatabase()};
     {
         LOCK(wallet.cs_wallet);
@@ -173,7 +174,7 @@ static void AvailableCoins(benchmark::Bench& bench, const std::vector<OutputType
 {
     const auto test_setup = MakeNoLogFileContext<const TestingSetup>();
     // Set clock to genesis block, so the descriptors/keys creation time don't interfere with the blocks scanning process.
-    NodeClockContext clock_ctx{test_setup->m_node.chainman->GetParams().GenesisBlock().Time()};
+    FakeNodeClock clock{test_setup->m_node.chainman->GetParams().GenesisBlock().Time()};
     CWallet wallet{test_setup->m_node.chain.get(), "", CreateMockableWalletDatabase()};
     {
         LOCK(wallet.cs_wallet);
diff --git a/src/bench/wallet_encrypt.cpp b/src/bench/wallet_encrypt.cpp
index 1f4db614dfc7..81e64a282a74 100644
--- a/src/bench/wallet_encrypt.cpp
+++ b/src/bench/wallet_encrypt.cpp
@@ -3,18 +3,29 @@
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
 #include <bench/bench.h>
+#include <key.h>
 #include <key_io.h>
-#include <outputtype.h>
 #include <random.h>
+#include <script/descriptor.h>
+#include <script/signingprovider.h>
 #include <support/allocators/secure.h>
+#include <sync.h>
 #include <test/util/setup_common.h>
-#include <util/time.h>
+#include <test/util/time.h>
+#include <util/check.h>
 #include <wallet/context.h>
+#include <wallet/crypter.h>
+#include <wallet/db.h>
 #include <wallet/test/util.h>
 #include <wallet/wallet.h>
 #include <wallet/walletutil.h>
 
-#include <cassert>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
 
 namespace wallet {
 static void WalletEncrypt(benchmark::Bench& bench, unsigned int key_count)
@@ -44,7 +55,7 @@ static void WalletEncrypt(benchmark::Bench& bench, unsigned int key_count)
 
     // Setting a mock time is necessary to force default derive iteration count during
     // wallet encryption.
-    SetMockTime(1);
+    FakeNodeClock clock{1s};
 
     std::unique_ptr<WalletDatabase> database;
     std::shared_ptr<CWallet> wallet;
diff --git a/src/bench/wallet_ismine.cpp b/src/bench/wallet_ismine.cpp
index 6bfbb42de429..572a2717f223 100644
--- a/src/bench/wallet_ismine.cpp
+++ b/src/bench/wallet_ismine.cpp
@@ -11,17 +11,19 @@
 #include <script/signingprovider.h>
 #include <sync.h>
 #include <test/util/setup_common.h>
+#include <util/check.h>
 #include <wallet/context.h>
 #include <wallet/db.h>
 #include <wallet/test/util.h>
 #include <wallet/wallet.h>
 #include <wallet/walletutil.h>
 
-#include <cassert>
 #include <cstdint>
+#include <functional>
 #include <memory>
 #include <string>
 #include <utility>
+#include <vector>
 
 namespace wallet {
 static void WalletIsMine(benchmark::Bench& bench, int num_combo = 0)
diff --git a/src/bench/wallet_loading.cpp b/src/bench/wallet_loading.cpp
index 09028acdb030..6b1208ea0bea 100644
--- a/src/bench/wallet_loading.cpp
+++ b/src/bench/wallet_loading.cpp
@@ -7,8 +7,10 @@
 #include <consensus/amount.h>
 #include <outputtype.h>
 #include <primitives/transaction.h>
+#include <script/script.h>
 #include <test/util/setup_common.h>
 #include <util/check.h>
+#include <util/translation.h>
 #include <wallet/context.h>
 #include <wallet/db.h>
 #include <wallet/test/util.h>
@@ -18,6 +20,8 @@
 
 #include <cstdint>
 #include <memory>
+#include <optional>
+#include <string>
 #include <utility>
 #include <vector>
 
diff --git a/src/bench/wallet_migration.cpp b/src/bench/wallet_migration.cpp
index 578fdb50d6b1..22caec7548d7 100644
--- a/src/bench/wallet_migration.cpp
+++ b/src/bench/wallet_migration.cpp
@@ -2,20 +2,34 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
+#include <addresstype.h>
 #include <bench/bench.h>
-#include <interfaces/chain.h>
+#include <consensus/amount.h>
 #include <interfaces/wallet.h>
-#include <kernel/chain.h>
-#include <kernel/types.h>
-#include <node/context.h>
-#include <test/util/mining.h>
+#include <key.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
+#include <pubkey.h>
+#include <script/script.h>
+#include <sync.h>
 #include <test/util/setup_common.h>
-#include <wallet/context.h>
-#include <wallet/receive.h>
+#include <tinyformat.h>
+#include <util/check.h>
+#include <util/result.h>
+#include <wallet/db.h>
+#include <wallet/scriptpubkeyman.h>
 #include <wallet/test/util.h>
+#include <wallet/transaction.h>
 #include <wallet/wallet.h>
+#include <wallet/walletdb.h>
 
+#include <algorithm>
+#include <cstddef>
+#include <memory>
 #include <optional>
+#include <string>
+#include <utility>
+#include <vector>
 
 namespace wallet{
 
diff --git a/src/bip324.h b/src/bip324.h
index 396a28a44894..821cc3f759fc 100644
--- a/src/bip324.h
+++ b/src/bip324.h
@@ -15,6 +15,8 @@
 #include <pubkey.h>
 #include <span.h>
 
+static constexpr unsigned BIP324_SHORTIDS_IMPLEMENTED{38};
+
 /** The BIP324 packet cipher, encapsulating its key derivation, stream cipher, and AEAD. */
 class BIP324Cipher
 {
diff --git a/src/bitcoin-tx.cpp b/src/bitcoin-tx.cpp
index f21db40f3c3c..017e8e1e6c50 100644
--- a/src/bitcoin-tx.cpp
+++ b/src/bitcoin-tx.cpp
@@ -556,7 +556,7 @@ static CAmount AmountFromValue(const UniValue& value)
 {
     if (!value.isNum() && !value.isStr())
         throw std::runtime_error("Amount is not a number or string");
-    CAmount amount;
+    int64_t amount;
     if (!ParseFixedPoint(value.getValStr(), 8, &amount))
         throw std::runtime_error("Invalid amount");
     if (!MoneyRange(amount))
diff --git a/src/checkqueue.h b/src/checkqueue.h
index 1e265525df8d..7d107a186f17 100644
--- a/src/checkqueue.h
+++ b/src/checkqueue.h
@@ -149,7 +149,7 @@ class CCheckQueue
         m_worker_threads.reserve(worker_threads_num);
         for (int n = 0; n < worker_threads_num; ++n) {
             m_worker_threads.emplace_back([this, n]() {
-                util::ThreadRename(strprintf("scriptch.%i", n));
+                util::ThreadRename(strprintf("scriptch.%02i", n));
                 Loop(false /* worker thread */);
             });
         }
diff --git a/src/common/args.cpp b/src/common/args.cpp
index c24ec4912a31..cfd36e1f6a5a 100644
--- a/src/common/args.cpp
+++ b/src/common/args.cpp
@@ -668,6 +668,14 @@ void ArgsManager::AddArg(const std::string& name, const std::string& help, unsig
     std::string arg_name = name.substr(0, eq_index);
 
     LOCK(cs_args);
+
+    // Allow duplicates involving HIDDEN — it is used as a placeholder for args
+    // unavailable in this binary but tolerated for shared config files (see #13441).
+    for (const auto& arg_map : m_available_args) {
+        if (arg_map.first == OptionsCategory::HIDDEN || cat == OptionsCategory::HIDDEN) continue;
+        Assert(!arg_map.second.contains(arg_name));
+    }
+
     std::map<std::string, Arg>& arg_map = m_available_args[cat];
     auto ret = arg_map.emplace(arg_name, Arg{name.substr(eq_index, name.size() - eq_index), help, flags});
     assert(ret.second); // Make sure an insertion actually happened
diff --git a/src/common/interfaces.cpp b/src/common/interfaces.cpp
index de028f9ca257..b501493d6bf8 100644
--- a/src/common/interfaces.cpp
+++ b/src/common/interfaces.cpp
@@ -2,9 +2,9 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <btcsignals.h>
 #include <interfaces/echo.h>
 #include <interfaces/handler.h>
+#include <util/btcsignals.h>
 
 #include <memory>
 #include <utility>
diff --git a/src/common/settings.cpp b/src/common/settings.cpp
index e9b929794ff0..7d511b574dea 100644
--- a/src/common/settings.cpp
+++ b/src/common/settings.cpp
@@ -86,7 +86,7 @@ bool ReadSettings(const fs::path& path, std::map<std::string, SettingsValue>& va
 
     SettingsValue in;
     if (!in.read(std::string{std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>()})) {
-        errors.emplace_back(strprintf("Settings file %s does not contain valid JSON. This is probably caused by disk corruption or a crash, "
+        errors.emplace_back(strprintf("Settings file %s does not contain valid JSON. This may be caused by a crash, power loss, full disk, or storage error, "
                                       "and can be fixed by removing the file, which will reset settings to default values.",
                                       fs::PathToString(path)));
         return false;
@@ -139,7 +139,15 @@ bool WriteSettings(const fs::path& path,
         return false;
     }
     file << out.write(/* prettyIndent= */ 4, /* indentLevel= */ 1) << std::endl;
+    if (file.fail()) {
+        errors.emplace_back(strprintf("Error: Unable to write settings file %s", fs::PathToString(path)));
+        return false;
+    }
     file.close();
+    if (file.fail()) {
+        errors.emplace_back(strprintf("Error: Unable to close settings file %s", fs::PathToString(path)));
+        return false;
+    }
     return true;
 }
 
diff --git a/src/crypto/hmac_sha256.cpp b/src/crypto/hmac_sha256.cpp
index a95ef70849b5..0796bbeb3271 100644
--- a/src/crypto/hmac_sha256.cpp
+++ b/src/crypto/hmac_sha256.cpp
@@ -5,6 +5,7 @@
 #include <crypto/hmac_sha256.h>
 
 #include <crypto/sha256.h>
+#include <support/cleanse.h>
 
 #include <cstring>
 
@@ -26,6 +27,8 @@ CHMAC_SHA256::CHMAC_SHA256(const unsigned char* key, size_t keylen)
     for (int n = 0; n < 64; n++)
         rkey[n] ^= 0x5c ^ 0x36;
     inner.Write(rkey, 64);
+
+    memory_cleanse(rkey, sizeof(rkey));
 }
 
 void CHMAC_SHA256::Finalize(unsigned char hash[OUTPUT_SIZE])
@@ -33,4 +36,5 @@ void CHMAC_SHA256::Finalize(unsigned char hash[OUTPUT_SIZE])
     unsigned char temp[32];
     inner.Finalize(temp);
     outer.Write(temp, 32).Finalize(hash);
+    memory_cleanse(temp, sizeof(temp));
 }
diff --git a/src/crypto/hmac_sha512.cpp b/src/crypto/hmac_sha512.cpp
index f37e709d13cf..0a9d1041a67d 100644
--- a/src/crypto/hmac_sha512.cpp
+++ b/src/crypto/hmac_sha512.cpp
@@ -5,6 +5,7 @@
 #include <crypto/hmac_sha512.h>
 
 #include <crypto/sha512.h>
+#include <support/cleanse.h>
 
 #include <cstring>
 
@@ -26,6 +27,8 @@ CHMAC_SHA512::CHMAC_SHA512(const unsigned char* key, size_t keylen)
     for (int n = 0; n < 128; n++)
         rkey[n] ^= 0x5c ^ 0x36;
     inner.Write(rkey, 128);
+
+    memory_cleanse(rkey, sizeof(rkey));
 }
 
 void CHMAC_SHA512::Finalize(unsigned char hash[OUTPUT_SIZE])
@@ -33,4 +36,5 @@ void CHMAC_SHA512::Finalize(unsigned char hash[OUTPUT_SIZE])
     unsigned char temp[64];
     inner.Finalize(temp);
     outer.Write(temp, 64).Finalize(hash);
+    memory_cleanse(temp, sizeof(temp));
 }
diff --git a/src/hash.h b/src/hash.h
index 34486af64a1d..b671761fbb6e 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -13,12 +13,20 @@
 #include <prevector.h>
 #include <serialize.h>
 #include <span.h>
+#include <support/cleanse.h>
 #include <uint256.h>
 
 #include <string>
 #include <vector>
 
-typedef uint256 ChainCode;
+/** A BIP32 chain code. Cleansed on destruction. */
+class ChainCode : public base_blob<256> {
+public:
+    constexpr ChainCode() = default;
+    constexpr explicit ChainCode(std::span<const unsigned char> vch) : base_blob<256>(vch) {}
+    constexpr explicit ChainCode(const base_blob<256>& b) : base_blob<256>(b) {}
+    ~ChainCode() { memory_cleanse(data(), size()); }
+};
 
 /** A hasher class for Bitcoin's 256-bit hash (double SHA-256). */
 class CHash256 {
diff --git a/src/index/base.cpp b/src/index/base.cpp
index bb41cc2a632a..906ed265174f 100644
--- a/src/index/base.cpp
+++ b/src/index/base.cpp
@@ -92,8 +92,8 @@ void BaseIndex::DB::WriteBestBlock(CDBBatch& batch, const CBlockLocator& locator
     batch.Write(DB_BEST_BLOCK, locator);
 }
 
-BaseIndex::BaseIndex(std::unique_ptr<interfaces::Chain> chain, std::string name)
-    : m_chain{std::move(chain)}, m_name{std::move(name)} {}
+BaseIndex::BaseIndex(std::unique_ptr<interfaces::Chain> chain, std::string name, std::string thread_name)
+    : m_chain{std::move(chain)}, m_name{std::move(name)}, m_thread_name{std::move(thread_name)} {}
 
 BaseIndex::~BaseIndex()
 {
@@ -460,7 +460,7 @@ bool BaseIndex::StartBackgroundSync()
 {
     if (!m_init) throw std::logic_error("Error: Cannot start a non-initialized index");
 
-    m_thread_sync = std::thread(&util::TraceThread, GetName(), [this] { Sync(); });
+    m_thread_sync = std::thread(&util::TraceThread, m_thread_name, [this] { Sync(); });
     return true;
 }
 
diff --git a/src/index/base.h b/src/index/base.h
index 761b6f56bc2c..6d7e86ec0fa1 100644
--- a/src/index/base.h
+++ b/src/index/base.h
@@ -117,6 +117,7 @@ class BaseIndex : public CValidationInterface
     std::unique_ptr<interfaces::Chain> m_chain;
     Chainstate* m_chainstate{nullptr};
     const std::string m_name;
+    const std::string m_thread_name;
 
     void BlockConnected(const kernel::ChainstateRole& role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override;
 
@@ -141,7 +142,7 @@ class BaseIndex : public CValidationInterface
     void SetBestBlockIndex(const CBlockIndex* block);
 
 public:
-    BaseIndex(std::unique_ptr<interfaces::Chain> chain, std::string name);
+    BaseIndex(std::unique_ptr<interfaces::Chain> chain, std::string name, std::string thread_name);
     /// Destructor interrupts sync thread if running and blocks until it exits.
     virtual ~BaseIndex();
 
diff --git a/src/index/blockfilterindex.cpp b/src/index/blockfilterindex.cpp
index d4fd70259817..5c4a181325ff 100644
--- a/src/index/blockfilterindex.cpp
+++ b/src/index/blockfilterindex.cpp
@@ -61,6 +61,15 @@ constexpr size_t CF_HEADERS_CACHE_MAX_SZ{2000};
 
 namespace {
 
+std::string BlockFilterThreadName(BlockFilterType filter_type)
+{
+    switch (filter_type) {
+    case BlockFilterType::BASIC: return "blkfltbscidx";
+    case BlockFilterType::INVALID: return "";
+    } // no default case, so the compiler can warn about missing cases
+    assert(false);
+}
+
 struct DBVal {
     uint256 hash;
     uint256 header;
@@ -75,7 +84,7 @@ static std::map<BlockFilterType, BlockFilterIndex> g_filter_indexes;
 
 BlockFilterIndex::BlockFilterIndex(std::unique_ptr<interfaces::Chain> chain, BlockFilterType filter_type,
                                    size_t n_cache_size, bool f_memory, bool f_wipe)
-    : BaseIndex(std::move(chain), BlockFilterTypeName(filter_type) + " block filter index")
+    : BaseIndex(std::move(chain), BlockFilterTypeName(filter_type) + " block filter index", BlockFilterThreadName(filter_type))
     , m_filter_type(filter_type)
 {
     const std::string& filter_name = BlockFilterTypeName(filter_type);
diff --git a/src/index/coinstatsindex.cpp b/src/index/coinstatsindex.cpp
index 80a6d8dfd2b3..204f4341a9dd 100644
--- a/src/index/coinstatsindex.cpp
+++ b/src/index/coinstatsindex.cpp
@@ -87,7 +87,7 @@ struct DBVal {
 std::unique_ptr<CoinStatsIndex> g_coin_stats_index;
 
 CoinStatsIndex::CoinStatsIndex(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory, bool f_wipe)
-    : BaseIndex(std::move(chain), "coinstatsindex")
+    : BaseIndex(std::move(chain), "coinstatsindex", "coinstatsidx")
 {
     // An earlier version of the index used "indexes/coinstats" but it contained
     // a bug and is superseded by a fixed version at "indexes/coinstatsindex".
diff --git a/src/index/txindex.cpp b/src/index/txindex.cpp
index 4b0c82877ab2..5e71e6bb77a1 100644
--- a/src/index/txindex.cpp
+++ b/src/index/txindex.cpp
@@ -66,7 +66,7 @@ void TxIndex::DB::WriteTxs(const std::vector<std::pair<Txid, CDiskTxPos>>& v_pos
 }
 
 TxIndex::TxIndex(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory, bool f_wipe)
-    : BaseIndex(std::move(chain), "txindex"), m_db(std::make_unique<TxIndex::DB>(n_cache_size, f_memory, f_wipe))
+    : BaseIndex(std::move(chain), "txindex", "txidx"), m_db(std::make_unique<TxIndex::DB>(n_cache_size, f_memory, f_wipe))
 {}
 
 TxIndex::~TxIndex() = default;
diff --git a/src/index/txospenderindex.cpp b/src/index/txospenderindex.cpp
index f0d559a958f5..3d7b56b6a956 100644
--- a/src/index/txospenderindex.cpp
+++ b/src/index/txospenderindex.cpp
@@ -60,7 +60,7 @@ struct DBKey {
 };
 
 TxoSpenderIndex::TxoSpenderIndex(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory, bool f_wipe)
-    : BaseIndex(std::move(chain), "txospenderindex"), m_db{std::make_unique<DB>(gArgs.GetDataDirNet() / "indexes" / "txospenderindex" / "db", n_cache_size, f_memory, f_wipe)}
+    : BaseIndex(std::move(chain), "txospenderindex", "txospenderidx"), m_db{std::make_unique<DB>(gArgs.GetDataDirNet() / "indexes" / "txospenderindex" / "db", n_cache_size, f_memory, f_wipe)}
 {
     if (!m_db->Read("siphash_key", m_siphash_key)) {
         FastRandomContext rng(false);
diff --git a/src/init.cpp b/src/init.cpp
index da58efe74c42..d2e2902040ff 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -7,13 +7,10 @@
 
 #include <init.h>
 
-#include <kernel/checks.h>
-
 #include <addrdb.h>
 #include <addrman.h>
 #include <banman.h>
 #include <blockfilter.h>
-#include <btcsignals.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <chainparamsbase.h>
@@ -42,6 +39,7 @@
 #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>
@@ -87,6 +85,7 @@
 #include <uint256.h>
 #include <util/asmap.h>
 #include <util/batchpriority.h>
+#include <util/btcsignals.h>
 #include <util/chaintype.h>
 #include <util/check.h>
 #include <util/fs.h>
@@ -1574,7 +1573,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
      * be disabled when initialisation is finished.
      */
     if (args.GetBoolArg("-server", false)) {
-        uiInterface.InitMessage_connect(SetRPCWarmupStatus);
+        uiInterface.InitMessage.connect(SetRPCWarmupStatus);
         if (!AppInitServers(node))
             return InitError(_("Unable to start HTTP server. See debug log for details."));
     }
@@ -2026,7 +2025,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
 #if HAVE_SYSTEM
     const std::string block_notify = args.GetArg("-blocknotify", "");
     if (!block_notify.empty()) {
-        uiInterface.NotifyBlockTip_connect([block_notify](SynchronizationState sync_state, const CBlockIndex& block, double /* verification_progress */) {
+        uiInterface.NotifyBlockTip.connect([block_notify](SynchronizationState sync_state, const CBlockIndex& block, double /* verification_progress */) {
             if (sync_state != SynchronizationState::POST_INIT) return;
             std::string command = block_notify;
             ReplaceAll(command, "%s", block.GetBlockHash().GetHex());
diff --git a/src/interfaces/node.h b/src/interfaces/node.h
index ad6298e621f6..8b8402ece163 100644
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -219,8 +219,7 @@ class Node
     virtual std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) = 0;
 
     //! Register handler for message box messages.
-    using MessageBoxFn =
-        std::function<bool(const bilingual_str& message, unsigned int style)>;
+    using MessageBoxFn = std::function<void(const bilingual_str& message, unsigned int style)>;
     virtual std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn) = 0;
 
     //! Register handler for question messages.
diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index ba3a57d44225..13d37c51aea8 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -1143,9 +1143,9 @@ int btck_block_check(const btck_Block* block, const btck_ConsensusParams* consen
     const bool check_pow    = (flags & btck_BlockCheckFlags_POW) != 0;
     const bool check_merkle = (flags & btck_BlockCheckFlags_MERKLE) != 0;
 
-    const bool result = CheckBlock(*btck_Block::get(block), state, btck_ConsensusParams::get(consensus_params), /*fCheckPOW=*/check_pow, /*fCheckMerkleRoot=*/check_merkle);
+    state = CheckBlock(*btck_Block::get(block), btck_ConsensusParams::get(consensus_params), /*fCheckPOW=*/check_pow, /*fCheckMerkleRoot=*/check_merkle);
 
-    return result ? 1 : 0;
+    return state.IsValid() ? 1 : 0;
 }
 
 size_t btck_block_count_transactions(const btck_Block* block)
@@ -1343,11 +1343,9 @@ btck_BlockValidationState* btck_chainstate_manager_process_block_header(
 {
     try {
         auto& chainman = btck_ChainstateManager::get(chainstate_manager).m_chainman;
+        auto state = chainman->ProcessNewBlockHeaders({&btck_BlockHeader::get(header), 1}, /*min_pow_checked=*/true);
 
-        auto state = btck_BlockValidationState::create();
-        bool result{chainman->ProcessNewBlockHeaders({&btck_BlockHeader::get(header), 1}, /*min_pow_checked=*/true, btck_BlockValidationState::get(state))};
-        assert(result == btck_BlockValidationState::get(state).IsValid());
-        return state;
+        return btck_BlockValidationState::create(state);
     } catch (const std::exception& e) {
         LogError("Failed to process block header: %s", e.what());
         return nullptr;
diff --git a/src/logging/timer.h b/src/logging/timer.h
index 2b183822e969..1706c9e71bb3 100644
--- a/src/logging/timer.h
+++ b/src/logging/timer.h
@@ -99,13 +99,13 @@ class Timer
 
 
 #define LOG_TIME_MICROS_WITH_CATEGORY(end_msg, log_category) \
-    BCLog::Timer<std::chrono::microseconds> UNIQUE_NAME(logging_timer)(__func__, end_msg, log_category)
+    BCLog::Timer<std::chrono::microseconds> BITCOIN_UNIQUE_NAME(logging_timer)(__func__, end_msg, log_category)
 #define LOG_TIME_MILLIS_WITH_CATEGORY(end_msg, log_category) \
-    BCLog::Timer<std::chrono::milliseconds> UNIQUE_NAME(logging_timer)(__func__, end_msg, log_category)
+    BCLog::Timer<std::chrono::milliseconds> BITCOIN_UNIQUE_NAME(logging_timer)(__func__, end_msg, log_category)
 #define LOG_TIME_MILLIS_WITH_CATEGORY_MSG_ONCE(end_msg, log_category) \
-    BCLog::Timer<std::chrono::milliseconds> UNIQUE_NAME(logging_timer)(__func__, end_msg, log_category, /* msg_on_completion=*/false)
+    BCLog::Timer<std::chrono::milliseconds> BITCOIN_UNIQUE_NAME(logging_timer)(__func__, end_msg, log_category, /* msg_on_completion=*/false)
 #define LOG_TIME_SECONDS(end_msg) \
-    BCLog::Timer<std::chrono::seconds> UNIQUE_NAME(logging_timer)(__func__, end_msg)
+    BCLog::Timer<std::chrono::seconds> BITCOIN_UNIQUE_NAME(logging_timer)(__func__, end_msg)
 
 
 #endif // BITCOIN_LOGGING_TIMER_H
diff --git a/src/musig.cpp b/src/musig.cpp
index d211790c43b2..d187ad001338 100644
--- a/src/musig.cpp
+++ b/src/musig.cpp
@@ -11,10 +11,7 @@
 
 //! MuSig2 chaincode as defined by BIP 328
 using namespace util::hex_literals;
-constexpr uint256 MUSIG_CHAINCODE{
-    // Use immediate lambda to work around GCC-14 bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=117966
-    []() consteval { return uint256{"868087ca02a6f974c4598924c36b57762d32cb45717167e300622c7167e38965"_hex_u8}; }(),
-};
+const ChainCode MUSIG_CHAINCODE{"868087ca02a6f974c4598924c36b57762d32cb45717167e300622c7167e38965"_hex_u8};
 
 static bool GetMuSig2KeyAggCache(const std::vector<CPubKey>& pubkeys, secp256k1_musig_keyagg_cache& keyagg_cache)
 {
diff --git a/src/musig.h b/src/musig.h
index 4e1ad5e9e6bd..b17d299c6d2b 100644
--- a/src/musig.h
+++ b/src/musig.h
@@ -59,7 +59,7 @@ class MuSig2SecNonce
 
 /**
  * Computes an arbitrary unique session ID to identify ongoing signing sessions.
- * It is the SHA256 of the aggregate xonly key, the participant pubkey, the sighash, and the pubnonce
+ * It is the SHA256 of the signing (aggregate) pubkey, the participant pubkey, the sighash, and the pubnonce
  */
 uint256 MuSig2SessionID(const CPubKey& script_pubkey, const CPubKey& part_pubkey, const uint256& sighash, const std::vector<uint8_t>& pubnonce);
 
diff --git a/src/net.cpp b/src/net.cpp
index 6fb541180a68..951e804f8877 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -29,6 +29,7 @@
 #include <random.h>
 #include <scheduler.h>
 #include <util/fs.h>
+#include <util/overflow.h>
 #include <util/sock.h>
 #include <util/strencodings.h>
 #include <util/thread.h>
@@ -296,7 +297,7 @@ bool AddLocal(const CService& addr_, int nScore)
         const auto [it, is_newly_added] = mapLocalHost.emplace(addr, LocalServiceInfo());
         LocalServiceInfo &info = it->second;
         if (is_newly_added || nScore >= info.nScore) {
-            info.nScore = nScore + (is_newly_added ? 0 : 1);
+            info.nScore = SaturatingAdd(nScore, is_newly_added ? 0 : 1);
             info.nPort = addr.GetPort();
         }
     }
@@ -325,7 +326,7 @@ bool SeenLocal(const CService& addr)
     LOCK(g_maplocalhost_mutex);
     const auto it = mapLocalHost.find(addr);
     if (it == mapLocalHost.end()) return false;
-    ++it->second.nScore;
+    it->second.nScore = SaturatingAdd(it->second.nScore, 1);
     return true;
 }
 
@@ -921,7 +922,7 @@ namespace {
  * Only message types that are actually implemented in this codebase need to be listed, as other
  * messages get ignored anyway - whether we know how to decode them or not.
  */
-const std::array<std::string, 33> V2_MESSAGE_IDS = {
+const std::array<std::string, BIP324_SHORTIDS_IMPLEMENTED> V2_MESSAGE_IDS = {
     "", // 12 bytes follow encoding the message type like in V1
     NetMsgType::ADDR,
     NetMsgType::BLOCK,
@@ -951,11 +952,10 @@ const std::array<std::string, 33> V2_MESSAGE_IDS = {
     NetMsgType::GETCFCHECKPT,
     NetMsgType::CFCHECKPT,
     NetMsgType::ADDRV2,
-    // Unimplemented message types that are assigned in BIP324:
-    "",
-    "",
-    "",
-    ""
+    "", "", "", // Unimplemented message types 29-31
+    "", "", "", "", // Unimplemented message types 32-35
+    "",  // Unimplemented message type 36
+    NetMsgType::FEATURE,
 };
 
 class V2MessageMap
diff --git a/src/net.h b/src/net.h
index f54a8e0cdb72..d0cfe7c9ac31 100644
--- a/src/net.h
+++ b/src/net.h
@@ -831,6 +831,13 @@ class CNode
         return m_conn_type == ConnectionType::PRIVATE_BROADCAST;
     }
 
+    /** Protocol version advertised in our VERSION message.
+     *  Private broadcast connections use a fixed version to maximise anonymity. */
+    int AdvertisedVersion() const
+    {
+        return IsPrivateBroadcastConn() ? WTXID_RELAY_VERSION : PROTOCOL_VERSION;
+    }
+
     bool IsInboundConn() const {
         return m_conn_type == ConnectionType::INBOUND;
     }
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 50ea62ff05c5..e0db091bba9f 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -575,6 +575,9 @@ class PeerManagerImpl final : public PeerManager
      *  May return an empty shared_ptr if the Peer object can't be found. */
     PeerRef RemovePeer(NodeId id) EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
 
+    /// Get all existing peers in m_peer_map.
+    std::vector<PeerRef> GetAllPeers() const EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
+
     /** Mark a peer as misbehaving, which will cause it to be disconnected and its
      *  address discouraged. */
     void Misbehaving(Peer& peer, const std::string& message);
@@ -722,6 +725,15 @@ class PeerManagerImpl final : public PeerManager
     {
         m_connman.PushMessage(&node, NetMsg::Make(std::move(msg_type), std::forward<Args>(args)...));
     }
+    template <typename... Args>
+    void MakeAndPushFeature(CNode& node, std::string_view feature_id, Args&&... args) const
+    {
+        if (!Assume(feature_id.size() >= 4 && feature_id.size() <= MAX_FEATUREID_LENGTH)) return;
+        std::vector<unsigned char> feature_data;
+        VectorWriter{feature_data, 0, std::forward<Args>(args)...};
+        if (!Assume(feature_data.size() <= MAX_FEATUREDATA_LENGTH)) return;
+        MakeAndPushMessage(node, NetMsgType::FEATURE, feature_id, std::move(feature_data));
+    }
 
     /** Send a version message to a peer */
     void PushNodeVersion(CNode& pnode, const Peer& peer);
@@ -1575,7 +1587,7 @@ void PeerManagerImpl::PushNodeVersion(CNode& pnode, const Peer& peer)
     MakeAndPushMessage(
         pnode,
         NetMsgType::VERSION,
-        PROTOCOL_VERSION,
+        pnode.AdvertisedVersion(),
         my_services,
         my_time,
         // your_services + CNetAddr::V1(your_addr) is the pre-version-31402 serialization of your_addr (without nTime)
@@ -1589,7 +1601,7 @@ void PeerManagerImpl::PushNodeVersion(CNode& pnode, const Peer& peer)
 
     LogDebug(
         BCLog::NET, "send version message: version=%d, blocks=%d%s, txrelay=%d, peer=%d\n",
-        PROTOCOL_VERSION, my_height,
+        pnode.AdvertisedVersion(), my_height,
         fLogIPs ? strprintf(", them=%s", your_addr.ToStringAddrPort()) : "",
         my_tx_relay, pnode.GetId());
 }
@@ -1785,6 +1797,17 @@ PeerRef PeerManagerImpl::RemovePeer(NodeId id)
     return ret;
 }
 
+std::vector<PeerRef> PeerManagerImpl::GetAllPeers() const
+{
+    std::vector<PeerRef> peers;
+    LOCK(m_peer_mutex);
+    peers.reserve(m_peer_map.size());
+    for (const auto& [_, peer] : m_peer_map) {
+        peers.push_back(peer);
+    }
+    return peers;
+}
+
 bool PeerManagerImpl::GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats) const
 {
     {
@@ -1852,6 +1875,7 @@ PeerManagerInfo PeerManagerImpl::GetInfo() const
     return PeerManagerInfo{
         .median_outbound_time_offset = m_outbound_time_offsets.Median(),
         .ignores_incoming_txs = m_opts.ignore_incoming_txs,
+        .private_broadcast = m_opts.private_broadcast,
     };
 }
 
@@ -1962,6 +1986,12 @@ util::Expected<void, std::string> PeerManagerImpl::FetchBlock(NodeId peer_id, co
 {
     if (m_chainman.m_blockman.LoadingBlocks()) return util::Unexpected{"Loading blocks ..."};
 
+    // The lock must be taken here before fetching Peer so another thread does
+    // not delete the CNodeState from under the current thread, causing an
+    // assertion failure in BlockRequested. This lock can be replaced with a
+    // net-specific lock when more of CNodeState is moved into Peer.
+    LOCK(cs_main);
+
     // Ensure this peer exists and hasn't been disconnected
     PeerRef peer = GetPeerRef(peer_id);
     if (peer == nullptr) return util::Unexpected{"Peer does not exist"};
@@ -1969,8 +1999,6 @@ util::Expected<void, std::string> PeerManagerImpl::FetchBlock(NodeId peer_id, co
     // Ignore pre-segwit peers
     if (!CanServeWitnesses(*peer)) return util::Unexpected{"Pre-SegWit peer"};
 
-    LOCK(cs_main);
-
     // Forget about all prior requests
     RemoveBlockRequest(block_index.GetBlockHash(), std::nullopt);
 
@@ -2243,9 +2271,10 @@ void PeerManagerImpl::SendPings()
 
 void PeerManagerImpl::InitiateTxBroadcastToAll(const Txid& txid, const Wtxid& wtxid)
 {
-    LOCK(m_peer_mutex);
-    for(auto& it : m_peer_map) {
-        Peer& peer = *it.second;
+    for (const PeerRef& peer_ref : GetAllPeers()) {
+        if (!peer_ref) continue;
+        Peer& peer{*peer_ref};
+
         auto tx_relay = peer.GetTxRelay();
         if (!tx_relay) continue;
 
@@ -3079,26 +3108,26 @@ void PeerManagerImpl::ProcessHeadersMessage(CNode& pfrom, Peer& peer,
     bool received_new_header{last_received_header == nullptr};
 
     // Now process all the headers.
-    BlockValidationState state;
-    const bool processed{m_chainman.ProcessNewBlockHeaders(headers,
+    BlockValidationState state{m_chainman.ProcessNewBlockHeaders(headers,
                                                            /*min_pow_checked=*/true,
-                                                           state, &pindexLast)};
-    if (!processed) {
-        if (state.IsInvalid()) {
+                                                           &pindexLast)};
+    if (!state.IsValid()) {
+        // ProcessNewBlockHeaders only sets Invalid, never Error state.
+        if (Assume(state.IsInvalid())) {
             if (!pfrom.IsInboundConn() && state.GetResult() == BlockValidationResult::BLOCK_CACHED_INVALID) {
                 // Warn user if outgoing peers send us headers of blocks that we previously marked as invalid.
                 LogWarning("%s (received from peer=%i). "
-                           "If this happens with all peers, consider database corruption (that -reindex may fix) "
-                           "or a potential consensus incompatibility.",
-                           state.GetDebugMessage(), pfrom.GetId());
+                            "If this happens with all peers, consider database corruption (that -reindex may fix) "
+                            "or a potential consensus incompatibility.",
+                            state.GetDebugMessage(), pfrom.GetId());
             }
             MaybePunishNodeForBlock(pfrom.GetId(), state, via_compact_block, "invalid header received");
-            return;
         }
+        return;
     }
     assert(pindexLast);
 
-    if (processed && received_new_header) {
+    if (received_new_header) {
         LogBlockHeader(*pindexLast, pfrom, /*via_compact_block=*/false);
     }
 
@@ -3663,7 +3692,7 @@ void PeerManagerImpl::ProcessMessage(Peer& peer, CNode& pfrom, const std::string
         }
 
         // Change version
-        const int greatest_common_version = std::min(nVersion, PROTOCOL_VERSION);
+        const int greatest_common_version = std::min(nVersion, pfrom.AdvertisedVersion());
         pfrom.SetCommonVersion(greatest_common_version);
         pfrom.nVersion = nVersion;
 
@@ -3738,6 +3767,11 @@ void PeerManagerImpl::ProcessMessage(Peer& peer, CNode& pfrom, const std::string
             }
         }
 
+        if (greatest_common_version >= FEATURE_VERSION) {
+            // announce supported features
+            // MakeAndPushFeature(pfrom, NetMsgFeature::FOO, uint32_t{1});
+        }
+
         MakeAndPushMessage(pfrom, NetMsgType::VERACK);
 
         // Potentially mark this peer as a preferred download peer.
@@ -3953,6 +3987,45 @@ void PeerManagerImpl::ProcessMessage(Peer& peer, CNode& pfrom, const std::string
         return;
     }
 
+    if (msg_type == NetMsgType::FEATURE) {
+        if (pfrom.fSuccessfullyConnected) {
+            // Disconnect peers that send a FEATURE message after VERACK.
+            LogDebug(BCLog::NET, "feature received after verack, %s", pfrom.DisconnectMsg());
+            pfrom.fDisconnect = true;
+            return;
+        } else if (pfrom.GetCommonVersion() < FEATURE_VERSION) {
+            // Disconnect peers that send a FEATURE message without valid version negotiation.
+            LogDebug(BCLog::NET, "feature received with incompatible version %d, %s", pfrom.GetCommonVersion(), pfrom.DisconnectMsg());
+            pfrom.fDisconnect = true;
+            return;
+        }
+
+        std::string feature_id;
+        DataStream feature_data;
+        try {
+            vRecv >> LIMITED_STRING(feature_id, MAX_FEATUREID_LENGTH);
+            std::vector<unsigned char> feature_data_vec;
+            vRecv >> LIMITED_VECTOR(feature_data_vec, MAX_FEATUREDATA_LENGTH);
+            feature_data = DataStream(feature_data_vec);
+        } catch (const std::exception&) {
+            feature_id.clear(); // use empty feature_id as error indicator
+        }
+        if (feature_id.size() < 4 || !vRecv.empty()) {
+            LogDebug(BCLog::NET, "invalid feature payload, %s", pfrom.DisconnectMsg());
+            pfrom.fDisconnect = true;
+            return;
+        }
+
+        // if (feature_id == NetMsgFeature::FOO) {
+        //     ...
+        //     return;
+        // }
+
+        // ignore unknown feature_id
+        LogDebug(BCLog::NET, "unknown feature advertised: %s", SanitizeString(feature_id));
+        return;
+    }
+
     // Received from a peer demonstrating readiness to announce transactions via reconciliations.
     // This feature negotiation must happen between VERSION and VERACK to avoid relay problems
     // from switching announcement protocols after the connection is up.
@@ -4501,15 +4574,16 @@ void PeerManagerImpl::ProcessMessage(Peer& peer, CNode& pfrom, const std::string
         }
 
         const CBlockIndex *pindex = nullptr;
-        BlockValidationState state;
-        if (!m_chainman.ProcessNewBlockHeaders({{cmpctblock.header}}, /*min_pow_checked=*/true, state, &pindex)) {
-            if (state.IsInvalid()) {
+        BlockValidationState state{m_chainman.ProcessNewBlockHeaders({{cmpctblock.header}}, /*min_pow_checked=*/true, &pindex)};
+        if (!state.IsValid()) {
+            // ProcessNewBlockHeaders only sets Invalid, never Error state.
+            if (Assume(state.IsInvalid())) {
                 MaybePunishNodeForBlock(pfrom.GetId(), state, /*via_compact_block=*/true, "invalid header via cmpctblock");
-                return;
             }
+            return;
         }
 
-        // If AcceptBlockHeader returned true, it set pindex
+        // If AcceptBlockHeader returned valid, it set pindex
         Assert(pindex);
         if (received_new_header) {
             LogBlockHeader(*pindex, pfrom, /*via_compact_block=*/true);
diff --git a/src/net_processing.h b/src/net_processing.h
index 4ae48f84e4b9..630656e2af6d 100644
--- a/src/net_processing.h
+++ b/src/net_processing.h
@@ -71,6 +71,7 @@ struct CNodeStateStats {
 struct PeerManagerInfo {
     std::chrono::seconds median_outbound_time_offset{0s};
     bool ignores_incoming_txs{false};
+    bool private_broadcast{DEFAULT_PRIVATE_BROADCAST};
 };
 
 class PeerManager : public CValidationInterface, public NetEventsInterface
diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp
index b0842a005059..c8c8882eb703 100644
--- a/src/node/blockstorage.cpp
+++ b/src/node/blockstorage.cpp
@@ -7,6 +7,7 @@
 #include <arith_uint256.h>
 #include <chain.h>
 #include <consensus/params.h>
+#include <consensus/validation.h>
 #include <crypto/hex_base.h>
 #include <dbwrapper.h>
 #include <flatfile.h>
@@ -258,7 +259,6 @@ CBlockIndex* BlockManager::AddToBlockIndex(const CBlockHeader& block, CBlockInde
 void BlockManager::PruneOneBlockFile(const int fileNumber)
 {
     AssertLockHeld(cs_main);
-    LOCK(cs_LastBlockFile);
 
     for (auto& entry : m_block_index) {
         CBlockIndex* pindex = &entry.second;
@@ -296,7 +296,7 @@ void BlockManager::FindFilesToPruneManual(
 {
     assert(IsPruneMode() && nManualPruneHeight > 0);
 
-    LOCK2(cs_main, cs_LastBlockFile);
+    LOCK(::cs_main);
     if (chain.m_chain.Height() < 0) {
         return;
     }
@@ -324,7 +324,7 @@ void BlockManager::FindFilesToPrune(
     const Chainstate& chain,
     ChainstateManager& chainman)
 {
-    LOCK2(cs_main, cs_LastBlockFile);
+    LOCK(::cs_main);
     // Compute `target` value with maximum size (in bytes) of blocks below the
     // `last_prune` height which should be preserved and not pruned. The
     // `target` value will be derived from the -prune preference provided by the
@@ -487,7 +487,9 @@ bool BlockManager::LoadBlockIndex(const std::optional<uint256>& snapshot_blockha
                     pindex->m_chain_tx_count = pindex->pprev->m_chain_tx_count + pindex->nTx;
                 } else {
                     pindex->m_chain_tx_count = 0;
-                    m_blocks_unlinked.insert(std::make_pair(pindex->pprev, pindex));
+                    if (pindex->nStatus & BLOCK_HAVE_DATA) {
+                        m_blocks_unlinked.insert(std::make_pair(pindex->pprev, pindex));
+                    }
                 }
             } else {
                 pindex->m_chain_tx_count = pindex->nTx;
@@ -528,12 +530,13 @@ void BlockManager::WriteBlockIndexDB()
         vBlocks.push_back(*it);
         m_dirty_blockindex.erase(it++);
     }
-    int max_blockfile = WITH_LOCK(cs_LastBlockFile, return this->MaxBlockfileNum());
+    int max_blockfile{this->MaxBlockfileNum()};
     m_block_tree_db->WriteBatchSync(vFiles, max_blockfile, vBlocks);
 }
 
 bool BlockManager::LoadBlockIndexDB(const std::optional<uint256>& snapshot_blockhash)
 {
+    AssertLockHeld(::cs_main);
     if (!LoadBlockIndex(snapshot_blockhash)) {
         return false;
     }
@@ -573,7 +576,6 @@ bool BlockManager::LoadBlockIndexDB(const std::optional<uint256>& snapshot_block
 
     {
         // Initialize the blockfile cursors.
-        LOCK(cs_LastBlockFile);
         for (size_t i = 0; i < m_blockfile_info.size(); ++i) {
             const auto last_height_in_file = m_blockfile_info[i].nHeightLast;
             m_blockfile_cursors[BlockfileTypeForHeight(last_height_in_file)] = {static_cast<int>(i), 0};
@@ -597,7 +599,7 @@ bool BlockManager::LoadBlockIndexDB(const std::optional<uint256>& snapshot_block
 void BlockManager::ScanAndUnlinkAlreadyPrunedFiles()
 {
     AssertLockHeld(::cs_main);
-    int max_blockfile = WITH_LOCK(cs_LastBlockFile, return this->MaxBlockfileNum());
+    int max_blockfile{this->MaxBlockfileNum()};
     if (!m_have_pruned) {
         return;
     }
@@ -695,8 +697,7 @@ void BlockManager::CleanupBlockRevFiles() const
 
 CBlockFileInfo* BlockManager::GetBlockFileInfo(size_t n)
 {
-    LOCK(cs_LastBlockFile);
-
+    AssertLockHeld(::cs_main);
     return &m_blockfile_info.at(n);
 }
 
@@ -747,8 +748,8 @@ bool BlockManager::FlushUndoFile(int block_file, bool finalize)
 
 bool BlockManager::FlushBlockFile(int blockfile_num, bool fFinalize, bool finalize_undo)
 {
+    AssertLockHeld(::cs_main);
     bool success = true;
-    LOCK(cs_LastBlockFile);
 
     if (m_blockfile_info.size() < 1) {
         // Return if we haven't loaded any blockfiles yet. This happens during
@@ -784,7 +785,7 @@ BlockfileType BlockManager::BlockfileTypeForHeight(int height)
 
 bool BlockManager::FlushChainstateBlockFile(int tip_height)
 {
-    LOCK(cs_LastBlockFile);
+    AssertLockHeld(::cs_main);
     auto& cursor = m_blockfile_cursors[BlockfileTypeForHeight(tip_height)];
     // If the cursor does not exist, it means an assumeutxo snapshot is loaded,
     // but no blocks past the snapshot height have been written yet, so there
@@ -798,8 +799,7 @@ bool BlockManager::FlushChainstateBlockFile(int tip_height)
 
 uint64_t BlockManager::CalculateCurrentUsage()
 {
-    LOCK(cs_LastBlockFile);
-
+    AssertLockHeld(::cs_main);
     uint64_t retval = 0;
     for (const CBlockFileInfo& file : m_blockfile_info) {
         retval += file.nSize + file.nUndoSize;
@@ -838,8 +838,7 @@ fs::path BlockManager::GetBlockPosFilename(const FlatFilePos& pos) const
 
 FlatFilePos BlockManager::FindNextBlockPos(unsigned int nAddSize, unsigned int nHeight, uint64_t nTime)
 {
-    LOCK(cs_LastBlockFile);
-
+    AssertLockHeld(::cs_main);
     const BlockfileType chain_type = BlockfileTypeForHeight(nHeight);
 
     if (!m_blockfile_cursors[chain_type]) {
@@ -928,8 +927,7 @@ FlatFilePos BlockManager::FindNextBlockPos(unsigned int nAddSize, unsigned int n
 
 void BlockManager::UpdateBlockInfo(const CBlock& block, unsigned int nHeight, const FlatFilePos& pos)
 {
-    LOCK(cs_LastBlockFile);
-
+    AssertLockHeld(::cs_main);
     // Update the cursor so it points to the last file.
     const BlockfileType chain_type{BlockfileTypeForHeight(nHeight)};
     auto& cursor{m_blockfile_cursors[chain_type]};
@@ -950,10 +948,9 @@ void BlockManager::UpdateBlockInfo(const CBlock& block, unsigned int nHeight, co
 
 bool BlockManager::FindUndoPos(BlockValidationState& state, int nFile, FlatFilePos& pos, unsigned int nAddSize)
 {
+    AssertLockHeld(::cs_main);
     pos.nFile = nFile;
 
-    LOCK(cs_LastBlockFile);
-
     pos.nPos = m_blockfile_info[nFile].nUndoSize;
     m_blockfile_info[nFile].nUndoSize += nAddSize;
     m_dirty_fileinfo.insert(nFile);
@@ -961,7 +958,8 @@ bool BlockManager::FindUndoPos(BlockValidationState& state, int nFile, FlatFileP
     bool out_of_space;
     size_t bytes_allocated = m_undo_file_seq.Allocate(pos, nAddSize, out_of_space);
     if (out_of_space) {
-        return FatalError(m_opts.notifications, state, _("Disk space is too low!"));
+        state = FatalError(m_opts.notifications, _("Disk space is too low!"));
+        return false;
     }
     if (bytes_allocated != 0 && IsPruneMode()) {
         m_check_for_pruning = true;
@@ -974,7 +972,7 @@ bool BlockManager::WriteBlockUndo(const CBlockUndo& blockundo, BlockValidationSt
 {
     AssertLockHeld(::cs_main);
     const BlockfileType type = BlockfileTypeForHeight(block.nHeight);
-    auto& cursor = *Assert(WITH_LOCK(cs_LastBlockFile, return m_blockfile_cursors[type]));
+    auto& cursor = *Assert(m_blockfile_cursors[type]);
 
     // Write undo information to disk
     if (block.GetUndoPos().IsNull()) {
@@ -989,7 +987,8 @@ bool BlockManager::WriteBlockUndo(const CBlockUndo& blockundo, BlockValidationSt
         AutoFile file{OpenUndoFile(pos)};
         if (file.IsNull()) {
             LogError("OpenUndoFile failed for %s while writing block undo", pos.ToString());
-            return FatalError(m_opts.notifications, state, _("Failed to write undo data."));
+            state = FatalError(m_opts.notifications, _("Failed to write undo data."));
+            return false;
         }
         {
             BufferedWriter fileout{file};
@@ -1010,7 +1009,8 @@ bool BlockManager::WriteBlockUndo(const CBlockUndo& blockundo, BlockValidationSt
         // Make sure that the file is closed before we call `FlushUndoFile`.
         if (file.fclose() != 0) {
             LogError("Failed to close block undo file %s: %s", pos.ToString(), SysErrorString(errno));
-            return FatalError(m_opts.notifications, state, _("Failed to close block undo file."));
+            state = FatalError(m_opts.notifications, _("Failed to close block undo file."));
+            return false;
         }
 
         // rev files are written in block height order, whereas blk files are written as blocks come in (often out of order)
@@ -1139,6 +1139,7 @@ BlockManager::ReadRawBlockResult BlockManager::ReadRawBlock(const FlatFilePos& p
 
 FlatFilePos BlockManager::WriteBlock(const CBlock& block, int nHeight)
 {
+    AssertLockHeld(::cs_main);
     const unsigned int block_size{static_cast<unsigned int>(GetSerializeSize(TX_WITH_WITNESS(block)))};
     FlatFilePos pos{FindNextBlockPos(block_size + STORAGE_HEADER_BYTES, nHeight, block.GetBlockTime())};
     if (pos.IsNull()) {
diff --git a/src/node/blockstorage.h b/src/node/blockstorage.h
index 0857ba4c8a8d..347dbc3c9e86 100644
--- a/src/node/blockstorage.h
+++ b/src/node/blockstorage.h
@@ -209,7 +209,7 @@ class BlockManager
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /** Return false if block file or undo file flushing fails. */
-    [[nodiscard]] bool FlushBlockFile(int blockfile_num, bool fFinalize, bool finalize_undo);
+    [[nodiscard]] bool FlushBlockFile(int blockfile_num, bool fFinalize, bool finalize_undo) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     /** Return false if undo file flushing fails. */
     [[nodiscard]] bool FlushUndoFile(int block_file, bool finalize = false);
@@ -223,9 +223,9 @@ class BlockManager
      * The nAddSize argument passed to this function should include not just the size of the serialized CBlock, but also the size of
      * separator fields (STORAGE_HEADER_BYTES).
      */
-    [[nodiscard]] FlatFilePos FindNextBlockPos(unsigned int nAddSize, unsigned int nHeight, uint64_t nTime);
-    [[nodiscard]] bool FlushChainstateBlockFile(int tip_height);
-    bool FindUndoPos(BlockValidationState& state, int nFile, FlatFilePos& pos, unsigned int nAddSize);
+    [[nodiscard]] FlatFilePos FindNextBlockPos(unsigned int nAddSize, unsigned int nHeight, uint64_t nTime) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    [[nodiscard]] bool FlushChainstateBlockFile(int tip_height) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    [[nodiscard]] bool FindUndoPos(BlockValidationState& state, int nFile, FlatFilePos& pos, unsigned int nAddSize) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     AutoFile OpenUndoFile(const FlatFilePos& pos, bool fReadOnly = false) const;
 
@@ -257,8 +257,6 @@ class BlockManager
         const Chainstate& chain,
         ChainstateManager& chainman);
 
-    RecursiveMutex cs_LastBlockFile;
-
     //! Since assumedvalid chainstates may be syncing a range of the chain that is very
     //! far away from the normal/background validation process, we should segment blockfiles
     //! for assumed chainstates. Otherwise, we might have wildly different height ranges
@@ -270,12 +268,13 @@ class BlockManager
     //!
     //! The first element is the NORMAL cursor, second is ASSUMED.
     std::array<std::optional<BlockfileCursor>, BlockfileType::NUM_TYPES>
-        m_blockfile_cursors GUARDED_BY(cs_LastBlockFile) = {
+        m_blockfile_cursors GUARDED_BY(::cs_main) = {
             BlockfileCursor{},
             std::nullopt,
     };
-    int MaxBlockfileNum() const EXCLUSIVE_LOCKS_REQUIRED(cs_LastBlockFile)
+    int MaxBlockfileNum() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
     {
+        AssertLockHeld(::cs_main);
         static const BlockfileCursor empty_cursor;
         const auto& normal = m_blockfile_cursors[BlockfileType::NORMAL].value_or(empty_cursor);
         const auto& assumed = m_blockfile_cursors[BlockfileType::ASSUMED].value_or(empty_cursor);
@@ -381,7 +380,7 @@ class BlockManager
     const CBlockIndex* LookupBlockIndex(const uint256& hash) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /** Get block file info entry for one block file */
-    CBlockFileInfo* GetBlockFileInfo(size_t n);
+    CBlockFileInfo* GetBlockFileInfo(size_t n) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     bool WriteBlockUndo(const CBlockUndo& blockundo, BlockValidationState& state, CBlockIndex& block)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
@@ -394,7 +393,7 @@ class BlockManager
      * @returns in case of success, the position to which the block was written to
      *          in case of an error, an empty FlatFilePos
      */
-    FlatFilePos WriteBlock(const CBlock& block, int nHeight);
+    FlatFilePos WriteBlock(const CBlock& block, int nHeight) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     /** Update blockfile info while processing a block during reindex. The block must be available on disk.
      *
@@ -402,7 +401,7 @@ class BlockManager
      * @param[in]  nHeight      the height of the block
      * @param[in]  pos          the position of the serialized CBlock on disk
      */
-    void UpdateBlockInfo(const CBlock& block, unsigned int nHeight, const FlatFilePos& pos);
+    void UpdateBlockInfo(const CBlock& block, unsigned int nHeight, const FlatFilePos& pos) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     /** Whether running in -prune mode. */
     [[nodiscard]] bool IsPruneMode() const { return m_prune_mode; }
@@ -414,7 +413,7 @@ class BlockManager
     [[nodiscard]] bool LoadingBlocks() const { return m_importing || !m_blockfiles_indexed; }
 
     /** Calculate the amount of disk space the block & undo files currently use */
-    uint64_t CalculateCurrentUsage();
+    uint64_t CalculateCurrentUsage() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     //! Check if all blocks in the [upper_block, lower_block] range have data available as
     //! defined by the status mask.
diff --git a/src/node/caches.cpp b/src/node/caches.cpp
index 94d0ced88f69..c98b8ce60407 100644
--- a/src/node/caches.cpp
+++ b/src/node/caches.cpp
@@ -58,16 +58,27 @@ CacheSizes CalculateCacheSizes(const ArgsManager& args, size_t n_indexes)
 {
     size_t total_cache{CalculateDbCacheBytes(args)};
 
+    // Allocate proportional to usage pattern benefit:
+    // - txindex (10%): serves getrawtransaction RPCs with mostly unique,
+    //   non-repetitive lookups across the entire blockchain.
+    // - blockfilterindex (5%): serves BIP 157 light clients that repeatedly
+    //   query recent blocks, benefiting from LevelDB cache, but the
+    //   working set for a typical 2-week offline gap is ~200kiB, well within 5%
+    //   of the total cache.
+    // - txospenderindex (5%): serves gettxspendingprevout RPCs with very
+    //   specific, rarely repeated outpoint queries.
+    // - coinstatsindex: intentionally not included here, since usage pattern
+    //   does not seem to suggest it would be necessary to cache.
     IndexCacheSizes index_sizes;
-    index_sizes.tx_index = std::min(total_cache / 8, args.GetBoolArg("-txindex", DEFAULT_TXINDEX) ? MAX_TX_INDEX_CACHE : 0);
-    total_cache -= index_sizes.tx_index;
-    index_sizes.txospender_index = std::min(total_cache / 8, args.GetBoolArg("-txospenderindex", DEFAULT_TXOSPENDERINDEX) ? MAX_TXOSPENDER_INDEX_CACHE : 0);
-    total_cache -= index_sizes.txospender_index;
+    index_sizes.tx_index = std::min(total_cache * 10 / 100, args.GetBoolArg("-txindex", DEFAULT_TXINDEX) ? MAX_TX_INDEX_CACHE : 0);
+    index_sizes.txospender_index = std::min(total_cache * 5 / 100, args.GetBoolArg("-txospenderindex", DEFAULT_TXOSPENDERINDEX) ? MAX_TXOSPENDER_INDEX_CACHE : 0);
     if (n_indexes > 0) {
-        size_t max_cache = std::min(total_cache / 8, MAX_FILTER_INDEX_CACHE);
+        size_t max_cache = std::min(total_cache * 5 / 100, MAX_FILTER_INDEX_CACHE);
         index_sizes.filter_index = max_cache / n_indexes;
         total_cache -= index_sizes.filter_index * n_indexes;
     }
+    total_cache -= index_sizes.tx_index;
+    total_cache -= index_sizes.txospender_index;
     return {index_sizes, kernel::CacheSizes{total_cache}};
 }
 
diff --git a/src/node/interface_ui.cpp b/src/node/interface_ui.cpp
index 6b1fe72fae46..74922f21f945 100644
--- a/src/node/interface_ui.cpp
+++ b/src/node/interface_ui.cpp
@@ -4,7 +4,7 @@
 
 #include <node/interface_ui.h>
 
-#include <btcsignals.h>
+#include <util/btcsignals.h>
 #include <util/string.h>
 #include <util/translation.h>
 
@@ -12,51 +12,6 @@ using util::MakeUnorderedList;
 
 CClientUIInterface uiInterface;
 
-struct UISignals {
-    btcsignals::signal<CClientUIInterface::ThreadSafeMessageBoxSig, btcsignals::optional_last_value<bool>> ThreadSafeMessageBox;
-    btcsignals::signal<CClientUIInterface::ThreadSafeQuestionSig, btcsignals::optional_last_value<bool>> ThreadSafeQuestion;
-    btcsignals::signal<CClientUIInterface::InitMessageSig> InitMessage;
-    btcsignals::signal<CClientUIInterface::InitWalletSig> InitWallet;
-    btcsignals::signal<CClientUIInterface::NotifyNumConnectionsChangedSig> NotifyNumConnectionsChanged;
-    btcsignals::signal<CClientUIInterface::NotifyNetworkActiveChangedSig> NotifyNetworkActiveChanged;
-    btcsignals::signal<CClientUIInterface::NotifyAlertChangedSig> NotifyAlertChanged;
-    btcsignals::signal<CClientUIInterface::ShowProgressSig> ShowProgress;
-    btcsignals::signal<CClientUIInterface::NotifyBlockTipSig> NotifyBlockTip;
-    btcsignals::signal<CClientUIInterface::NotifyHeaderTipSig> NotifyHeaderTip;
-    btcsignals::signal<CClientUIInterface::BannedListChangedSig> BannedListChanged;
-};
-static UISignals g_ui_signals;
-
-#define ADD_SIGNALS_IMPL_WRAPPER(signal_name)                                                                 \
-    btcsignals::connection CClientUIInterface::signal_name##_connect(std::function<signal_name##Sig> fn) \
-    {                                                                                                         \
-        return g_ui_signals.signal_name.connect(fn);                                                          \
-    }
-
-ADD_SIGNALS_IMPL_WRAPPER(ThreadSafeMessageBox);
-ADD_SIGNALS_IMPL_WRAPPER(ThreadSafeQuestion);
-ADD_SIGNALS_IMPL_WRAPPER(InitMessage);
-ADD_SIGNALS_IMPL_WRAPPER(InitWallet);
-ADD_SIGNALS_IMPL_WRAPPER(NotifyNumConnectionsChanged);
-ADD_SIGNALS_IMPL_WRAPPER(NotifyNetworkActiveChanged);
-ADD_SIGNALS_IMPL_WRAPPER(NotifyAlertChanged);
-ADD_SIGNALS_IMPL_WRAPPER(ShowProgress);
-ADD_SIGNALS_IMPL_WRAPPER(NotifyBlockTip);
-ADD_SIGNALS_IMPL_WRAPPER(NotifyHeaderTip);
-ADD_SIGNALS_IMPL_WRAPPER(BannedListChanged);
-
-bool CClientUIInterface::ThreadSafeMessageBox(const bilingual_str& message, unsigned int style) { return g_ui_signals.ThreadSafeMessageBox(message, style).value_or(false);}
-bool CClientUIInterface::ThreadSafeQuestion(const bilingual_str& message, const std::string& non_interactive_message, unsigned int style) { return g_ui_signals.ThreadSafeQuestion(message, non_interactive_message, style).value_or(false);}
-void CClientUIInterface::InitMessage(const std::string& message) { return g_ui_signals.InitMessage(message); }
-void CClientUIInterface::InitWallet() { return g_ui_signals.InitWallet(); }
-void CClientUIInterface::NotifyNumConnectionsChanged(int newNumConnections) { return g_ui_signals.NotifyNumConnectionsChanged(newNumConnections); }
-void CClientUIInterface::NotifyNetworkActiveChanged(bool networkActive) { return g_ui_signals.NotifyNetworkActiveChanged(networkActive); }
-void CClientUIInterface::NotifyAlertChanged() { return g_ui_signals.NotifyAlertChanged(); }
-void CClientUIInterface::ShowProgress(const std::string& title, int nProgress, bool resume_possible) { return g_ui_signals.ShowProgress(title, nProgress, resume_possible); }
-void CClientUIInterface::NotifyBlockTip(SynchronizationState s, const CBlockIndex& block, double verification_progress) { return g_ui_signals.NotifyBlockTip(s, block, verification_progress); }
-void CClientUIInterface::NotifyHeaderTip(SynchronizationState s, int64_t height, int64_t timestamp, bool presync) { return g_ui_signals.NotifyHeaderTip(s, height, timestamp, presync); }
-void CClientUIInterface::BannedListChanged() { return g_ui_signals.BannedListChanged(); }
-
 bool InitError(const bilingual_str& str)
 {
     uiInterface.ThreadSafeMessageBox(str, CClientUIInterface::MSG_ERROR);
diff --git a/src/node/interface_ui.h b/src/node/interface_ui.h
index 8175683f9fa8..9615919661af 100644
--- a/src/node/interface_ui.h
+++ b/src/node/interface_ui.h
@@ -6,6 +6,8 @@
 #ifndef BITCOIN_NODE_INTERFACE_UI_H
 #define BITCOIN_NODE_INTERFACE_UI_H
 
+#include <util/btcsignals.h>
+
 #include <cstdint>
 #include <functional>
 #include <string>
@@ -15,10 +17,6 @@ class CBlockIndex;
 enum class SynchronizationState;
 struct bilingual_str;
 
-namespace btcsignals {
-    class connection;
-} // namespace btcsignals
-
 /** Signals for UI communication. */
 class CClientUIInterface
 {
@@ -66,48 +64,43 @@ class CClientUIInterface
         MSG_ERROR = (ICON_ERROR | BTN_OK | MODAL)
     };
 
-#define ADD_SIGNALS_DECL_WRAPPER(signal_name, rtype, ...)                                  \
-    rtype signal_name(__VA_ARGS__);                                                        \
-    using signal_name##Sig = rtype(__VA_ARGS__);                                           \
-    btcsignals::connection signal_name##_connect(std::function<signal_name##Sig> fn)
-
     /** Show message box. */
-    ADD_SIGNALS_DECL_WRAPPER(ThreadSafeMessageBox, bool, const bilingual_str& message, unsigned int style);
+    btcsignals::signal<void(const bilingual_str& message, unsigned int style)> ThreadSafeMessageBox;
 
     /** If possible, ask the user a question. If not, falls back to ThreadSafeMessageBox(noninteractive_message, style) and returns false. */
-    ADD_SIGNALS_DECL_WRAPPER(ThreadSafeQuestion, bool, const bilingual_str& message, const std::string& noninteractive_message, unsigned int style);
+    btcsignals::signal<bool(const bilingual_str& message, const std::string& noninteractive_message, unsigned int style), btcsignals::any_of> ThreadSafeQuestion;
 
     /** Progress message during initialization. */
-    ADD_SIGNALS_DECL_WRAPPER(InitMessage, void, const std::string& message);
+    btcsignals::signal<void(const std::string& message)> InitMessage;
 
     /** Wallet loader created. */
-    ADD_SIGNALS_DECL_WRAPPER(InitWallet, void, );
+    btcsignals::signal<void()> InitWallet;
 
     /** Number of network connections changed. */
-    ADD_SIGNALS_DECL_WRAPPER(NotifyNumConnectionsChanged, void, int newNumConnections);
+    btcsignals::signal<void(int newNumConnections)> NotifyNumConnectionsChanged;
 
     /** Network activity state changed. */
-    ADD_SIGNALS_DECL_WRAPPER(NotifyNetworkActiveChanged, void, bool networkActive);
+    btcsignals::signal<void(bool networkActive)> NotifyNetworkActiveChanged;
 
     /**
      * Status bar alerts changed.
      */
-    ADD_SIGNALS_DECL_WRAPPER(NotifyAlertChanged, void, );
+    btcsignals::signal<void()> NotifyAlertChanged;
 
     /**
      * Show progress e.g. for verifychain.
      * resume_possible indicates shutting down now will result in the current progress action resuming upon restart.
      */
-    ADD_SIGNALS_DECL_WRAPPER(ShowProgress, void, const std::string& title, int nProgress, bool resume_possible);
+    btcsignals::signal<void(const std::string& title, int nProgress, bool resume_possible)> ShowProgress;
 
     /** New block has been accepted */
-    ADD_SIGNALS_DECL_WRAPPER(NotifyBlockTip, void, SynchronizationState, const CBlockIndex& block, double verification_progress);
+    btcsignals::signal<void(SynchronizationState, const CBlockIndex& block, double verification_progress)> NotifyBlockTip;
 
     /** Best header has changed */
-    ADD_SIGNALS_DECL_WRAPPER(NotifyHeaderTip, void, SynchronizationState, int64_t height, int64_t timestamp, bool presync);
+    btcsignals::signal<void(SynchronizationState, int64_t height, int64_t timestamp, bool presync)> NotifyHeaderTip;
 
     /** Banlist did change. */
-    ADD_SIGNALS_DECL_WRAPPER(BannedListChanged, void, void);
+    btcsignals::signal<void(void)> BannedListChanged;
 };
 
 /** Show warning message **/
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 2f68f414f0da..3e34c3abf398 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -6,7 +6,6 @@
 
 #include <banman.h>
 #include <blockfilter.h>
-#include <btcsignals.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <coins.h>
@@ -60,6 +59,7 @@
 #include <txmempool.h>
 #include <uint256.h>
 #include <univalue.h>
+#include <util/btcsignals.h>
 #include <util/check.h>
 #include <util/result.h>
 #include <util/signalinterrupt.h>
@@ -386,50 +386,50 @@ class NodeImpl : public Node
     }
     std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) override
     {
-        return MakeSignalHandler(::uiInterface.InitMessage_connect(fn));
+        return MakeSignalHandler(::uiInterface.InitMessage.connect(fn));
     }
     std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn) override
     {
-        return MakeSignalHandler(::uiInterface.ThreadSafeMessageBox_connect(fn));
+        return MakeSignalHandler(::uiInterface.ThreadSafeMessageBox.connect(fn));
     }
     std::unique_ptr<Handler> handleQuestion(QuestionFn fn) override
     {
-        return MakeSignalHandler(::uiInterface.ThreadSafeQuestion_connect(fn));
+        return MakeSignalHandler(::uiInterface.ThreadSafeQuestion.connect(fn));
     }
     std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) override
     {
-        return MakeSignalHandler(::uiInterface.ShowProgress_connect(fn));
+        return MakeSignalHandler(::uiInterface.ShowProgress.connect(fn));
     }
     std::unique_ptr<Handler> handleInitWallet(InitWalletFn fn) override
     {
-        return MakeSignalHandler(::uiInterface.InitWallet_connect(fn));
+        return MakeSignalHandler(::uiInterface.InitWallet.connect(fn));
     }
     std::unique_ptr<Handler> handleNotifyNumConnectionsChanged(NotifyNumConnectionsChangedFn fn) override
     {
-        return MakeSignalHandler(::uiInterface.NotifyNumConnectionsChanged_connect(fn));
+        return MakeSignalHandler(::uiInterface.NotifyNumConnectionsChanged.connect(fn));
     }
     std::unique_ptr<Handler> handleNotifyNetworkActiveChanged(NotifyNetworkActiveChangedFn fn) override
     {
-        return MakeSignalHandler(::uiInterface.NotifyNetworkActiveChanged_connect(fn));
+        return MakeSignalHandler(::uiInterface.NotifyNetworkActiveChanged.connect(fn));
     }
     std::unique_ptr<Handler> handleNotifyAlertChanged(NotifyAlertChangedFn fn) override
     {
-        return MakeSignalHandler(::uiInterface.NotifyAlertChanged_connect(fn));
+        return MakeSignalHandler(::uiInterface.NotifyAlertChanged.connect(fn));
     }
     std::unique_ptr<Handler> handleBannedListChanged(BannedListChangedFn fn) override
     {
-        return MakeSignalHandler(::uiInterface.BannedListChanged_connect(fn));
+        return MakeSignalHandler(::uiInterface.BannedListChanged.connect(fn));
     }
     std::unique_ptr<Handler> handleNotifyBlockTip(NotifyBlockTipFn fn) override
     {
-        return MakeSignalHandler(::uiInterface.NotifyBlockTip_connect([fn](SynchronizationState sync_state, const CBlockIndex& block, double verification_progress) {
+        return MakeSignalHandler(::uiInterface.NotifyBlockTip.connect([fn](SynchronizationState sync_state, const CBlockIndex& block, double verification_progress) {
             fn(sync_state, BlockTip{block.nHeight, block.GetBlockTime(), block.GetBlockHash()}, verification_progress);
         }));
     }
     std::unique_ptr<Handler> handleNotifyHeaderTip(NotifyHeaderTipFn fn) override
     {
         return MakeSignalHandler(
-            ::uiInterface.NotifyHeaderTip_connect([fn](SynchronizationState sync_state, int64_t height, int64_t timestamp, bool presync) {
+            ::uiInterface.NotifyHeaderTip.connect([fn](SynchronizationState sync_state, int64_t height, int64_t timestamp, bool presync) {
                 fn(sync_state, BlockTip{(int)height, timestamp, uint256{}}, presync);
             }));
     }
diff --git a/src/node/protocol_version.h b/src/node/protocol_version.h
index 7904086fe555..a72ac7774655 100644
--- a/src/node/protocol_version.h
+++ b/src/node/protocol_version.h
@@ -9,7 +9,7 @@
  * network protocol versioning
  */
 
-static const int PROTOCOL_VERSION = 70016;
+static const int PROTOCOL_VERSION = 70017;
 
 //! initial proto version, to be increased after version/verack negotiation
 static const int INIT_PROTO_VERSION = 209;
@@ -35,4 +35,7 @@ static const int INVALID_CB_NO_BAN_VERSION = 70015;
 //! "wtxidrelay" message type for wtxid-based relay starts with this version
 static const int WTXID_RELAY_VERSION = 70016;
 
+//! "feature" message type for feature negotiation starts with this version
+static const int FEATURE_VERSION = 70017;
+
 #endif // BITCOIN_NODE_PROTOCOL_VERSION_H
diff --git a/src/noui.cpp b/src/noui.cpp
index 12ebc401c7f9..2450fddac593 100644
--- a/src/noui.cpp
+++ b/src/noui.cpp
@@ -5,8 +5,8 @@
 
 #include <noui.h>
 
-#include <btcsignals.h>
 #include <node/interface_ui.h>
+#include <util/btcsignals.h>
 #include <util/log.h>
 #include <util/translation.h>
 
@@ -17,7 +17,7 @@ btcsignals::connection noui_ThreadSafeMessageBoxConn;
 btcsignals::connection noui_ThreadSafeQuestionConn;
 btcsignals::connection noui_InitMessageConn;
 
-bool noui_ThreadSafeMessageBox(const bilingual_str& message, unsigned int style)
+void noui_ThreadSafeMessageBox(const bilingual_str& message, unsigned int style)
 {
     bool fSecure = style & CClientUIInterface::SECURE;
     style &= ~CClientUIInterface::SECURE;
@@ -41,12 +41,12 @@ bool noui_ThreadSafeMessageBox(const bilingual_str& message, unsigned int style)
     }
 
     tfm::format(std::cerr, "%s%s\n", strCaption, message.original);
-    return false;
 }
 
 bool noui_ThreadSafeQuestion(const bilingual_str& /* ignored interactive message */, const std::string& message, unsigned int style)
 {
-    return noui_ThreadSafeMessageBox(Untranslated(message), style);
+    noui_ThreadSafeMessageBox(Untranslated(message), style);
+    return false; // Answer the question with false in the noui context
 }
 
 void noui_InitMessage(const std::string& message)
@@ -56,15 +56,14 @@ void noui_InitMessage(const std::string& message)
 
 void noui_connect()
 {
-    noui_ThreadSafeMessageBoxConn = uiInterface.ThreadSafeMessageBox_connect(noui_ThreadSafeMessageBox);
-    noui_ThreadSafeQuestionConn = uiInterface.ThreadSafeQuestion_connect(noui_ThreadSafeQuestion);
-    noui_InitMessageConn = uiInterface.InitMessage_connect(noui_InitMessage);
+    noui_ThreadSafeMessageBoxConn = uiInterface.ThreadSafeMessageBox.connect(noui_ThreadSafeMessageBox);
+    noui_ThreadSafeQuestionConn = uiInterface.ThreadSafeQuestion.connect(noui_ThreadSafeQuestion);
+    noui_InitMessageConn = uiInterface.InitMessage.connect(noui_InitMessage);
 }
 
-bool noui_ThreadSafeMessageBoxRedirect(const bilingual_str& message, unsigned int style)
+void noui_ThreadSafeMessageBoxRedirect(const bilingual_str& message, unsigned int style)
 {
     LogInfo("%s", message.original);
-    return false;
 }
 
 bool noui_ThreadSafeQuestionRedirect(const bilingual_str& /* ignored interactive message */, const std::string& message, unsigned int style)
@@ -83,9 +82,9 @@ void noui_test_redirect()
     noui_ThreadSafeMessageBoxConn.disconnect();
     noui_ThreadSafeQuestionConn.disconnect();
     noui_InitMessageConn.disconnect();
-    noui_ThreadSafeMessageBoxConn = uiInterface.ThreadSafeMessageBox_connect(noui_ThreadSafeMessageBoxRedirect);
-    noui_ThreadSafeQuestionConn = uiInterface.ThreadSafeQuestion_connect(noui_ThreadSafeQuestionRedirect);
-    noui_InitMessageConn = uiInterface.InitMessage_connect(noui_InitMessageRedirect);
+    noui_ThreadSafeMessageBoxConn = uiInterface.ThreadSafeMessageBox.connect(noui_ThreadSafeMessageBoxRedirect);
+    noui_ThreadSafeQuestionConn = uiInterface.ThreadSafeQuestion.connect(noui_ThreadSafeQuestionRedirect);
+    noui_InitMessageConn = uiInterface.InitMessage.connect(noui_InitMessageRedirect);
 }
 
 void noui_reconnect()
diff --git a/src/noui.h b/src/noui.h
index 332346f51eff..71f284bde8e7 100644
--- a/src/noui.h
+++ b/src/noui.h
@@ -10,7 +10,7 @@
 struct bilingual_str;
 
 /** Non-GUI handler, which logs and prints messages. */
-bool noui_ThreadSafeMessageBox(const bilingual_str& message, unsigned int style);
+void noui_ThreadSafeMessageBox(const bilingual_str& message, unsigned int style);
 /** Non-GUI handler, which logs and prints questions. */
 bool noui_ThreadSafeQuestion(const bilingual_str& /* ignored interactive message */, const std::string& message, unsigned int style);
 /** Non-GUI handler, which only logs a message. */
diff --git a/src/prevector.h b/src/prevector.h
index 91be488039ea..e8a71bc9a02a 100644
--- a/src/prevector.h
+++ b/src/prevector.h
@@ -7,11 +7,11 @@
 
 #include <algorithm>
 #include <cassert>
-#include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <iterator>
+#include <new>
 #include <type_traits>
 #include <utility>
 
diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index 34bb9571c153..3a7735e149b6 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -403,4 +403,16 @@ struct CMutableTransaction
 typedef std::shared_ptr<const CTransaction> CTransactionRef;
 template <typename Tx> static inline CTransactionRef MakeTransactionRef(Tx&& txIn) { return std::make_shared<const CTransaction>(std::forward<Tx>(txIn)); }
 
+namespace std {
+/** Disable default std::hash for CTransactionRef to prevent accidentally
+ *  comparing by pointer. Use CTransactionRefHash or provide a custom
+ *  hasher. */
+template <>
+struct hash<CTransactionRef> {
+    hash() = delete;
+    // Belt-and-suspenders, already implied by the above.
+    size_t operator()(const CTransactionRef&) const = delete;
+};
+} // namespace std
+
 #endif // BITCOIN_PRIMITIVES_TRANSACTION_H
diff --git a/src/protocol.h b/src/protocol.h
index 8ed90dd3f8ef..24851e2fc49d 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -264,6 +264,10 @@ inline constexpr const char* WTXIDRELAY{"wtxidrelay"};
  * txreconciliation, as described by BIP 330.
  */
 inline constexpr const char* SENDTXRCNCL{"sendtxrcncl"};
+/**
+ * BIP 434 Peer feature negotiation
+ */
+inline constexpr const char* FEATURE{"feature"};
 }; // namespace NetMsgType
 
 /** All known message types (see above). Keep this in the same order as the list of messages above. */
@@ -303,8 +307,16 @@ inline const std::array ALL_NET_MESSAGE_TYPES{std::to_array<std::string>({
     NetMsgType::CFCHECKPT,
     NetMsgType::WTXIDRELAY,
     NetMsgType::SENDTXRCNCL,
+    NetMsgType::FEATURE,
 })};
 
+static constexpr size_t MAX_FEATUREID_LENGTH{80};
+static constexpr size_t MAX_FEATUREDATA_LENGTH{512};
+
+namespace NetMsgFeature {
+//inline constexpr std::string_view FOO{"BIP-FOO"};
+}
+
 /** nServices flags */
 enum ServiceFlags : uint64_t {
     // NOTE: When adding here, be sure to update serviceFlagToStr too
diff --git a/src/pubkey.h b/src/pubkey.h
index 02ad7371a796..0391609ebcc3 100644
--- a/src/pubkey.h
+++ b/src/pubkey.h
@@ -27,8 +27,6 @@ class CKeyID : public uint160
     explicit CKeyID(const uint160& in) : uint160(in) {}
 };
 
-typedef uint256 ChainCode;
-
 /** An encapsulated public key. */
 class CPubKey
 {
diff --git a/src/qt/bitcoin.cpp b/src/qt/bitcoin.cpp
index bf42f78da044..97eb957c93ec 100644
--- a/src/qt/bitcoin.cpp
+++ b/src/qt/bitcoin.cpp
@@ -6,7 +6,6 @@
 
 #include <qt/bitcoin.h>
 
-#include <btcsignals.h>
 #include <chainparams.h>
 #include <common/args.h>
 #include <common/init.h>
@@ -31,6 +30,7 @@
 #include <qt/utilitydialog.h>
 #include <qt/winshutdownmonitor.h>
 #include <uint256.h>
+#include <util/btcsignals.h>
 #include <util/exception.h>
 #include <util/log.h>
 #include <util/string.h>
@@ -485,9 +485,9 @@ int GuiMain(int argc, char* argv[])
     util::ThreadSetInternalName("main");
 
     // Subscribe to global signals from core
-    btcsignals::scoped_connection handler_message_box = ::uiInterface.ThreadSafeMessageBox_connect(noui_ThreadSafeMessageBox);
-    btcsignals::scoped_connection handler_question = ::uiInterface.ThreadSafeQuestion_connect(noui_ThreadSafeQuestion);
-    btcsignals::scoped_connection handler_init_message = ::uiInterface.InitMessage_connect(noui_InitMessage);
+    btcsignals::scoped_connection handler_message_box{::uiInterface.ThreadSafeMessageBox.connect(noui_ThreadSafeMessageBox)};
+    btcsignals::scoped_connection handler_question{::uiInterface.ThreadSafeQuestion.connect(noui_ThreadSafeQuestion)};
+    btcsignals::scoped_connection handler_init_message{::uiInterface.InitMessage.connect(noui_InitMessage)};
 
     // Do not refer to data directory yet, this can be overridden by Intro::pickDataDirectory
 
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
index 96ea3f4a7060..9d3f7ad639ff 100644
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -1589,7 +1589,7 @@ void BitcoinGUI::showModalOverlay()
         modalOverlay->toggleVisibility();
 }
 
-static bool ThreadSafeMessageBox(BitcoinGUI* gui, const bilingual_str& message, unsigned int style)
+[[nodiscard]] static bool ThreadSafeMessageBox(BitcoinGUI* gui, const bilingual_str& message, unsigned int style)
 {
     bool modal = (style & CClientUIInterface::MODAL);
     // The SECURE flag has no effect in the Qt GUI.
@@ -1621,7 +1621,7 @@ void BitcoinGUI::subscribeToCoreSignals()
 {
     // Connect signals to client
     m_handler_message_box = m_node.handleMessageBox([this](const bilingual_str& message, unsigned int style) {
-        return ThreadSafeMessageBox(this, message, style);
+        (void)ThreadSafeMessageBox(this, message, style);
     });
     m_handler_question = m_node.handleQuestion([this](const bilingual_str& message, const std::string& /*non_interactive_message*/, unsigned int style) {
         return ThreadSafeMessageBox(this, message, style);
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 14412c90fcc9..d78b82bce3e5 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -33,6 +33,7 @@
 #include <node/utxo_snapshot.h>
 #include <node/warnings.h>
 #include <primitives/transaction.h>
+#include <rpc/rawtransaction_util.h>
 #include <rpc/server.h>
 #include <rpc/server_util.h>
 #include <rpc/util.h>
@@ -743,32 +744,62 @@ static CBlockUndo GetUndoChecked(BlockManager& blockman, const CBlockIndex& bloc
     return blockUndo;
 }
 
-const RPCResult& GetBlockVin()
+static std::vector<RPCResult> GetBlockFields(RPCResult tx_result, std::optional<std::string> elision_msg = std::nullopt)
 {
-    static const RPCResult getblock_vin{
-        RPCResult::Type::ARR, "vin", "",
+    auto fields = std::vector<RPCResult>{
+        {RPCResult::Type::STR_HEX, "hash", "the block hash (same as provided)"},
+        {RPCResult::Type::NUM, "confirmations", "The number of confirmations, or -1 if the block is not on the main chain"},
+        {RPCResult::Type::NUM, "size", "The block size"},
+        {RPCResult::Type::NUM, "strippedsize", "The block size excluding witness data"},
+        {RPCResult::Type::NUM, "weight", "The block weight as defined in BIP 141"},
+        {RPCResult::Type::OBJ, "coinbase_tx", "Coinbase transaction metadata",
         {
-            {RPCResult::Type::OBJ, "", "",
-            {
-                {RPCResult::Type::ELISION, "", "The same output as verbosity = 2"},
-                {RPCResult::Type::OBJ, "prevout", "(Only if undo information is available)",
-                {
-                    {RPCResult::Type::BOOL, "generated", "Coinbase or not"},
-                    {RPCResult::Type::NUM, "height", "The height of the prevout"},
-                    {RPCResult::Type::STR_AMOUNT, "value", "The value in " + CURRENCY_UNIT},
-                    {RPCResult::Type::OBJ, "scriptPubKey", "",
-                    {
-                        {RPCResult::Type::STR, "asm", "Disassembly of the output script"},
-                        {RPCResult::Type::STR, "desc", "Inferred descriptor for the output"},
-                        {RPCResult::Type::STR_HEX, "hex", "The raw output script bytes, hex-encoded"},
-                        {RPCResult::Type::STR, "address", /*optional=*/true, "The Bitcoin address (only if a well-defined address exists)"},
-                        {RPCResult::Type::STR, "type", "The type (one of: " + GetAllOutputTypes() + ")"},
-                    }},
-                }},
-            }},
-        }
+            {RPCResult::Type::NUM, "version", "The coinbase transaction version"},
+            {RPCResult::Type::NUM, "locktime", "The coinbase transaction's locktime (nLockTime)"},
+            {RPCResult::Type::NUM, "sequence", "The coinbase input's sequence number (nSequence)"},
+            {RPCResult::Type::STR_HEX, "coinbase", "The coinbase input's script"},
+            {RPCResult::Type::STR_HEX, "witness", /*optional=*/true, "The coinbase input's first (and only) witness stack element, if present"},
+        }},
+        {RPCResult::Type::NUM, "height", "The block height or index"},
+        {RPCResult::Type::NUM, "version", "The block version"},
+        {RPCResult::Type::STR_HEX, "versionHex", "The block version formatted in hexadecimal"},
+        {RPCResult::Type::STR_HEX, "merkleroot", "The merkle root"},
     };
-    return getblock_vin;
+    fields.push_back(std::move(tx_result));
+    fields.emplace_back(RPCResult::Type::NUM_TIME, "time", "The block time expressed in " + UNIX_EPOCH_TIME);
+    fields.emplace_back(RPCResult::Type::NUM_TIME, "mediantime", "The median block time expressed in " + UNIX_EPOCH_TIME);
+    fields.emplace_back(RPCResult::Type::NUM, "nonce", "The nonce");
+    fields.emplace_back(RPCResult::Type::STR_HEX, "bits", "nBits: compact representation of the block difficulty target");
+    fields.emplace_back(RPCResult::Type::STR_HEX, "target", "The difficulty target");
+    fields.emplace_back(RPCResult::Type::NUM, "difficulty", "The difficulty");
+    fields.emplace_back(RPCResult::Type::STR_HEX, "chainwork", "Expected number of hashes required to produce the chain up to this block (in hex)");
+    fields.emplace_back(RPCResult::Type::NUM, "nTx", "The number of transactions in the block");
+    fields.emplace_back(RPCResult::Type::STR_HEX, "previousblockhash", /*optional=*/true, "The hash of the previous block (if available)");
+    fields.emplace_back(RPCResult::Type::STR_HEX, "nextblockhash", /*optional=*/true, "The hash of the next block (if available)");
+    if (elision_msg) {
+        // Elide all block-level fields except the tx array (which differs per verbosity)
+        std::vector<RPCResult> new_fields;
+        new_fields.reserve(fields.size());
+        bool first = true;
+        for (const auto& f : fields) {
+            if (f.m_key_name == "tx") {
+                new_fields.push_back(f);
+                continue;
+            }
+            if (first) {
+                RPCResultOptions eopts = f.m_opts;
+                eopts.print_elision = *elision_msg;
+                new_fields.emplace_back(f, std::move(eopts));
+                first = false;
+            } else {
+                RPCResultOptions eopts = f.m_opts;
+                eopts.print_elision = HelpElisionSkip{};
+                new_fields.emplace_back(f, std::move(eopts));
+            }
+        }
+        fields = std::move(new_fields);
+    }
+    return fields;
 }
 
 static RPCMethod getblock()
@@ -785,67 +816,33 @@ static RPCMethod getblock()
                      RPCArgOptions{.skip_type_check = true}},
                 },
                 {
-                    RPCResult{"for verbosity = 0",
-                RPCResult::Type::STR_HEX, "", "A string that is serialized, hex-encoded data for block 'hash'"},
-                    RPCResult{"for verbosity = 1",
-                RPCResult::Type::OBJ, "", "",
-                {
-                    {RPCResult::Type::STR_HEX, "hash", "the block hash (same as provided)"},
-                    {RPCResult::Type::NUM, "confirmations", "The number of confirmations, or -1 if the block is not on the main chain"},
-                    {RPCResult::Type::NUM, "size", "The block size"},
-                    {RPCResult::Type::NUM, "strippedsize", "The block size excluding witness data"},
-                    {RPCResult::Type::NUM, "weight", "The block weight as defined in BIP 141"},
-                    {RPCResult::Type::OBJ, "coinbase_tx", "Coinbase transaction metadata",
-                    {
-                        {RPCResult::Type::NUM, "version", "The coinbase transaction version"},
-                        {RPCResult::Type::NUM, "locktime", "The coinbase transaction's locktime (nLockTime)"},
-                        {RPCResult::Type::NUM, "sequence", "The coinbase input's sequence number (nSequence)"},
-                        {RPCResult::Type::STR_HEX, "coinbase", "The coinbase input's script"},
-                        {RPCResult::Type::STR_HEX, "witness", /*optional=*/true, "The coinbase input's first (and only) witness stack element, if present"},
-                    }},
-                    {RPCResult::Type::NUM, "height", "The block height or index"},
-                    {RPCResult::Type::NUM, "version", "The block version"},
-                    {RPCResult::Type::STR_HEX, "versionHex", "The block version formatted in hexadecimal"},
-                    {RPCResult::Type::STR_HEX, "merkleroot", "The merkle root"},
-                    {RPCResult::Type::ARR, "tx", "The transaction ids",
-                        {{RPCResult::Type::STR_HEX, "", "The transaction id"}}},
-                    {RPCResult::Type::NUM_TIME, "time",       "The block time expressed in " + UNIX_EPOCH_TIME},
-                    {RPCResult::Type::NUM_TIME, "mediantime", "The median block time expressed in " + UNIX_EPOCH_TIME},
-                    {RPCResult::Type::NUM, "nonce", "The nonce"},
-                    {RPCResult::Type::STR_HEX, "bits", "nBits: compact representation of the block difficulty target"},
-                    {RPCResult::Type::STR_HEX, "target", "The difficulty target"},
-                    {RPCResult::Type::NUM, "difficulty", "The difficulty"},
-                    {RPCResult::Type::STR_HEX, "chainwork", "Expected number of hashes required to produce the chain up to this block (in hex)"},
-                    {RPCResult::Type::NUM, "nTx", "The number of transactions in the block"},
-                    {RPCResult::Type::STR_HEX, "previousblockhash", /*optional=*/true, "The hash of the previous block (if available)"},
-                    {RPCResult::Type::STR_HEX, "nextblockhash", /*optional=*/true, "The hash of the next block (if available)"},
-                }},
-                    RPCResult{"for verbosity = 2",
-                RPCResult::Type::OBJ, "", "",
-                {
-                    {RPCResult::Type::ELISION, "", "Same output as verbosity = 1"},
-                    {RPCResult::Type::ARR, "tx", "",
-                    {
-                        {RPCResult::Type::OBJ, "", "",
+                    RPCResult{"for verbosity = 0", RPCResult::Type::STR_HEX, "", "A string that is serialized, hex-encoded data for block 'hash'"},
+                    RPCResult{"for verbosity = 1", RPCResult::Type::OBJ, "", "",
+                        GetBlockFields({RPCResult::Type::ARR, "tx", "The transaction ids",
+                            {{RPCResult::Type::STR_HEX, "", "The transaction id"}}})},
+                    RPCResult{"for verbosity = 2", RPCResult::Type::OBJ, "", "",
+                        GetBlockFields({RPCResult::Type::ARR, "tx", "",
                         {
-                            {RPCResult::Type::ELISION, "", "The transactions in the format of the getrawtransaction RPC. Different from verbosity = 1 \"tx\" result"},
-                            {RPCResult::Type::NUM, "fee", /*optional=*/true, "The transaction fee in " + CURRENCY_UNIT + ", omitted if block undo data is not available"},
-                        }},
-                    }},
-                }},
-                    RPCResult{"for verbosity = 3",
-                RPCResult::Type::OBJ, "", "",
-                {
-                    {RPCResult::Type::ELISION, "", "Same output as verbosity = 2"},
-                    {RPCResult::Type::ARR, "tx", "",
-                    {
-                        {RPCResult::Type::OBJ, "", "",
+                            {RPCResult::Type::OBJ, "", "",
+                                TxDoc({.elision_mode = ElisionMode::WithSummary,
+                                       .elision_summary = "The transactions in the format of the getrawtransaction RPC. Different from verbosity = 1 \"tx\" result",
+                                       .fee = true, .hex = true,
+                                       .fee_doc = "The transaction fee in " + CURRENCY_UNIT + ", omitted if block undo data is not available"})},
+                        }}, /*elision_msg=*/"Same output as verbosity = 1")},
+                    RPCResult{"for verbosity = 3", RPCResult::Type::OBJ, "", "",
+                        GetBlockFields({RPCResult::Type::ARR, "tx", "",
                         {
-                            GetBlockVin(),
-                        }},
-                    }},
-                }},
-        },
+                            {RPCResult::Type::OBJ, "", "",
+                                TxDoc({.elision_mode = ElisionMode::Silent,
+                                       .prevout = true,
+                                       .prevout_optional = true,
+                                       .fee = true,
+                                       .hex = true,
+                                       .vin_item_doc = "",
+                                       .prevout_doc = "(Only if undo information is available)",
+                                       .vin_inner_elision = "The same output as verbosity = 2"})},
+                        }}, /*elision_msg=*/"Same output as verbosity = 2")},
+                },
                 RPCExamples{
                     HelpExampleCli("getblock", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\"")
             + HelpExampleRpc("getblock", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\"")
diff --git a/src/rpc/fees.cpp b/src/rpc/fees.cpp
index b19826698a36..450af530d941 100644
--- a/src/rpc/fees.cpp
+++ b/src/rpc/fees.cpp
@@ -94,6 +94,35 @@ static RPCMethod estimatesmartfee()
     };
 }
 
+static std::vector<RPCResult> FeeRateBucketDoc(bool elide = false)
+{
+    auto fields = std::vector<RPCResult>{
+        {RPCResult::Type::NUM, "startrange", "start of feerate range"},
+        {RPCResult::Type::NUM, "endrange", "end of feerate range"},
+        {RPCResult::Type::NUM, "withintarget", "number of txs over history horizon in the feerate range that were confirmed within target"},
+        {RPCResult::Type::NUM, "totalconfirmed", "number of txs over history horizon in the feerate range that were confirmed at any point"},
+        {RPCResult::Type::NUM, "inmempool", "current number of txs in mempool in the feerate range unconfirmed for at least target blocks"},
+        {RPCResult::Type::NUM, "leftmempool", "number of txs over history horizon in the feerate range that left mempool unconfirmed after target"},
+    };
+    return elide ? ElideGroup(std::move(fields)) : fields;
+}
+
+static std::vector<RPCResult> FeeEstimateHorizonDoc(bool elide = false)
+{
+    auto fields = std::vector<RPCResult>{
+        {RPCResult::Type::NUM, "feerate", /*optional=*/true, "estimate fee rate in " + CURRENCY_UNIT + "/kvB"},
+        {RPCResult::Type::NUM, "decay", "exponential decay (per block) for historical moving average of confirmation data"},
+        {RPCResult::Type::NUM, "scale", "The resolution of confirmation targets at this time horizon"},
+        {RPCResult::Type::OBJ, "pass", /*optional=*/true, "information about the lowest range of feerates to succeed in meeting the threshold", FeeRateBucketDoc()},
+        {RPCResult::Type::OBJ, "fail", /*optional=*/true, "information about the highest range of feerates to fail to meet the threshold", FeeRateBucketDoc(/*elide=*/true)},
+        {RPCResult::Type::ARR, "errors", /*optional=*/true, "Errors encountered during processing (if there are any)",
+        {
+            {RPCResult::Type::STR, "error", ""},
+        }},
+    };
+    return elide ? ElideGroup(std::move(fields)) : fields;
+}
+
 static RPCMethod estimaterawfee()
 {
     return RPCMethod{
@@ -115,36 +144,11 @@ static RPCMethod estimaterawfee()
             RPCResult::Type::OBJ, "", "Results are returned for any horizon which tracks blocks up to the confirmation target",
             {
                 {RPCResult::Type::OBJ, "short", /*optional=*/true, "estimate for short time horizon",
-                    {
-                        {RPCResult::Type::NUM, "feerate", /*optional=*/true, "estimate fee rate in " + CURRENCY_UNIT + "/kvB"},
-                        {RPCResult::Type::NUM, "decay", "exponential decay (per block) for historical moving average of confirmation data"},
-                        {RPCResult::Type::NUM, "scale", "The resolution of confirmation targets at this time horizon"},
-                        {RPCResult::Type::OBJ, "pass", /*optional=*/true, "information about the lowest range of feerates to succeed in meeting the threshold",
-                        {
-                                {RPCResult::Type::NUM, "startrange", "start of feerate range"},
-                                {RPCResult::Type::NUM, "endrange", "end of feerate range"},
-                                {RPCResult::Type::NUM, "withintarget", "number of txs over history horizon in the feerate range that were confirmed within target"},
-                                {RPCResult::Type::NUM, "totalconfirmed", "number of txs over history horizon in the feerate range that were confirmed at any point"},
-                                {RPCResult::Type::NUM, "inmempool", "current number of txs in mempool in the feerate range unconfirmed for at least target blocks"},
-                                {RPCResult::Type::NUM, "leftmempool", "number of txs over history horizon in the feerate range that left mempool unconfirmed after target"},
-                        }},
-                        {RPCResult::Type::OBJ, "fail", /*optional=*/true, "information about the highest range of feerates to fail to meet the threshold",
-                        {
-                            {RPCResult::Type::ELISION, "", ""},
-                        }},
-                        {RPCResult::Type::ARR, "errors", /*optional=*/true, "Errors encountered during processing (if there are any)",
-                        {
-                            {RPCResult::Type::STR, "error", ""},
-                        }},
-                }},
+                    FeeEstimateHorizonDoc()},
                 {RPCResult::Type::OBJ, "medium", /*optional=*/true, "estimate for medium time horizon",
-                {
-                    {RPCResult::Type::ELISION, "", ""},
-                }},
+                    FeeEstimateHorizonDoc(/*elide=*/true)},
                 {RPCResult::Type::OBJ, "long", /*optional=*/true, "estimate for long time horizon",
-                {
-                    {RPCResult::Type::ELISION, "", ""},
-                }},
+                    FeeEstimateHorizonDoc(/*elide=*/true)},
             }},
         RPCExamples{
             HelpExampleCli("estimaterawfee", "6 0.9")
diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index 98450b907895..0358aeae9381 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -143,7 +143,8 @@ static RPCMethod getprivatebroadcastinfo()
 {
     return RPCMethod{
         "getprivatebroadcastinfo",
-        "Returns information about transactions that are currently being privately broadcast.\n",
+        "Returns information about transactions that are currently being privately broadcast.\n"
+        "This method is only available when running with -privatebroadcast enabled.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ, "", "",
@@ -176,6 +177,10 @@ static RPCMethod getprivatebroadcastinfo()
         {
             const NodeContext& node{EnsureAnyNodeContext(request.context)};
             const PeerManager& peerman{EnsurePeerman(node)};
+            if (!peerman.GetInfo().private_broadcast) {
+                throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Private broadcast is not enabled. Ensure you're running Bitcoin Core with -privatebroadcast=1.");
+            }
+
             const auto txs{peerman.GetPrivateBroadcastInfo()};
 
             UniValue transactions(UniValue::VARR);
@@ -211,7 +216,8 @@ static RPCMethod abortprivatebroadcast()
     return RPCMethod{
         "abortprivatebroadcast",
         "Abort private broadcast attempts for a transaction currently being privately broadcast.\n"
-        "The transaction will be removed from the private broadcast queue.\n",
+        "The transaction will be removed from the private broadcast queue.\n"
+        "This method is only available when running with -privatebroadcast enabled.\n",
         {
             {"id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "A transaction identifier to abort. It will be matched against both txid and wtxid for all transactions in the private broadcast queue.\n"
                                                                 "If the provided id matches a txid that corresponds to multiple transactions with different wtxids, multiple transactions will be removed and returned."},
@@ -236,10 +242,14 @@ static RPCMethod abortprivatebroadcast()
         },
         [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
         {
-            const uint256 id{ParseHashV(self.Arg<UniValue>("id"), "id")};
 
             const NodeContext& node{EnsureAnyNodeContext(request.context)};
             PeerManager& peerman{EnsurePeerman(node)};
+            if (!peerman.GetInfo().private_broadcast) {
+                throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Private broadcast is not enabled. Ensure you're running Bitcoin Core with -privatebroadcast=1.");
+            }
+
+            const uint256 id{ParseHashV(self.Arg<UniValue>("id"), "id")};
 
             const auto removed_txs{peerman.AbortPrivateBroadcast(id)};
             if (removed_txs.empty()) {
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 1d72c699c593..40c4557754df 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -1164,8 +1164,7 @@ static RPCMethod submitheader()
         }
     }
 
-    BlockValidationState state;
-    chainman.ProcessNewBlockHeaders({{h}}, /*min_pow_checked=*/true, state);
+    BlockValidationState state{chainman.ProcessNewBlockHeaders({{h}}, /*min_pow_checked=*/true)};
     if (state.IsValid()) return UniValue::VNULL;
     if (state.IsError()) {
         throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
diff --git a/src/rpc/node.cpp b/src/rpc/node.cpp
index aad24b0f5b33..74d950ca7077 100644
--- a/src/rpc/node.cpp
+++ b/src/rpc/node.cpp
@@ -29,6 +29,7 @@
 #include <util/time.h>
 
 #include <cstdint>
+#include <limits>
 #ifdef HAVE_MALLOC_INFO
 #include <malloc.h>
 #endif
@@ -61,7 +62,9 @@ static RPCMethod setmocktime()
     LOCK(cs_main);
 
     const int64_t time{request.params[0].getInt<int64_t>()};
-    constexpr int64_t max_time{Ticks<std::chrono::seconds>(std::chrono::nanoseconds::max())};
+    // block timestamps are uint32_t, so mocking time beyond that is meaningless for anything
+    // consensus-related and can cause integer overflow/truncation issues in time arithmetic.
+    constexpr int64_t max_time{std::numeric_limits<uint32_t>::max()};
     if (time < 0 || time > max_time) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Mocktime must be in the range [0, %s], not %s.", max_time, time));
     }
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index f00ee62d7eca..31a877b8f048 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -213,6 +213,23 @@ PartiallySignedTransaction ProcessPSBT(const std::string& psbt_string, const std
 
 static RPCMethod getrawtransaction()
 {
+    const std::vector<RPCResult> verbosity_1_block{
+        {RPCResult::Type::BOOL, "in_active_chain", /*optional=*/true, "Whether specified block is in the active chain or not (only present with explicit \"blockhash\" argument)"},
+        {RPCResult::Type::STR_HEX, "blockhash", /*optional=*/true, "the block hash"},
+        {RPCResult::Type::NUM, "confirmations", /*optional=*/true, "The confirmations"},
+        {RPCResult::Type::NUM_TIME, "blocktime", /*optional=*/true, "The block time expressed in " + UNIX_EPOCH_TIME},
+        {RPCResult::Type::NUM, "time", /*optional=*/true, "Same as \"blocktime\""},
+        {RPCResult::Type::STR_HEX, "hex", "The serialized, hex-encoded data for 'txid'"},
+    };
+    const auto v2_extras = Cat<std::vector<RPCResult>>(
+        std::vector<RPCResult>{{
+            RPCResult::Type::NUM, "fee", /*optional=*/true,
+            "transaction fee in " + CURRENCY_UNIT + ", omitted if block undo data is not available"
+        }},
+        TxDoc({.elision_mode = ElisionMode::Silent,
+               .prevout = true,
+               .prevout_optional = true,
+               .vin_inner_elision = "Same vin fields as verbosity = 1"}));
     return RPCMethod{
                 "getrawtransaction",
 
@@ -238,36 +255,11 @@ static RPCMethod getrawtransaction()
                      RPCResult{"if verbosity is set to 1",
                          RPCResult::Type::OBJ, "", "",
                          Cat<std::vector<RPCResult>>(
-                         {
-                             {RPCResult::Type::BOOL, "in_active_chain", /*optional=*/true, "Whether specified block is in the active chain or not (only present with explicit \"blockhash\" argument)"},
-                             {RPCResult::Type::STR_HEX, "blockhash", /*optional=*/true, "the block hash"},
-                             {RPCResult::Type::NUM, "confirmations", /*optional=*/true, "The confirmations"},
-                             {RPCResult::Type::NUM_TIME, "blocktime", /*optional=*/true, "The block time expressed in " + UNIX_EPOCH_TIME},
-                             {RPCResult::Type::NUM, "time", /*optional=*/true, "Same as \"blocktime\""},
-                             {RPCResult::Type::STR_HEX, "hex", "The serialized, hex-encoded data for 'txid'"},
-                         },
+                         verbosity_1_block,
                          TxDoc({.txid_field_doc="The transaction id (same as provided)"})),
                     },
-                    RPCResult{"for verbosity = 2",
-                        RPCResult::Type::OBJ, "", "",
-                        {
-                            {RPCResult::Type::ELISION, "", "Same output as verbosity = 1"},
-                            {RPCResult::Type::NUM, "fee", /*optional=*/true, "transaction fee in " + CURRENCY_UNIT + ", omitted if block undo data is not available"},
-                            {RPCResult::Type::ARR, "vin", "",
-                            {
-                                {RPCResult::Type::OBJ, "", "utxo being spent",
-                                {
-                                    {RPCResult::Type::ELISION, "", "Same output as verbosity = 1"},
-                                    {RPCResult::Type::OBJ, "prevout", /*optional=*/true, "The previous output, omitted if block undo data is not available",
-                                    {
-                                        {RPCResult::Type::BOOL, "generated", "Coinbase or not"},
-                                        {RPCResult::Type::NUM, "height", "The height of the prevout"},
-                                        {RPCResult::Type::STR_AMOUNT, "value", "The value in " + CURRENCY_UNIT},
-                                        {RPCResult::Type::OBJ, "scriptPubKey", "", ScriptPubKeyDoc()},
-                                    }},
-                                }},
-                            }},
-                        }},
+                    RPCResult{"for verbosity = 2", RPCResult::Type::OBJ, "", "",
+                    Cat(ElideGroup(verbosity_1_block, "Same output as verbosity = 1"), v2_extras)},
                 },
                 RPCExamples{
                     HelpExampleCli("getrawtransaction", "\"mytxid\"")
@@ -799,7 +791,7 @@ const RPCResult& DecodePSBTInputs()
             {RPCResult::Type::OBJ, "", "",
             {
                 {RPCResult::Type::OBJ, "non_witness_utxo", /*optional=*/true, "Decoded network transaction for non-witness UTXOs",
-                    TxDoc({.elision_description="The layout is the same as the output of decoderawtransaction."})
+                    TxDoc({.elision_mode = ElisionMode::WithSummary, .elision_summary = "The layout is the same as the output of decoderawtransaction."})
                 },
                 {RPCResult::Type::OBJ, "witness_utxo", /*optional=*/true, "Transaction output for witness UTXOs",
                 {
@@ -987,7 +979,7 @@ const RPCResult& DecodePSBTOutputs()
                 }},
                 {RPCResult::Type::NUM, "amount", /* optional=*/ true, "The amount (nValue) for this output"},
                 {RPCResult::Type::OBJ, "script", /* optional=*/ true, "The output script (scriptPubKey) for this output",
-                    {{RPCResult::Type::ELISION, "", "The layout is the same as the output of scriptPubKeys in decoderawtransaction."}},
+                    ElideGroup(ScriptPubKeyDoc(), "The layout is the same as the output of scriptPubKeys in decoderawtransaction."),
                 },
                 {RPCResult::Type::STR_HEX, "taproot_internal_key", /*optional=*/ true, "The hex-encoded Taproot x-only internal key"},
                 {RPCResult::Type::ARR, "taproot_tree", /*optional=*/ true, "The tuples that make up the Taproot tree, in depth first search order",
@@ -1055,7 +1047,7 @@ static RPCMethod decodepsbt()
                     RPCResult::Type::OBJ, "", "",
                     {
                         {RPCResult::Type::OBJ, "tx", /*optional=*/true, "The decoded network-serialized unsigned transaction.",
-                            TxDoc({.elision_description="The layout is the same as the output of decoderawtransaction."})
+                            TxDoc({.elision_mode = ElisionMode::WithSummary, .elision_summary = "The layout is the same as the output of decoderawtransaction."})
                         },
                         {RPCResult::Type::ARR, "global_xpubs", "",
                         {
diff --git a/src/rpc/rawtransaction_util.cpp b/src/rpc/rawtransaction_util.cpp
index f8b6e20875c2..c90ead5ac554 100644
--- a/src/rpc/rawtransaction_util.cpp
+++ b/src/rpc/rawtransaction_util.cpp
@@ -17,6 +17,7 @@
 #include <script/signingprovider.h>
 #include <tinyformat.h>
 #include <univalue.h>
+#include <util/check.h>
 #include <util/rbf.h>
 #include <util/string.h>
 #include <util/strencodings.h>
@@ -346,35 +347,75 @@ void SignTransactionResultToJSON(CMutableTransaction& mtx, bool complete, const
 
 std::vector<RPCResult> TxDoc(const TxDocOptions& opts)
 {
-    std::optional<std::string> maybe_skip{};
-    if (opts.elision_description) maybe_skip.emplace();
-    return {
-        {RPCResult::Type::STR_HEX, "txid", opts.txid_field_doc, {}, {.print_elision=opts.elision_description}},
-        {RPCResult::Type::STR_HEX, "hash", "The transaction hash (differs from txid for witness transactions)", {}, {.print_elision=maybe_skip}},
-        {RPCResult::Type::NUM, "size", "The serialized transaction size", {}, {.print_elision=maybe_skip}},
-        {RPCResult::Type::NUM, "vsize", "The virtual transaction size (differs from size for witness transactions)", {}, {.print_elision=maybe_skip}},
-        {RPCResult::Type::NUM, "weight", "The transaction's weight (between vsize*4-3 and vsize*4)", {}, {.print_elision=maybe_skip}},
-        {RPCResult::Type::NUM, "version", "The version", {}, {.print_elision=maybe_skip}},
-        {RPCResult::Type::NUM_TIME, "locktime", "The lock time", {}, {.print_elision=maybe_skip}},
+    CHECK_NONFATAL(!opts.fee_doc || opts.fee);
+    CHECK_NONFATAL(!opts.prevout_doc || opts.prevout);
+    CHECK_NONFATAL(!opts.vin_item_doc || opts.vin_inner_elision);
+    CHECK_NONFATAL(opts.elision_mode != ElisionMode::WithSummary || opts.elision_summary.has_value());
+
+    const std::string fee_doc{opts.fee_doc.value_or(
+        "transaction fee in " + CURRENCY_UNIT + ", omitted if block undo data is not available")};
+    const std::string prevout_doc{opts.prevout_doc.value_or(
+        "The previous output, omitted if block undo data is not available")};
+    const std::string vin_item_doc{opts.vin_item_doc.value_or("utxo being spent")};
+
+    auto vin_inner = std::vector<RPCResult>{
+        {RPCResult::Type::STR_HEX, "coinbase", /*optional=*/true, "The coinbase value (only if coinbase transaction)"},
+        {RPCResult::Type::STR_HEX, "txid", /*optional=*/true, "The transaction id (if not coinbase transaction)"},
+        {RPCResult::Type::NUM, "vout", /*optional=*/true, "The output number (if not coinbase transaction)"},
+        {RPCResult::Type::OBJ, "scriptSig", /*optional=*/true, "The script (if not coinbase transaction)",
+        {
+            {RPCResult::Type::STR, "asm", "Disassembly of the signature script"},
+            {RPCResult::Type::STR_HEX, "hex", "The raw signature script bytes, hex-encoded"},
+        }},
+        {RPCResult::Type::ARR, "txinwitness", /*optional=*/true, "",
+        {
+            {RPCResult::Type::STR_HEX, "hex", "hex-encoded witness data (if any)"},
+        }},
+    };
+    if (opts.prevout) {
+        vin_inner.emplace_back(
+            RPCResult::Type::OBJ, "prevout", opts.prevout_optional, prevout_doc,
+            std::vector<RPCResult>{
+                {RPCResult::Type::BOOL, "generated", "Coinbase or not"},
+                {RPCResult::Type::NUM, "height", "The height of the prevout"},
+                {RPCResult::Type::STR_AMOUNT, "value", "The value in " + CURRENCY_UNIT},
+                {RPCResult::Type::OBJ, "scriptPubKey", "", ScriptPubKeyDoc()},
+            }
+        );
+    }
+    vin_inner.emplace_back(RPCResult::Type::NUM, "sequence", "The script sequence number");
+
+    if (opts.vin_inner_elision) {
+        vin_inner = ElideGroup(std::move(vin_inner), *opts.vin_inner_elision);
+        if (opts.prevout) {
+            // prevout remains visible even when other fields are elided
+            std::vector<RPCResult> new_vin;
+            new_vin.reserve(vin_inner.size());
+            for (const auto& r : vin_inner) {
+                if (r.m_key_name == "prevout") {
+                    RPCResultOptions unopts = r.m_opts;
+                    unopts.print_elision = HelpElisionNone{};
+                    new_vin.emplace_back(r, std::move(unopts));
+                } else {
+                    new_vin.push_back(r);
+                }
+            }
+            vin_inner = std::move(new_vin);
+        }
+    }
+
+    auto fields = std::vector<RPCResult>{
+        {RPCResult::Type::STR_HEX, "txid", opts.txid_field_doc},
+        {RPCResult::Type::STR_HEX, "hash", "The transaction hash (differs from txid for witness transactions)"},
+        {RPCResult::Type::NUM, "size", "The serialized transaction size"},
+        {RPCResult::Type::NUM, "vsize", "The virtual transaction size (differs from size for witness transactions)"},
+        {RPCResult::Type::NUM, "weight", "The transaction's weight (between vsize*4-3 and vsize*4)"},
+        {RPCResult::Type::NUM, "version", "The version"},
+        {RPCResult::Type::NUM_TIME, "locktime", "The lock time"},
         {RPCResult::Type::ARR, "vin", "",
         {
-            {RPCResult::Type::OBJ, "", "",
-            {
-                {RPCResult::Type::STR_HEX, "coinbase", /*optional=*/true, "The coinbase value (only if coinbase transaction)"},
-                {RPCResult::Type::STR_HEX, "txid", /*optional=*/true, "The transaction id (if not coinbase transaction)"},
-                {RPCResult::Type::NUM, "vout", /*optional=*/true, "The output number (if not coinbase transaction)"},
-                {RPCResult::Type::OBJ, "scriptSig", /*optional=*/true, "The script (if not coinbase transaction)",
-                {
-                    {RPCResult::Type::STR, "asm", "Disassembly of the signature script"},
-                    {RPCResult::Type::STR_HEX, "hex", "The raw signature script bytes, hex-encoded"},
-                }},
-                {RPCResult::Type::ARR, "txinwitness", /*optional=*/true, "",
-                {
-                    {RPCResult::Type::STR_HEX, "hex", "hex-encoded witness data (if any)"},
-                }},
-                {RPCResult::Type::NUM, "sequence", "The script sequence number"},
-            }},
-        }, {.print_elision=maybe_skip}},
+            {RPCResult::Type::OBJ, "", opts.vin_inner_elision ? vin_item_doc : "", std::move(vin_inner)},
+        }},
         {RPCResult::Type::ARR, "vout", "",
         {
             {RPCResult::Type::OBJ, "", "", Cat(
@@ -383,11 +424,43 @@ std::vector<RPCResult> TxDoc(const TxDocOptions& opts)
                     {RPCResult::Type::NUM, "n", "index"},
                     {RPCResult::Type::OBJ, "scriptPubKey", "", ScriptPubKeyDoc()},
                 },
-                    opts.wallet ?
+                opts.wallet ?
                     std::vector<RPCResult>{{RPCResult::Type::BOOL, "ischange", /*optional=*/true, "Output script is change (only present if true)"}} :
                     std::vector<RPCResult>{}
-                )
-            },
-        }, {.print_elision=maybe_skip}},
+            )},
+        }},
     };
+
+    if (opts.fee) fields.emplace_back(RPCResult::Type::NUM, "fee", /*optional=*/true, fee_doc);
+    if (opts.hex) fields.emplace_back(RPCResult::Type::STR_HEX, "hex", "The hex-encoded transaction data");
+
+    if (opts.elision_mode != ElisionMode::None) {
+        const bool silent = opts.elision_mode == ElisionMode::Silent;
+        std::vector<RPCResult> new_fields;
+        new_fields.reserve(fields.size());
+        bool first = true;
+        for (const auto& f : fields) {
+            if (!silent && f.m_key_name == "fee") {
+                new_fields.push_back(f);
+                continue;
+            }
+            if (f.m_key_name == "vin" && opts.vin_inner_elision) {
+                new_fields.push_back(f);
+                continue;
+            }
+            if (!silent && first) {
+                RPCResultOptions eopts = f.m_opts;
+                eopts.print_elision = opts.elision_summary.value_or("");
+                new_fields.emplace_back(f, std::move(eopts));
+                first = false;
+            } else {
+                RPCResultOptions eopts = f.m_opts;
+                eopts.print_elision = HelpElisionSkip{};
+                new_fields.emplace_back(f, std::move(eopts));
+            }
+        }
+        fields = std::move(new_fields);
+    }
+
+    return fields;
 }
diff --git a/src/rpc/rawtransaction_util.h b/src/rpc/rawtransaction_util.h
index 5a1bc6047c79..52d5e394a994 100644
--- a/src/rpc/rawtransaction_util.h
+++ b/src/rpc/rawtransaction_util.h
@@ -56,13 +56,37 @@ void AddOutputs(CMutableTransaction& rawTx, const UniValue& outputs_in);
 /** Create a transaction from univalue parameters */
 CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniValue& outputs_in, const UniValue& locktime, std::optional<bool> rbf, uint32_t version);
 
+enum class ElisionMode {
+    None,        ///< no elision, all top-level fields rendered normally
+    WithSummary, ///< first field carries elision_summary as "...", rest skipped
+    Silent,      ///< all top-level fields skipped silently (no "..." line)
+};
+
 struct TxDocOptions {
     /// The description of the txid field
     std::string txid_field_doc{"The transaction id"};
     /// Include wallet-related fields (e.g. ischange on outputs)
     bool wallet{false};
-    /// Treat this as an elided Result in the help
-    std::optional<std::string> elision_description{};
+    /// Controls top-level field elision in the help
+    ElisionMode elision_mode{ElisionMode::None};
+    /// Summary text shown as "..." required for elision_mode == WithSummary
+    std::optional<std::string> elision_summary{};
+    /// Include prevout field
+    bool prevout{false};
+    /// Mark prevout field as optional (omitted when undo data unavailable)
+    bool prevout_optional{false};
+    /// Include fee field
+    bool fee{false};
+    /// Include hex field
+    bool hex{false};
+    /// Customize the vin item object's description (only meaningful when vin_inner_elision is set)
+    std::optional<std::string> vin_item_doc{};
+    /// Customize the prevout field's description (only meaningful when prevout is true)
+    std::optional<std::string> prevout_doc{};
+    /// Customize the fee field's description (only meaningful when fee is true)
+    std::optional<std::string> fee_doc{};
+    /// Elide vin inner fields but keep vin array with prevout expanded.
+    std::optional<std::string> vin_inner_elision{};
 };
 /** Explain the UniValue "decoded" transaction object, may include extra fields if processed by wallet **/
 std::vector<RPCResult> TxDoc(const TxDocOptions& opts = {});
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 80b08d0140c4..410bb741c15c 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -99,7 +99,7 @@ CAmount AmountFromValue(const UniValue& value, int decimals)
 {
     if (!value.isNum() && !value.isStr())
         throw JSONRPCError(RPC_TYPE_ERROR, "Amount is not a number or string");
-    CAmount amount;
+    int64_t amount;
     if (!ParseFixedPoint(value.getValStr(), decimals, &amount))
         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount");
     if (!MoneyRange(amount))
@@ -1015,25 +1015,22 @@ void RPCResult::ToSections(Sections& sections, const OuterType outer_type, const
                (this->m_description.empty() ? "" : " " + this->m_description);
     };
 
-    // Ensure at least one elision description exists, if there is any elision
+    // Ensure at least one visible field exists when elision is used
     const auto elision_has_description{[](const std::vector<RPCResult>& inner) {
-        return std::ranges::none_of(inner, [](const auto& res) { return res.m_opts.print_elision.has_value(); }) ||
-               std::ranges::any_of(inner, [](const auto& res) { return res.m_opts.print_elision.has_value() && !res.m_opts.print_elision->empty(); });
+        return std::ranges::any_of(inner, [](const auto& res) {
+            return !std::holds_alternative<HelpElisionSkip>(res.m_opts.print_elision);
+        });
     }};
 
-    if (m_opts.print_elision) {
-        if (!m_opts.print_elision->empty()) {
-            sections.PushSection({indent + "..." + maybe_separator, *m_opts.print_elision});
-        }
+    if (const auto* text = std::get_if<std::string>(&m_opts.print_elision)) {
+        sections.PushSection({indent + "..." + maybe_separator, *text});
         return;
     }
-
-    switch (m_type) {
-    case Type::ELISION: {
-        // Deprecated alias of m_opts.print_elision
-        sections.PushSection({indent + "..." + maybe_separator, m_description});
+    if (std::holds_alternative<HelpElisionSkip>(m_opts.print_elision)) {
         return;
     }
+
+    switch (m_type) {
     case Type::ANY: {
         NONFATAL_UNREACHABLE(); // Only for testing
     }
@@ -1073,7 +1070,7 @@ void RPCResult::ToSections(Sections& sections, const OuterType outer_type, const
         }
         CHECK_NONFATAL(!m_inner.empty());
         CHECK_NONFATAL(elision_has_description(m_inner));
-        if (m_type == Type::ARR && m_inner.back().m_type != Type::ELISION) {
+        if (m_type == Type::ARR && !std::holds_alternative<std::string>(m_inner.back().m_opts.print_elision)) {
             sections.PushSection({indent_next + "...", ""});
         } else {
             // Remove final comma, which would be invalid JSON
@@ -1093,7 +1090,7 @@ void RPCResult::ToSections(Sections& sections, const OuterType outer_type, const
         for (const auto& i : m_inner) {
             i.ToSections(sections, OuterType::OBJ, current_indent + 2);
         }
-        if (m_type == Type::OBJ_DYN && m_inner.back().m_type != Type::ELISION) {
+        if (m_type == Type::OBJ_DYN) {
             // If the dictionary keys are dynamic, use three dots for continuation
             sections.PushSection({indent_next + "...", ""});
         } else {
@@ -1111,7 +1108,6 @@ static std::optional<UniValue::VType> ExpectedType(RPCResult::Type type)
 {
     using Type = RPCResult::Type;
     switch (type) {
-    case Type::ELISION:
     case Type::ANY: {
         return std::nullopt;
     }
@@ -1169,7 +1165,6 @@ UniValue RPCResult::MatchesType(const UniValue& result) const
     }
 
     if (UniValue::VOBJ == result.getType()) {
-        if (!m_inner.empty() && m_inner.at(0).m_type == Type::ELISION) return true;
         UniValue errors(UniValue::VOBJ);
         if (m_type == Type::OBJ_DYN) {
             const RPCResult& doc_inner{m_inner.at(0)}; // Assume all types are the same, randomly pick the first
@@ -1418,3 +1413,20 @@ uint256 GetTarget(const CBlockIndex& blockindex, const uint256 pow_limit)
     arith_uint256 target{*CHECK_NONFATAL(DeriveTarget(blockindex.nBits, pow_limit))};
     return ArithToUint256(target);
 }
+
+std::vector<RPCResult> ElideGroup(std::vector<RPCResult> fields, std::string summary)
+{
+    if (fields.empty()) return fields;
+    std::vector<RPCResult> result;
+    result.reserve(fields.size());
+    for (size_t i = 0; i < fields.size(); ++i) {
+        RPCResultOptions opts = fields[i].m_opts;
+        if (i == 0) {
+            opts.print_elision = summary;
+        } else {
+            opts.print_elision = HelpElisionSkip{};
+        }
+        result.emplace_back(fields[i], std::move(opts));
+    }
+    return result;
+}
diff --git a/src/rpc/util.h b/src/rpc/util.h
index 77199dfe3fd6..9627e945392a 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -292,18 +292,17 @@ struct RPCArg {
     std::string ToDescriptionString(bool is_named_arg) const;
 };
 
+/// Controls how an RPCResult is rendered in human-readable help text.
+/// The std::string alternative carries the summary text rendered as "...".
+struct HelpElisionNone {}; //!< field printed normally
+struct HelpElisionSkip {}; //!< field hidden from help
+using HelpElision = std::variant<HelpElisionNone, HelpElisionSkip, std::string>;
+
 struct RPCResultOptions {
     bool skip_type_check{false};
-    /// Whether to treat this as elided in the human-readable description, and
-    /// possibly supply a description for the elision. Normally, there will be
-    /// one string on any of the elided results, for example `Same output as
-    /// verbosity = 1`, and all other elided strings will be empty.
-    ///
-    /// - If nullopt: normal display.
-    /// - If empty string: suppress from help.
-    /// - If non-empty: show "..." with this description.
-    std::optional<std::string> print_elision{std::nullopt};
+    HelpElision print_elision{HelpElisionNone{}};
 };
+
 // NOLINTNEXTLINE(misc-no-recursion)
 struct RPCResult {
     enum class Type {
@@ -319,7 +318,6 @@ struct RPCResult {
         OBJ_DYN,    //!< Special dictionary with keys that are not literals
         ARR_FIXED,  //!< Special array that has a fixed number of entries
         NUM_TIME,   //!< Special numeric to denote unix epoch time
-        ELISION,    //!< Special type to denote elision (...)
     };
 
     const Type m_type;
@@ -385,6 +383,16 @@ struct RPCResult {
         RPCResultOptions opts = {})
         : RPCResult{type, std::move(m_key_name), /*optional=*/false, std::move(description), std::move(inner), std::move(opts)} {}
 
+    /// Copy with replacement options, for stamping new opts onto an existing result.
+    RPCResult(const RPCResult& other, RPCResultOptions opts)
+        : m_type{other.m_type},
+          m_key_name{other.m_key_name},
+          m_inner{other.m_inner},
+          m_optional{other.m_optional},
+          m_opts{std::move(opts)},
+          m_description{other.m_description},
+          m_cond{other.m_cond} {}
+
     /** Append the sections of the result. */
     void ToSections(Sections& sections, OuterType outer_type = OuterType::NONE, int current_indent = 0) const;
     /** Return the type string of the result when it is in an object (dict). */
@@ -400,6 +408,10 @@ struct RPCResult {
     void CheckInnerDoc() const;
 };
 
+/// Stamp elision onto an entire vector of RPCResult fields at once.
+/// Merges into existing m_opts so that flags like skip_type_check are preserved.
+std::vector<RPCResult> ElideGroup(std::vector<RPCResult> fields, std::string summary = "");
+
 struct RPCResults {
     const std::vector<RPCResult> m_results;
 
diff --git a/src/script/miniscript.h b/src/script/miniscript.h
index 1e25a30e3e9c..4e8beb19e6bb 100644
--- a/src/script/miniscript.h
+++ b/src/script/miniscript.h
@@ -18,7 +18,6 @@
 #include <util/vector.h>
 
 #include <algorithm>
-#include <compare>
 #include <concepts>
 #include <cstdint>
 #include <cstdlib>
diff --git a/src/secp256k1/.github/workflows/ci.yml b/src/secp256k1/.github/workflows/ci.yml
index 152f9a1f4d6b..9b836cd6d6e5 100644
--- a/src/secp256k1/.github/workflows/ci.yml
+++ b/src/secp256k1/.github/workflows/ci.yml
@@ -604,11 +604,10 @@ jobs:
     steps:
       - *CHECKOUT
 
-      - name: Add cl.exe to PATH
-        uses: ilammy/msvc-dev-cmd@v1
-
       - name: C++ (public headers)
+        shell: cmd
         run: |
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           cl.exe -c -WX -TP include/*.h
 
   cxx_fpermissive_debian:
diff --git a/src/secp256k1/CMakeLists.txt b/src/secp256k1/CMakeLists.txt
index 4ef69c089138..a84305c340fe 100644
--- a/src/secp256k1/CMakeLists.txt
+++ b/src/secp256k1/CMakeLists.txt
@@ -147,6 +147,8 @@ if(MSVC)
   string(REGEX REPLACE "/DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
   string(REGEX REPLACE "/DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
   string(REGEX REPLACE "/DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL}")
+  # Match GCC/Clang's size-optimization macro for the inline guard
+  add_compile_definitions($<$<CONFIG:MinSizeRel>:__OPTIMIZE_SIZE__=1>)
 else()
   string(REGEX REPLACE "-DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
   string(REGEX REPLACE "-DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
diff --git a/src/secp256k1/ci/linux-debian.Dockerfile b/src/secp256k1/ci/linux-debian.Dockerfile
index a575d9b1c489..e743cda8598c 100644
--- a/src/secp256k1/ci/linux-debian.Dockerfile
+++ b/src/secp256k1/ci/linux-debian.Dockerfile
@@ -40,7 +40,7 @@ RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install --no-instal
         apt-get clean && rm -rf /var/lib/apt/lists/*
 
 # Build and install gcc snapshot
-ARG GCC_SNAPSHOT_MAJOR=16
+ARG GCC_SNAPSHOT_MAJOR=17
 RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install --no-install-recommends -y \
     wget libgmp-dev libmpfr-dev libmpc-dev flex && \
     mkdir gcc && cd gcc && \
diff --git a/src/secp256k1/cmake/SetLibtoolAbiVersion.cmake b/src/secp256k1/cmake/SetLibtoolAbiVersion.cmake
new file mode 100644
index 000000000000..0e981053df77
--- /dev/null
+++ b/src/secp256k1/cmake/SetLibtoolAbiVersion.cmake
@@ -0,0 +1,61 @@
+#[=[
+This emulates Libtool to make sure Libtool and CMake agree on
+the ABI version and file naming for shared libraries.
+
+The `version_type` variable is set in `libtool.m4` (installed
+by autoreconf into autotools-aux/m4/).
+For the `major` and `versuffix` variables, see below "Calculate
+the version variables" in `ltmain.sh` (installed by autoreconf
+into autotools-aux/).
+]=]
+function(set_libtool_abi_version target current revision age)
+  if(CMAKE_SYSTEM_NAME MATCHES "^(Linux|FreeBSD)$")
+    # version_type = linux | freebsd-elf
+    # major = $current - $age
+    # versuffix = $major.$age.$revision
+    math(EXPR _major "${current} - ${age}")
+    set_target_properties(${target} PROPERTIES
+      SOVERSION ${_major}
+      VERSION ${_major}.${age}.${revision}
+    )
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "NetBSD")
+    # version_type = sunos
+    # major = $current
+    # versuffix = $current.$revision
+    set_target_properties(${target} PROPERTIES
+      SOVERSION ${current}
+      VERSION ${current}.${revision}
+    )
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")
+    # version_type = sunos
+    # major = $current
+    # versuffix = $current.$revision
+    set_target_properties(${target} PROPERTIES
+      # OpenBSD has no `soname_spec` defined in `libtool.m4`.
+      VERSION ${current}.${revision}
+    )
+  elseif(APPLE)
+    # version_type = darwin
+    # major = $current - $age
+    math(EXPR _major "${current} - ${age}")
+    math(EXPR _compatibility "${current} + 1")
+    set_target_properties(${target} PROPERTIES
+      SOVERSION ${_major}
+      MACHO_COMPATIBILITY_VERSION ${_compatibility}
+      MACHO_CURRENT_VERSION ${_compatibility}.${revision}
+    )
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+    # version_type = windows
+    # major = $current - $age
+    # versuffix = $major
+    math(EXPR _major "${current} - ${age}")
+    set(_windows_name "secp256k1")
+    if(MSVC)
+      set(_windows_name "${PROJECT_NAME}")
+    endif()
+    set_target_properties(${target} PROPERTIES
+      ARCHIVE_OUTPUT_NAME "${_windows_name}"
+      RUNTIME_OUTPUT_NAME "${_windows_name}-${_major}"
+    )
+  endif()
+endfunction()
diff --git a/src/secp256k1/include/secp256k1.h b/src/secp256k1/include/secp256k1.h
index b7ec6a228319..2f3383e16ab3 100644
--- a/src/secp256k1/include/secp256k1.h
+++ b/src/secp256k1/include/secp256k1.h
@@ -687,7 +687,7 @@ SECP256K1_API const secp256k1_nonce_function secp256k1_nonce_function_default;
  *  Returns: 1: signature created
  *           0: the nonce generation function failed, or the secret key was invalid.
  *  Args:    ctx:       pointer to a context object (not secp256k1_context_static).
- *  Out:     sig:       pointer to an array where the signature will be placed.
+ *  Out:     sig:       pointer to a signature object.
  *  In:      msghash32: the 32-byte message hash being signed.
  *           seckey:    pointer to a 32-byte secret key.
  *           noncefp:   pointer to a nonce generation function. If NULL,
diff --git a/src/secp256k1/include/secp256k1_recovery.h b/src/secp256k1/include/secp256k1_recovery.h
index 2430f9939710..45f20aba764e 100644
--- a/src/secp256k1/include/secp256k1_recovery.h
+++ b/src/secp256k1/include/secp256k1_recovery.h
@@ -73,7 +73,7 @@ SECP256K1_API int secp256k1_ecdsa_recoverable_signature_serialize_compact(
  *  Returns: 1: signature created
  *           0: the nonce generation function failed, or the secret key was invalid.
  *  Args:    ctx:       pointer to a context object (not secp256k1_context_static).
- *  Out:     sig:       pointer to an array where the signature will be placed.
+ *  Out:     sig:       pointer to a signature object.
  *  In:      msghash32: the 32-byte message hash being signed.
  *           seckey:    pointer to a 32-byte secret key.
  *           noncefp:   pointer to a nonce generation function. If NULL,
diff --git a/src/secp256k1/src/CMakeLists.txt b/src/secp256k1/src/CMakeLists.txt
index 322f1987dde7..a45eeb93e45f 100644
--- a/src/secp256k1/src/CMakeLists.txt
+++ b/src/secp256k1/src/CMakeLists.txt
@@ -94,35 +94,12 @@ set_target_properties(secp256k1_objs PROPERTIES
   INTERFACE_INCLUDE_DIRECTORIES "$<TARGET_PROPERTY:secp256k1,INTERFACE_INCLUDE_DIRECTORIES>"
 )
 
-# This emulates Libtool to make sure Libtool and CMake agree on the ABI version,
-# see below "Calculate the version variables" in autotools-aux/ltmain.sh.
-math(EXPR ${PROJECT_NAME}_soversion "${${PROJECT_NAME}_LIB_VERSION_CURRENT} - ${${PROJECT_NAME}_LIB_VERSION_AGE}")
-set_target_properties(secp256k1 PROPERTIES
-  SOVERSION ${${PROJECT_NAME}_soversion}
+include(SetLibtoolAbiVersion)
+set_libtool_abi_version(secp256k1
+  ${${PROJECT_NAME}_LIB_VERSION_CURRENT}
+  ${${PROJECT_NAME}_LIB_VERSION_REVISION}
+  ${${PROJECT_NAME}_LIB_VERSION_AGE}
 )
-if(CMAKE_SYSTEM_NAME MATCHES "^(Linux|FreeBSD)$")
-  set_target_properties(secp256k1 PROPERTIES
-    VERSION ${${PROJECT_NAME}_soversion}.${${PROJECT_NAME}_LIB_VERSION_AGE}.${${PROJECT_NAME}_LIB_VERSION_REVISION}
-  )
-elseif(APPLE)
-  math(EXPR ${PROJECT_NAME}_compatibility_version "${${PROJECT_NAME}_LIB_VERSION_CURRENT} + 1")
-  set_target_properties(secp256k1 PROPERTIES
-    MACHO_COMPATIBILITY_VERSION ${${PROJECT_NAME}_compatibility_version}
-    MACHO_CURRENT_VERSION ${${PROJECT_NAME}_compatibility_version}.${${PROJECT_NAME}_LIB_VERSION_REVISION}
-  )
-  unset(${PROJECT_NAME}_compatibility_version)
-elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
-  set(${PROJECT_NAME}_windows "secp256k1")
-  if(MSVC)
-    set(${PROJECT_NAME}_windows "${PROJECT_NAME}")
-  endif()
-  set_target_properties(secp256k1 PROPERTIES
-    ARCHIVE_OUTPUT_NAME "${${PROJECT_NAME}_windows}"
-    RUNTIME_OUTPUT_NAME "${${PROJECT_NAME}_windows}-${${PROJECT_NAME}_soversion}"
-  )
-  unset(${PROJECT_NAME}_windows)
-endif()
-unset(${PROJECT_NAME}_soversion)
 
 if(SECP256K1_BUILD_BENCHMARK)
   add_executable(bench bench.c)
diff --git a/src/secp256k1/src/bench_ecmult.c b/src/secp256k1/src/bench_ecmult.c
index eb546db414ab..12d550a6aeb1 100644
--- a/src/secp256k1/src/bench_ecmult.c
+++ b/src/secp256k1/src/bench_ecmult.c
@@ -88,7 +88,7 @@ static void bench_ecmult_teardown_helper(bench_data* data, size_t* seckey_offset
             secp256k1_scalar_add(&sum_scalars, &sum_scalars, &s);
         }
     }
-    secp256k1_ecmult_gen(&data->ctx->ecmult_gen_ctx, &tmp, &sum_scalars);
+    secp256k1_ecmult_gen_gej(&data->ctx->ecmult_gen_ctx, &tmp, &sum_scalars);
     CHECK(secp256k1_gej_eq_var(&tmp, &sum_output));
 }
 
@@ -104,7 +104,7 @@ static void bench_ecmult_gen(void* arg, int iters) {
     int i;
 
     for (i = 0; i < iters; ++i) {
-        secp256k1_ecmult_gen(&data->ctx->ecmult_gen_ctx, &data->output[i], &data->scalars[(data->offset1+i) % POINTS]);
+        secp256k1_ecmult_gen_gej(&data->ctx->ecmult_gen_ctx, &data->output[i], &data->scalars[(data->offset1+i) % POINTS]);
     }
 }
 
diff --git a/src/secp256k1/src/bench_internal.c b/src/secp256k1/src/bench_internal.c
index f3c1be987f70..453f3bb3f836 100644
--- a/src/secp256k1/src/bench_internal.c
+++ b/src/secp256k1/src/bench_internal.c
@@ -194,6 +194,17 @@ static void bench_field_normalize(void* arg, int iters) {
     }
 }
 
+static void bench_field_normalize_var(void* arg, int iters) {
+    int i;
+    bench_inv *data = (bench_inv*)arg;
+
+    /* Note that this benchmark measures the optimistic path. The worst-case path with the final
+       reduction is very unlikely to be needed, so this is representative of the common case. */
+    for (i = 0; i < iters; i++) {
+        secp256k1_fe_normalize_var(&data->fe[0]);
+    }
+}
+
 static void bench_field_normalize_weak(void* arg, int iters) {
     int i;
     bench_inv *data = (bench_inv*)arg;
@@ -421,6 +432,7 @@ int main(int argc, char **argv) {
 
     if (d || have_flag(argc, argv, "field") || have_flag(argc, argv, "half")) run_benchmark("field_half", bench_field_half, bench_setup, NULL, &data, 10, iters*100);
     if (d || have_flag(argc, argv, "field") || have_flag(argc, argv, "normalize")) run_benchmark("field_normalize", bench_field_normalize, bench_setup, NULL, &data, 10, iters*100);
+    if (d || have_flag(argc, argv, "field") || have_flag(argc, argv, "normalize")) run_benchmark("field_normalize_var", bench_field_normalize_var, bench_setup, NULL, &data, 10, iters*100);
     if (d || have_flag(argc, argv, "field") || have_flag(argc, argv, "normalize")) run_benchmark("field_normalize_weak", bench_field_normalize_weak, bench_setup, NULL, &data, 10, iters*100);
     if (d || have_flag(argc, argv, "field") || have_flag(argc, argv, "sqr")) run_benchmark("field_sqr", bench_field_sqr, bench_setup, NULL, &data, 10, iters*10);
     if (d || have_flag(argc, argv, "field") || have_flag(argc, argv, "mul")) run_benchmark("field_mul", bench_field_mul, bench_setup, NULL, &data, 10, iters*10);
diff --git a/src/secp256k1/src/ctime_tests.c b/src/secp256k1/src/ctime_tests.c
index f80042a8e86c..8a885ca2b4fe 100644
--- a/src/secp256k1/src/ctime_tests.c
+++ b/src/secp256k1/src/ctime_tests.c
@@ -40,6 +40,11 @@
 #include "../include/secp256k1_ellswift.h"
 #endif
 
+#if defined(__GNUC__)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic warning "-Wunused-function"
+#endif
+
 static void run_tests(secp256k1_context *ctx, unsigned char *key);
 
 int main(void) {
@@ -265,3 +270,7 @@ static void run_tests(secp256k1_context *ctx, unsigned char *key) {
 
 #endif
 }
+
+#if defined(__GNUC__)
+# pragma GCC diagnostic pop
+#endif
diff --git a/src/secp256k1/src/ecdsa_impl.h b/src/secp256k1/src/ecdsa_impl.h
index 163539ebc14d..32f1e58500b1 100644
--- a/src/secp256k1/src/ecdsa_impl.h
+++ b/src/secp256k1/src/ecdsa_impl.h
@@ -273,14 +273,12 @@ static int secp256k1_ecdsa_sig_verify(const secp256k1_scalar *sigr, const secp25
 
 static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context *ctx, secp256k1_scalar *sigr, secp256k1_scalar *sigs, const secp256k1_scalar *seckey, const secp256k1_scalar *message, const secp256k1_scalar *nonce, int *recid) {
     unsigned char b[32];
-    secp256k1_gej rp;
     secp256k1_ge r;
     secp256k1_scalar n;
     int overflow = 0;
     int high;
 
-    secp256k1_ecmult_gen(ctx, &rp, nonce);
-    secp256k1_ge_set_gej(&r, &rp);
+    secp256k1_ecmult_gen_ge(ctx, &r, nonce);
     secp256k1_fe_normalize(&r.x);
     secp256k1_fe_normalize(&r.y);
     secp256k1_fe_get_b32(b, &r.x);
@@ -296,7 +294,6 @@ static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context *ctx, sec
     secp256k1_scalar_inverse(sigs, nonce);
     secp256k1_scalar_mul(sigs, sigs, &n);
     secp256k1_scalar_clear(&n);
-    secp256k1_gej_clear(&rp);
     secp256k1_ge_clear(&r);
     high = secp256k1_scalar_is_high(sigs);
     secp256k1_scalar_cond_negate(sigs, high);
diff --git a/src/secp256k1/src/ecmult_gen.h b/src/secp256k1/src/ecmult_gen.h
index 8bc4f14c310a..770b2cb21a19 100644
--- a/src/secp256k1/src/ecmult_gen.h
+++ b/src/secp256k1/src/ecmult_gen.h
@@ -137,7 +137,8 @@ static void secp256k1_ecmult_gen_context_build(secp256k1_ecmult_gen_context* ctx
 static void secp256k1_ecmult_gen_context_clear(secp256k1_ecmult_gen_context* ctx);
 
 /** Multiply with the generator: R = a*G */
-static void secp256k1_ecmult_gen(const secp256k1_ecmult_gen_context* ctx, secp256k1_gej *r, const secp256k1_scalar *a);
+static void secp256k1_ecmult_gen_gej(const secp256k1_ecmult_gen_context* ctx, secp256k1_gej *r, const secp256k1_scalar *a);
+static void secp256k1_ecmult_gen_ge(const secp256k1_ecmult_gen_context* ctx, secp256k1_ge *r, const secp256k1_scalar *a);
 
 static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context *ctx, const secp256k1_hash_ctx *hash_ctx, const unsigned char *seed32);
 
diff --git a/src/secp256k1/src/ecmult_gen_impl.h b/src/secp256k1/src/ecmult_gen_impl.h
index 5a954977ebe1..a7a6d34d71b4 100644
--- a/src/secp256k1/src/ecmult_gen_impl.h
+++ b/src/secp256k1/src/ecmult_gen_impl.h
@@ -51,7 +51,7 @@ static void secp256k1_ecmult_gen_scalar_diff(secp256k1_scalar* diff) {
     secp256k1_scalar_add(diff, diff, &neghalf);
 }
 
-static void secp256k1_ecmult_gen(const secp256k1_ecmult_gen_context *ctx, secp256k1_gej *r, const secp256k1_scalar *gn) {
+static void secp256k1_ecmult_gen_gej(const secp256k1_ecmult_gen_context *ctx, secp256k1_gej *r, const secp256k1_scalar *gn) {
     uint32_t comb_off;
     secp256k1_ge add;
     secp256k1_fe neg;
@@ -281,11 +281,19 @@ static void secp256k1_ecmult_gen(const secp256k1_ecmult_gen_context *ctx, secp25
     secp256k1_memclear_explicit(&recoded, sizeof(recoded));
 }
 
+SECP256K1_INLINE static void secp256k1_ecmult_gen_ge(const secp256k1_ecmult_gen_context *ctx, secp256k1_ge *r, const secp256k1_scalar *a) {
+    secp256k1_gej rj;
+    secp256k1_ecmult_gen_gej(ctx, &rj, a);
+    secp256k1_ge_set_gej(r, &rj);
+    /* Jacobian coordinates resulting from our multiplication algorithm could potentially leak
+     * information about the secret input scalar, so clear the memory out to be on the safe side. */
+    secp256k1_gej_clear(&rj);
+}
+
 /* Setup blinding values for secp256k1_ecmult_gen. */
 static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context *ctx, const secp256k1_hash_ctx *hash_ctx, const unsigned char *seed32) {
     secp256k1_scalar b;
     secp256k1_scalar diff;
-    secp256k1_gej gb;
     secp256k1_fe f;
     unsigned char nonce32[32];
     secp256k1_rfc6979_hmac_sha256 rng;
@@ -325,15 +333,13 @@ static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context *ctx, const
      * which secp256k1_gej_add_ge cannot handle. */
     secp256k1_scalar_cmov(&b, &secp256k1_scalar_one, secp256k1_scalar_is_zero(&b));
     secp256k1_rfc6979_hmac_sha256_finalize(&rng);
-    secp256k1_ecmult_gen(ctx, &gb, &b);
+    secp256k1_ecmult_gen_ge(ctx, &ctx->ge_offset, &b);
     secp256k1_scalar_negate(&b, &b);
     secp256k1_scalar_add(&ctx->scalar_offset, &b, &diff);
-    secp256k1_ge_set_gej(&ctx->ge_offset, &gb);
 
     /* Clean up. */
     secp256k1_memclear_explicit(nonce32, sizeof(nonce32));
     secp256k1_scalar_clear(&b);
-    secp256k1_gej_clear(&gb);
     secp256k1_fe_clear(&f);
     secp256k1_rfc6979_hmac_sha256_clear(&rng);
 }
diff --git a/src/secp256k1/src/field_5x52_impl.h b/src/secp256k1/src/field_5x52_impl.h
index 3a976135ebdc..0e0e2d652a73 100644
--- a/src/secp256k1/src/field_5x52_impl.h
+++ b/src/secp256k1/src/field_5x52_impl.h
@@ -338,11 +338,11 @@ SECP256K1_INLINE static void secp256k1_fe_impl_add(secp256k1_fe *r, const secp25
     r->n[4] += a->n[4];
 }
 
-SECP256K1_INLINE static void secp256k1_fe_impl_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe * SECP256K1_RESTRICT b) {
+SECP256K1_FORCE_INLINE static void secp256k1_fe_impl_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe * SECP256K1_RESTRICT b) {
     secp256k1_fe_mul_inner(r->n, a->n, b->n);
 }
 
-SECP256K1_INLINE static void secp256k1_fe_impl_sqr(secp256k1_fe *r, const secp256k1_fe *a) {
+SECP256K1_FORCE_INLINE static void secp256k1_fe_impl_sqr(secp256k1_fe *r, const secp256k1_fe *a) {
     secp256k1_fe_sqr_inner(r->n, a->n);
 }
 
diff --git a/src/secp256k1/src/field_5x52_int128_impl.h b/src/secp256k1/src/field_5x52_int128_impl.h
index f23f8ee1c443..8d1977b2718a 100644
--- a/src/secp256k1/src/field_5x52_int128_impl.h
+++ b/src/secp256k1/src/field_5x52_int128_impl.h
@@ -15,7 +15,7 @@
 #define VERIFY_BITS(x, n) VERIFY_CHECK(((x) >> (n)) == 0)
 #define VERIFY_BITS_128(x, n) VERIFY_CHECK(secp256k1_u128_check_bits((x), (n)))
 
-SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const uint64_t *a, const uint64_t * SECP256K1_RESTRICT b) {
+SECP256K1_FORCE_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const uint64_t *a, const uint64_t * SECP256K1_RESTRICT b) {
     secp256k1_uint128 c, d;
     uint64_t t3, t4, tx, u0;
     uint64_t a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4];
@@ -151,7 +151,7 @@ SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const uint64_t
     /* [r4 r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
 }
 
-SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint64_t *r, const uint64_t *a) {
+SECP256K1_FORCE_INLINE static void secp256k1_fe_sqr_inner(uint64_t *r, const uint64_t *a) {
     secp256k1_uint128 c, d;
     uint64_t a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4];
     uint64_t t3, t4, tx, u0;
diff --git a/src/secp256k1/src/modules/ecdh/Makefile.am.include b/src/secp256k1/src/modules/ecdh/Makefile.am.include
index 186605352917..81bc62791733 100644
--- a/src/secp256k1/src/modules/ecdh/Makefile.am.include
+++ b/src/secp256k1/src/modules/ecdh/Makefile.am.include
@@ -1,5 +1,6 @@
 include_HEADERS += include/secp256k1_ecdh.h
 noinst_HEADERS += src/modules/ecdh/main_impl.h
 noinst_HEADERS += src/modules/ecdh/tests_impl.h
+noinst_HEADERS += src/modules/ecdh/tests_exhaustive_impl.h
 noinst_HEADERS += src/modules/ecdh/bench_impl.h
 noinst_HEADERS += src/wycheproof/ecdh_secp256k1_test.h
diff --git a/src/secp256k1/src/modules/ecdh/tests_exhaustive_impl.h b/src/secp256k1/src/modules/ecdh/tests_exhaustive_impl.h
new file mode 100644
index 000000000000..2bcd243493a5
--- /dev/null
+++ b/src/secp256k1/src/modules/ecdh/tests_exhaustive_impl.h
@@ -0,0 +1,56 @@
+/***********************************************************************
+ * Distributed under the MIT software license, see the accompanying    *
+ * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
+ ***********************************************************************/
+
+#ifndef SECP256K1_MODULE_ECDH_TESTS_EXHAUSTIVE_H
+#define SECP256K1_MODULE_ECDH_TESTS_EXHAUSTIVE_H
+
+#include "../../../include/secp256k1_ecdh.h"
+#include "main_impl.h"
+
+static void test_exhaustive_ecdh(const secp256k1_context *ctx, const secp256k1_ge *group) {
+    int i, j;
+    unsigned char seckeys[EXHAUSTIVE_TEST_ORDER - 1][32];
+    secp256k1_pubkey pubkeys[EXHAUSTIVE_TEST_ORDER - 1];
+
+    /* Construct key pairs (32-byte secret key, public key object) for the entire group. */
+    for (i = 1; i < EXHAUSTIVE_TEST_ORDER; i++) {
+        secp256k1_scalar scalar;
+        secp256k1_scalar_set_int(&scalar, i);
+        secp256k1_scalar_get_b32(seckeys[i - 1], &scalar);
+        CHECK(secp256k1_ec_pubkey_create(ctx, &pubkeys[i - 1], seckeys[i - 1]));
+    }
+
+    /* Loop over key combinations. */
+    for (i = 1; i < EXHAUSTIVE_TEST_ORDER; i++) {
+        for (j = 1; j < EXHAUSTIVE_TEST_ORDER; j++) {
+            unsigned char ecdh_result_ij[32];
+            unsigned char ecdh_result_ji[32];
+
+            /* Calculate ECDH(i*G, j) and ECDH(j*G, i) using API function and verify that the results match. */
+            CHECK(secp256k1_ecdh(ctx, ecdh_result_ij, &pubkeys[i - 1], seckeys[j - 1], NULL, NULL));
+            CHECK(secp256k1_ecdh(ctx, ecdh_result_ji, &pubkeys[j - 1], seckeys[i - 1], NULL, NULL));
+            CHECK(secp256k1_memcmp_var(ecdh_result_ij, ecdh_result_ji, 32) == 0);
+
+            /* Recalculate the expected ECDH result manually by invoking the default ECDH hash
+             * function on the precomputed group element (group[i * j]) coordinates, and verify
+             * that it matches the previously calculated public API results. */
+            {
+                secp256k1_ge ecdh_ge_expected = group[(i * j) % EXHAUSTIVE_TEST_ORDER];
+                unsigned char ecdh_result_expected[32];
+                unsigned char x[32];
+                unsigned char y[32];
+
+                secp256k1_fe_normalize_var(&ecdh_ge_expected.x);
+                secp256k1_fe_normalize_var(&ecdh_ge_expected.y);
+                secp256k1_fe_get_b32(x, &ecdh_ge_expected.x);
+                secp256k1_fe_get_b32(y, &ecdh_ge_expected.y);
+                CHECK(secp256k1_ecdh_hash_function_default(ecdh_result_expected, x, y, NULL));
+                CHECK(secp256k1_memcmp_var(ecdh_result_ij, ecdh_result_expected, 32) == 0);
+            }
+        }
+    }
+}
+
+#endif
diff --git a/src/secp256k1/src/modules/musig/session_impl.h b/src/secp256k1/src/modules/musig/session_impl.h
index 6a37bfdf8e06..c05801eecf0f 100644
--- a/src/secp256k1/src/modules/musig/session_impl.h
+++ b/src/secp256k1/src/modules/musig/session_impl.h
@@ -415,7 +415,7 @@ static int secp256k1_musig_nonce_gen_internal(const secp256k1_context* ctx, secp
 
     /* Compute pubnonce as two gejs */
     for (i = 0; i < 2; i++) {
-        secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &nonce_ptj[i], &k[i]);
+        secp256k1_ecmult_gen_gej(&ctx->ecmult_gen_ctx, &nonce_ptj[i], &k[i]);
         secp256k1_scalar_clear(&k[i]);
     }
 
@@ -483,11 +483,9 @@ int secp256k1_musig_nonce_gen_counter(const secp256k1_context* ctx, secp256k1_mu
     (void) ret;
 #endif
 
-    if (!secp256k1_musig_nonce_gen_internal(ctx, secnonce, pubnonce, buf, seckey, &pubkey, msg32, keyagg_cache, extra_input32)) {
-        return 0;
-    }
+    ret = secp256k1_musig_nonce_gen_internal(ctx, secnonce, pubnonce, buf, seckey, &pubkey, msg32, keyagg_cache, extra_input32);
     secp256k1_memclear_explicit(seckey, sizeof(seckey));
-    return 1;
+    return ret;
 }
 
 static int secp256k1_musig_sum_pubnonces(const secp256k1_context* ctx, secp256k1_gej *summed_pubnonces, const secp256k1_musig_pubnonce * const* pubnonces, size_t n_pubnonces) {
diff --git a/src/secp256k1/src/modules/musig/tests_impl.h b/src/secp256k1/src/modules/musig/tests_impl.h
index cc6449166a78..3a30c233a00e 100644
--- a/src/secp256k1/src/modules/musig/tests_impl.h
+++ b/src/secp256k1/src/modules/musig/tests_impl.h
@@ -374,7 +374,7 @@ static void musig_api_tests(void) {
         secp256k1_ge aggnonce_pt[2];
         secp256k1_musig_aggnonce_load(CTX, aggnonce_pt, &aggnonce);
         for (i = 0; i < 2; i++) {
-            secp256k1_ge_is_infinity(&aggnonce_pt[i]);
+            CHECK(secp256k1_ge_is_infinity(&aggnonce_pt[i]) == 1);
         }
     }
     CHECK(secp256k1_musig_nonce_agg(CTX, &aggnonce, pubnonce_ptr, 2) == 1);
@@ -862,7 +862,7 @@ static void musig_test_vectors_nonceagg(void) {
         }
         CHECK(secp256k1_musig_nonce_agg(CTX, &aggnonce, pubnonce_ptr, 2));
         CHECK(secp256k1_musig_aggnonce_serialize(CTX, aggnonce66, &aggnonce));
-        CHECK(secp256k1_memcmp_var(aggnonce66, c->expected, 33) == 0);
+        CHECK(secp256k1_memcmp_var(aggnonce66, c->expected, sizeof(aggnonce66)) == 0);
     }
     for (i = 0; i < ARRAY_SIZE(vector->error_case); i++) {
         const struct musig_nonce_agg_test_case *c = &vector->error_case[i];
diff --git a/src/secp256k1/src/modules/schnorrsig/main_impl.h b/src/secp256k1/src/modules/schnorrsig/main_impl.h
index 5100557f4dd7..efc7216546de 100644
--- a/src/secp256k1/src/modules/schnorrsig/main_impl.h
+++ b/src/secp256k1/src/modules/schnorrsig/main_impl.h
@@ -123,7 +123,6 @@ static int secp256k1_schnorrsig_sign_internal(const secp256k1_context* ctx, unsi
     secp256k1_scalar sk;
     secp256k1_scalar e;
     secp256k1_scalar k;
-    secp256k1_gej rj;
     secp256k1_ge pk;
     secp256k1_ge r;
     unsigned char nonce32[32] = { 0 };
@@ -160,8 +159,7 @@ static int secp256k1_schnorrsig_sign_internal(const secp256k1_context* ctx, unsi
     ret &= !secp256k1_scalar_is_zero(&k);
     secp256k1_scalar_cmov(&k, &secp256k1_scalar_one, !ret);
 
-    secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &rj, &k);
-    secp256k1_ge_set_gej(&r, &rj);
+    secp256k1_ecmult_gen_ge(&ctx->ecmult_gen_ctx, &r, &k);
 
     /* We declassify r to allow using it as a branch point. This is fine
      * because r is not a secret. */
@@ -183,7 +181,6 @@ static int secp256k1_schnorrsig_sign_internal(const secp256k1_context* ctx, unsi
     secp256k1_scalar_clear(&sk);
     secp256k1_memclear_explicit(seckey, sizeof(seckey));
     secp256k1_memclear_explicit(nonce32, sizeof(nonce32));
-    secp256k1_gej_clear(&rj);
 
     return ret;
 }
diff --git a/src/secp256k1/src/secp256k1.c b/src/secp256k1/src/secp256k1.c
index e4b80fff24c4..b216872e12a4 100644
--- a/src/secp256k1/src/secp256k1.c
+++ b/src/secp256k1/src/secp256k1.c
@@ -624,15 +624,12 @@ int secp256k1_ec_seckey_verify(const secp256k1_context* ctx, const unsigned char
 }
 
 static int secp256k1_ec_pubkey_create_helper(const secp256k1_ecmult_gen_context *ecmult_gen_ctx, secp256k1_scalar *seckey_scalar, secp256k1_ge *p, const unsigned char *seckey) {
-    secp256k1_gej pj;
     int ret;
 
     ret = secp256k1_scalar_set_b32_seckey(seckey_scalar, seckey);
     secp256k1_scalar_cmov(seckey_scalar, &secp256k1_scalar_one, !ret);
 
-    secp256k1_ecmult_gen(ecmult_gen_ctx, &pj, seckey_scalar);
-    secp256k1_ge_set_gej(p, &pj);
-    secp256k1_gej_clear(&pj);
+    secp256k1_ecmult_gen_ge(ecmult_gen_ctx, p, seckey_scalar);
     return ret;
 }
 
diff --git a/src/secp256k1/src/tests.c b/src/secp256k1/src/tests.c
index 862bef61a7ca..6c3cd39f2fe0 100644
--- a/src/secp256k1/src/tests.c
+++ b/src/secp256k1/src/tests.c
@@ -37,6 +37,11 @@
 #include "int128_impl.h"
 #endif
 
+#if defined(__GNUC__)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic warning "-Wunused-function"
+#endif
+
 #define CONDITIONAL_TEST(cnt, nam) if (COUNT < (cnt)) { printf("Skipping %s (iteration count too low)\n", nam); } else
 
 static secp256k1_context *CTX = NULL;
@@ -241,7 +246,6 @@ static void run_proper_context_tests(int use_prealloc) {
     void *my_ctx_prealloc = NULL;
     unsigned char seed[32] = {0x17};
 
-    secp256k1_gej pubj;
     secp256k1_ge pub;
     secp256k1_scalar msg, key, nonce;
     secp256k1_scalar sigr, sigs;
@@ -329,8 +333,7 @@ static void run_proper_context_tests(int use_prealloc) {
     /*** attempt to use them ***/
     testutil_random_scalar_order_test(&msg);
     testutil_random_scalar_order_test(&key);
-    secp256k1_ecmult_gen(&my_ctx->ecmult_gen_ctx, &pubj, &key);
-    secp256k1_ge_set_gej(&pub, &pubj);
+    secp256k1_ecmult_gen_ge(&my_ctx->ecmult_gen_ctx, &pub, &key);
 
     /* obtain a working nonce */
     do {
@@ -4304,19 +4307,16 @@ static void test_ec_combine(void) {
     const secp256k1_pubkey* d[6];
     secp256k1_pubkey sd;
     secp256k1_pubkey sd2;
-    secp256k1_gej Qj;
     secp256k1_ge Q;
     int i;
     for (i = 1; i <= 6; i++) {
         secp256k1_scalar s;
         testutil_random_scalar_order_test(&s);
         secp256k1_scalar_add(&sum, &sum, &s);
-        secp256k1_ecmult_gen(&CTX->ecmult_gen_ctx, &Qj, &s);
-        secp256k1_ge_set_gej(&Q, &Qj);
+        secp256k1_ecmult_gen_ge(&CTX->ecmult_gen_ctx, &Q, &s);
         secp256k1_pubkey_save(&data[i - 1], &Q);
         d[i - 1] = &data[i - 1];
-        secp256k1_ecmult_gen(&CTX->ecmult_gen_ctx, &Qj, &sum);
-        secp256k1_ge_set_gej(&Q, &Qj);
+        secp256k1_ecmult_gen_ge(&CTX->ecmult_gen_ctx, &Q, &sum);
         secp256k1_pubkey_save(&sd, &Q);
         CHECK(secp256k1_ec_pubkey_combine(CTX, &sd2, d, i) == 1);
         CHECK(secp256k1_memcmp_var(&sd, &sd2, sizeof(sd)) == 0);
@@ -4593,9 +4593,9 @@ static void test_ecmult_target(const secp256k1_scalar* target, int mode) {
 
     /* EC multiplications */
     if (mode == 0) {
-        secp256k1_ecmult_gen(&CTX->ecmult_gen_ctx, &p1j, &n1);
-        secp256k1_ecmult_gen(&CTX->ecmult_gen_ctx, &p2j, &n2);
-        secp256k1_ecmult_gen(&CTX->ecmult_gen_ctx, &ptj, target);
+        secp256k1_ecmult_gen_gej(&CTX->ecmult_gen_ctx, &p1j, &n1);
+        secp256k1_ecmult_gen_gej(&CTX->ecmult_gen_ctx, &p2j, &n2);
+        secp256k1_ecmult_gen_gej(&CTX->ecmult_gen_ctx, &ptj, target);
     } else if (mode == 1) {
         secp256k1_ecmult(&p1j, &pj, &n1, &secp256k1_scalar_zero);
         secp256k1_ecmult(&p2j, &pj, &n2, &secp256k1_scalar_zero);
@@ -5162,7 +5162,7 @@ static int test_ecmult_multi_random(secp256k1_scratch *scratch) {
             secp256k1_scalar_mul(&scalars[filled], &sc_tmp, &g_scalar);
             secp256k1_scalar_inverse_var(&sc_tmp, &sc_tmp);
             secp256k1_scalar_negate(&sc_tmp, &sc_tmp);
-            secp256k1_ecmult_gen(&CTX->ecmult_gen_ctx, &gejs[filled], &sc_tmp);
+            secp256k1_ecmult_gen_gej(&CTX->ecmult_gen_ctx, &gejs[filled], &sc_tmp);
             ++filled;
             ++mults;
         }
@@ -5642,7 +5642,7 @@ static void test_ecmult_accumulate(secp256k1_sha256* acc, const secp256k1_scalar
     size_t i;
     secp256k1_gej_set_ge(&gj, &secp256k1_ge_const_g);
     secp256k1_gej_set_infinity(&infj);
-    secp256k1_ecmult_gen(&CTX->ecmult_gen_ctx, &rj[0], x);
+    secp256k1_ecmult_gen_gej(&CTX->ecmult_gen_ctx, &rj[0], x);
     secp256k1_ecmult(&rj[1], &gj, x, NULL);
     secp256k1_ecmult(&rj[2], &gj, x, &secp256k1_scalar_zero);
     secp256k1_ecmult(&rj[3], &infj, &secp256k1_scalar_zero, x);
@@ -5786,6 +5786,25 @@ static void run_ecmult_constants(void) {
     }
 }
 
+static void run_ecmult_gen_ge(void) {
+    /* Test that secp256k1_ecmult_gen_ge result matches secp256k1_ecmult_gen_gej with
+     * manual Jacobian-to-affine conversion (secp256k1_ge_set_gej) over random scalars */
+    int i;
+
+    for (i = 0; i < COUNT; i++) {
+        secp256k1_scalar scalar;
+        secp256k1_gej result_gej;
+        secp256k1_ge result_ge, expected_ge;
+
+        testutil_random_scalar_order_test(&scalar);
+        secp256k1_ecmult_gen_gej(&CTX->ecmult_gen_ctx, &result_gej, &scalar);
+        secp256k1_ge_set_gej(&expected_ge, &result_gej);
+        secp256k1_ecmult_gen_ge(&CTX->ecmult_gen_ctx, &result_ge, &scalar);
+
+        CHECK(secp256k1_ge_eq_var(&result_ge, &expected_ge));
+    }
+}
+
 static void test_ecmult_gen_blind(void) {
     /* Test ecmult_gen() blinding and confirm that the blinding changes, the affine points match, and the z's don't match. */
     secp256k1_scalar key;
@@ -5796,13 +5815,13 @@ static void test_ecmult_gen_blind(void) {
     secp256k1_ge p;
     secp256k1_ge pge;
     testutil_random_scalar_order_test(&key);
-    secp256k1_ecmult_gen(&CTX->ecmult_gen_ctx, &pgej, &key);
+    secp256k1_ecmult_gen_gej(&CTX->ecmult_gen_ctx, &pgej, &key);
     testrand256(seed32);
     b = CTX->ecmult_gen_ctx.scalar_offset;
     p = CTX->ecmult_gen_ctx.ge_offset;
     secp256k1_ecmult_gen_blind(&CTX->ecmult_gen_ctx, secp256k1_get_hash_context(CTX), seed32);
     CHECK(!secp256k1_scalar_eq(&b, &CTX->ecmult_gen_ctx.scalar_offset));
-    secp256k1_ecmult_gen(&CTX->ecmult_gen_ctx, &pgej2, &key);
+    secp256k1_ecmult_gen_gej(&CTX->ecmult_gen_ctx, &pgej2, &key);
     CHECK(!gej_xyz_equals_gej(&pgej, &pgej2));
     CHECK(!secp256k1_ge_eq_var(&p, &CTX->ecmult_gen_ctx.ge_offset));
     secp256k1_ge_set_gej(&pge, &pgej);
@@ -5832,7 +5851,7 @@ static void test_ecmult_gen_edge_cases(void) {
 
     for (i = -1; i < 2; ++i) {
         /* Run test with gn = i - scalar_offset (so that the ecmult_gen recoded value represents i). */
-        secp256k1_ecmult_gen(&CTX->ecmult_gen_ctx, &res1, &gn);
+        secp256k1_ecmult_gen_gej(&CTX->ecmult_gen_ctx, &res1, &gn);
         secp256k1_ecmult(&res2, NULL, &secp256k1_scalar_zero, &gn);
         secp256k1_ecmult_const(&res3, &secp256k1_ge_const_g, &gn);
         CHECK(secp256k1_gej_eq_var(&res1, &res2));
@@ -6515,7 +6534,6 @@ static void random_sign(secp256k1_scalar *sigr, secp256k1_scalar *sigs, const se
 }
 
 static void test_ecdsa_sign_verify(void) {
-    secp256k1_gej pubj;
     secp256k1_ge pub;
     secp256k1_scalar one;
     secp256k1_scalar msg, key;
@@ -6524,8 +6542,7 @@ static void test_ecdsa_sign_verify(void) {
     int recid;
     testutil_random_scalar_order_test(&msg);
     testutil_random_scalar_order_test(&key);
-    secp256k1_ecmult_gen(&CTX->ecmult_gen_ctx, &pubj, &key);
-    secp256k1_ge_set_gej(&pub, &pubj);
+    secp256k1_ecmult_gen_ge(&CTX->ecmult_gen_ctx, &pub, &key);
     getrec = testrand_bits(1);
     /* The specific way in which this conditional is written sidesteps a potential bug in clang.
        See the commit messages of the commit that introduced this comment for details. */
@@ -7284,7 +7301,6 @@ static void run_ecdsa_edge_cases(void) {
 
     /* Test the case where ECDSA recomputes a point that is infinity. */
     {
-        secp256k1_gej keyj;
         secp256k1_ge key;
         secp256k1_scalar msg;
         secp256k1_scalar sr, ss;
@@ -7292,8 +7308,7 @@ static void run_ecdsa_edge_cases(void) {
         secp256k1_scalar_negate(&ss, &ss);
         secp256k1_scalar_inverse(&ss, &ss);
         secp256k1_scalar_set_int(&sr, 1);
-        secp256k1_ecmult_gen(&CTX->ecmult_gen_ctx, &keyj, &sr);
-        secp256k1_ge_set_gej(&key, &keyj);
+        secp256k1_ecmult_gen_ge(&CTX->ecmult_gen_ctx, &key, &sr);
         msg = ss;
         CHECK(secp256k1_ecdsa_sig_verify(&sr, &ss, &key, &msg) == 0);
     }
@@ -7969,6 +7984,7 @@ static const struct tf_test_entry tests_ecmult[] = {
     CASE(ecmult_near_split_bound),
     CASE(ecmult_chain),
     CASE(ecmult_constants),
+    CASE(ecmult_gen_ge),
     CASE(ecmult_gen_blind),
     CASE(ecmult_const_tests),
     CASE(ecmult_multi_tests),
@@ -8080,3 +8096,7 @@ int main(int argc, char **argv) {
     if (tf_init(&tf, argc, argv) != 0) return EXIT_FAILURE;
     return tf_run(&tf);
 }
+
+#if defined(__GNUC__)
+# pragma GCC diagnostic pop
+#endif
diff --git a/src/secp256k1/src/tests_exhaustive.c b/src/secp256k1/src/tests_exhaustive.c
index 68d4bec3f071..99d7b2448d4d 100644
--- a/src/secp256k1/src/tests_exhaustive.c
+++ b/src/secp256k1/src/tests_exhaustive.c
@@ -31,6 +31,11 @@
 #include "testutil.h"
 #include "util.h"
 
+#if defined(__GNUC__)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic warning "-Wunused-function"
+#endif
+
 static int count = 2;
 
 static uint32_t num_cores = 1;
@@ -337,6 +342,10 @@ static void test_exhaustive_sign(const secp256k1_context *ctx, const secp256k1_g
      */
 }
 
+#ifdef ENABLE_MODULE_ECDH
+#include "modules/ecdh/tests_exhaustive_impl.h"
+#endif
+
 #ifdef ENABLE_MODULE_RECOVERY
 #include "modules/recovery/tests_exhaustive_impl.h"
 #endif
@@ -417,12 +426,10 @@ int main(int argc, char** argv) {
             /* Verify against ecmult_gen */
             {
                 secp256k1_scalar scalar_i;
-                secp256k1_gej generatedj;
                 secp256k1_ge generated;
 
                 secp256k1_scalar_set_int(&scalar_i, i);
-                secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &generatedj, &scalar_i);
-                secp256k1_ge_set_gej(&generated, &generatedj);
+                secp256k1_ecmult_gen_ge(&ctx->ecmult_gen_ctx, &generated, &scalar_i);
 
                 CHECK(!secp256k1_ge_is_infinity(&group[i]));
                 CHECK(secp256k1_ge_eq_var(&group[i], &generated));
@@ -437,6 +444,9 @@ int main(int argc, char** argv) {
         test_exhaustive_sign(ctx, group);
         test_exhaustive_verify(ctx, group);
 
+#ifdef ENABLE_MODULE_ECDH
+        test_exhaustive_ecdh(ctx, group);
+#endif
 #ifdef ENABLE_MODULE_RECOVERY
         test_exhaustive_recovery(ctx, group);
 #endif
@@ -462,3 +472,7 @@ int main(int argc, char** argv) {
     printf("no problems found\n");
     return EXIT_SUCCESS;
 }
+
+#if defined(__GNUC__)
+# pragma GCC diagnostic pop
+#endif
diff --git a/src/secp256k1/src/unit_test.c b/src/secp256k1/src/unit_test.c
index a1858a117a79..2ac709cc6c4d 100644
--- a/src/secp256k1/src/unit_test.c
+++ b/src/secp256k1/src/unit_test.c
@@ -17,6 +17,11 @@
 #include "testrand.h"
 #include "tests_common.h"
 
+#if defined(__GNUC__)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic warning "-Wunused-function"
+#endif
+
 #define UNUSED(x) (void)(x)
 
 /* Number of times certain tests will run */
@@ -477,3 +482,7 @@ static int tf_run(struct tf_framework* tf) {
 
     return status;
 }
+
+#if defined(__GNUC__)
+# pragma GCC diagnostic pop
+#endif
diff --git a/src/secp256k1/src/util.h b/src/secp256k1/src/util.h
index 5d03e4c76dd7..492a5929ef9b 100644
--- a/src/secp256k1/src/util.h
+++ b/src/secp256k1/src/util.h
@@ -57,6 +57,17 @@ static void print_buf_plain(const unsigned char *buf, size_t len) {
 #  define SECP256K1_INLINE inline
 # endif
 
+# if !defined(_DEBUG) && !defined(__NO_INLINE__) && !defined(__OPTIMIZE_SIZE__)
+#  if defined(__OPTIMIZE__) && (SECP256K1_GNUC_PREREQ(3, 0) || defined(__clang__))
+#   define SECP256K1_FORCE_INLINE SECP256K1_INLINE __attribute__((always_inline))
+#  elif defined(_MSC_VER)
+#   define SECP256K1_FORCE_INLINE __forceinline
+#  endif
+# endif
+# ifndef SECP256K1_FORCE_INLINE
+#  define SECP256K1_FORCE_INLINE SECP256K1_INLINE
+# endif
+
 /** Assert statically that expr is true.
  *
  * This is a statement-like macro and can only be used inside functions.
diff --git a/src/serialize.h b/src/serialize.h
index 5cef72a9e03d..5d38a5100760 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -24,6 +24,7 @@
 #include <set>
 #include <span>
 #include <string>
+#include <string_view>
 #include <utility>
 #include <vector>
 
@@ -493,6 +494,7 @@ static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&
 #define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
 #define COMPACTSIZE(obj) Using<CompactSizeFormatter<true>>(obj)
 #define LIMITED_STRING(obj,n) Using<LimitedStringFormatter<n>>(obj)
+#define LIMITED_VECTOR(obj,n) Using<LimitedVectorFormatter<n>>(obj)
 
 /** Serialization wrapper class for integers in VarInt format. */
 template<VarIntMode Mode>
@@ -705,6 +707,12 @@ struct VectorFormatter
 template<typename Stream, typename C> void Serialize(Stream& os, const std::basic_string<C>& str);
 template<typename Stream, typename C> void Unserialize(Stream& is, std::basic_string<C>& str);
 
+/**
+ *  string_view
+ */
+template<typename Stream, typename C> void Serialize(Stream& os, const std::basic_string_view<C>& str);
+template<typename Stream, typename C> void Unserialize(Stream& is, std::basic_string_view<C>& str) = delete;
+
 /**
  * prevector
  */
@@ -783,6 +791,35 @@ struct DefaultFormatter
     static void Unser(Stream& s, T& t) { Unserialize(s, t); }
 };
 
+/**
+ * Limited vector formatter. Throws an error if a vector is oversized.
+ */
+
+template<size_t Limit, class Formatter = DefaultFormatter>
+struct LimitedVectorFormatter
+{
+    template<typename Stream, typename V>
+    void Unser(Stream& s, V& v)
+    {
+        Formatter formatter;
+        v.clear();
+        size_t size = ReadCompactSize(s);
+        if (size > Limit) {
+            throw std::ios_base::failure("Vector length limit exceeded");
+        }
+        v.reserve(size);
+        for (size_t i = 0; i < size; ++i) {
+            v.emplace_back();
+            formatter.Unser(s, v.back());
+        }
+    }
+
+    template<typename Stream, typename V>
+    void Ser(Stream& s, const V& v)
+    {
+        VectorFormatter<Formatter>{}.Ser(s, v);
+    }
+};
 
 
 
@@ -807,7 +844,17 @@ void Unserialize(Stream& is, std::basic_string<C>& str)
         is.read(MakeWritableByteSpan(str));
 }
 
-
+/**
+ * string_view
+ */
+template<typename Stream, typename C>
+void Serialize(Stream& os, const std::basic_string_view<C>& str)
+{
+    WriteCompactSize(os, str.size());
+    if (!str.empty()) {
+        os.write(MakeByteSpan(str));
+    }
+}
 
 /**
  * prevector
diff --git a/src/support/lockedpool.cpp b/src/support/lockedpool.cpp
index ff3a9e69c581..97f0df409fb9 100644
--- a/src/support/lockedpool.cpp
+++ b/src/support/lockedpool.cpp
@@ -262,7 +262,8 @@ size_t PosixLockedPageAllocator::GetLimit()
 #ifdef RLIMIT_MEMLOCK
     struct rlimit rlim;
     if (getrlimit(RLIMIT_MEMLOCK, &rlim) == 0) {
-        if (rlim.rlim_cur != RLIM_INFINITY) {
+        if (rlim.rlim_cur != RLIM_INFINITY &&
+            std::cmp_less_equal(rlim.rlim_cur, static_cast<rlim_t>(std::numeric_limits<size_t>::max()))) {
             return rlim.rlim_cur;
         }
     }
diff --git a/src/sync.h b/src/sync.h
index 123184d44f61..28bc78e91157 100644
--- a/src/sync.h
+++ b/src/sync.h
@@ -251,7 +251,7 @@ class SCOPED_LOCKABLE UniqueLock : public MutexType::unique_lock
 // it is not possible to use the lock's copy of the mutex for that purpose.
 // Instead, the original mutex needs to be passed back to the reverse_lock for
 // the sake of thread-safety analysis, but it is not actually used otherwise.
-#define REVERSE_LOCK(g, cs) typename std::decay<decltype(g)>::type::reverse_lock UNIQUE_NAME(revlock)(g, cs, #cs, __FILE__, __LINE__)
+#define REVERSE_LOCK(g, cs) typename std::decay<decltype(g)>::type::reverse_lock BITCOIN_UNIQUE_NAME(revlock)(g, cs, #cs, __FILE__, __LINE__)
 
 // When locking a Mutex, require negative capability to ensure the lock
 // is not already held
@@ -265,7 +265,7 @@ inline MutexType& MaybeCheckNotHeld(MutexType& m) LOCKS_EXCLUDED(m) LOCK_RETURNE
 template <typename MutexType>
 inline MutexType* MaybeCheckNotHeld(MutexType* m) LOCKS_EXCLUDED(m) LOCK_RETURNED(m) { return m; }
 
-#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
+#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
 #define LOCK2(cs1, cs2)                                               \
     UniqueLock criticalblock1(MaybeCheckNotHeld(cs1), #cs1, __FILE__, __LINE__); \
     UniqueLock criticalblock2(MaybeCheckNotHeld(cs2), #cs2, __FILE__, __LINE__)
diff --git a/src/test/addrman_tests.cpp b/src/test/addrman_tests.cpp
index cd1c651a08c2..0348a87f39af 100644
--- a/src/test/addrman_tests.cpp
+++ b/src/test/addrman_tests.cpp
@@ -9,6 +9,7 @@
 #include <clientversion.h>
 #include <hash.h>
 #include <netbase.h>
+#include <netgroup.h>
 #include <random.h>
 #include <test/data/asmap.raw.h>
 #include <test/util/setup_common.h>
@@ -97,8 +98,7 @@ BOOST_AUTO_TEST_CASE(addrman_simple)
 
 BOOST_AUTO_TEST_CASE(addrman_terrible_many_failures)
 {
-    auto now = Now<NodeSeconds>();
-    SetMockTime(now - (ADDRMAN_MIN_FAIL + 24h));
+    FakeNodeClock clock{};
 
     auto addrman{std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node))};
 
@@ -109,7 +109,7 @@ BOOST_AUTO_TEST_CASE(addrman_terrible_many_failures)
     BOOST_CHECK(addrman->Add({addr}, source));
     BOOST_CHECK(addrman->Good(addr));
 
-    SetMockTime(now);
+    clock += ADDRMAN_MIN_FAIL + 24h;
 
     CAddress addr_helper{CAddress(ResolveService("251.252.2.3", 8333), NODE_NONE)};
     addr_helper.nTime = Now<NodeSeconds>();
@@ -132,7 +132,7 @@ BOOST_AUTO_TEST_CASE(addrman_terrible_many_failures)
 
 BOOST_AUTO_TEST_CASE(addrman_penalty_self_announcement)
 {
-    SetMockTime(Now<NodeSeconds>());
+    FakeNodeClock clock{};
     auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
 
     const auto base_time{Now<NodeSeconds>() - 10000s};
@@ -1031,8 +1031,8 @@ BOOST_AUTO_TEST_CASE(addrman_evictionworks)
     BOOST_CHECK_EQUAL(addrman->SelectTriedCollision().first.ToStringAddrPort(), "250.1.1.36:0");
 
     // Eviction is also successful if too much time has passed since last try
-    NodeClockContext clock_ctx{};
-    clock_ctx += 4h;
+    FakeNodeClock clock{};
+    clock += 4h;
     addrman->ResolveCollisions();
     BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() == "[::]:0");
     //Now 19 is in tried again, and 36 back to new
diff --git a/src/test/banman_tests.cpp b/src/test/banman_tests.cpp
index d1e79e357742..a2053896b04c 100644
--- a/src/test/banman_tests.cpp
+++ b/src/test/banman_tests.cpp
@@ -17,7 +17,7 @@ BOOST_FIXTURE_TEST_SUITE(banman_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(file)
 {
-    NodeClockContext clock_ctx{777s};
+    FakeNodeClock clock{777s};
     const fs::path banlist_path{m_args.GetDataDirBase() / "banlist_test"};
     {
         const std::string entries_write{
diff --git a/src/test/blockfilter_index_tests.cpp b/src/test/blockfilter_index_tests.cpp
index e9d9a4094777..c4cd8bcf5381 100644
--- a/src/test/blockfilter_index_tests.cpp
+++ b/src/test/blockfilter_index_tests.cpp
@@ -21,11 +21,11 @@
 #include <test/util/blockfilter.h>
 #include <test/util/common.h>
 #include <test/util/setup_common.h>
+#include <test/util/time.h>
 #include <tinyformat.h>
 #include <uint256.h>
 #include <util/check.h>
 #include <util/fs.h>
-#include <util/time.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
@@ -127,8 +127,7 @@ bool BuildChainTestingSetup::BuildChain(const CBlockIndex* pindex,
     for (auto& block : chain) {
         block = std::make_shared<CBlock>(CreateBlock(pindex, no_txns, coinbase_script_pub_key));
 
-        BlockValidationState state;
-        if (!Assert(m_node.chainman)->ProcessNewBlockHeaders({{*block}}, true, state, &pindex)) {
+        if (!Assert(m_node.chainman)->ProcessNewBlockHeaders({{*block}}, true, &pindex).IsValid()) {
             return false;
         }
     }
@@ -332,14 +331,14 @@ BOOST_FIXTURE_TEST_CASE(blockfilter_index_init_destroy, BasicTestingSetup)
 class IndexReorgCrash : public BaseIndex
 {
 private:
+    FakeNodeClock& m_clock;
     std::unique_ptr<BaseIndex::DB> m_db;
     std::shared_future<void> m_blocker;
     int m_blocking_height;
 
 public:
-    explicit IndexReorgCrash(std::unique_ptr<interfaces::Chain> chain, std::shared_future<void> blocker,
-                             int blocking_height) : BaseIndex(std::move(chain), "test index"), m_blocker(blocker),
-                                                    m_blocking_height(blocking_height)
+    explicit IndexReorgCrash(std::unique_ptr<interfaces::Chain> chain, std::shared_future<void> blocker, int blocking_height, FakeNodeClock& clock)
+        : BaseIndex(std::move(chain), "test index", "testidx"), m_clock(clock), m_blocker(blocker), m_blocking_height(blocking_height)
     {
         const fs::path path = gArgs.GetDataDirNet() / "index";
         fs::create_directories(path);
@@ -356,7 +355,7 @@ class IndexReorgCrash : public BaseIndex
 
         // Move mock time forward so the best index gets updated only when we are not at the blocking height
         if (block.height == m_blocking_height - 1 || block.height > m_blocking_height) {
-            SetMockTime(GetTime<std::chrono::seconds>() + 31s);
+            m_clock += 31s;
         }
 
         return true;
@@ -365,14 +364,11 @@ class IndexReorgCrash : public BaseIndex
 
 BOOST_FIXTURE_TEST_CASE(index_reorg_crash, BuildChainTestingSetup)
 {
-    // Enable mock time
-    SetMockTime(GetTime<std::chrono::minutes>());
-
     std::promise<void> promise;
     std::shared_future<void> blocker(promise.get_future());
     int blocking_height = WITH_LOCK(cs_main, return m_node.chainman->ActiveChain().Tip()->nHeight);
 
-    IndexReorgCrash index(interfaces::MakeChain(m_node), blocker, blocking_height);
+    IndexReorgCrash index{interfaces::MakeChain(m_node), blocker, blocking_height, m_clock};
     BOOST_REQUIRE(index.Init());
     BOOST_REQUIRE(index.StartBackgroundSync());
 
diff --git a/src/test/blockmanager_tests.cpp b/src/test/blockmanager_tests.cpp
index 6ca4eb9b07a5..2eea73d04d31 100644
--- a/src/test/blockmanager_tests.cpp
+++ b/src/test/blockmanager_tests.cpp
@@ -42,6 +42,7 @@ BOOST_AUTO_TEST_CASE(blockmanager_find_block_pos)
     };
     BlockManager blockman{*Assert(m_node.shutdown_signal), blockman_opts};
     // simulate adding a genesis block normally
+    LOCK(::cs_main);
     BOOST_CHECK_EQUAL(blockman.WriteBlock(params->GenesisBlock(), 0).nPos, STORAGE_HEADER_BYTES);
     // simulate what happens during reindex
     // simulate a well-formed genesis block being found at offset 8 in the blk00000.dat file
@@ -257,6 +258,7 @@ BOOST_AUTO_TEST_CASE(blockmanager_flush_block_file)
     constexpr int TEST_BLOCK_SIZE{81};
 
     // Blockstore is empty
+    LOCK(::cs_main);
     BOOST_CHECK_EQUAL(blockman.CalculateCurrentUsage(), 0);
 
     // Write the first block to a new location.
diff --git a/src/test/btcsignals_tests.cpp b/src/test/btcsignals_tests.cpp
index b3203ebeb231..d6122896801c 100644
--- a/src/test/btcsignals_tests.cpp
+++ b/src/test/btcsignals_tests.cpp
@@ -2,8 +2,8 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <btcsignals.h>
 #include <test/util/setup_common.h>
+#include <util/btcsignals.h>
 
 #include <boost/test/unit_test.hpp>
 
@@ -12,22 +12,6 @@
 namespace {
 
 
-struct MoveOnlyData {
-    MoveOnlyData(int data) : m_data(data) {}
-    MoveOnlyData(MoveOnlyData&&) = default;
-
-    MoveOnlyData& operator=(MoveOnlyData&&) = delete;
-    MoveOnlyData(const MoveOnlyData&) = delete;
-    MoveOnlyData& operator=(const MoveOnlyData&) = delete;
-
-    int m_data;
-};
-
-MoveOnlyData MoveOnlyReturnCallback(int val)
-{
-    return {val};
-}
-
 void IncrementCallback(int& val)
 {
     val++;
@@ -97,61 +81,48 @@ BOOST_AUTO_TEST_CASE(disconnects)
     BOOST_CHECK_EQUAL(val, 6);
 }
 
-/* Check that move-only return types work correctly
- */
-BOOST_AUTO_TEST_CASE(moveonly_return)
-{
-    btcsignals::signal<MoveOnlyData(int)> sig0;
-    sig0.connect(MoveOnlyReturnCallback);
-    int data{3};
-    auto ret = sig0(data);
-    BOOST_CHECK_EQUAL(ret->m_data, 3);
-}
-
-/* The result of the signal invocation should always be the result of the last
- * enabled callback.
- */
-BOOST_AUTO_TEST_CASE(return_value)
+BOOST_AUTO_TEST_CASE(any_of_combiner)
 {
-    btcsignals::signal<bool()> sig0;
+    btcsignals::signal<bool(), btcsignals::any_of> sig0;
     decltype(sig0)::result_type ret;
     ret = sig0();
-    BOOST_CHECK(!ret);
+    BOOST_CHECK_EQUAL(ret, false);
     {
-        btcsignals::scoped_connection conn0 = sig0.connect(ReturnTrue);
+        btcsignals::scoped_connection conn0{sig0.connect(ReturnTrue)};
         ret = sig0();
-        BOOST_CHECK(ret && *ret == true);
+        BOOST_CHECK_EQUAL(ret, true);
     }
     ret = sig0();
-    BOOST_CHECK(!ret);
+    BOOST_CHECK_EQUAL(ret, false);
     {
-        btcsignals::scoped_connection conn1 = sig0.connect(ReturnTrue);
-        btcsignals::scoped_connection conn0 = sig0.connect(ReturnFalse);
+        btcsignals::scoped_connection conn0{sig0.connect(ReturnTrue)};
+        btcsignals::scoped_connection conn1{sig0.connect(ReturnFalse)};
         ret = sig0();
-        BOOST_CHECK(ret && *ret == false);
+        BOOST_CHECK_EQUAL(ret, true);
         conn0.disconnect();
         ret = sig0();
-        BOOST_CHECK(ret && *ret == true);
+        BOOST_CHECK_EQUAL(ret, false);
     }
     ret = sig0();
-    BOOST_CHECK(!ret);
+    BOOST_CHECK_EQUAL(ret, false);
 }
 
 /* Test the thread-safety of connect/disconnect/empty/connected/callbacks.
  * Connect sig0 to an incrementor function and loop in a thread.
  * Meanwhile, in another thread, inject and call new increment callbacks.
  * Both threads are constantly calling empty/connected.
- * Though the end-result is undefined due to a non-deterministic number of
- * total callbacks executed, this should all be completely threadsafe.
+ * The end-result must be deterministic for the atomic modified by conn0.
+ * Though, the end-result for the atomic modified by the extra connections is
+ * undefined due to a non-deterministic number of total callbacks executed.
+ * In any case, this should all be completely threadsafe.
  * Sanitizers should pick up any buggy data race behavior (if present).
  */
 BOOST_AUTO_TEST_CASE(thread_safety)
 {
     btcsignals::signal<void()> sig0;
-    std::atomic<uint32_t> val{0};
-    auto conn0 = sig0.connect([&val] {
-        val++;
-    });
+    std::atomic<uint32_t> val_det{0};
+    std::atomic<uint32_t> val_non_det{0};
+    auto conn0 = sig0.connect([&val_det] { val_det++; });
 
     std::thread incrementor([&conn0, &sig0] {
         for (int i = 0; i < 1000; i++) {
@@ -164,16 +135,17 @@ BOOST_AUTO_TEST_CASE(thread_safety)
         assert(conn0.connected());
     });
 
-    std::thread extra_increment_injector([&conn0, &sig0, &val] {
+    std::thread extra_increment_injector([&conn0, &sig0, &val_non_det] {
         static constexpr size_t num_extra_conns{1000};
         std::vector<btcsignals::scoped_connection> extra_conns;
         extra_conns.reserve(num_extra_conns);
         for (size_t i = 0; i < num_extra_conns; i++) {
             BOOST_CHECK(!sig0.empty());
             BOOST_CHECK(conn0.connected());
-            extra_conns.emplace_back(sig0.connect([&val] {
-                val++;
-            }));
+            btcsignals::scoped_connection extra{sig0.connect([&val_non_det] { val_non_det++; })};
+            if (i % 2 == 0) {
+                extra_conns.emplace_back(std::move(extra));
+            }
             sig0();
         }
     });
@@ -182,10 +154,16 @@ BOOST_AUTO_TEST_CASE(thread_safety)
     conn0.disconnect();
     BOOST_CHECK(sig0.empty());
 
-    // sig will have been called 2000 times, and at least 1000 of those will
-    // have been executing multiple incrementing callbacks. So while val is
-    // probably MUCH bigger, it's guaranteed to be at least 3000.
-    BOOST_CHECK_GE(val.load(), 3000);
+    // sig0 will have been called 2000 times, and only the first connection did
+    // increment val_det, so it must be 2000.
+    BOOST_CHECK_EQUAL(val_det.load(), 2000);
+    // The number of connections that increment val_non_det is growing from 1
+    // to 500, where 500 are disconnected immediately again after the step.
+    // Before the end of each step the connections are called at least once.
+    // However, it is unknown how often the connections have been called
+    // exactly. The 500th Triangular Number gives a lower estimate.
+    // T_n=n(n+1)/2
+    BOOST_CHECK_GE(val_non_det.load(), 500 * 501 / 2);
 }
 
 /* Test that connection and disconnection works from within signal
diff --git a/src/test/chainstate_write_tests.cpp b/src/test/chainstate_write_tests.cpp
index d0925b6192f6..5461073176a7 100644
--- a/src/test/chainstate_write_tests.cpp
+++ b/src/test/chainstate_write_tests.cpp
@@ -30,22 +30,21 @@ BOOST_FIXTURE_TEST_CASE(chainstate_write_interval, TestingSetup)
     const auto sub{std::make_shared<TestSubscriber>()};
     m_node.validation_signals->RegisterSharedValidationInterface(sub);
     auto& chainstate{Assert(m_node.chainman)->ActiveChainstate()};
-    BlockValidationState state_dummy{};
-    NodeClockContext clock_ctx{};
+    FakeNodeClock clock{};
 
     // The first periodic flush sets m_next_write and does not flush
-    chainstate.FlushStateToDisk(state_dummy, FlushStateMode::PERIODIC);
+    /*state=*/chainstate.FlushStateToDisk(FlushStateMode::PERIODIC);
     m_node.validation_signals->SyncWithValidationInterfaceQueue();
     BOOST_CHECK(!sub->m_did_flush);
 
     // The periodic flush interval is between 50 and 70 minutes (inclusive)
-    clock_ctx += DATABASE_WRITE_INTERVAL_MIN - 1min;
-    chainstate.FlushStateToDisk(state_dummy, FlushStateMode::PERIODIC);
+    clock += DATABASE_WRITE_INTERVAL_MIN - 1min;
+    /*state=*/chainstate.FlushStateToDisk(FlushStateMode::PERIODIC);
     m_node.validation_signals->SyncWithValidationInterfaceQueue();
     BOOST_CHECK(!sub->m_did_flush);
 
-    clock_ctx += DATABASE_WRITE_INTERVAL_MAX;
-    chainstate.FlushStateToDisk(state_dummy, FlushStateMode::PERIODIC);
+    clock += DATABASE_WRITE_INTERVAL_MAX;
+    /*state=*/chainstate.FlushStateToDisk(FlushStateMode::PERIODIC);
     m_node.validation_signals->SyncWithValidationInterfaceQueue();
     BOOST_CHECK(sub->m_did_flush);
 }
@@ -84,11 +83,11 @@ BOOST_FIXTURE_TEST_CASE(write_during_multiblock_activation, TestChain100Setup)
     BOOST_CHECK_EQUAL(second_from_tip->pprev, chainstate.m_chain.Tip());
 
     // Set m_next_write to current time
-    chainstate.FlushStateToDisk(state_dummy, FlushStateMode::FORCE_FLUSH);
+    /*state=*/chainstate.FlushStateToDisk(FlushStateMode::FORCE_FLUSH);
     m_node.validation_signals->SyncWithValidationInterfaceQueue();
     // The periodic flush interval is between 50 and 70 minutes (inclusive)
     // The next call to a PERIODIC write will flush
-    SetMockTime(GetMockTime() + DATABASE_WRITE_INTERVAL_MAX);
+    m_clock += DATABASE_WRITE_INTERVAL_MAX;
 
     const auto sub{std::make_shared<TestSubscriber>()};
     m_node.validation_signals->RegisterSharedValidationInterface(sub);
diff --git a/src/test/coinstatsindex_tests.cpp b/src/test/coinstatsindex_tests.cpp
index 42c01ca5b8f7..98d6ee757fee 100644
--- a/src/test/coinstatsindex_tests.cpp
+++ b/src/test/coinstatsindex_tests.cpp
@@ -101,9 +101,10 @@ BOOST_FIXTURE_TEST_CASE(coinstatsindex_unclean_shutdown, TestChain100Setup)
             new_block = std::make_shared<CBlock>(block);
 
             LOCK(cs_main);
-            BlockValidationState state;
-            BOOST_CHECK(CheckBlock(block, state, params.GetConsensus()));
-            BOOST_CHECK(m_node.chainman->AcceptBlock(new_block, state, &new_block_index, true, nullptr, nullptr, true));
+            BlockValidationState state{CheckBlock(block, params.GetConsensus())};
+            BOOST_CHECK(state.IsValid());
+            state = m_node.chainman->AcceptBlock(new_block, &new_block_index, true, nullptr, nullptr, true);
+            BOOST_CHECK(state.IsValid());
             CCoinsViewCache view(&chainstate.CoinsTip());
             BOOST_CHECK(chainstate.ConnectBlock(block, state, new_block_index, view));
         }
diff --git a/src/test/denialofservice_tests.cpp b/src/test/denialofservice_tests.cpp
index 9709eacd8b7b..1a003c00a9ec 100644
--- a/src/test/denialofservice_tests.cpp
+++ b/src/test/denialofservice_tests.cpp
@@ -91,8 +91,8 @@ BOOST_AUTO_TEST_CASE(outbound_slow_chain_eviction)
     }
     connman.FlushSendBuffer(dummyNode1);
 
-    NodeClockContext clock_ctx{};
-    clock_ctx += 21min;
+    FakeNodeClock clock{};
+    clock += 21min;
 
     BOOST_CHECK(peerman.SendMessages(dummyNode1)); // should result in getheaders
     {
@@ -101,7 +101,7 @@ BOOST_AUTO_TEST_CASE(outbound_slow_chain_eviction)
         BOOST_CHECK(!to_send.empty());
     }
 
-    clock_ctx += 3min;
+    clock += 3min;
     BOOST_CHECK(peerman.SendMessages(dummyNode1)); // should result in disconnect
     BOOST_CHECK(dummyNode1.fDisconnect == true);
 
@@ -153,7 +153,7 @@ BOOST_FIXTURE_TEST_CASE(stale_tip_peer_management, OutboundTest)
     options.m_max_automatic_connections = DEFAULT_MAX_PEER_CONNECTIONS;
 
     const auto time_init{Now<NodeSeconds>()};
-    NodeClockContext clock_ctx{time_init};
+    FakeNodeClock clock{time_init};
     const auto delta{3 * std::chrono::seconds{m_node.chainman->GetConsensus().nPowTargetSpacing} + 1s};
     connman->Init(options);
     std::vector<CNode *> vNodes;
@@ -170,7 +170,7 @@ BOOST_FIXTURE_TEST_CASE(stale_tip_peer_management, OutboundTest)
         BOOST_CHECK(node->fDisconnect == false);
     }
 
-    clock_ctx += delta;
+    clock += delta;
 
     // Now tip should definitely be stale, and we should look for an extra
     // outbound peer
@@ -185,9 +185,9 @@ BOOST_FIXTURE_TEST_CASE(stale_tip_peer_management, OutboundTest)
     // If we add one more peer, something should get marked for eviction
     // on the next check (since we're mocking the time to be in the future, the
     // required time connected check should be satisfied).
-    clock_ctx.set(time_init);
+    clock.set(time_init);
     AddRandomOutboundPeer(id, vNodes, *peerLogic, *connman, ConnectionType::OUTBOUND_FULL_RELAY);
-    clock_ctx += delta;
+    clock += delta;
 
     peerLogic->CheckForStaleTipAndEvictPeers();
     for (int i = 0; i < max_outbound_full_relay; ++i) {
@@ -213,9 +213,9 @@ BOOST_FIXTURE_TEST_CASE(stale_tip_peer_management, OutboundTest)
 
     // Add an onion peer, that will be protected because it is the only one for
     // its network, so another peer gets disconnected instead.
-    clock_ctx.set(time_init);
+    clock.set(time_init);
     AddRandomOutboundPeer(id, vNodes, *peerLogic, *connman, ConnectionType::OUTBOUND_FULL_RELAY, /*onion_peer=*/true);
-    clock_ctx += delta;
+    clock += delta;
     peerLogic->CheckForStaleTipAndEvictPeers();
 
     for (int i = 0; i < max_outbound_full_relay - 2; ++i) {
@@ -226,9 +226,9 @@ BOOST_FIXTURE_TEST_CASE(stale_tip_peer_management, OutboundTest)
     BOOST_CHECK(vNodes[max_outbound_full_relay]->fDisconnect == false);
 
     // Add a second onion peer which won't be protected
-    clock_ctx.set(time_init);
+    clock.set(time_init);
     AddRandomOutboundPeer(id, vNodes, *peerLogic, *connman, ConnectionType::OUTBOUND_FULL_RELAY, /*onion_peer=*/true);
-    clock_ctx += delta;
+    clock += delta;
     peerLogic->CheckForStaleTipAndEvictPeers();
 
     BOOST_CHECK(vNodes.back()->fDisconnect == true);
@@ -243,6 +243,7 @@ BOOST_FIXTURE_TEST_CASE(stale_tip_peer_management, OutboundTest)
 BOOST_FIXTURE_TEST_CASE(block_relay_only_eviction, OutboundTest)
 {
     NodeId id{0};
+    FakeNodeClock clock{};
     auto connman = std::make_unique<ConnmanTestMsg>(0x1337, 0x1337, *m_node.addrman, *m_node.netgroupman, Params());
     auto peerLogic = PeerManager::make(*connman, *m_node.addrman, nullptr, *m_node.chainman, *m_node.mempool, *m_node.warnings, {});
 
@@ -274,8 +275,7 @@ BOOST_FIXTURE_TEST_CASE(block_relay_only_eviction, OutboundTest)
     }
     BOOST_CHECK(vNodes.back()->fDisconnect == false);
 
-    NodeClockContext clock_ctx{};
-    clock_ctx += MINIMUM_CONNECT_TIME;
+    clock += MINIMUM_CONNECT_TIME;
     peerLogic->CheckForStaleTipAndEvictPeers();
     for (int i = 0; i < max_outbound_block_relay; ++i) {
         BOOST_CHECK(vNodes[i]->fDisconnect == false);
@@ -413,7 +413,7 @@ BOOST_AUTO_TEST_CASE(DoS_bantime)
     auto peerLogic = PeerManager::make(*connman, *m_node.addrman, banman.get(), *m_node.chainman, *m_node.mempool, *m_node.warnings, {});
 
     banman->ClearBanned();
-    const NodeClockContext clock_ctx{}; // keep mocktime constant
+    const FakeNodeClock clock{}; // keep mocktime constant
 
     CAddress addr(ip(0xa0b0c001), NODE_NONE);
     NodeId id{0};
diff --git a/src/test/descriptor_tests.cpp b/src/test/descriptor_tests.cpp
index 347efd774493..5e4039ad1e1c 100644
--- a/src/test/descriptor_tests.cpp
+++ b/src/test/descriptor_tests.cpp
@@ -983,6 +983,7 @@ BOOST_AUTO_TEST_CASE(descriptor_test)
 
     // Multisig constructions
     Check("multi(1,L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1,5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss)", "multi(1,03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd,04a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea235)", "multi(1,03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd,04a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea235)", SIGNABLE, {{"512103a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd4104a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea23552ae"}}, std::nullopt, /*op_desc_id=*/uint256{"b147e25eb4a9d3da4e86ed8e970d817563ae2cb9c71a756b11cfdeb4dc11b70c"});
+    Check("multi(2,KzoAz5CanayRKex3fSLQ2BwJpN7U52gZvxMyk78nDMHuqrUxuSJy,KwGNz6YCCQtYvFzMtrC6D3tKTKdBBboMrLTsjr2NYVBwapCkn7Mr,KxogYhiNfwxuswvXV66eFyKcCpm7dZ7TqHVqujHAVUjJxyivxQ9X)", "multi(2,03669b8afcec803a0d323e9a17f3ea8e68e8abe5a278020a929adbec52421adbd0,0260b2003c386519fc9eadf2b5cf124dd8eea4c4e68d5e154050a9346ea98ce600,0362a74e399c39ed5593852a30147f2959b56bb827dfa3e60e464b02ccf87dc5e8)", "multi(2,03669b8afcec803a0d323e9a17f3ea8e68e8abe5a278020a929adbec52421adbd0,0260b2003c386519fc9eadf2b5cf124dd8eea4c4e68d5e154050a9346ea98ce600,0362a74e399c39ed5593852a30147f2959b56bb827dfa3e60e464b02ccf87dc5e8)", SIGNABLE, {{"522103669b8afcec803a0d323e9a17f3ea8e68e8abe5a278020a929adbec52421adbd0210260b2003c386519fc9eadf2b5cf124dd8eea4c4e68d5e154050a9346ea98ce600210362a74e399c39ed5593852a30147f2959b56bb827dfa3e60e464b02ccf87dc5e853ae"}}, std::nullopt); // Bare multisig at TOP level with exactly 3 pubkeys is allowed
     Check("sortedmulti(1,L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1,5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss)", "sortedmulti(1,03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd,04a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea235)", "sortedmulti(1,03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd,04a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea235)", SIGNABLE, {{"512103a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd4104a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea23552ae"}}, std::nullopt, /*op_desc_id=*/uint256{"62b59d1e32a62176ef7a17538f3b80c7d1afc53e5644eb753525bdb5d556486c"});
     Check("sortedmulti(1,5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss,L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1)", "sortedmulti(1,04a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea235,03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd)", "sortedmulti(1,04a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea235,03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd)", SIGNABLE, {{"512103a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd4104a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea23552ae"}}, std::nullopt);
     Check("sh(multi(2,[00000000/111'/222]xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc,xprv9uPDJpEQgRQfDcW7BkF7eTya6RPxXeJCqCJGHuCJ4GiRVLzkTXBAJMu2qaMWPrS7AANYqdq6vcBcBUdJCVVFceUvJFjaPdGZ2y9WACViL4L/0))", "sh(multi(2,[00000000/111'/222]xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL,xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrADWgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y/0))", "sh(multi(2,[00000000/111h/222]xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL,xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrADWgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y/0))", DEFAULT, {{"a91445a9a622a8b0a1269944be477640eedc447bbd8487"}}, OutputType::LEGACY, /*op_desc_id=*/std::nullopt, {{0x8000006FUL,222},{0}});
diff --git a/src/test/feerounder_tests.cpp b/src/test/feerounder_tests.cpp
index 82cd7d65b409..d88a4f771b6c 100644
--- a/src/test/feerounder_tests.cpp
+++ b/src/test/feerounder_tests.cpp
@@ -9,7 +9,7 @@
 
 #include <set>
 
-BOOST_AUTO_TEST_SUITE(fee_rounder_tests)
+BOOST_AUTO_TEST_SUITE(feerounder_tests)
 
 BOOST_AUTO_TEST_CASE(FeeRounder)
 {
diff --git a/src/test/fuzz/addrman.cpp b/src/test/fuzz/addrman.cpp
index 750480285de9..435de296d846 100644
--- a/src/test/fuzz/addrman.cpp
+++ b/src/test/fuzz/addrman.cpp
@@ -117,7 +117,7 @@ FUZZ_TARGET(addrman, .init = initialize_addrman)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
     auto addr_man_ptr = std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider, GetCheckRatio());
     if (fuzzed_data_provider.ConsumeBool()) {
@@ -202,7 +202,7 @@ FUZZ_TARGET(addrman_serdeser, .init = initialize_addrman)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
 
     NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
     AddrManDeterministic addr_man1{netgroupman, fuzzed_data_provider, GetCheckRatio()};
diff --git a/src/test/fuzz/banman.cpp b/src/test/fuzz/banman.cpp
index aa7e76b90c79..aac93c9dad75 100644
--- a/src/test/fuzz/banman.cpp
+++ b/src/test/fuzz/banman.cpp
@@ -45,7 +45,7 @@ FUZZ_TARGET(banman, .init = initialize_banman)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     fs::path banlist_file = gArgs.GetDataDirNet() / "fuzzed_banlist";
 
     const bool start_with_corrupted_banlist{fuzzed_data_provider.ConsumeBool()};
@@ -125,7 +125,7 @@ FUZZ_TARGET(banman, .init = initialize_banman)
         }
         if (!force_read_and_write_to_err) {
             ban_man.DumpBanlist();
-            clock_ctx.set(ConsumeTime(fuzzed_data_provider));
+            clock.set(ConsumeTime(fuzzed_data_provider));
             banmap_t banmap;
             ban_man.GetBanned(banmap);
             BanMan ban_man_read{banlist_file, /*client_interface=*/nullptr, /*default_ban_time=*/0};
diff --git a/src/test/fuzz/block.cpp b/src/test/fuzz/block.cpp
index 7b874429852a..02f9abff4578 100644
--- a/src/test/fuzz/block.cpp
+++ b/src/test/fuzz/block.cpp
@@ -31,23 +31,19 @@ FUZZ_TARGET(block, .init = initialize_block)
         return;
     }
     const Consensus::Params& consensus_params = Params().GetConsensus();
-    BlockValidationState validation_state_pow_and_merkle;
-    const bool valid_incl_pow_and_merkle = CheckBlock(block, validation_state_pow_and_merkle, consensus_params, /* fCheckPOW= */ true, /* fCheckMerkleRoot= */ true);
+    BlockValidationState validation_state_pow_and_merkle{CheckBlock(block, consensus_params, /* fCheckPOW= */ true, /* fCheckMerkleRoot= */ true)};
     assert(validation_state_pow_and_merkle.IsValid() || validation_state_pow_and_merkle.IsInvalid() || validation_state_pow_and_merkle.IsError());
     (void)validation_state_pow_and_merkle.Error("");
-    BlockValidationState validation_state_pow;
-    const bool valid_incl_pow = CheckBlock(block, validation_state_pow, consensus_params, /* fCheckPOW= */ true, /* fCheckMerkleRoot= */ false);
+    const BlockValidationState validation_state_pow{CheckBlock(block, consensus_params, /* fCheckPOW= */ true, /* fCheckMerkleRoot= */ false)};
     assert(validation_state_pow.IsValid() || validation_state_pow.IsInvalid() || validation_state_pow.IsError());
-    BlockValidationState validation_state_merkle;
-    const bool valid_incl_merkle = CheckBlock(block, validation_state_merkle, consensus_params, /* fCheckPOW= */ false, /* fCheckMerkleRoot= */ true);
+    const BlockValidationState validation_state_merkle{CheckBlock(block, consensus_params, /* fCheckPOW= */ false, /* fCheckMerkleRoot= */ true)};
     assert(validation_state_merkle.IsValid() || validation_state_merkle.IsInvalid() || validation_state_merkle.IsError());
-    BlockValidationState validation_state_none;
-    const bool valid_incl_none = CheckBlock(block, validation_state_none, consensus_params, /* fCheckPOW= */ false, /* fCheckMerkleRoot= */ false);
+    const BlockValidationState validation_state_none{CheckBlock(block, consensus_params, /* fCheckPOW= */ false, /* fCheckMerkleRoot= */ false)};
     assert(validation_state_none.IsValid() || validation_state_none.IsInvalid() || validation_state_none.IsError());
-    if (valid_incl_pow_and_merkle) {
-        assert(valid_incl_pow && valid_incl_merkle && valid_incl_none);
-    } else if (valid_incl_merkle || valid_incl_pow) {
-        assert(valid_incl_none);
+    if (validation_state_pow_and_merkle.IsValid()) {
+        assert(validation_state_pow.IsValid() && validation_state_merkle.IsValid() && validation_state_none.IsValid());
+    } else if (validation_state_merkle.IsValid() || validation_state_pow.IsValid()) {
+        assert(validation_state_none.IsValid());
     }
     (void)block.GetHash();
     (void)block.ToString();
diff --git a/src/test/fuzz/block_index_tree.cpp b/src/test/fuzz/block_index_tree.cpp
index 2eac6d6bd264..ad38f6e608f9 100644
--- a/src/test/fuzz/block_index_tree.cpp
+++ b/src/test/fuzz/block_index_tree.cpp
@@ -42,7 +42,7 @@ void initialize_block_index_tree()
 FUZZ_TARGET(block_index_tree, .init = initialize_block_index_tree)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     auto& chainman = static_cast<TestChainstateManager&>(*g_setup->m_node.chainman);
     auto& blockman = static_cast<TestBlockManager&>(chainman.m_blockman);
     CBlockIndex* genesis = chainman.ActiveChainstate().m_chain[0];
diff --git a/src/test/fuzz/cmpctblock.cpp b/src/test/fuzz/cmpctblock.cpp
index 882169c93a33..ff5279caed80 100644
--- a/src/test/fuzz/cmpctblock.cpp
+++ b/src/test/fuzz/cmpctblock.cpp
@@ -163,7 +163,7 @@ FUZZ_TARGET(cmpctblock, .init = initialize_cmpctblock)
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
 
-    NodeClockContext clock_ctx{1610000000s};
+    FakeNodeClock clock{1610000000s};
 
     auto setup = g_setup;
     auto& mempool = *setup->m_node.mempool;
@@ -453,10 +453,10 @@ FUZZ_TARGET(cmpctblock, .init = initialize_cmpctblock)
             [&]() {
                 // Set mock time randomly or to tip's time.
                 if (fuzzed_data_provider.ConsumeBool()) {
-                    clock_ctx.set(ConsumeTime(fuzzed_data_provider));
+                    clock.set(ConsumeTime(fuzzed_data_provider));
                 } else {
                     const NodeSeconds tip_time = WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()->Time());
-                    clock_ctx.set(tip_time);
+                    clock.set(tip_time);
                 }
 
                 sent_net_msg = false;
diff --git a/src/test/fuzz/connman.cpp b/src/test/fuzz/connman.cpp
index 669a1169a839..614bdf4f337d 100644
--- a/src/test/fuzz/connman.cpp
+++ b/src/test/fuzz/connman.cpp
@@ -41,7 +41,7 @@ FUZZ_TARGET(connman, .init = initialize_connman)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     auto netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
     auto addr_man_ptr{std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider, GetCheckRatio())};
     if (fuzzed_data_provider.ConsumeBool()) {
diff --git a/src/test/fuzz/dbwrapper.cpp b/src/test/fuzz/dbwrapper.cpp
index 784b696d8166..1b5cd7b025d0 100644
--- a/src/test/fuzz/dbwrapper.cpp
+++ b/src/test/fuzz/dbwrapper.cpp
@@ -167,7 +167,16 @@ void VerifyIterator(CDBWrapper& dbw, const Oracle& oracle,
 }
 
 /** Maximum number of concurrent reader threads in dbwrapper_concurrent_reads. */
-constexpr size_t MAX_READ_WORKERS{16};
+constexpr size_t MAX_READ_WORKERS{8};
+
+ThreadPool g_read_pool{"dbfuzz"};
+Mutex g_read_pool_mutex;
+
+void StartReadPoolIfNeeded() EXCLUSIVE_LOCKS_REQUIRED(!g_read_pool_mutex)
+{
+    LOCK(g_read_pool_mutex);
+    if (!g_read_pool.WorkersCount()) g_read_pool.Start(MAX_READ_WORKERS);
+}
 
 /** Build randomized DBParams from the fuzz input, shared by all targets. */
 DBParams ConsumeDBParams(FuzzedDataProvider& provider, leveldb::Env* testing_env,
@@ -185,39 +194,6 @@ DBParams ConsumeDBParams(FuzzedDataProvider& provider, leveldb::Env* testing_env
     };
 }
 
-/** A single read-only operation run concurrently in dbwrapper_concurrent_reads. */
-enum class ReadOp { Read, Exists, IteratorSeek };
-using ReadQuery = std::tuple<ReadOp, uint16_t>;
-using Results = std::vector<std::optional<std::string>>;
-
-Results RunReadQueries(CDBWrapper& db, const std::vector<ReadQuery>& queries, FastRandomContext& rng)
-{
-    std::vector<size_t> order(queries.size());
-    std::iota(order.begin(), order.end(), size_t{0});
-    std::shuffle(order.begin(), order.end(), rng);
-
-    Results results(queries.size());
-    for (const auto i : order) {
-        const auto& [op, key] = queries[i];
-        std::string v;
-        switch (op) {
-        case ReadOp::Read:
-            if (db.Read(key, v)) results[i] = std::move(v);
-            break;
-        case ReadOp::Exists:
-            if (db.Exists(key)) results[i] = std::move(v);
-            break;
-        case ReadOp::IteratorSeek: {
-            const std::unique_ptr<CDBIterator> it{db.NewIterator()};
-            it->Seek(key);
-            if (it->Valid() && it->GetValue(v)) results[i] = std::move(v);
-            break;
-        }
-        }
-    }
-    return results;
-}
-
 template <typename DrainWorkFn, typename RunOneFn>
 void TestDbWrapper(FuzzedDataProvider& provider,
                       leveldb::Env* testing_env,
@@ -381,8 +357,9 @@ FUZZ_TARGET(dbwrapper_threaded, .init = [] { static auto setup{MakeNoLogFileCont
         /*allow_force_compact=*/true);
 }
 
-FUZZ_TARGET(dbwrapper_concurrent_reads, .init = [] { static auto setup{MakeNoLogFileContext<>()}; })
+FUZZ_TARGET(dbwrapper_concurrent_reads, .init = [] { static auto setup{MakeNoLogFileContext<>()}; }) EXCLUSIVE_LOCKS_REQUIRED(!g_read_pool_mutex)
 {
+    StartReadPoolIfNeeded();
     SeedRandomStateForTest(SeedRand::ZEROS);
 
     FuzzedDataProvider provider{buffer.data(), buffer.size()};
@@ -394,17 +371,20 @@ FUZZ_TARGET(dbwrapper_concurrent_reads, .init = [] { static auto setup{MakeNoLog
 
     // Seed the DB. Drain work after small batches so we don't deadlock on a
     // scheduled compaction.
-    const size_t num_entries{provider.ConsumeIntegralInRange<size_t>(100, 5'000)};
+    const size_t num_entries{provider.ConsumeIntegralInRange<size_t>(100, 3'000)};
     std::vector<uint16_t> keys;
     keys.reserve(num_entries);
+    Oracle oracle;
     constexpr size_t SEED_BATCH_SIZE{400};
     for (size_t start{0}; start < num_entries; start += SEED_BATCH_SIZE) {
         CDBBatch batch{db};
         const size_t end{std::min(start + SEED_BATCH_SIZE, num_entries)};
         for (size_t i{start}; i < end; ++i) {
             const auto k{ConsumeKey(provider)};
-            batch.Write(k, MakeValue(k, ConsumeValueSize(provider)));
+            const auto size{ConsumeValueSize(provider)};
+            batch.Write(k, MakeValue(k, size));
             keys.push_back(k);
+            oracle[k] = size;
         }
         det_env.DrainWork();
         db.WriteBatch(batch, /*fSync=*/true);
@@ -414,40 +394,71 @@ FUZZ_TARGET(dbwrapper_concurrent_reads, .init = [] { static auto setup{MakeNoLog
 
     // Build query list from seeded and random keys.
     const size_t num_queries{provider.ConsumeIntegralInRange<size_t>(1, 2'000)};
-    std::vector<ReadQuery> queries;
+    enum class ReadOp { Read, Exists, IteratorSeek };
+    std::vector<std::tuple<ReadOp, uint16_t>> queries;
     queries.reserve(num_queries);
     for (size_t i{0}; i < num_queries; ++i) {
-        const auto op{static_cast<ReadOp>(provider.ConsumeIntegralInRange<int>(0, 2))};
+        const auto op{provider.PickValueInArray({ReadOp::Read, ReadOp::Exists, ReadOp::IteratorSeek})};
         const uint16_t key{provider.ConsumeBool()
                                ? keys[provider.ConsumeIntegralInRange<size_t>(0, keys.size() - 1)]
                                : ConsumeKey(provider)};
         queries.emplace_back(op, key);
     }
 
-    // Baseline read on a single thread
-    FastRandomContext rng{ConsumeUInt256(provider)};
-    const Results baseline{RunReadQueries(db, queries, rng)};
-
-    ThreadPool pool{"dbfuzz"};
-    pool.Start(MAX_READ_WORKERS);
 
     // Workers + main thread synchronize on the latch so all reads start together.
     std::latch start_latch{static_cast<ptrdiff_t>(MAX_READ_WORKERS + 1)};
-    std::vector<std::function<Results()>> tasks(MAX_READ_WORKERS);
-    std::generate(tasks.begin(), tasks.end(), [&] {
-        return [&, seed = rng.rand256()]() -> Results {
+    std::vector<std::function<void()>> tasks(MAX_READ_WORKERS);
+    FastRandomContext rng{ConsumeUInt256(provider)};
+    std::ranges::generate(tasks, [&] {
+        return [&, seed = rng.rand256()] {
             FastRandomContext thread_rng{seed};
+            std::vector<size_t> order(queries.size());
+            std::iota(order.begin(), order.end(), size_t{0});
+            std::ranges::shuffle(order, thread_rng);
+            std::vector<uint8_t> v;
+            std::string key_str;
             start_latch.arrive_and_wait();
-            return RunReadQueries(db, queries, thread_rng);
+            const std::unique_ptr<CDBIterator> it{db.NewIterator()};
+            // Every read must agree with the oracle, the source of truth.
+            for (const auto i : order) {
+                const auto& [op, key] = queries[i];
+                switch (op) {
+                case ReadOp::Read:
+                    if (const auto oit{oracle.find(key)}; oit != oracle.end()) {
+                        assert(db.Read(key, v) && v == MakeValue(key, oit->second));
+                    } else {
+                        assert(!db.Read(key, v));
+                    }
+                    break;
+                case ReadOp::Exists:
+                    assert(db.Exists(key) == oracle.contains(key));
+                    break;
+                case ReadOp::IteratorSeek:
+                    it->Seek(key);
+                    // Skip the obfuscation metadata entry (a non-uint16_t key) if we land
+                    // on it, so the result matches the oracle, which only tracks user keys.
+                    if (it->Valid() && it->GetKey(key_str) && key_str == OBFUSCATION_KEY) it->Next();
+                    if (const auto oit{oracle.lower_bound(key)}; oit != oracle.end()) {
+                        assert(it->Valid());
+                        uint16_t actual_key;
+                        assert(it->GetKey(actual_key) && actual_key == oit->first);
+                        assert(it->GetValue(v) && v == MakeValue(actual_key, oit->second));
+                    } else {
+                        assert(!it->Valid());
+                    }
+                    break;
+                }
+            }
         };
     });
-    auto futures{*Assert(pool.Submit(std::move(tasks)))};
+    auto futures{*Assert(g_read_pool.Submit(std::move(tasks)))};
 
     // Release the workers and immediately run the queued compaction on this
     // thread, so compaction races against the concurrent reads.
     start_latch.arrive_and_wait();
     det_env.DrainWork();
 
-    for (auto& fut : futures) assert(fut.get() == baseline);
+    for (auto& fut : futures) fut.get();
     det_env.DrainWork();
 }
diff --git a/src/test/fuzz/descriptor_parse.cpp b/src/test/fuzz/descriptor_parse.cpp
index 6b3084e23d15..2e73cfcc438a 100644
--- a/src/test/fuzz/descriptor_parse.cpp
+++ b/src/test/fuzz/descriptor_parse.cpp
@@ -55,7 +55,11 @@ static void TestDescriptor(const Descriptor& desc, FlatSigningProvider& sig_prov
     }
 
     const auto max_sat_maxsig{desc.MaxSatisfactionWeight(true)};
-    const auto max_sat_nonmaxsig{desc.MaxSatisfactionWeight(true)};
+    const auto max_sat_nonmaxsig{desc.MaxSatisfactionWeight(false)};
+    // Whether an estimate is available must not depend on the signature-size
+    // assumption, and assuming non-max-size signatures must never increase it.
+    assert(max_sat_maxsig.has_value() == max_sat_nonmaxsig.has_value());
+    assert(max_sat_nonmaxsig <= max_sat_maxsig);
     const auto max_elems{desc.MaxSatisfactionElems()};
     // We must be able to estimate the max satisfaction size for any solvable descriptor (but combo).
     const bool is_nontop_or_nonsolvable{!*is_solvable || !desc.GetOutputType()};
diff --git a/src/test/fuzz/headerssync.cpp b/src/test/fuzz/headerssync.cpp
index f54ea980e4e5..54a179aa89fb 100644
--- a/src/test/fuzz/headerssync.cpp
+++ b/src/test/fuzz/headerssync.cpp
@@ -60,7 +60,7 @@ FUZZ_TARGET(headers_sync_state, .init = initialize_headers_sync_state_fuzz)
     CBlockHeader genesis_header{Params().GenesisBlock()};
     CBlockIndex start_index(genesis_header);
 
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider, /*min=*/start_index.GetMedianTimePast())};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider, /*min=*/start_index.GetMedianTimePast())};
 
     const uint256 genesis_hash = genesis_header.GetHash();
     start_index.phashBlock = &genesis_hash;
diff --git a/src/test/fuzz/i2p.cpp b/src/test/fuzz/i2p.cpp
index d262e1d0f319..5c94a19b8d82 100644
--- a/src/test/fuzz/i2p.cpp
+++ b/src/test/fuzz/i2p.cpp
@@ -27,7 +27,7 @@ FUZZ_TARGET(i2p, .init = initialize_i2p)
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
 
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
 
     // Mock CreateSock() to create FuzzedSock.
     auto CreateSockOrig = CreateSock;
diff --git a/src/test/fuzz/key.cpp b/src/test/fuzz/key.cpp
index e4bedff8b512..19101ae81c2d 100644
--- a/src/test/fuzz/key.cpp
+++ b/src/test/fuzz/key.cpp
@@ -85,7 +85,7 @@ FUZZ_TARGET(key, .init = initialize_key)
     {
         CKey child_key;
         ChainCode child_chaincode;
-        const bool ok = key.Derive(child_key, child_chaincode, 0, random_uint256);
+        const bool ok = key.Derive(child_key, child_chaincode, 0, ChainCode{random_uint256});
         assert(ok);
         assert(child_key.IsValid());
         assert(!(child_key == key));
@@ -275,7 +275,7 @@ FUZZ_TARGET(key, .init = initialize_key)
     {
         CPubKey child_pubkey;
         ChainCode child_chaincode;
-        const bool ok = pubkey.Derive(child_pubkey, child_chaincode, 0, random_uint256);
+        const bool ok = pubkey.Derive(child_pubkey, child_chaincode, 0, ChainCode{random_uint256});
         assert(ok);
         assert(child_pubkey != pubkey);
         assert(child_pubkey.IsCompressed());
diff --git a/src/test/fuzz/load_external_block_file.cpp b/src/test/fuzz/load_external_block_file.cpp
index 8b86f70dd237..be7e2bde8fb8 100644
--- a/src/test/fuzz/load_external_block_file.cpp
+++ b/src/test/fuzz/load_external_block_file.cpp
@@ -29,7 +29,7 @@ void initialize_load_external_block_file()
 FUZZ_TARGET(load_external_block_file, .init = initialize_load_external_block_file)
 {
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     FuzzedFileProvider fuzzed_file_provider{fuzzed_data_provider};
     AutoFile fuzzed_block_file{fuzzed_file_provider.open()};
     if (fuzzed_block_file.IsNull()) {
diff --git a/src/test/fuzz/mini_miner.cpp b/src/test/fuzz/mini_miner.cpp
index daa3dae34112..27bf32379221 100644
--- a/src/test/fuzz/mini_miner.cpp
+++ b/src/test/fuzz/mini_miner.cpp
@@ -49,7 +49,7 @@ FUZZ_TARGET(mini_miner, .init = initialize_miner)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     bilingual_str error;
     CTxMemPool pool{CTxMemPool::Options{}, error};
     Assert(error.empty());
diff --git a/src/test/fuzz/net.cpp b/src/test/fuzz/net.cpp
index 20fbae1594bd..93ea00cb94c4 100644
--- a/src/test/fuzz/net.cpp
+++ b/src/test/fuzz/net.cpp
@@ -32,7 +32,7 @@ void initialize_net()
 FUZZ_TARGET(net, .init = initialize_net)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     CNode node{ConsumeNode(fuzzed_data_provider)};
     node.SetCommonVersion(fuzzed_data_provider.ConsumeIntegral<int>());
     if (const auto service_opt =
@@ -81,7 +81,7 @@ FUZZ_TARGET(net, .init = initialize_net)
 FUZZ_TARGET(local_address, .init = initialize_net)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     CService service{ConsumeService(fuzzed_data_provider)};
     CNode node{ConsumeNode(fuzzed_data_provider)};
     {
diff --git a/src/test/fuzz/p2p_handshake.cpp b/src/test/fuzz/p2p_handshake.cpp
index 85b18476f1e1..affc63c9a163 100644
--- a/src/test/fuzz/p2p_handshake.cpp
+++ b/src/test/fuzz/p2p_handshake.cpp
@@ -41,7 +41,7 @@ FUZZ_TARGET(p2p_handshake, .init = ::initialize)
     auto& node{g_setup->m_node};
     auto& connman{static_cast<ConnmanTestMsg&>(*node.connman)};
     auto& chainman{static_cast<TestChainstateManager&>(*node.chainman)};
-    NodeClockContext clock_ctx{1610000000s}; // any time to successfully reset ibd
+    FakeNodeClock clock{1610000000s}; // any time to successfully reset ibd
     chainman.ResetIbd();
 
     node.banman.reset();
@@ -80,7 +80,7 @@ FUZZ_TARGET(p2p_handshake, .init = ::initialize)
             continue;
         }
 
-        clock_ctx += std::chrono::seconds{
+        clock += std::chrono::seconds{
                     fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(
                         -std::chrono::seconds{10min}.count(), // Allow mocktime to go backwards slightly
                         std::chrono::seconds{TIMEOUT_INTERVAL}.count()),
diff --git a/src/test/fuzz/p2p_headers_presync.cpp b/src/test/fuzz/p2p_headers_presync.cpp
index 0e60cb2aded0..d8a748ee6ea9 100644
--- a/src/test/fuzz/p2p_headers_presync.cpp
+++ b/src/test/fuzz/p2p_headers_presync.cpp
@@ -168,7 +168,7 @@ FUZZ_TARGET(p2p_headers_presync, .init = initialize)
 
     ChainstateManager& chainman = *g_testing_setup->m_node.chainman;
     CBlockHeader base{chainman.GetParams().GenesisBlock()};
-    const NodeClockContext clock_ctx{base.Time()};
+    const FakeNodeClock clock{base.Time()};
 
     LOCK(NetEventsInterface::g_msgproc_mutex);
 
diff --git a/src/test/fuzz/partially_downloaded_block.cpp b/src/test/fuzz/partially_downloaded_block.cpp
index 12fdb8f7d2e1..56815c4690d3 100644
--- a/src/test/fuzz/partially_downloaded_block.cpp
+++ b/src/test/fuzz/partially_downloaded_block.cpp
@@ -48,7 +48,7 @@ FUZZ_TARGET(partially_downloaded_block, .init = initialize_pdb)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
 
     auto block{ConsumeDeserializable<CBlock>(fuzzed_data_provider, TX_WITH_WITNESS)};
     if (!block || block->vtx.size() == 0 ||
diff --git a/src/test/fuzz/process_message.cpp b/src/test/fuzz/process_message.cpp
index 3ebedd919a22..f5d59891f25e 100644
--- a/src/test/fuzz/process_message.cpp
+++ b/src/test/fuzz/process_message.cpp
@@ -83,7 +83,7 @@ FUZZ_TARGET(process_message, .init = initialize_process_message)
     connman.Reset();
     auto& chainman{static_cast<TestChainstateManager&>(*node.chainman)};
     const auto block_index_size{WITH_LOCK(chainman.GetMutex(), return chainman.BlockIndex().size())};
-    NodeClockContext clock_ctx{1610000000s}; // any time to successfully reset ibd
+    FakeNodeClock clock{1610000000s}; // any time to successfully reset ibd
     chainman.ResetIbd();
     chainman.DisableNextWrite();
 
@@ -116,7 +116,7 @@ FUZZ_TARGET(process_message, .init = initialize_process_message)
     connman.AddTestNode(p2p_node);
     FillNode(fuzzed_data_provider, connman, p2p_node);
 
-    clock_ctx.set(ConsumeTime(fuzzed_data_provider));
+    clock.set(ConsumeTime(fuzzed_data_provider));
 
     CSerializedNetMsg net_msg;
     net_msg.m_type = random_message_type;
diff --git a/src/test/fuzz/process_messages.cpp b/src/test/fuzz/process_messages.cpp
index 21b445151879..68eb2b8ddb96 100644
--- a/src/test/fuzz/process_messages.cpp
+++ b/src/test/fuzz/process_messages.cpp
@@ -72,7 +72,7 @@ FUZZ_TARGET(process_messages, .init = initialize_process_messages)
     connman.Reset();
     auto& chainman{static_cast<TestChainstateManager&>(*node.chainman)};
     const auto block_index_size{WITH_LOCK(chainman.GetMutex(), return chainman.BlockIndex().size())};
-    NodeClockContext clock_ctx{1610000000s}; // any time to successfully reset ibd
+    FakeNodeClock clock{1610000000s}; // any time to successfully reset ibd
     chainman.ResetIbd();
     chainman.DisableNextWrite();
 
@@ -110,7 +110,7 @@ FUZZ_TARGET(process_messages, .init = initialize_process_messages)
     {
         const std::string random_message_type{fuzzed_data_provider.ConsumeBytesAsString(CMessageHeader::MESSAGE_TYPE_SIZE).c_str()};
 
-        clock_ctx.set(ConsumeTime(fuzzed_data_provider));
+        clock.set(ConsumeTime(fuzzed_data_provider));
 
         CSerializedNetMsg net_msg;
         net_msg.m_type = random_message_type;
diff --git a/src/test/fuzz/rbf.cpp b/src/test/fuzz/rbf.cpp
index 26488f1e9944..a94d2b9dc7a0 100644
--- a/src/test/fuzz/rbf.cpp
+++ b/src/test/fuzz/rbf.cpp
@@ -54,7 +54,7 @@ FUZZ_TARGET(rbf, .init = initialize_rbf)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     std::optional<CMutableTransaction> mtx = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider, TX_WITH_WITNESS);
     if (!mtx) {
         return;
@@ -96,7 +96,7 @@ FUZZ_TARGET(package_rbf, .init = initialize_package_rbf)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
 
     // "Real" virtual size is not important for this test since ConsumeTxMemPoolEntry generates its own virtual size values
     // so we construct small transactions for performance reasons. Child simply needs an input for later to perhaps connect to parent.
diff --git a/src/test/fuzz/rpc.cpp b/src/test/fuzz/rpc.cpp
index a6e486ce80d6..e3d3e540dcb5 100644
--- a/src/test/fuzz/rpc.cpp
+++ b/src/test/fuzz/rpc.cpp
@@ -372,7 +372,7 @@ FUZZ_TARGET(rpc, .init = initialize_rpc)
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
     bool good_data{true};
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     const std::string rpc_command = fuzzed_data_provider.ConsumeRandomLengthString(64);
     if (!g_limit_to_rpc_command.empty() && rpc_command != g_limit_to_rpc_command) {
         return;
diff --git a/src/test/fuzz/script_sign.cpp b/src/test/fuzz/script_sign.cpp
index 036b9ff3e49b..ba269beddd4e 100644
--- a/src/test/fuzz/script_sign.cpp
+++ b/src/test/fuzz/script_sign.cpp
@@ -67,7 +67,7 @@ FUZZ_TARGET(script_sign, .init = initialize_script_sign)
         }
         std::map<CPubKey, KeyOriginInfo> deserialized_hd_keypaths;
         try {
-            DeserializeHDKeypaths(serialized, key, hd_keypaths);
+            DeserializeHDKeypaths(serialized, key, deserialized_hd_keypaths);
         } catch (const std::ios_base::failure&) {
         }
         assert(hd_keypaths.size() >= deserialized_hd_keypaths.size());
diff --git a/src/test/fuzz/socks5.cpp b/src/test/fuzz/socks5.cpp
index 12db69a23687..0bd1710d2a88 100644
--- a/src/test/fuzz/socks5.cpp
+++ b/src/test/fuzz/socks5.cpp
@@ -31,7 +31,7 @@ void initialize_socks5()
 FUZZ_TARGET(socks5, .init = initialize_socks5)
 {
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     ProxyCredentials proxy_credentials;
     proxy_credentials.username = fuzzed_data_provider.ConsumeRandomLengthString(512);
     proxy_credentials.password = fuzzed_data_provider.ConsumeRandomLengthString(512);
diff --git a/src/test/fuzz/txdownloadman.cpp b/src/test/fuzz/txdownloadman.cpp
index a2c7fc562c9a..ab08fd254356 100644
--- a/src/test/fuzz/txdownloadman.cpp
+++ b/src/test/fuzz/txdownloadman.cpp
@@ -169,7 +169,7 @@ FUZZ_TARGET(txdownloadman, .init = initialize)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
 
     // Initialize txdownloadman
     bilingual_str error;
@@ -294,7 +294,7 @@ FUZZ_TARGET(txdownloadman_impl, .init = initialize)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
 
     // Initialize a TxDownloadManagerImpl
     bilingual_str error;
diff --git a/src/test/fuzz/txorphan.cpp b/src/test/fuzz/txorphan.cpp
index 394aed30ef65..fcb530b03da7 100644
--- a/src/test/fuzz/txorphan.cpp
+++ b/src/test/fuzz/txorphan.cpp
@@ -41,7 +41,7 @@ FUZZ_TARGET(txorphan, .init = initialize_orphanage)
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     FastRandomContext orphanage_rng{ConsumeUInt256(fuzzed_data_provider)};
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
 
     auto orphanage = node::MakeTxOrphanage();
     std::vector<COutPoint> outpoints; // Duplicates are tolerated
@@ -232,7 +232,7 @@ FUZZ_TARGET(txorphan_protected, .init = initialize_orphanage)
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     FastRandomContext orphanage_rng{ConsumeUInt256(fuzzed_data_provider)};
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
 
     // We have num_peers peers. Some subset of them will never exceed their reserved weight or announcement count, and
     // should therefore never have any orphans evicted.
diff --git a/src/test/fuzz/util/check_globals.cpp b/src/test/fuzz/util/check_globals.cpp
index ca3111534d3b..1c29906932c5 100644
--- a/src/test/fuzz/util/check_globals.cpp
+++ b/src/test/fuzz/util/check_globals.cpp
@@ -19,6 +19,7 @@ struct CheckGlobalsImpl {
         g_seeded_g_prng_zero = false;
         g_used_system_time = false;
         SetMockTime(0s);
+        MockableSteadyClock::ClearMockTime();
     }
     ~CheckGlobalsImpl()
     {
@@ -43,7 +44,7 @@ struct CheckGlobalsImpl {
                          "The current fuzz target accessed system time.\n\n"
 
                          "This is acceptable, but requires the fuzz target to use \n"
-                         "a NodeClockContext, SteadyClockContext or call \n"
+                         "a FakeNodeClock, SteadyClockContext or call \n"
                          "SetMockTime() at the \n" "beginning of processing the \n"
                          "fuzz input.\n\n"
 
diff --git a/src/test/fuzz/utxo_snapshot.cpp b/src/test/fuzz/utxo_snapshot.cpp
index ed286865d087..bfcf54ad3af5 100644
--- a/src/test/fuzz/utxo_snapshot.cpp
+++ b/src/test/fuzz/utxo_snapshot.cpp
@@ -89,8 +89,7 @@ void initialize_chain()
     if constexpr (INVALID) {
         auto& chainman{*setup->m_node.chainman};
         for (const auto& block : chain) {
-            BlockValidationState dummy;
-            bool processed{chainman.ProcessNewBlockHeaders({{*block}}, true, dummy)};
+            bool processed{chainman.ProcessNewBlockHeaders({{*block}}, true).IsValid()};
             Assert(processed);
             const auto* index{WITH_LOCK(::cs_main, return chainman.m_blockman.LookupBlockIndex(block->GetHash()))};
             Assert(index);
@@ -104,7 +103,7 @@ void utxo_snapshot_fuzz(FuzzBufferType buffer)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider, /*min=*/1296688602)}; // regtest genesis block timestamp
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider, /*min=*/1296688602)}; // regtest genesis block timestamp
     auto& setup{*g_setup};
     bool dirty_chainman{false}; // Reuse the global chainman, but reset it when it is dirty
     auto& chainman{*setup.m_node.chainman};
@@ -171,8 +170,7 @@ void utxo_snapshot_fuzz(FuzzBufferType buffer)
         // Consume the bool, but skip the code for the INVALID fuzz target
         if constexpr (!INVALID) {
             for (const auto& block : *g_chain) {
-                BlockValidationState dummy;
-                bool processed{chainman.ProcessNewBlockHeaders({{*block}}, true, dummy)};
+                bool processed{chainman.ProcessNewBlockHeaders({{*block}}, true).IsValid()};
                 Assert(processed);
                 const auto* index{WITH_LOCK(::cs_main, return chainman.m_blockman.LookupBlockIndex(block->GetHash()))};
                 Assert(index);
diff --git a/src/test/fuzz/utxo_total_supply.cpp b/src/test/fuzz/utxo_total_supply.cpp
index b59cbf997db6..a6e70372c32d 100644
--- a/src/test/fuzz/utxo_total_supply.cpp
+++ b/src/test/fuzz/utxo_total_supply.cpp
@@ -35,7 +35,7 @@ FUZZ_TARGET(utxo_total_supply)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider, /*min=*/1296688602)}; // regtest genesis block timestamp
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider, /*min=*/1296688602)}; // regtest genesis block timestamp
     /** The testing setup that creates a chainman only (no chainstate) */
     ChainTestingSetup test_setup{
         ChainType::REGTEST,
diff --git a/src/test/fuzz/validation_load_mempool.cpp b/src/test/fuzz/validation_load_mempool.cpp
index 9180945d0e7a..b859f2455695 100644
--- a/src/test/fuzz/validation_load_mempool.cpp
+++ b/src/test/fuzz/validation_load_mempool.cpp
@@ -41,7 +41,7 @@ FUZZ_TARGET(validation_load_mempool, .init = initialize_validation_load_mempool)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     FuzzedFileProvider fuzzed_file_provider{fuzzed_data_provider};
 
     bilingual_str error;
diff --git a/src/test/mempool_tests.cpp b/src/test/mempool_tests.cpp
index 77024c3edc6d..daaf2e61c28b 100644
--- a/src/test/mempool_tests.cpp
+++ b/src/test/mempool_tests.cpp
@@ -252,29 +252,29 @@ BOOST_AUTO_TEST_CASE(MempoolSizeLimitTest)
     TryAddToMempool(pool, entry.Fee(900LL).FromTx(tx7));
 
     std::vector<CTransactionRef> vtx;
-    NodeClockContext clock_ctx{42s};
+    FakeNodeClock clock{42s};
     constexpr std::chrono::seconds HALFLIFE{CTxMemPool::ROLLING_FEE_HALFLIFE};
-    clock_ctx += HALFLIFE;
+    clock += HALFLIFE;
     BOOST_CHECK_EQUAL(pool.GetMinFee(1).GetFeePerK(), maxFeeRateRemoved.GetFeePerK() + DEFAULT_INCREMENTAL_RELAY_FEE);
     // ... we should keep the same min fee until we get a block
     pool.removeForBlock(vtx, 1);
-    clock_ctx += HALFLIFE;
+    clock += HALFLIFE;
     BOOST_CHECK_EQUAL(pool.GetMinFee(1).GetFeePerK(), llround((maxFeeRateRemoved.GetFeePerK() + DEFAULT_INCREMENTAL_RELAY_FEE)/2.0));
     // ... then feerate should drop 1/2 each halflife
 
-    clock_ctx += HALFLIFE / 2;
+    clock += HALFLIFE / 2;
     BOOST_CHECK_EQUAL(pool.GetMinFee(pool.DynamicMemoryUsage() * 5 / 2).GetFeePerK(), llround((maxFeeRateRemoved.GetFeePerK() + DEFAULT_INCREMENTAL_RELAY_FEE)/4.0));
     // ... with a 1/2 halflife when mempool is < 1/2 its target size
 
-    clock_ctx += HALFLIFE / 4;
+    clock += HALFLIFE / 4;
     BOOST_CHECK_EQUAL(pool.GetMinFee(pool.DynamicMemoryUsage() * 9 / 2).GetFeePerK(), llround((maxFeeRateRemoved.GetFeePerK() + DEFAULT_INCREMENTAL_RELAY_FEE)/8.0));
     // ... with a 1/4 halflife when mempool is < 1/4 its target size
 
-    clock_ctx += 5 * HALFLIFE;
+    clock += 5 * HALFLIFE;
     BOOST_CHECK_EQUAL(pool.GetMinFee(1).GetFeePerK(), DEFAULT_INCREMENTAL_RELAY_FEE);
     // ... but feerate should never drop below DEFAULT_INCREMENTAL_RELAY_FEE
 
-    clock_ctx += HALFLIFE;
+    clock += HALFLIFE;
     BOOST_CHECK_EQUAL(pool.GetMinFee(1).GetFeePerK(), 0);
     // ... unless it has gone all the way to 0 (after getting past DEFAULT_INCREMENTAL_RELAY_FEE/2)
 }
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index fd9559b543c4..2c1983fa15be 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -26,13 +26,13 @@
 #include <test/util/common.h>
 #include <test/util/setup_common.h>
 #include <test/util/transaction_utils.h>
+#include <test/util/time.h>
 #include <test/util/txmempool.h>
 #include <txmempool.h>
 #include <uint256.h>
 #include <util/check.h>
 #include <util/feefrac.h>
 #include <util/strencodings.h>
-#include <util/time.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <versionbits.h>
@@ -342,6 +342,8 @@ std::vector<CTransactionRef> CreateBigSigOpsCluster(const CTransactionRef& first
 
 void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst, int baseheight)
 {
+    FakeNodeClock clock{};
+
     Txid hash;
     CMutableTransaction tx;
     TestMemPoolEntryHelper entry;
@@ -565,7 +567,7 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
     LOCK(tx_mempool.cs);
 
     // non-final txs in mempool
-    SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1);
+    clock.set(std::chrono::seconds{m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1});
     const int flags{LOCKTIME_VERIFY_SEQUENCE};
     // height map
     std::vector<int> prevheights;
@@ -670,7 +672,7 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
         ancestor->nTime += SEQUENCE_LOCK_TIME; // Trick the MedianTimePast
     }
     m_node.chainman->ActiveChain().Tip()->nHeight++;
-    SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1);
+    clock.set(std::chrono::seconds{m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1});
 
     block_template = mining->createNewBlock(options, /*cooldown=*/false);
     BOOST_REQUIRE(block_template);
@@ -896,12 +898,10 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
     TestBasicMining(scriptPubKey, txFirst, baseheight);
 
     m_node.chainman->ActiveChain().Tip()->nHeight--;
-    SetMockTime(0);
 
     TestPackageSelection(scriptPubKey, txFirst);
 
     m_node.chainman->ActiveChain().Tip()->nHeight--;
-    SetMockTime(0);
 
     TestPrioritisedMining(scriptPubKey, txFirst);
 }
diff --git a/src/test/net_tests.cpp b/src/test/net_tests.cpp
index 32801d97b8bd..a2b647509a95 100644
--- a/src/test/net_tests.cpp
+++ b/src/test/net_tests.cpp
@@ -3,6 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <addrman.h>
+#include <bip324.h>
 #include <chainparams.h>
 #include <clientversion.h>
 #include <common/args.h>
@@ -802,6 +803,41 @@ BOOST_AUTO_TEST_CASE(LocalAddress_BasicLifecycle)
     BOOST_CHECK(!IsLocal(addr));
 }
 
+BOOST_AUTO_TEST_CASE(LocalAddress_nScore_Overflow)
+{
+    g_reachable_nets.Add(NET_IPV4);
+    const CService addr{UtilBuildAddress(0x002, 0x001, 0x001, 0x001), 1000}; // 2.1.1.1:1000
+
+    const auto get_score = [](const CService& service) -> int {
+        LOCK(g_maplocalhost_mutex);
+        const auto it = mapLocalHost.find(service);
+        return it != mapLocalHost.end() ? it->second.nScore : 0;
+    };
+
+    const int initial_score = 1000;
+    BOOST_REQUIRE(AddLocal(addr, initial_score));
+    BOOST_REQUIRE(IsLocal(addr));
+    BOOST_CHECK_EQUAL(get_score(addr), initial_score);
+
+    // SeenLocal should increment nScore by 1.
+    BOOST_CHECK(SeenLocal(addr));
+    BOOST_CHECK_EQUAL(get_score(addr), initial_score + 1);
+
+    // AddLocal() saturates nScore when updating an existing entry at INT_MAX.
+    BOOST_REQUIRE(AddLocal(addr, std::numeric_limits<int>::max()));
+    BOOST_CHECK_EQUAL(get_score(addr), std::numeric_limits<int>::max());
+
+    BOOST_CHECK(AddLocal(addr, std::numeric_limits<int>::max()));
+    BOOST_CHECK_EQUAL(get_score(addr), std::numeric_limits<int>::max());
+
+    // SeenLocal() also saturates at INT_MAX.
+    BOOST_CHECK(SeenLocal(addr));
+    BOOST_CHECK_EQUAL(get_score(addr), std::numeric_limits<int>::max());
+
+    RemoveLocal(addr);
+    BOOST_CHECK(!IsLocal(addr));
+}
+
 BOOST_AUTO_TEST_CASE(initial_advertise_from_version_message)
 {
     LOCK(NetEventsInterface::g_msgproc_mutex);
@@ -1533,7 +1569,7 @@ BOOST_AUTO_TEST_CASE(v2transport_test)
         tester.CompareSessionIDs();
         auto msg_data_1 = m_rng.randbytes<uint8_t>(4000000); // test that receiving 4M payload works
         auto msg_data_2 = m_rng.randbytes<uint8_t>(4000000); // test that sending 4M payload works
-        tester.SendMessage(uint8_t(m_rng.randrange(223) + 33), {}); // unknown short id
+        tester.SendMessage(uint8_t(m_rng.randrange(256 - BIP324_SHORTIDS_IMPLEMENTED) + BIP324_SHORTIDS_IMPLEMENTED), {}); // unknown short id
         tester.SendMessage(uint8_t(2), msg_data_1); // "block" short id
         tester.AddMessage("blocktxn", msg_data_2); // schedule blocktxn to be sent to us
         ret = tester.Interact();
diff --git a/src/test/orphanage_tests.cpp b/src/test/orphanage_tests.cpp
index f001360a1774..c09f987aca47 100644
--- a/src/test/orphanage_tests.cpp
+++ b/src/test/orphanage_tests.cpp
@@ -432,7 +432,7 @@ BOOST_AUTO_TEST_CASE(DoS_mapOrphans)
     FillableSigningProvider keystore;
     BOOST_CHECK(keystore.AddKey(key));
 
-    NodeClockContext clock_ctx{};
+    FakeNodeClock clock{};
 
     std::vector<CTransactionRef> orphans_added;
 
diff --git a/src/test/pcp_tests.cpp b/src/test/pcp_tests.cpp
index 51b004a5d525..8ecbab58d255 100644
--- a/src/test/pcp_tests.cpp
+++ b/src/test/pcp_tests.cpp
@@ -92,7 +92,6 @@ class PCPTestSock final : public Sock
           m_local_ip(local_ip),
           m_gateway_ip(gateway_ip)
     {
-        ElapseTime(std::chrono::seconds(0)); // start mocking steady time
         PrepareOp();
     }
 
@@ -193,10 +192,10 @@ class PCPTestSock final : public Sock
     {
         // Only handles receive events.
         if (AtEndOfScript() || requested != Sock::RECV) {
-            ElapseTime(timeout);
+            m_clock += timeout;
         } else {
             std::chrono::milliseconds delay = std::min(m_time_left, timeout);
-            ElapseTime(delay);
+            m_clock += delay;
             m_time_left -= delay;
             if (CurOp().op == TestOp::RECV && m_time_left == 0s && occurred != nullptr) {
                 *occurred = Sock::RECV;
@@ -223,18 +222,12 @@ class PCPTestSock final : public Sock
     const std::vector<TestOp> m_script;
     mutable size_t m_script_ptr = 0;
     mutable std::chrono::milliseconds m_time_left;
-    mutable std::chrono::milliseconds m_time{MockableSteadyClock::INITIAL_MOCK_TIME};
+    mutable SteadyClockContext m_clock{};
     mutable bool m_connected{false};
     mutable CService m_bound;
     mutable CNetAddr m_local_ip;
     mutable CNetAddr m_gateway_ip;
 
-    void ElapseTime(std::chrono::milliseconds duration) const
-    {
-        m_time += duration;
-        MockableSteadyClock::SetMockTime(m_time);
-    }
-
     bool AtEndOfScript() const { return m_script_ptr == m_script.size(); }
     const TestOp &CurOp() const {
         BOOST_REQUIRE(m_script_ptr < m_script.size());
diff --git a/src/test/peerman_tests.cpp b/src/test/peerman_tests.cpp
index 9044e9c2e1a0..a2d88ea5302d 100644
--- a/src/test/peerman_tests.cpp
+++ b/src/test/peerman_tests.cpp
@@ -12,8 +12,8 @@
 #include <protocol.h>
 #include <sync.h>
 #include <test/util/setup_common.h>
+#include <test/util/time.h>
 #include <util/check.h>
-#include <util/time.h>
 #include <validation.h>
 #include <validationinterface.h>
 
@@ -27,17 +27,17 @@ BOOST_FIXTURE_TEST_SUITE(peerman_tests, RegTestingSetup)
 /** Window, in blocks, for connecting to NODE_NETWORK_LIMITED peers */
 static constexpr int64_t NODE_NETWORK_LIMITED_ALLOW_CONN_BLOCKS = 144;
 
-static void mineBlock(node::NodeContext& node, std::chrono::seconds block_time)
+static void mineBlock(node::NodeContext& node, FakeNodeClock& clock, std::chrono::seconds block_time)
 {
     auto curr_time = GetTime<std::chrono::seconds>();
-    SetMockTime(block_time); // update time so the block is created with it
+    clock.set(block_time); // update time so the block is created with it
     auto mining{interfaces::MakeMining(node)};
     auto block_template{mining->createNewBlock({}, /*cooldown=*/false)};
     BOOST_REQUIRE(block_template);
     CBlock block{block_template->getBlock()};
     while (!CheckProofOfWork(block.GetHash(), block.nBits, node.chainman->GetConsensus())) ++block.nNonce;
     block.fChecked = true; // little speedup
-    SetMockTime(curr_time); // process block at current time
+    clock.set(curr_time); // process block at current time
     Assert(node.chainman->ProcessNewBlock(std::make_shared<const CBlock>(block), /*force_processing=*/true, /*min_pow_checked=*/true, nullptr));
     node.validation_signals->SyncWithValidationInterfaceQueue(); // drain events queue
 }
@@ -45,6 +45,7 @@ static void mineBlock(node::NodeContext& node, std::chrono::seconds block_time)
 // Verifying when network-limited peer connections are desirable based on the node's proximity to the tip
 BOOST_AUTO_TEST_CASE(connections_desirable_service_flags)
 {
+    FakeNodeClock clock{};
     std::unique_ptr<PeerManager> peerman = PeerManager::make(*m_node.connman, *m_node.addrman, nullptr, *m_node.chainman, *m_node.mempool, *m_node.warnings, {});
     auto consensus = m_node.chainman->GetParams().GetConsensus();
 
@@ -58,15 +59,15 @@ BOOST_AUTO_TEST_CASE(connections_desirable_service_flags)
     int tip_block_height = tip->nHeight;
     peerman->SetBestBlock(tip_block_height, std::chrono::seconds{tip_block_time});
 
-    SetMockTime(tip_block_time + 1); // Set node time to tip time
+    clock.set(std::chrono::seconds{tip_block_time + 1}); // Set node time to tip time
     BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS));
 
     // Check we don't disallow limited peers connections when we are behind but still recoverable (below the connection safety window)
-    SetMockTime(GetTime<std::chrono::seconds>() + std::chrono::seconds{consensus.nPowTargetSpacing * (NODE_NETWORK_LIMITED_ALLOW_CONN_BLOCKS - 1)});
+    clock += std::chrono::seconds{consensus.nPowTargetSpacing * (NODE_NETWORK_LIMITED_ALLOW_CONN_BLOCKS - 1)};
     BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS));
 
     // Check we disallow limited peers connections when we are further than the limited peers safety window
-    SetMockTime(GetTime<std::chrono::seconds>() + std::chrono::seconds{consensus.nPowTargetSpacing * 2});
+    clock += std::chrono::seconds{consensus.nPowTargetSpacing * 2};
     BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK | NODE_WITNESS));
 
     // By now, we tested that the connections desirable services flags change based on the node's time proximity to the tip.
@@ -75,15 +76,15 @@ BOOST_AUTO_TEST_CASE(connections_desirable_service_flags)
 
     // First, verify a block in the past doesn't enable limited peers connections
     // At this point, our time is (NODE_NETWORK_LIMITED_ALLOW_CONN_BLOCKS + 1) * 10 minutes ahead the tip's time.
-    mineBlock(m_node, /*block_time=*/std::chrono::seconds{tip_block_time + 1});
+    mineBlock(m_node, clock, /*block_time=*/std::chrono::seconds{tip_block_time + 1});
     BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK | NODE_WITNESS));
 
     // Verify a block close to the tip enables limited peers connections
-    mineBlock(m_node, /*block_time=*/GetTime<std::chrono::seconds>());
+    mineBlock(m_node, clock, /*block_time=*/GetTime<std::chrono::seconds>());
     BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS));
 
     // Lastly, verify the stale tip checks can disallow limited peers connections after not receiving blocks for a prolonged period.
-    SetMockTime(GetTime<std::chrono::seconds>() + std::chrono::seconds{consensus.nPowTargetSpacing * NODE_NETWORK_LIMITED_ALLOW_CONN_BLOCKS + 1});
+    clock += std::chrono::seconds{consensus.nPowTargetSpacing * NODE_NETWORK_LIMITED_ALLOW_CONN_BLOCKS + 1};
     BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK | NODE_WITNESS));
 }
 
diff --git a/src/test/private_broadcast_tests.cpp b/src/test/private_broadcast_tests.cpp
index 048284b23db1..8e7d13551ae6 100644
--- a/src/test/private_broadcast_tests.cpp
+++ b/src/test/private_broadcast_tests.cpp
@@ -5,6 +5,7 @@
 #include <primitives/transaction.h>
 #include <private_broadcast.h>
 #include <test/util/setup_common.h>
+#include <test/util/time.h>
 #include <util/time.h>
 
 #include <algorithm>
@@ -26,7 +27,7 @@ static CTransactionRef MakeDummyTx(uint32_t id, size_t num_witness)
 
 BOOST_AUTO_TEST_CASE(basic)
 {
-    SetMockTime(Now<NodeSeconds>());
+    FakeNodeClock clock{};
 
     PrivateBroadcast pb;
     const NodeId recipient1{1};
@@ -94,7 +95,7 @@ BOOST_AUTO_TEST_CASE(basic)
     BOOST_CHECK_EQUAL(pb.GetStale().size(), 0);
 
     // 2. Fast-forward the mock clock past the INITIAL_STALE_DURATION.
-    SetMockTime(Now<NodeSeconds>() + PrivateBroadcast::INITIAL_STALE_DURATION + 1min);
+    clock += PrivateBroadcast::INITIAL_STALE_DURATION + 1min;
 
     // 3. Now that the initial duration has passed, both unconfirmed transactions should be stale.
     BOOST_CHECK_EQUAL(pb.GetStale().size(), 2);
@@ -125,7 +126,7 @@ BOOST_AUTO_TEST_CASE(basic)
     BOOST_CHECK_EQUAL(stale_state.size(), 1);
     BOOST_CHECK_EQUAL(stale_state[0], tx_for_recipient2);
 
-    SetMockTime(Now<NodeSeconds>() + 10h);
+    clock += 10h;
 
     BOOST_CHECK_EQUAL(pb.GetStale().size(), 2);
 
@@ -141,7 +142,7 @@ BOOST_AUTO_TEST_CASE(basic)
 
 BOOST_AUTO_TEST_CASE(stale_unpicked_tx)
 {
-    SetMockTime(Now<NodeSeconds>());
+    FakeNodeClock clock{};
 
     PrivateBroadcast pb;
     const auto tx{MakeDummyTx(/*id=*/42, /*num_witness=*/0)};
@@ -149,9 +150,9 @@ BOOST_AUTO_TEST_CASE(stale_unpicked_tx)
 
     // Unpicked transactions use the longer INITIAL_STALE_DURATION.
     BOOST_CHECK_EQUAL(pb.GetStale().size(), 0);
-    SetMockTime(Now<NodeSeconds>() + PrivateBroadcast::INITIAL_STALE_DURATION - 1min);
+    clock += PrivateBroadcast::INITIAL_STALE_DURATION - 1min;
     BOOST_CHECK_EQUAL(pb.GetStale().size(), 0);
-    SetMockTime(Now<NodeSeconds>() + 2min);
+    clock += 2min;
     const auto stale_state{pb.GetStale()};
     BOOST_REQUIRE_EQUAL(stale_state.size(), 1);
     BOOST_CHECK_EQUAL(stale_state[0], tx);
diff --git a/src/test/rpc_tests.cpp b/src/test/rpc_tests.cpp
index 1b6dbda0d925..390cd50c3c33 100644
--- a/src/test/rpc_tests.cpp
+++ b/src/test/rpc_tests.cpp
@@ -11,6 +11,7 @@
 #include <rpc/util.h>
 #include <test/util/common.h>
 #include <test/util/setup_common.h>
+#include <test/util/time.h>
 #include <univalue.h>
 #include <util/time.h>
 
@@ -341,10 +342,9 @@ BOOST_AUTO_TEST_CASE(rpc_ban)
 
     BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
 
-    auto now = 10'000s;
-    SetMockTime(now);
+    FakeNodeClock clock{10'000s};
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0/24 add 200")));
-    SetMockTime(now += 2s);
+    clock += 2s;
     const int64_t time_remaining_expected{198};
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
@@ -355,7 +355,7 @@ BOOST_AUTO_TEST_CASE(rpc_ban)
     const int64_t ban_duration{o1.find_value("ban_duration").getInt<int64_t>()};
     const int64_t time_remaining{o1.find_value("time_remaining").getInt<int64_t>()};
     BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/24");
-    BOOST_CHECK_EQUAL(banned_until, time_remaining_expected + now.count());
+    BOOST_CHECK_EQUAL(banned_until, time_remaining_expected + TicksSinceEpoch<std::chrono::seconds>(NodeClock::now()));
     BOOST_CHECK_EQUAL(ban_duration, banned_until - ban_created);
     BOOST_CHECK_EQUAL(time_remaining, time_remaining_expected);
 
diff --git a/src/test/serialize_tests.cpp b/src/test/serialize_tests.cpp
index f646ba5fafbd..9c2f16f03e30 100644
--- a/src/test/serialize_tests.cpp
+++ b/src/test/serialize_tests.cpp
@@ -9,6 +9,7 @@
 #include <test/util/setup_common.h>
 #include <util/strencodings.h>
 
+#include <algorithm>
 #include <cstdint>
 #include <string>
 
@@ -241,6 +242,40 @@ BOOST_AUTO_TEST_CASE(noncanonical)
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure, isCanonicalException);
 }
 
+BOOST_AUTO_TEST_CASE(string_view)
+{
+    const std::string_view sv{"hello, world"};
+    DataStream ss;
+    ss << sv;
+    std::string s;
+    ss >> s;
+    BOOST_CHECK_EQUAL(sv, s);
+}
+
+BOOST_AUTO_TEST_CASE(limited_vector)
+{
+    const std::vector<int> v = {1,2,3,4,-5,-6,-7,-8,-9,-10,10000,20000,-30000};
+
+    auto check = [&]<size_t N>() {
+        DataStream ss;
+        ss << v;
+        try {
+            std::vector<int> r;
+            ss >> LIMITED_VECTOR(r, N);
+            BOOST_CHECK_LE(r.size(), N);
+            BOOST_CHECK(std::ranges::equal(r, v));
+        } catch (const std::ios_base::failure&) {
+            BOOST_CHECK_GT(v.size(), N);
+        }
+    };
+    check.operator()<0>();
+    check.operator()<10>();
+    check.operator()<12>();
+    check.operator()<13>();
+    check.operator()<14>();
+    check.operator()<100>();
+}
+
 BOOST_AUTO_TEST_CASE(class_methods)
 {
     int intval(100);
diff --git a/src/test/settings_tests.cpp b/src/test/settings_tests.cpp
index 54d3b0581186..0d8e3b1b7aee 100644
--- a/src/test/settings_tests.cpp
+++ b/src/test/settings_tests.cpp
@@ -101,7 +101,7 @@ BOOST_AUTO_TEST_CASE(ReadWrite)
     // Check invalid json not allowed
     WriteText(path, R"(invalid json)");
     BOOST_CHECK(!common::ReadSettings(path, values, errors));
-    std::vector<std::string> fail_parse = {strprintf("Settings file %s does not contain valid JSON. This is probably caused by disk corruption or a crash, "
+    std::vector<std::string> fail_parse = {strprintf("Settings file %s does not contain valid JSON. This may be caused by a crash, power loss, full disk, or storage error, "
                                                      "and can be fixed by removing the file, which will reset settings to default values.",
                                                      fs::PathToString(path))};
     BOOST_CHECK_EQUAL_COLLECTIONS(errors.begin(), errors.end(), fail_parse.begin(), fail_parse.end());
diff --git a/src/test/testnet4_miner_tests.cpp b/src/test/testnet4_miner_tests.cpp
index ccd12cb23f7f..ecaec1d18c6b 100644
--- a/src/test/testnet4_miner_tests.cpp
+++ b/src/test/testnet4_miner_tests.cpp
@@ -42,7 +42,7 @@ BOOST_AUTO_TEST_CASE(MiningInterface)
 
     // Set node time a few minutes past the testnet4 genesis block
     const auto template_time{3min + WITH_LOCK(cs_main, return m_node.chainman->ActiveChain().Tip()->Time())};
-    NodeClockContext clock_ctx{template_time};
+    FakeNodeClock clock{template_time};
 
     block_template = mining->createNewBlock({}, /*cooldown=*/false);
     BOOST_REQUIRE(block_template);
@@ -57,14 +57,14 @@ BOOST_AUTO_TEST_CASE(MiningInterface)
     BOOST_REQUIRE(should_be_nullptr == nullptr);
 
     // This remains the case when exactly 20 minutes have gone by
-    clock_ctx += 17min;
+    clock += 17min;
     should_be_nullptr = block_template->waitNext(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;
+    clock += 1s;
     block_template = block_template->waitNext(wait_options);
     BOOST_REQUIRE(block_template);
 }
diff --git a/src/test/util/logging.h b/src/test/util/logging.h
index ed3ee19e1bbf..6df208d841d5 100644
--- a/src/test/util/logging.h
+++ b/src/test/util/logging.h
@@ -39,6 +39,6 @@ class DebugLogHelper
     MatchFn m_match;
 };
 
-#define ASSERT_DEBUG_LOG(message) DebugLogHelper UNIQUE_NAME(debugloghelper)(message)
+#define ASSERT_DEBUG_LOG(message) DebugLogHelper BITCOIN_UNIQUE_NAME(debugloghelper)(message)
 
 #endif // BITCOIN_TEST_UTIL_LOGGING_H
diff --git a/src/test/util/net.cpp b/src/test/util/net.cpp
index c4850c64cfd3..1415c8d4968e 100644
--- a/src/test/util/net.cpp
+++ b/src/test/util/net.cpp
@@ -56,7 +56,7 @@ void ConnmanTestMsg::Handshake(CNode& node,
     FlushSendBuffer(node); // Drop the verack message added by SendMessages.
     if (node.fDisconnect) return;
     assert(node.nVersion == version);
-    assert(node.GetCommonVersion() == std::min(version, PROTOCOL_VERSION));
+    assert(node.GetCommonVersion() == std::min(version, node.AdvertisedVersion()));
     CNodeStateStats statestats;
     assert(peerman.GetNodeStateStats(node.GetId(), statestats));
     assert(statestats.m_relay_txs == (relay_txs && !node.IsBlockOnlyConn()));
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index d7b7b29d5841..8097494dfa31 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -416,7 +416,6 @@ TestChain100Setup::TestChain100Setup(
     TestOpts opts)
     : TestingSetup{ChainType::REGTEST, opts}
 {
-    SetMockTime(1598887952);
     constexpr std::array<unsigned char, 32> vchKey = {
         {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}};
     coinbaseKey.Set(vchKey.begin(), vchKey.end(), true);
@@ -438,7 +437,7 @@ void TestChain100Setup::mineBlocks(int num_blocks)
     for (int i = 0; i < num_blocks; i++) {
         std::vector<CMutableTransaction> noTxns;
         CBlock b = CreateAndProcessBlock(noTxns, scriptPubKey);
-        SetMockTime(GetTime() + 1);
+        m_clock += 1s;
         m_coinbase_txns.push_back(b.vtx[0]);
     }
 }
diff --git a/src/test/util/setup_common.h b/src/test/util/setup_common.h
index 62bfaba9a970..d03f5baefb87 100644
--- a/src/test/util/setup_common.h
+++ b/src/test/util/setup_common.h
@@ -14,6 +14,7 @@
 #include <primitives/transaction.h>
 #include <random.h>
 #include <test/util/random.h>
+#include <test/util/time.h>
 #include <util/chaintype.h> // IWYU pragma: export
 #include <util/fs.h>
 #include <util/signalinterrupt.h>
@@ -226,6 +227,7 @@ struct TestChain100Setup : public TestingSetup {
      */
     std::vector<CTransactionRef> PopulateMempool(FastRandomContext& det_rand, size_t num_transactions, bool submit);
 
+    FakeNodeClock m_clock{std::chrono::seconds{1598887952}}; // 2020-08-31, arbitrary
     std::vector<CTransactionRef> m_coinbase_txns; // For convenience, coinbase transactions
     CKey coinbaseKey; // private/public key needed to spend coinbase transactions
 };
diff --git a/src/test/util/time.h b/src/test/util/time.h
index 8cd9a1dafcb9..2bc2553fea26 100644
--- a/src/test/util/time.h
+++ b/src/test/util/time.h
@@ -8,10 +8,24 @@
 #include <util/check.h>
 #include <util/time.h>
 
+/// CRTP Helper to limit a class to at most one at a time.
+template <class T>
+class LimitOne
+{
+public:
+    LimitOne() { Assert(g_T_available) = false; }
+    ~LimitOne() { g_T_available = true; }
+    LimitOne(const LimitOne&) = delete;
+    LimitOne& operator=(const LimitOne&) = delete;
+
+private:
+    static inline bool g_T_available{true};
+};
+
 
 /// Helper to initialize the global MockableSteadyClock, let a duration elapse,
 /// and reset it after use in a test.
-class SteadyClockContext
+class SteadyClockContext : public LimitOne<SteadyClockContext>
 {
     MockableSteadyClock::mock_time_point::duration t{MockableSteadyClock::INITIAL_MOCK_TIME};
 
@@ -36,22 +50,22 @@ class SteadyClockContext
 
 /// Helper to initialize the global NodeClock, let a duration elapse,
 /// and reset it after use in a test.
-class NodeClockContext
+class FakeNodeClock : public LimitOne<FakeNodeClock>
 {
     NodeSeconds m_t{std::chrono::seconds::max()};
 
 public:
     /// Initialize with the given time.
-    explicit NodeClockContext(NodeSeconds init_time) { set(init_time); }
-    explicit NodeClockContext(std::chrono::seconds init_time) { set(init_time); }
-    /// Initialize with current time, using the next tick to avoid going back by rounding to seconds.
-    explicit NodeClockContext() { set(++Now<NodeSeconds>().time_since_epoch()); }
+    explicit FakeNodeClock(NodeSeconds init_time) { set(init_time); }
+    explicit FakeNodeClock(std::chrono::seconds init_time) { set(init_time); }
+    /// Initialize with current time.
+    explicit FakeNodeClock() { set(Now<NodeSeconds>()); }
 
     /// Unset mocktime.
-    ~NodeClockContext() { set(0s); }
+    ~FakeNodeClock() { set(0s); }
 
-    NodeClockContext(const NodeClockContext&) = delete;
-    NodeClockContext& operator=(const NodeClockContext&) = delete;
+    FakeNodeClock(const FakeNodeClock&) = delete;
+    FakeNodeClock& operator=(const FakeNodeClock&) = delete;
 
     /// Set mocktime.
     void set(NodeSeconds t) { SetMockTime(m_t = t); }
diff --git a/src/test/util/transaction_utils.cpp b/src/test/util/transaction_utils.cpp
index b65a9568c65d..cf4ed9346690 100644
--- a/src/test/util/transaction_utils.cpp
+++ b/src/test/util/transaction_utils.cpp
@@ -7,7 +7,7 @@
 #include <script/signingprovider.h>
 #include <test/util/transaction_utils.h>
 
-CMutableTransaction BuildCreditingTransaction(const CScript& scriptPubKey, int nValue)
+CMutableTransaction BuildCreditingTransaction(const CScript& scriptPubKey, CAmount nValue)
 {
     CMutableTransaction txCredit;
     txCredit.version = 1;
diff --git a/src/test/util/transaction_utils.h b/src/test/util/transaction_utils.h
index 867554f80570..ca643f0be52f 100644
--- a/src/test/util/transaction_utils.h
+++ b/src/test/util/transaction_utils.h
@@ -15,7 +15,7 @@ class CCoinsViewCache;
 
 // create crediting transaction
 // [1 coinbase input => 1 output with given scriptPubkey and value]
-CMutableTransaction BuildCreditingTransaction(const CScript& scriptPubKey, int nValue = 0);
+CMutableTransaction BuildCreditingTransaction(const CScript& scriptPubKey, CAmount nValue = 0);
 
 // create spending transaction
 // [1 input with referenced transaction outpoint, scriptSig, scriptWitness =>
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
index 5747c3b080e8..e26234f8696b 100644
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -587,7 +587,7 @@ BOOST_AUTO_TEST_CASE(strprintf_numbers)
 
 BOOST_AUTO_TEST_CASE(util_mocktime)
 {
-    NodeClockContext clock_ctx{111s};
+    FakeNodeClock clock{111s};
     // Check that mock time does not change after a sleep
     for (const auto& num_sleep : {0ms, 1ms}) {
         UninterruptibleSleep(num_sleep);
diff --git a/src/test/util_threadnames_tests.cpp b/src/test/util_threadnames_tests.cpp
index f22eb12dcf1c..e10553b8222f 100644
--- a/src/test/util_threadnames_tests.cpp
+++ b/src/test/util_threadnames_tests.cpp
@@ -17,7 +17,7 @@ using util::ToString;
 
 BOOST_AUTO_TEST_SUITE(util_threadnames_tests)
 
-const std::string TEST_THREAD_NAME_BASE = "test_thread.";
+const std::string TEST_THREAD_NAME_BASE = "test_thrd.";
 
 /**
  * Run a bunch of threads to all call util::ThreadRename.
@@ -56,7 +56,7 @@ BOOST_AUTO_TEST_CASE(util_threadnames_test_rename_threaded)
 
     BOOST_CHECK_EQUAL(names.size(), 100U);
 
-    // Names "test_thread.[n]" should exist for n = [0, 99]
+    // Names "test_thrd.[n]" should exist for n = [0, 99]
     for (int i = 0; i < 100; ++i) {
         BOOST_CHECK(names.contains(TEST_THREAD_NAME_BASE + ToString(i)));
     }
diff --git a/src/test/validation_block_tests.cpp b/src/test/validation_block_tests.cpp
index 5de893768d10..caf82d3dc75b 100644
--- a/src/test/validation_block_tests.cpp
+++ b/src/test/validation_block_tests.cpp
@@ -120,8 +120,7 @@ std::shared_ptr<CBlock> MinerTestingSetup::FinalizeBlock(std::shared_ptr<CBlock>
 
     // submit block header, so that miner can get the block height from the
     // global state and the node has the topology of the chain
-    BlockValidationState ignored;
-    BOOST_CHECK(Assert(m_node.chainman)->ProcessNewBlockHeaders({{*pblock}}, true, ignored));
+    BOOST_CHECK(Assert(m_node.chainman)->ProcessNewBlockHeaders({{*pblock}}, true).IsValid());
 
     return pblock;
 }
@@ -383,4 +382,10 @@ BOOST_AUTO_TEST_CASE(witness_commitment_index)
 
     BOOST_CHECK_EQUAL(GetWitnessCommitmentIndex(pblock), 2);
 }
+
+BOOST_AUTO_TEST_CASE(test_empty_process_new_block_headers)
+{
+    auto res = m_node.chainman->ProcessNewBlockHeaders({}, true);
+    BOOST_CHECK(res.IsValid());
+}
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/validation_chainstate_tests.cpp b/src/test/validation_chainstate_tests.cpp
index 141c67da4a70..f75a00c7e954 100644
--- a/src/test/validation_chainstate_tests.cpp
+++ b/src/test/validation_chainstate_tests.cpp
@@ -154,11 +154,10 @@ BOOST_FIXTURE_TEST_CASE(chainstate_update_tip, TestChain100Setup)
     // once it is changed to support multiple chainstates.
     {
         LOCK(::cs_main);
-        bool checked = CheckBlock(*pblockone, state, chainparams.GetConsensus());
-        BOOST_CHECK(checked);
-        bool accepted = chainman.AcceptBlock(
-            pblockone, state, &pindex, true, nullptr, &newblock, true);
-        BOOST_CHECK(accepted);
+        state = CheckBlock(*pblockone, chainparams.GetConsensus());
+        BOOST_CHECK(state.IsValid());
+        state = chainman.AcceptBlock(pblockone, &pindex, true, nullptr, &newblock, true);
+        BOOST_CHECK(state.IsValid());
     }
 
     // UpdateTip is called here
diff --git a/src/btcsignals.h b/src/util/btcsignals.h
similarity index 80%
rename from src/btcsignals.h
rename to src/util/btcsignals.h
index ebe7a5acb783..1da402986621 100644
--- a/src/btcsignals.h
+++ b/src/util/btcsignals.h
@@ -2,8 +2,8 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef BITCOIN_BTCSIGNALS_H
-#define BITCOIN_BTCSIGNALS_H
+#ifndef BITCOIN_UTIL_BTCSIGNALS_H
+#define BITCOIN_UTIL_BTCSIGNALS_H
 
 #include <sync.h>
 
@@ -30,21 +30,23 @@
 
 namespace btcsignals {
 
-/*
- * optional_last_value is the default and only supported combiner.
- * As such, its behavior is embedded into the signal functor.
- *
- * Because optional<void> is undefined, void must be special-cased.
- */
+/// The default combiner, which only returns void.
+class null_value
+{
+public:
+    using result_type = void;
+};
 
-template <typename T>
-class optional_last_value
+/// A combiner, which checks if at least one callback returned true.
+class any_of
 {
 public:
-    using result_type = std::conditional_t<std::is_void_v<T>, void, std::optional<T>>;
+    // This is the only supported combiner with a non-void return type. As
+    // such, its behavior is embedded into the signal functor.
+    using result_type = bool;
 };
 
-template <typename Signature, typename Combiner = optional_last_value<typename std::function<Signature>::result_type>>
+template <typename Signature, typename Combiner = null_value>
 class signal;
 
 /*
@@ -120,14 +122,14 @@ class scoped_connection
     connection m_conn;
 
 public:
-    scoped_connection(connection rhs) noexcept : m_conn{std::move(rhs)} {}
+    explicit scoped_connection(connection rhs) noexcept : m_conn{std::move(rhs)} {}
 
     scoped_connection(scoped_connection&&) noexcept = default;
-    scoped_connection& operator=(scoped_connection&&) noexcept = default;
 
     /**
-     * For simplicity, disable copy assignment and construction.
+     * For simplicity, disable copy construction and copy/move assignment.
      */
+    scoped_connection& operator=(scoped_connection&&) = delete;
     scoped_connection& operator=(const scoped_connection&) = delete;
     scoped_connection(const scoped_connection&) = delete;
 
@@ -150,8 +152,6 @@ class signal
 {
     using function_type = std::function<Signature>;
 
-    static_assert(std::is_same_v<Combiner, optional_last_value<typename function_type::result_type>>, "only the optional_last_value combiner is supported");
-
     /*
      * Helper struct for maintaining a callback and its associated connection liveness
      */
@@ -184,9 +184,7 @@ class signal
 
     /*
      * Execute all enabled callbacks for the signal. Rather than allowing for
-     * custom combiners, the behavior of optional_last_value is hard-coded
-     * here. Return the value of the last executed callback, or nullopt if none
-     * were executed.
+     * custom combiners, the behavior of any_of is hard-coded here.
      *
      * Callbacks which return void require special handling.
      *
@@ -200,7 +198,7 @@ class signal
      * more than one callback is enabled.
      */
     template <typename... Args>
-    result_type operator()(Args&&... args) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
+    [[nodiscard]] result_type operator()(Args&&... args) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
     {
         std::vector<std::shared_ptr<connection_holder>> connections;
         {
@@ -208,16 +206,22 @@ class signal
             connections = m_connections;
         }
         if constexpr (std::is_void_v<result_type>) {
+            static_assert(std::is_same_v<result_type, typename function_type::result_type>,
+                          "Callback result type must be equal to the combiner result type (void).");
             for (const auto& connection : connections) {
                 if (connection->connected()) {
                     connection->m_callback(args...);
                 }
             }
         } else {
-            result_type ret{std::nullopt};
+            static_assert(std::is_same_v<Combiner, any_of>,
+                          "only the any_of combiner is supported and hard-coded into this functor.");
+            static_assert(std::is_same_v<result_type, typename function_type::result_type>,
+                          "Callback result type must be equal to the combiner result type (bool).");
+            result_type ret{false};
             for (const auto& connection : connections) {
                 if (connection->connected()) {
-                    ret.emplace(connection->m_callback(args...));
+                    ret |= connection->m_callback(args...);
                 }
             }
             return ret;
@@ -254,4 +258,4 @@ class signal
 
 } // namespace btcsignals
 
-#endif // BITCOIN_BTCSIGNALS_H
+#endif // BITCOIN_UTIL_BTCSIGNALS_H
diff --git a/src/util/fs_helpers.cpp b/src/util/fs_helpers.cpp
index 097fbef9af39..bc0179b55ac9 100644
--- a/src/util/fs_helpers.cpp
+++ b/src/util/fs_helpers.cpp
@@ -10,12 +10,14 @@
 #include <sync.h>
 #include <tinyformat.h>
 #include <util/byte_units.h> // IWYU pragma: keep
+#include <util/check.h>
 #include <util/fs.h>
 #include <util/log.h>
 #include <util/syserror.h>
 
 #include <cerrno>
 #include <fstream>
+#include <limits>
 #include <map>
 #include <memory>
 #include <optional>
@@ -154,27 +156,40 @@ bool TruncateFile(FILE* file, unsigned int length)
 #endif
 }
 
-/**
- * this function tries to raise the file descriptor limit to the requested number.
- * It returns the actual file descriptor limit (which may be more or less than nMinFD)
- */
-int RaiseFileDescriptorLimit(int nMinFD)
+int RaiseFileDescriptorLimit(int min_fd)
 {
+    Assert(min_fd >= 0);
 #if defined(WIN32)
     return 2048;
 #else
     struct rlimit limitFD;
     if (getrlimit(RLIMIT_NOFILE, &limitFD) != -1) {
-        if (limitFD.rlim_cur < (rlim_t)nMinFD) {
-            limitFD.rlim_cur = nMinFD;
-            if (limitFD.rlim_cur > limitFD.rlim_max)
+        // If the current soft limit is already higher, don't raise it
+        if (limitFD.rlim_cur != RLIM_INFINITY && std::cmp_less(limitFD.rlim_cur, min_fd)) {
+            const auto current_limit{limitFD.rlim_cur};
+            static_assert(std::in_range<rlim_t>(std::numeric_limits<int>::max()));
+            limitFD.rlim_cur = static_cast<rlim_t>(min_fd);
+            // Don't raise soft limit beyond hard limit
+            if ((limitFD.rlim_max != RLIM_INFINITY) && (limitFD.rlim_cur > limitFD.rlim_max)) {
                 limitFD.rlim_cur = limitFD.rlim_max;
-            setrlimit(RLIMIT_NOFILE, &limitFD);
-            getrlimit(RLIMIT_NOFILE, &limitFD);
+            }
+            if (current_limit != limitFD.rlim_cur) {
+                setrlimit(RLIMIT_NOFILE, &limitFD);
+                getrlimit(RLIMIT_NOFILE, &limitFD);
+            }
+        }
+        // Check the (possibly raised) current soft limit against the special
+        // value of RLIM_INFINITY. Some platforms implement this as the maximum
+        // uint64, others as int64 (-1). Avoid casting even if the return type
+        // is changed to uint64_t. We also cap unlikely but possible values
+        // that would overflow int.
+        if (limitFD.rlim_cur == RLIM_INFINITY ||
+            std::cmp_greater_equal(limitFD.rlim_cur, std::numeric_limits<int>::max())) {
+            return std::numeric_limits<int>::max();
         }
-        return limitFD.rlim_cur;
+        return static_cast<int>(limitFD.rlim_cur);
     }
-    return nMinFD; // getrlimit failed, assume it's fine
+    return min_fd; // getrlimit failed, assume it's fine
 #endif
 }
 
diff --git a/src/util/fs_helpers.h b/src/util/fs_helpers.h
index f4d406f75f0f..a2399d4e97f6 100644
--- a/src/util/fs_helpers.h
+++ b/src/util/fs_helpers.h
@@ -45,7 +45,18 @@ bool FileCommit(FILE* file);
 void DirectoryCommit(const fs::path& dirname);
 
 bool TruncateFile(FILE* file, unsigned int length);
-int RaiseFileDescriptorLimit(int nMinFD);
+
+/**
+ * Try to raise the file descriptor limit to the requested number.
+ *
+ * @param[in] min_fd  The requested minimum number of file descriptors.
+ * @returns           The actual file descriptor limit. It may be lower or
+ *                    higher than min_fd. Returns std::numeric_limits<int>::max()
+ *                    if the OS imposes no limit (RLIM_INFINITY).
+ *
+ */
+int RaiseFileDescriptorLimit(int min_fd);
+
 void AllocateFileRange(FILE* file, unsigned int offset, unsigned int length);
 
 /**
diff --git a/src/util/macros.h b/src/util/macros.h
index 9ad2fa6ef46b..eedd23c69265 100644
--- a/src/util/macros.h
+++ b/src/util/macros.h
@@ -8,7 +8,7 @@
 #define PASTE(x, y) x ## y
 #define PASTE2(x, y) PASTE(x, y)
 
-#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
+#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
 
 /**
  * Converts the parameter X to a string after macro replacement on X has been performed.
diff --git a/src/util/stdmutex.h b/src/util/stdmutex.h
index ab89a987685c..d2ac1ba195e3 100644
--- a/src/util/stdmutex.h
+++ b/src/util/stdmutex.h
@@ -38,6 +38,6 @@ class LOCKABLE StdMutex : public std::mutex
 };
 
 // Provide STDLOCK(..) wrapper around StdMutex::Guard that checks the lock is not already held
-#define STDLOCK(cs) StdMutex::Guard UNIQUE_NAME(criticalblock){StdMutex::CheckNotHeld(cs)}
+#define STDLOCK(cs) StdMutex::Guard BITCOIN_UNIQUE_NAME(criticalblock){StdMutex::CheckNotHeld(cs)}
 
 #endif // BITCOIN_UTIL_STDMUTEX_H
diff --git a/src/util/strencodings.cpp b/src/util/strencodings.cpp
index 5edc686ca584..47574b1f17f7 100644
--- a/src/util/strencodings.cpp
+++ b/src/util/strencodings.cpp
@@ -10,7 +10,6 @@
 #include <util/check.h>
 #include <util/overflow.h>
 
-#include <compare>
 #include <limits>
 #include <optional>
 #include <sstream>
diff --git a/src/util/threadnames.cpp b/src/util/threadnames.cpp
index 0615b331994d..a9a3649b0b91 100644
--- a/src/util/threadnames.cpp
+++ b/src/util/threadnames.cpp
@@ -3,6 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <util/threadnames.h>
+#include <util/check.h>
 
 #include <algorithm>
 #include <cstring>
@@ -53,6 +54,7 @@ static void SetInternalName(const std::string& name)
 
 void util::ThreadRename(const std::string& name)
 {
+    Assume(name.size() <= 13); // Linux keeps 15 bytes
     SetThreadName(("b-" + name).c_str());
     SetInternalName(name);
 }
diff --git a/src/util/threadpool.h b/src/util/threadpool.h
index ff0590f860a5..6c1685152573 100644
--- a/src/util/threadpool.h
+++ b/src/util/threadpool.h
@@ -112,7 +112,7 @@ class ThreadPool
         // Create workers
         m_workers.reserve(num_workers);
         for (int i = 0; i < num_workers; i++) {
-            m_workers.emplace_back(&util::TraceThread, strprintf("%s_pool_%d", m_name, i), [this] { WorkerThread(); });
+            m_workers.emplace_back(&util::TraceThread, strprintf("%s.%02d", m_name, i), [this] { WorkerThread(); });
         }
     }
 
diff --git a/src/util/time.h b/src/util/time.h
index 119c47a4e8e8..2e54ff85a709 100644
--- a/src/util/time.h
+++ b/src/util/time.h
@@ -23,7 +23,7 @@
 using namespace std::chrono_literals;
 
 /// Version of the system clock that is mockable in the context of tests (via
-/// NodeClockContext or ::SetMockTime), otherwise the system clock.
+/// FakeNodeClock or ::SetMockTime), otherwise the system clock.
 struct NodeClock : public std::chrono::system_clock {
     using time_point = std::chrono::time_point<NodeClock>;
     /** Return current system time or mocked time, if set */
diff --git a/src/validation.cpp b/src/validation.cpp
index 8a4986b49517..eb277d656a2d 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1798,8 +1798,7 @@ MempoolAcceptResult AcceptToMemoryPool(Chainstate& active_chainstate, const CTra
         );
     }
     // After we've (potentially) uncached entries, ensure our coins cache is still within its size limits
-    BlockValidationState state_dummy;
-    active_chainstate.FlushStateToDisk(state_dummy, FlushStateMode::PERIODIC);
+    /*state=*/active_chainstate.FlushStateToDisk(FlushStateMode::PERIODIC);
     return result;
 }
 
@@ -1830,8 +1829,7 @@ PackageMempoolAcceptResult ProcessNewPackage(Chainstate& active_chainstate, CTxM
         }
     }
     // Ensure the coins cache is still within limits.
-    BlockValidationState state_dummy;
-    active_chainstate.FlushStateToDisk(state_dummy, FlushStateMode::PERIODIC);
+    /*state=*/active_chainstate.FlushStateToDisk(FlushStateMode::PERIODIC);
     return result;
 }
 
@@ -2132,10 +2130,12 @@ bool CheckInputScripts(const CTransaction& tx, TxValidationState& state,
     return true;
 }
 
-bool FatalError(Notifications& notifications, BlockValidationState& state, const bilingual_str& message)
+BlockValidationState FatalError(Notifications& notifications, const bilingual_str& message)
 {
     notifications.fatalError(message);
-    return state.Error(message.original);
+    BlockValidationState state;
+    /*ret=*/state.Error(message.original);
+    return state;
 }
 
 /**
@@ -2316,12 +2316,14 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
     // is enforced in ContextualCheckBlockHeader(); we wouldn't want to
     // re-enforce that rule here (at least until we make it impossible for
     // the clock to go backward).
-    if (!CheckBlock(block, state, params.GetConsensus(), !fJustCheck, !fJustCheck)) {
+    state = CheckBlock(block, params.GetConsensus(), !fJustCheck, !fJustCheck);
+    if (!state.IsValid()) {
         if (state.GetResult() == BlockValidationResult::BLOCK_MUTATED) {
             // We don't write down blocks to disk if they may have been
             // corrupted, so this should be impossible unless we're having hardware
             // problems.
-            return FatalError(m_chainman.GetNotifications(), state, _("Corrupt block found indicating potential hardware failure."));
+            state = FatalError(m_chainman.GetNotifications(), _("Corrupt block found indicating potential hardware failure."));
+            return false;
         }
         LogError("%s: Consensus::CheckBlock: %s\n", __func__, state.ToString());
         return false;
@@ -2697,8 +2699,7 @@ CoinsCacheSizeState Chainstate::GetCoinsCacheSizeState(
     return CoinsCacheSizeState::OK;
 }
 
-bool Chainstate::FlushStateToDisk(
-    BlockValidationState &state,
+BlockValidationState Chainstate::FlushStateToDisk(
     FlushStateMode mode,
     int nManualPruneHeight)
 {
@@ -2715,7 +2716,6 @@ bool Chainstate::FlushStateToDisk(
         bool fFlushForPrune = false;
 
         CoinsCacheSizeState cache_state = GetCoinsCacheSizeState();
-        LOCK(m_blockman.cs_LastBlockFile);
         if (m_blockman.IsPruneMode() && (m_blockman.m_check_for_pruning || nManualPruneHeight > 0) && m_chainman.m_blockman.m_blockfiles_indexed) {
             // make sure we don't prune above any of the prune locks bestblocks
             // pruning is height-based
@@ -2774,7 +2774,7 @@ bool Chainstate::FlushStateToDisk(
 
             // Ensure we can write block index
             if (!CheckDiskSpace(m_blockman.m_opts.blocks_dir)) {
-                return FatalError(m_chainman.GetNotifications(), state, _("Disk space is too low!"));
+                return FatalError(m_chainman.GetNotifications(), _("Disk space is too low!"));
             }
             {
                 LOG_TIME_MILLIS_WITH_CATEGORY("write block and undo data to disk", BCLog::BENCH);
@@ -2807,7 +2807,7 @@ bool Chainstate::FlushStateToDisk(
                 // an overestimation, as most will delete an existing entry or
                 // overwrite one. Still, use a conservative safety factor of 2.
                 if (!CheckDiskSpace(m_chainman.m_options.datadir, 48 * 2 * 2 * CoinsTip().GetDirtyCount())) {
-                    return FatalError(m_chainman.GetNotifications(), state, _("Disk space is too low!"));
+                    return FatalError(m_chainman.GetNotifications(), _("Disk space is too low!"));
                 }
                 // Flush the chainstate (which may refer to block index entries).
                 empty_cache ? CoinsTip().Flush() : CoinsTip().Sync();
@@ -2831,24 +2831,22 @@ bool Chainstate::FlushStateToDisk(
         m_chainman.m_options.signals->ChainStateFlushed(this->GetRole(), GetLocator(m_chain.Tip()));
     }
     } catch (const std::runtime_error& e) {
-        return FatalError(m_chainman.GetNotifications(), state, strprintf(_("System error while flushing: %s"), e.what()));
+        return FatalError(m_chainman.GetNotifications(), strprintf(_("System error while flushing: %s"), e.what()));
     }
-    return true;
+    return BlockValidationState{};
 }
 
 void Chainstate::ForceFlushStateToDisk(bool wipe_cache)
 {
-    BlockValidationState state;
-    if (!this->FlushStateToDisk(state, wipe_cache ? FlushStateMode::FORCE_FLUSH : FlushStateMode::FORCE_SYNC)) {
+    if (auto state = this->FlushStateToDisk(wipe_cache ? FlushStateMode::FORCE_FLUSH : FlushStateMode::FORCE_SYNC); !state.IsValid()) {
         LogWarning("Failed to force flush state (%s)", state.ToString());
     }
 }
 
 void Chainstate::PruneAndFlush()
 {
-    BlockValidationState state;
     m_blockman.m_check_for_pruning = true;
-    if (!this->FlushStateToDisk(state, FlushStateMode::NONE)) {
+    if (auto state = this->FlushStateToDisk(FlushStateMode::NONE); !state.IsValid()) {
         LogWarning("Failed to flush state (%s)", state.ToString());
     }
 }
@@ -2965,7 +2963,8 @@ bool Chainstate::DisconnectTip(BlockValidationState& state, DisconnectedBlockTra
     }
 
     // Write the chain state to disk, if necessary.
-    if (!FlushStateToDisk(state, FlushStateMode::IF_NEEDED)) {
+    state = FlushStateToDisk(FlushStateMode::IF_NEEDED);
+    if (!state.IsValid()) {
         return false;
     }
 
@@ -3016,7 +3015,8 @@ bool Chainstate::ConnectTip(
     if (!block_to_connect) {
         std::shared_ptr<CBlock> pblockNew = std::make_shared<CBlock>();
         if (!m_blockman.ReadBlock(*pblockNew, *pindexNew)) {
-            return FatalError(m_chainman.GetNotifications(), state, _("Failed to read block."));
+            state = FatalError(m_chainman.GetNotifications(), _("Failed to read block."));
+            return false;
         }
         block_to_connect = std::move(pblockNew);
     } else {
@@ -3058,7 +3058,8 @@ bool Chainstate::ConnectTip(
              Ticks<SecondsDouble>(m_chainman.time_flush),
              Ticks<MillisecondsDouble>(m_chainman.time_flush) / m_chainman.num_blocks_total);
     // Write the chain state to disk, if necessary.
-    if (!FlushStateToDisk(state, FlushStateMode::IF_NEEDED)) {
+    state = FlushStateToDisk(FlushStateMode::IF_NEEDED);
+    if (!state.IsValid()) {
         return false;
     }
     const auto time_5{SteadyClock::now()};
@@ -3199,7 +3200,7 @@ bool Chainstate::ActivateBestChainStep(BlockValidationState& state, CBlockIndex&
             // If we're unable to disconnect a block during normal operation,
             // then that is a failure of our local system -- we should abort
             // rather than stay on a less work chain.
-            FatalError(m_chainman.GetNotifications(), state, _("Failed to disconnect block."));
+            state = FatalError(m_chainman.GetNotifications(), _("Failed to disconnect block."));
             return false;
         }
         fBlocksDisconnected = true;
@@ -3445,7 +3446,8 @@ bool Chainstate::ActivateBestChain(BlockValidationState& state, std::shared_ptr<
             }
 
             // Write changes periodically to disk, after relay.
-            if (!FlushStateToDisk(state, FlushStateMode::PERIODIC)) {
+            state = FlushStateToDisk(FlushStateMode::PERIODIC);
+            if (!state.IsValid()) {
                 return false;
             }
 
@@ -3816,40 +3818,46 @@ void ChainstateManager::ReceivedBlockTransactions(const CBlock& block, CBlockInd
     }
 }
 
-static bool CheckBlockHeader(const CBlockHeader& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true)
+[[nodiscard]] static const BlockValidationState CheckBlockHeader(const CBlockHeader& block, const Consensus::Params& consensusParams, bool fCheckPOW = true)
 {
+    BlockValidationState state;
     // Check proof of work matches claimed amount
-    if (fCheckPOW && !CheckProofOfWork(block.GetHash(), block.nBits, consensusParams))
-        return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "high-hash", "proof of work failed");
-
-    return true;
+    if (fCheckPOW && !CheckProofOfWork(block.GetHash(), block.nBits, consensusParams)) {
+        /*ret=*/state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "high-hash", "proof of work failed");
+        return state;
+    }
+    return state;
 }
 
-static bool CheckMerkleRoot(const CBlock& block, BlockValidationState& state)
+[[nodiscard]] static const BlockValidationState CheckMerkleRoot(const CBlock& block)
 {
-    if (block.m_checked_merkle_root) return true;
+    if (block.m_checked_merkle_root) return BlockValidationState{};
 
     bool mutated;
     uint256 merkle_root = BlockMerkleRoot(block, &mutated);
     if (block.hashMerkleRoot != merkle_root) {
-        return state.Invalid(
+        BlockValidationState state;
+        /*ret=*/state.Invalid(
             /*result=*/BlockValidationResult::BLOCK_MUTATED,
             /*reject_reason=*/"bad-txnmrklroot",
             /*debug_message=*/"hashMerkleRoot mismatch");
+        return state;
     }
 
     // Check for merkle tree malleability (CVE-2012-2459): repeating sequences
     // of transactions in a block without affecting the merkle root of a block,
     // while still invalidating it.
     if (mutated) {
-        return state.Invalid(
+        BlockValidationState state;
+        /*ret=*/state.Invalid(
             /*result=*/BlockValidationResult::BLOCK_MUTATED,
             /*reject_reason=*/"bad-txns-duplicate",
             /*debug_message=*/"duplicate transaction");
+        return state;
     }
 
     block.m_checked_merkle_root = true;
-    return true;
+    return BlockValidationState{};
 }
 
 /** CheckWitnessMalleation performs checks for block malleation with regard to
@@ -3858,10 +3866,11 @@ static bool CheckMerkleRoot(const CBlock& block, BlockValidationState& state)
  * Note: If the witness commitment is expected (i.e. `expect_witness_commitment
  * = true`), then the block is required to have at least one transaction and the
  * first transaction needs to have at least one input. */
-static bool CheckWitnessMalleation(const CBlock& block, bool expect_witness_commitment, BlockValidationState& state)
+static const BlockValidationState CheckWitnessMalleation(const CBlock& block, bool expect_witness_commitment)
 {
+    BlockValidationState state;
     if (expect_witness_commitment) {
-        if (block.m_checked_witness_commitment) return true;
+        if (block.m_checked_witness_commitment) return state;
 
         int commitpos = GetWitnessCommitmentIndex(block);
         if (commitpos != NO_WITNESS_COMMITMENT) {
@@ -3869,10 +3878,11 @@ static bool CheckWitnessMalleation(const CBlock& block, bool expect_witness_comm
             const auto& witness_stack{block.vtx[0]->vin[0].scriptWitness.stack};
 
             if (witness_stack.size() != 1 || witness_stack[0].size() != 32) {
-                return state.Invalid(
+                /*ret=*/state.Invalid(
                     /*result=*/BlockValidationResult::BLOCK_MUTATED,
                     /*reject_reason=*/"bad-witness-nonce-size",
                     /*debug_message=*/strprintf("%s : invalid witness reserved value size", __func__));
+                return state;
             }
 
             // The malleation check is ignored; as the transaction tree itself
@@ -3882,50 +3892,56 @@ static bool CheckWitnessMalleation(const CBlock& block, bool expect_witness_comm
 
             CHash256().Write(hash_witness).Write(witness_stack[0]).Finalize(hash_witness);
             if (memcmp(hash_witness.begin(), &block.vtx[0]->vout[commitpos].scriptPubKey[6], 32)) {
-                return state.Invalid(
+                /*ret=*/state.Invalid(
                     /*result=*/BlockValidationResult::BLOCK_MUTATED,
                     /*reject_reason=*/"bad-witness-merkle-match",
                     /*debug_message=*/strprintf("%s : witness merkle commitment mismatch", __func__));
+                return state;
             }
 
             block.m_checked_witness_commitment = true;
-            return true;
+            return state;
         }
     }
 
     // No witness data is allowed in blocks that don't commit to witness data, as this would otherwise leave room for spam
     for (const auto& tx : block.vtx) {
         if (tx->HasWitness()) {
-            return state.Invalid(
+            /*ret=*/state.Invalid(
                 /*result=*/BlockValidationResult::BLOCK_MUTATED,
                 /*reject_reason=*/"unexpected-witness",
                 /*debug_message=*/strprintf("%s : unexpected witness data found", __func__));
+            return state;
         }
     }
 
-    return true;
+    return state;
 }
 
-bool CheckBlock(const CBlock& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW, bool fCheckMerkleRoot)
+BlockValidationState CheckBlock(const CBlock& block, const Consensus::Params& consensusParams, bool fCheckPOW, bool fCheckMerkleRoot)
 {
     // These are checks that are independent of context.
 
     if (block.fChecked)
-        return true;
+        return BlockValidationState{};
 
     // Check that the header is valid (particularly PoW).  This is mostly
     // redundant with the call in AcceptBlockHeader.
-    if (!CheckBlockHeader(block, state, consensusParams, fCheckPOW))
-        return false;
+    if (const auto state = CheckBlockHeader(block, consensusParams, fCheckPOW); !state.IsValid())
+        return state;
 
     // Signet only: check block solution
     if (consensusParams.signet_blocks && fCheckPOW && !CheckSignetBlockSolution(block, consensusParams)) {
-        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-signet-blksig", "signet block signature validation failure");
+        BlockValidationState state;
+        state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-signet-blksig", "signet block signature validation failure");
+        return state;
     }
 
     // Check the merkle root.
-    if (fCheckMerkleRoot && !CheckMerkleRoot(block, state)) {
-        return false;
+    if (fCheckMerkleRoot) {
+        if (const auto state = CheckMerkleRoot(block); !state.IsValid()) {
+            return state;
+        }
     }
 
     // All potential-corruption validation must be done before we do any
@@ -3935,15 +3951,25 @@ bool CheckBlock(const CBlock& block, BlockValidationState& state, const Consensu
     // checks that use witness data may be performed here.
 
     // Size limits
-    if (block.vtx.empty() || block.vtx.size() * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT || ::GetSerializeSize(TX_NO_WITNESS(block)) * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT)
-        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-length", "size limits failed");
+    if (block.vtx.empty() || block.vtx.size() * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT || ::GetSerializeSize(TX_NO_WITNESS(block)) * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT) {
+        BlockValidationState state;
+        state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-length", "size limits failed");
+        return state;
+    }
 
     // First transaction must be coinbase, the rest must not be
-    if (block.vtx.empty() || !block.vtx[0]->IsCoinBase())
-        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-missing", "first tx is not coinbase");
-    for (unsigned int i = 1; i < block.vtx.size(); i++)
-        if (block.vtx[i]->IsCoinBase())
-            return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-multiple", "more than one coinbase");
+    if (block.vtx.empty() || !block.vtx[0]->IsCoinBase()) {
+        BlockValidationState state;
+        state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-missing", "first tx is not coinbase");
+        return state;
+    }
+    for (unsigned int i = 1; i < block.vtx.size(); i++) {
+        if (block.vtx[i]->IsCoinBase()) {
+            BlockValidationState state;
+            state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-multiple", "more than one coinbase");
+            return state;
+        }
+    }
 
     // Check transactions
     // Must check for duplicate inputs (see CVE-2018-17144)
@@ -3953,8 +3979,10 @@ bool CheckBlock(const CBlock& block, BlockValidationState& state, const Consensu
             // CheckBlock() does context-free validation checks. The only
             // possible failures are consensus failures.
             assert(tx_state.GetResult() == TxValidationResult::TX_CONSENSUS);
-            return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
+            BlockValidationState state;
+            state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
                                  strprintf("Transaction check failed (tx hash %s) %s", tx->GetHash().ToString(), tx_state.GetDebugMessage()));
+            return state;
         }
     }
     // This underestimates the number of sigops, because unlike ConnectBlock it
@@ -3964,13 +3992,16 @@ bool CheckBlock(const CBlock& block, BlockValidationState& state, const Consensu
     {
         nSigOps += GetLegacySigOpCount(*tx);
     }
-    if (nSigOps * WITNESS_SCALE_FACTOR > MAX_BLOCK_SIGOPS_COST)
-        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-sigops", "out-of-bounds SigOpCount");
+    if (nSigOps * WITNESS_SCALE_FACTOR > MAX_BLOCK_SIGOPS_COST) {
+        BlockValidationState state;
+        state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-sigops", "out-of-bounds SigOpCount");
+        return state;
+    }
 
     if (fCheckPOW && fCheckMerkleRoot)
         block.fChecked = true;
 
-    return true;
+    return BlockValidationState{};
 }
 
 void ChainstateManager::UpdateUncommittedBlockStructures(CBlock& block, const CBlockIndex* pindexPrev) const
@@ -4017,8 +4048,7 @@ bool HasValidProofOfWork(std::span<const CBlockHeader> headers, const Consensus:
 
 bool IsBlockMutated(const CBlock& block, bool check_witness_root)
 {
-    BlockValidationState state;
-    if (!CheckMerkleRoot(block, state)) {
+    if (const auto state = CheckMerkleRoot(block); !state.IsValid()) {
         LogDebug(BCLog::VALIDATION, "Block mutated: %s\n", state.ToString());
         return true;
     }
@@ -4038,7 +4068,7 @@ bool IsBlockMutated(const CBlock& block, bool check_witness_root)
         // here as it requires at least 224 bits of work.
     }
 
-    if (!CheckWitnessMalleation(block, check_witness_root, state)) {
+    if (const auto state = CheckWitnessMalleation(block, check_witness_root); !state.IsValid()) {
         LogDebug(BCLog::VALIDATION, "Block mutated: %s\n", state.ToString());
         return true;
     }
@@ -4068,20 +4098,25 @@ arith_uint256 CalculateClaimedHeadersWork(std::span<const CBlockHeader> headers)
  *  v0.12 and v0.15 (when no additional protection was in place) whereby an attacker could unboundedly
  *  grow our in-memory block index. See https://bitcoincore.org/en/2024/07/03/disclose-header-spam.
  */
-static bool ContextualCheckBlockHeader(const CBlockHeader& block, BlockValidationState& state, const ChainstateManager& chainman, const CBlockIndex* pindexPrev) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
+[[nodiscard]] static const BlockValidationState ContextualCheckBlockHeader(const CBlockHeader& block, const ChainstateManager& chainman, const CBlockIndex* pindexPrev) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
 {
     AssertLockHeld(::cs_main);
     assert(pindexPrev != nullptr);
     const int nHeight = pindexPrev->nHeight + 1;
+    BlockValidationState state;
 
     // Check proof of work
     const Consensus::Params& consensusParams = chainman.GetConsensus();
-    if (block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams))
-        return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "bad-diffbits", "incorrect proof of work");
+    if (block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams)) {
+        state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "bad-diffbits", "incorrect proof of work");
+        return state;
+    }
 
     // Check timestamp against prev
-    if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast())
-        return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "time-too-old", "block's timestamp is too early");
+    if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast()) {
+        state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "time-too-old", "block's timestamp is too early");
+        return state;
+    }
 
     // Testnet4 and regtest only: Check timestamp against prev for difficulty-adjustment
     // blocks to prevent timewarp attacks (see https://github.com/bitcoin/bitcoin/pull/15482).
@@ -4090,25 +4125,28 @@ static bool ContextualCheckBlockHeader(const CBlockHeader& block, BlockValidatio
         // interval, except the genesis block.
         if (nHeight % consensusParams.DifficultyAdjustmentInterval() == 0) {
             if (block.GetBlockTime() < pindexPrev->GetBlockTime() - MAX_TIMEWARP) {
-                return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "time-timewarp-attack", "block's timestamp is too early on diff adjustment block");
+                state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "time-timewarp-attack", "block's timestamp is too early on diff adjustment block");
+                return state;
             }
         }
     }
 
     // Check timestamp
     if (block.Time() > NodeClock::now() + std::chrono::seconds{MAX_FUTURE_BLOCK_TIME}) {
-        return state.Invalid(BlockValidationResult::BLOCK_TIME_FUTURE, "time-too-new", "block timestamp too far in the future");
+        state.Invalid(BlockValidationResult::BLOCK_TIME_FUTURE, "time-too-new", "block timestamp too far in the future");
+        return state;
     }
 
     // Reject blocks with outdated version
     if ((block.nVersion < 2 && DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_HEIGHTINCB)) ||
         (block.nVersion < 3 && DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_DERSIG)) ||
         (block.nVersion < 4 && DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_CLTV))) {
-            return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, strprintf("bad-version(0x%08x)", block.nVersion),
+            state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, strprintf("bad-version(0x%08x)", block.nVersion),
                                  strprintf("rejected nVersion=0x%08x block", block.nVersion));
+            return state;
     }
 
-    return true;
+    return BlockValidationState{};
 }
 
 /** NOTE: This function is not currently invoked by ConnectBlock(), so we
@@ -4117,7 +4155,7 @@ static bool ContextualCheckBlockHeader(const CBlockHeader& block, BlockValidatio
  *  in ConnectBlock().
  *  Note that -reindex-chainstate skips the validation that happens here!
  */
-static bool ContextualCheckBlock(const CBlock& block, BlockValidationState& state, const ChainstateManager& chainman, const CBlockIndex* pindexPrev)
+static BlockValidationState ContextualCheckBlock(const CBlock& block, const ChainstateManager& chainman, const CBlockIndex* pindexPrev)
 {
     const int nHeight = pindexPrev == nullptr ? 0 : pindexPrev->nHeight + 1;
 
@@ -4135,7 +4173,9 @@ static bool ContextualCheckBlock(const CBlock& block, BlockValidationState& stat
     // Check that all transactions are finalized
     for (const auto& tx : block.vtx) {
         if (!IsFinalTx(*tx, nHeight, nLockTimeCutoff)) {
-            return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-nonfinal", "non-final transaction");
+            BlockValidationState state;
+            /*ret=*/state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-nonfinal", "non-final transaction");
+            return state;
         }
     }
 
@@ -4145,7 +4185,9 @@ static bool ContextualCheckBlock(const CBlock& block, BlockValidationState& stat
         CScript expect = CScript() << nHeight;
         if (block.vtx[0]->vin[0].scriptSig.size() < expect.size() ||
             !std::equal(expect.begin(), expect.end(), block.vtx[0]->vin[0].scriptSig.begin())) {
-            return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-height", "block height mismatch in coinbase");
+            BlockValidationState state;
+            /*ret=*/state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-height", "block height mismatch in coinbase");
+            return state;
         }
     }
 
@@ -4157,8 +4199,9 @@ static bool ContextualCheckBlock(const CBlock& block, BlockValidationState& stat
     // * There must be at least one output whose scriptPubKey is a single 36-byte push, the first 4 bytes of which are
     //   {0xaa, 0x21, 0xa9, 0xed}, and the following 32 bytes are SHA256^2(witness root, witness reserved value). In case there are
     //   multiple, the last one is used.
-    if (!CheckWitnessMalleation(block, DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_SEGWIT), state)) {
-        return false;
+    if (const auto state = CheckWitnessMalleation(block, DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_SEGWIT));
+        !state.IsValid()) {
+        return state;
     }
 
     // After the coinbase witness reserved value and commitment are verified,
@@ -4168,13 +4211,15 @@ static bool ContextualCheckBlock(const CBlock& block, BlockValidationState& stat
     // the block hash, so we couldn't mark the block as permanently
     // failed).
     if (GetBlockWeight(block) > MAX_BLOCK_WEIGHT) {
-        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-weight", strprintf("%s : weight limit failed", __func__));
+        BlockValidationState state;
+        /*ret=*/state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-weight", strprintf("%s : weight limit failed", __func__));
+        return state;
     }
 
-    return true;
+    return BlockValidationState{};
 }
 
-bool ChainstateManager::AcceptBlockHeader(const CBlockHeader& block, BlockValidationState& state, CBlockIndex** ppindex, bool min_pow_checked)
+BlockValidationState ChainstateManager::AcceptBlockHeader(const CBlockHeader& block, CBlockIndex** ppindex, bool min_pow_checked)
 {
     AssertLockHeld(cs_main);
 
@@ -4189,15 +4234,17 @@ bool ChainstateManager::AcceptBlockHeader(const CBlockHeader& block, BlockValida
                 *ppindex = pindex;
             if (pindex->nStatus & BLOCK_FAILED_VALID) {
                 LogDebug(BCLog::VALIDATION, "%s: block %s is marked invalid\n", __func__, hash.ToString());
-                return state.Invalid(BlockValidationResult::BLOCK_CACHED_INVALID, "duplicate-invalid",
+                BlockValidationState state;
+                /*ret=*/state.Invalid(BlockValidationResult::BLOCK_CACHED_INVALID, "duplicate-invalid",
                                      strprintf("block %s was previously marked invalid", hash.ToString()));
+                return state;
             }
-            return true;
+            return BlockValidationState{};
         }
 
-        if (!CheckBlockHeader(block, state, GetConsensus())) {
+        if (const auto state = CheckBlockHeader(block, GetConsensus()); !state.IsValid()) {
             LogDebug(BCLog::VALIDATION, "%s: Consensus::CheckBlockHeader: %s, %s\n", __func__, hash.ToString(), state.ToString());
-            return false;
+            return state;
         }
 
         // Get prev block index
@@ -4205,44 +4252,51 @@ bool ChainstateManager::AcceptBlockHeader(const CBlockHeader& block, BlockValida
         BlockMap::iterator mi{m_blockman.m_block_index.find(block.hashPrevBlock)};
         if (mi == m_blockman.m_block_index.end()) {
             LogDebug(BCLog::VALIDATION, "header %s has prev block not found: %s\n", hash.ToString(), block.hashPrevBlock.ToString());
-            return state.Invalid(BlockValidationResult::BLOCK_MISSING_PREV, "prev-blk-not-found");
+            BlockValidationState state;
+            /*ret=*/state.Invalid(BlockValidationResult::BLOCK_MISSING_PREV, "prev-blk-not-found");
+            return state;
         }
         pindexPrev = &((*mi).second);
         if (pindexPrev->nStatus & BLOCK_FAILED_VALID) {
             LogDebug(BCLog::VALIDATION, "header %s has prev block invalid: %s\n", hash.ToString(), block.hashPrevBlock.ToString());
-            return state.Invalid(BlockValidationResult::BLOCK_INVALID_PREV, "bad-prevblk");
+            BlockValidationState state;
+            /*ret=*/state.Invalid(BlockValidationResult::BLOCK_INVALID_PREV, "bad-prevblk");
+            return state;
         }
-        if (!ContextualCheckBlockHeader(block, state, *this, pindexPrev)) {
+        if (const auto state = ContextualCheckBlockHeader(block, *this, pindexPrev); !state.IsValid()) {
             LogDebug(BCLog::VALIDATION, "%s: Consensus::ContextualCheckBlockHeader: %s, %s\n", __func__, hash.ToString(), state.ToString());
-            return false;
+            return state;
         }
     }
     if (!min_pow_checked) {
         LogDebug(BCLog::VALIDATION, "%s: not adding new block header %s, missing anti-dos proof-of-work validation\n", __func__, hash.ToString());
-        return state.Invalid(BlockValidationResult::BLOCK_HEADER_LOW_WORK, "too-little-chainwork");
+        BlockValidationState state;
+        /*ret=*/state.Invalid(BlockValidationResult::BLOCK_HEADER_LOW_WORK, "too-little-chainwork");
+        return state;
     }
     CBlockIndex* pindex{m_blockman.AddToBlockIndex(block, m_best_header)};
 
     if (ppindex)
         *ppindex = pindex;
 
-    return true;
+    return BlockValidationState{};
 }
 
 // Exposed wrapper for AcceptBlockHeader
-bool ChainstateManager::ProcessNewBlockHeaders(std::span<const CBlockHeader> headers, bool min_pow_checked, BlockValidationState& state, const CBlockIndex** ppindex)
+BlockValidationState ChainstateManager::ProcessNewBlockHeaders(std::span<const CBlockHeader> headers, bool min_pow_checked, const CBlockIndex** ppindex)
 {
     AssertLockNotHeld(cs_main);
     {
         LOCK(cs_main);
         for (const CBlockHeader& header : headers) {
             CBlockIndex *pindex = nullptr; // Use a temp pindex instead of ppindex to avoid a const_cast
-            bool accepted{AcceptBlockHeader(header, state, &pindex, min_pow_checked)};
+            BlockValidationState state{AcceptBlockHeader(header, &pindex, min_pow_checked)};
             CheckBlockIndex();
 
-            if (!accepted) {
-                return false;
+            if (!state.IsValid()) {
+                return state;
             }
+
             if (ppindex) {
                 *ppindex = pindex;
             }
@@ -4257,7 +4311,8 @@ bool ChainstateManager::ProcessNewBlockHeaders(std::span<const CBlockHeader> hea
             LogInfo("Synchronizing blockheaders, height: %d (~%.2f%%)\n", last_accepted.nHeight, progress);
         }
     }
-    return true;
+
+    return BlockValidationState{};
 }
 
 void ChainstateManager::ReportHeadersPresync(int64_t height, int64_t timestamp)
@@ -4286,7 +4341,7 @@ void ChainstateManager::ReportHeadersPresync(int64_t height, int64_t timestamp)
 }
 
 /** Store block on disk. If dbp is non-nullptr, the file is known to already reside on disk */
-bool ChainstateManager::AcceptBlock(const std::shared_ptr<const CBlock>& pblock, BlockValidationState& state, CBlockIndex** ppindex, bool fRequested, const FlatFilePos* dbp, bool* fNewBlock, bool min_pow_checked)
+BlockValidationState ChainstateManager::AcceptBlock(const std::shared_ptr<const CBlock>& pblock, CBlockIndex** ppindex, bool fRequested, const FlatFilePos* dbp, bool* fNewBlock, bool min_pow_checked)
 {
     const CBlock& block = *pblock;
 
@@ -4296,11 +4351,11 @@ bool ChainstateManager::AcceptBlock(const std::shared_ptr<const CBlock>& pblock,
     CBlockIndex *pindexDummy = nullptr;
     CBlockIndex *&pindex = ppindex ? *ppindex : pindexDummy;
 
-    bool accepted_header{AcceptBlockHeader(block, state, &pindex, min_pow_checked)};
+    BlockValidationState state{AcceptBlockHeader(block, &pindex, min_pow_checked)};
     CheckBlockIndex();
 
-    if (!accepted_header)
-        return false;
+    if (!state.IsValid())
+        return state;
 
     // Check all requested blocks that we do not already have for validity and
     // save them to disk. Skip processing of unrequested blocks as an anti-DoS
@@ -4323,28 +4378,31 @@ bool ChainstateManager::AcceptBlock(const std::shared_ptr<const CBlock>& pblock,
 
     // TODO: deal better with return value and error conditions for duplicate
     // and unrequested blocks.
-    if (fAlreadyHave) return true;
+    if (fAlreadyHave) return state;
     if (!fRequested) {  // If we didn't ask for it:
-        if (pindex->nTx != 0) return true;    // This is a previously-processed block that was pruned
-        if (!fHasMoreOrSameWork) return true; // Don't process less-work chains
-        if (fTooFarAhead) return true;        // Block height is too high
+        if (pindex->nTx != 0) return state;    // This is a previously-processed block that was pruned
+        if (!fHasMoreOrSameWork) return state; // Don't process less-work chains
+        if (fTooFarAhead) return state;        // Block height is too high
 
         // Protect against DoS attacks from low-work chains.
         // If our tip is behind, a peer could try to send us
         // low-work blocks on a fake chain that we would never
         // request; don't process these.
-        if (pindex->nChainWork < MinimumChainWork()) return true;
+        if (pindex->nChainWork < MinimumChainWork()) return state;
     }
 
     const CChainParams& params{GetParams()};
 
-    if (!CheckBlock(block, state, params.GetConsensus()) ||
-        !ContextualCheckBlock(block, state, *this, pindex->pprev)) {
+    state = CheckBlock(block, params.GetConsensus());
+    if (state.IsValid()) {
+        state = ContextualCheckBlock(block, *this, pindex->pprev);
+    }
+    if (!state.IsValid()) {
         if (Assume(state.IsInvalid())) {
             ActiveChainstate().InvalidBlockFound(pindex, state);
         }
         LogError("%s: %s\n", __func__, state.ToString());
-        return false;
+        return state;
     }
 
     // Header is valid/has work, merkle tree and segwit merkle tree are good...RELAY NOW
@@ -4364,12 +4422,12 @@ bool ChainstateManager::AcceptBlock(const std::shared_ptr<const CBlock>& pblock,
             blockPos = m_blockman.WriteBlock(block, pindex->nHeight);
             if (blockPos.IsNull()) {
                 state.Error(strprintf("%s: Failed to find position to write new block to disk", __func__));
-                return false;
+                return state;
             }
         }
         ReceivedBlockTransactions(block, pindex, blockPos);
     } catch (const std::runtime_error& e) {
-        return FatalError(GetNotifications(), state, strprintf(_("System error while saving block to disk: %s"), e.what()));
+        return FatalError(GetNotifications(), strprintf(_("System error while saving block to disk: %s"), e.what()));
     }
 
     // TODO: FlushStateToDisk() handles flushing of both block and chainstate
@@ -4379,11 +4437,10 @@ bool ChainstateManager::AcceptBlock(const std::shared_ptr<const CBlock>& pblock,
     // the block files may be pruned, so we can just call this on one
     // chainstate (particularly if we haven't implemented pruning with
     // background validation yet).
-    ActiveChainstate().FlushStateToDisk(state, FlushStateMode::NONE);
-
+    state = ActiveChainstate().FlushStateToDisk(FlushStateMode::NONE);
     CheckBlockIndex();
 
-    return true;
+    return state;
 }
 
 bool ChainstateManager::ProcessNewBlock(const std::shared_ptr<const CBlock>& block, bool force_processing, bool min_pow_checked, bool* new_block)
@@ -4404,12 +4461,12 @@ bool ChainstateManager::ProcessNewBlock(const std::shared_ptr<const CBlock>& blo
         // malleability that cause CheckBlock() to fail; see e.g. CVE-2012-2459 and
         // https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2019-February/016697.html.  Because CheckBlock() is
         // not very expensive, the anti-DoS benefits of caching failure (of a definitely-invalid block) are not substantial.
-        bool ret = CheckBlock(*block, state, GetConsensus());
-        if (ret) {
+        state = CheckBlock(*block, GetConsensus());
+        if (state.IsValid()) {
             // Store to disk
-            ret = AcceptBlock(block, state, &pindex, force_processing, nullptr, new_block, min_pow_checked);
+            state = AcceptBlock(block, &pindex, force_processing, nullptr, new_block, min_pow_checked);
         }
-        if (!ret) {
+        if (!state.IsValid()) {
             if (m_options.signals) {
                 m_options.signals->BlockChecked(block, state);
             }
@@ -4471,10 +4528,10 @@ BlockValidationState TestBlockValidity(
     }
 
     // For signets CheckBlock() verifies the challenge iff fCheckPow is set.
-    if (!CheckBlock(block, state, chainstate.m_chainman.GetConsensus(), /*fCheckPow=*/check_pow, /*fCheckMerkleRoot=*/check_merkle_root)) {
+    if (const auto state = CheckBlock(block, chainstate.m_chainman.GetConsensus(), /*fCheckPow=*/check_pow, /*fCheckMerkleRoot=*/check_merkle_root);
+        !state.IsValid()) {
         // This should never happen, but belt-and-suspenders don't approve the
         // block if it does.
-        if (state.IsValid()) NONFATAL_UNREACHABLE();
         return state;
     }
 
@@ -4493,13 +4550,11 @@ BlockValidationState TestBlockValidity(
      * - do run ContextualCheckBlock()
      */
 
-    if (!ContextualCheckBlockHeader(block, state, chainstate.m_chainman, tip)) {
-        if (state.IsValid()) NONFATAL_UNREACHABLE();
+    if (const auto state = ContextualCheckBlockHeader(block, chainstate.m_chainman, tip); !state.IsValid()) {
         return state;
     }
 
-    if (!ContextualCheckBlock(block, state, chainstate.m_chainman, tip)) {
-        if (state.IsValid()) NONFATAL_UNREACHABLE();
+    if (const auto state = ContextualCheckBlock(block, chainstate.m_chainman, tip); !state.IsValid()) {
         return state;
     }
 
@@ -4513,23 +4568,19 @@ BlockValidationState TestBlockValidity(
     CCoinsViewCache view_dummy(&chainstate.CoinsTip());
 
     // Set fJustCheck to true in order to update, and not clear, validation caches.
-    if(!chainstate.ConnectBlock(block, state, &index_dummy, view_dummy, /*fJustCheck=*/true)) {
+    if (!chainstate.ConnectBlock(block, state, &index_dummy, view_dummy, /*fJustCheck=*/true)) {
         if (state.IsValid()) NONFATAL_UNREACHABLE();
         return state;
     }
 
-    // Ensure no check returned successfully while also setting an invalid state.
-    if (!state.IsValid()) NONFATAL_UNREACHABLE();
-
-    return state;
+    return BlockValidationState{};
 }
 
 /* This function is called from the RPC code for pruneblockchain */
 void PruneBlockFilesManual(Chainstate& active_chainstate, int nManualPruneHeight)
 {
-    BlockValidationState state;
-    if (!active_chainstate.FlushStateToDisk(
-            state, FlushStateMode::NONE, nManualPruneHeight)) {
+    if (auto state = active_chainstate.FlushStateToDisk(
+            FlushStateMode::NONE, nManualPruneHeight); !state.IsValid()) {
         LogWarning("Failed to flush state after manual prune (%s)", state.ToString());
     }
 }
@@ -4654,10 +4705,13 @@ VerifyDBResult CVerifyDB::VerifyDB(
             return VerifyDBResult::CORRUPTED_BLOCK_DB;
         }
         // check level 1: verify block validity
-        if (nCheckLevel >= 1 && !CheckBlock(block, state, consensus_params)) {
-            LogError("Verification error: found bad block at %d, hash=%s (%s)",
-                      pindex->nHeight, pindex->GetBlockHash().ToString(), state.ToString());
-            return VerifyDBResult::CORRUPTED_BLOCK_DB;
+        if (nCheckLevel >= 1) {
+            state = CheckBlock(block, consensus_params);
+            if (!state.IsValid()) {
+                LogError("Verification error: found bad block at %d, hash=%s (%s)",
+                          pindex->nHeight, pindex->GetBlockHash().ToString(), state.ToString());
+                return VerifyDBResult::CORRUPTED_BLOCK_DB;
+            }
         }
         // check level 2: verify undo validity
         if (nCheckLevel >= 2 && pindex) {
@@ -5026,8 +5080,8 @@ void ChainstateManager::LoadExternalBlockFile(
                         blkdat >> TX_WITH_WITNESS(*pblock);
                         nRewind = blkdat.GetPos();
 
-                        BlockValidationState state;
-                        if (AcceptBlock(pblock, state, nullptr, true, dbp, nullptr, true)) {
+                        BlockValidationState state{AcceptBlock(pblock, nullptr, true, dbp, nullptr, true)};
+                        if (state.IsValid()) {
                             nLoaded++;
                         }
                         if (state.IsError()) {
@@ -5084,8 +5138,7 @@ void ChainstateManager::LoadExternalBlockFile(
                             const auto& block_hash{pblockrecursive->GetHash()};
                             LogDebug(BCLog::REINDEX, "%s: Processing out of order child %s of %s", __func__, block_hash.ToString(), head.ToString());
                             LOCK(cs_main);
-                            BlockValidationState dummy;
-                            if (AcceptBlock(pblockrecursive, dummy, nullptr, true, &it->second, nullptr, true)) {
+                            if (auto state{AcceptBlock(pblockrecursive, nullptr, true, &it->second, nullptr, true)}; state.IsValid()) {
                                 nLoaded++;
                                 queue.push_back(block_hash);
                             }
@@ -5468,15 +5521,14 @@ bool Chainstate::ResizeCoinsCaches(size_t coinstip_size, size_t coinsdb_size)
     LogInfo("[%s] resized coinstip cache to %.1f MiB",
         this->ToString(), coinstip_size / double(1_MiB));
 
-    BlockValidationState state;
     bool ret;
 
     if (coinstip_size > old_coinstip_size) {
         // Likely no need to flush if cache sizes have grown.
-        ret = FlushStateToDisk(state, FlushStateMode::IF_NEEDED);
+        ret = FlushStateToDisk(FlushStateMode::IF_NEEDED).IsValid();
     } else {
         // Otherwise, flush state to disk and deallocate the in-memory coins map.
-        ret = FlushStateToDisk(state, FlushStateMode::FORCE_FLUSH);
+        ret = FlushStateToDisk(FlushStateMode::FORCE_FLUSH).IsValid();
     }
     return ret;
 }
diff --git a/src/validation.h b/src/validation.h
index 4cb5dc631e95..aa97ab4155e4 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -101,7 +101,7 @@ extern const std::vector<std::string> CHECKLEVEL_DOC;
 
 CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams);
 
-bool FatalError(kernel::Notifications& notifications, BlockValidationState& state, const bilingual_str& message);
+BlockValidationState FatalError(kernel::Notifications& notifications, const bilingual_str& message);
 
 /** Prune block files up to a given height */
 void PruneBlockFilesManual(Chainstate& active_chainstate, int nManualPruneHeight);
@@ -389,7 +389,7 @@ class ValidationCache
 /** Functions for validating blocks and updating the block tree */
 
 /** Context-independent validity checks */
-bool CheckBlock(const CBlock& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true, bool fCheckMerkleRoot = true);
+[[nodiscard]] BlockValidationState CheckBlock(const CBlock& block, const Consensus::Params& consensusParams, bool fCheckPOW = true, bool fCheckMerkleRoot = true);
 
 /**
  * Verify a block, including transactions.
@@ -734,10 +734,9 @@ class Chainstate
      * If FlushStateMode::NONE is used, then FlushStateToDisk(...) won't do anything
      * besides checking if we need to prune.
      *
-     * @returns true unless a system error occurred
+     * @returns a validation result with `IsValid() == true` unless a system error occurred
      */
-    bool FlushStateToDisk(
-        BlockValidationState& state,
+    BlockValidationState FlushStateToDisk(
         FlushStateMode mode,
         int nManualPruneHeight = 0);
 
@@ -964,9 +963,8 @@ class ChainstateManager
      * block index (permanent memory storage), indicating that the header is
      * known to be part of a sufficiently high-work chain (anti-dos check).
      */
-    bool AcceptBlockHeader(
+    [[nodiscard]] BlockValidationState AcceptBlockHeader(
         const CBlockHeader& block,
-        BlockValidationState& state,
         CBlockIndex** ppindex,
         bool min_pow_checked) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     friend Chainstate;
@@ -1268,11 +1266,12 @@ class ChainstateManager
      *
      * @param[in]  headers The block headers themselves
      * @param[in]  min_pow_checked  True if proof-of-work anti-DoS checks have been done by caller for headers chain
-     * @param[out] state This may be set to an Error state if any error occurred processing them
      * @param[out] ppindex If set, the pointer will be set to point to the last new block index object for the given headers
-     * @returns false if AcceptBlockHeader fails on any of the headers, true otherwise (including if headers were already known)
+     * @returns BlockValidationState indicating the result. IsValid() returns true if all headers
+     *          were accepted. On failure, IsInvalid() is false and the state contains the specific
+     *          validation failure reason.
      */
-    bool ProcessNewBlockHeaders(std::span<const CBlockHeader> headers, bool min_pow_checked, BlockValidationState& state, const CBlockIndex** ppindex = nullptr) LOCKS_EXCLUDED(cs_main);
+    [[nodiscard]] BlockValidationState ProcessNewBlockHeaders(std::span<const CBlockHeader> headers, bool min_pow_checked, const CBlockIndex** ppindex = nullptr) LOCKS_EXCLUDED(cs_main);
 
     /**
      * Sufficiently validate a block for disk storage (and store on disk).
@@ -1285,15 +1284,14 @@ class ChainstateManager
      * @param[in]   min_pow_checked True if proof-of-work anti-DoS checks have
      *                              been done by caller for headers chain
      *
-     * @param[out]  state       The state of the block validation.
      * @param[out]  ppindex     Optional return parameter to get the
      *                          CBlockIndex pointer for this block.
      * @param[out]  fNewBlock   Optional return parameter to indicate if the
      *                          block is new to our storage.
      *
-     * @returns   False if the block or header is invalid, or if saving to disk fails (likely a fatal error); true otherwise.
+     * @returns BlockValidationState indicating the result. IsValid() is false if the block or header is invalid, or if saving to disk fails (likely a fatal error); true otherwise.
      */
-    bool AcceptBlock(const std::shared_ptr<const CBlock>& pblock, BlockValidationState& state, CBlockIndex** ppindex, bool fRequested, const FlatFilePos* dbp, bool* fNewBlock, bool min_pow_checked) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    [[nodiscard]] BlockValidationState AcceptBlock(const std::shared_ptr<const CBlock>& pblock, CBlockIndex** ppindex, bool fRequested, const FlatFilePos* dbp, bool* fNewBlock, bool min_pow_checked) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     void ReceivedBlockTransactions(const CBlock& block, CBlockIndex* pindexNew, const FlatFilePos& pos) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
diff --git a/src/wallet/rpc/addresses.cpp b/src/wallet/rpc/addresses.cpp
index ed966d894414..8feae4786325 100644
--- a/src/wallet/rpc/addresses.cpp
+++ b/src/wallet/rpc/addresses.cpp
@@ -365,6 +365,52 @@ static UniValue DescribeWalletAddress(const CWallet& wallet, const CTxDestinatio
     return ret;
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
+static std::vector<RPCResult> GetAddressInfoEmbeddedFields(bool include_nested)
+{
+    auto fields = std::vector<RPCResult>{
+        {RPCResult::Type::STR, "address", /*optional=*/true, "The bitcoin address of the embedded script."},
+        {RPCResult::Type::STR_HEX, "scriptPubKey", /*optional=*/true, "The hex-encoded output script generated by the address."},
+        {RPCResult::Type::BOOL, "isscript", /*optional=*/true, "If the key is a script."},
+        {RPCResult::Type::BOOL, "iswitness", /*optional=*/true, "If the address is a witness address."},
+        {RPCResult::Type::NUM, "witness_version", /*optional=*/true, "The version number of the witness program."},
+        {RPCResult::Type::STR_HEX, "witness_program", /*optional=*/true, "The hex value of the witness program."},
+        {RPCResult::Type::STR, "script", /*optional=*/true,
+            "The output script type. Only if isscript is true and the redeemscript is known. Possible\n"
+            "types: nonstandard, pubkey, pubkeyhash, scripthash, multisig, nulldata, witness_v0_keyhash,\n"
+            "witness_v0_scripthash, witness_unknown."},
+        {RPCResult::Type::STR_HEX, "hex", /*optional=*/true, "The redeemscript for the p2sh address."},
+        {RPCResult::Type::ARR, "pubkeys", /*optional=*/true,
+            "Array of pubkeys associated with the known redeemscript (only if script is multisig).",
+            {
+                {RPCResult::Type::STR, "pubkey", ""},
+            }},
+        {RPCResult::Type::NUM, "sigsrequired", /*optional=*/true,
+            "The number of signatures required to spend multisig output (only if script is multisig)."},
+        {RPCResult::Type::STR_HEX, "pubkey", /*optional=*/true,
+            "The hex value of the raw public key for single-key addresses (possibly embedded in P2SH or P2WSH)."},
+    };
+
+    if (include_nested) {
+        fields.emplace_back(
+            RPCResult::Type::OBJ,
+            "embedded",
+            /*optional=*/true,
+            "Information about the address embedded in P2SH or P2WSH, if relevant and known.",
+            GetAddressInfoEmbeddedFields(/*include_nested=*/false)
+        );
+    }
+
+    fields.emplace_back(
+        RPCResult::Type::BOOL,
+        "iscompressed",
+        /*optional=*/true,
+        "If the pubkey is compressed."
+    );
+
+    return fields;
+}
+
 RPCMethod getaddressinfo()
 {
     return RPCMethod{
@@ -399,11 +445,13 @@ RPCMethod getaddressinfo()
                         }},
                         {RPCResult::Type::NUM, "sigsrequired", /*optional=*/true, "The number of signatures required to spend multisig output (only if script is multisig)."},
                         {RPCResult::Type::STR_HEX, "pubkey", /*optional=*/true, "The hex value of the raw public key for single-key addresses (possibly embedded in P2SH or P2WSH)."},
-                        {RPCResult::Type::OBJ, "embedded", /*optional=*/true, "Information about the address embedded in P2SH or P2WSH, if relevant and known.",
-                        {
-                            {RPCResult::Type::ELISION, "", "Includes all getaddressinfo output fields for the embedded address, excluding metadata (timestamp, hdkeypath, hdseedid)\n"
-                            "and relation to the wallet (ismine)."},
-                        }},
+                        {RPCResult::Type::OBJ, "embedded", /*optional=*/true,
+                        "Information about the address embedded in P2SH or P2WSH, if relevant and known.",
+                        ElideGroup(
+                            GetAddressInfoEmbeddedFields(/*include_nested=*/true),
+                            "Includes all getaddressinfo output fields for the embedded address, excluding metadata (timestamp, hdkeypath, hdseedid)\n"
+                            "and relation to the wallet (ismine)."
+                        )},
                         {RPCResult::Type::BOOL, "iscompressed", /*optional=*/true, "If the pubkey is compressed."},
                         {RPCResult::Type::NUM_TIME, "timestamp", /*optional=*/true, "The creation time of the key, if available, expressed in " + UNIX_EPOCH_TIME + "."},
                         {RPCResult::Type::STR, "hdkeypath", /*optional=*/true, "The HD keypath, if the key is HD and available."},
diff --git a/src/wallet/rpc/transactions.cpp b/src/wallet/rpc/transactions.cpp
index f69082e1e966..77af932ea680 100644
--- a/src/wallet/rpc/transactions.cpp
+++ b/src/wallet/rpc/transactions.cpp
@@ -523,6 +523,33 @@ RPCMethod listtransactions()
     };
 }
 
+static std::vector<RPCResult> ListSinceBlockTxFields()
+{
+    return Cat<std::vector<RPCResult>>(
+        {
+            {RPCResult::Type::STR, "address", /*optional=*/true, "The bitcoin address of the transaction (not returned if the output does not have an address, e.g. OP_RETURN null data)."},
+            {RPCResult::Type::STR, "category", "The transaction category.\n"
+                "\"send\"                  Transactions sent.\n"
+                "\"receive\"               Non-coinbase transactions received.\n"
+                "\"generate\"              Coinbase transactions received with more than 100 confirmations.\n"
+                "\"immature\"              Coinbase transactions received with 100 or fewer confirmations.\n"
+                "\"orphan\"                Orphaned coinbase transactions received."},
+            {RPCResult::Type::STR_AMOUNT, "amount", "The amount in " + CURRENCY_UNIT + ". This is negative for the 'send' category, and is positive\n"
+                "for all other categories"},
+            {RPCResult::Type::NUM, "vout", "the vout value"},
+            {RPCResult::Type::STR_AMOUNT, "fee", /*optional=*/true, "The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the\n"
+                 "'send' category of transactions."},
+        },
+        Cat(
+            TransactionDescriptionString(),
+            std::vector<RPCResult>{
+                {RPCResult::Type::BOOL, "abandoned", "'true' if the transaction has been abandoned (inputs are respendable)."},
+                {RPCResult::Type::STR, "label", /*optional=*/true, "A comment for the address/transaction, if any"},
+            }
+        )
+    );
+}
+
 RPCMethod listsinceblock()
 {
     return RPCMethod{
@@ -544,30 +571,13 @@ RPCMethod listsinceblock()
                     {
                         {RPCResult::Type::ARR, "transactions", "",
                         {
-                            {RPCResult::Type::OBJ, "", "", Cat(Cat<std::vector<RPCResult>>(
-                            {
-                                {RPCResult::Type::STR, "address",  /*optional=*/true, "The bitcoin address of the transaction (not returned if the output does not have an address, e.g. OP_RETURN null data)."},
-                                {RPCResult::Type::STR, "category", "The transaction category.\n"
-                                    "\"send\"                  Transactions sent.\n"
-                                    "\"receive\"               Non-coinbase transactions received.\n"
-                                    "\"generate\"              Coinbase transactions received with more than 100 confirmations.\n"
-                                    "\"immature\"              Coinbase transactions received with 100 or fewer confirmations.\n"
-                                    "\"orphan\"                Orphaned coinbase transactions received."},
-                                {RPCResult::Type::STR_AMOUNT, "amount", "The amount in " + CURRENCY_UNIT + ". This is negative for the 'send' category, and is positive\n"
-                                    "for all other categories"},
-                                {RPCResult::Type::NUM, "vout", "the vout value"},
-                                {RPCResult::Type::STR_AMOUNT, "fee", /*optional=*/true, "The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the\n"
-                                     "'send' category of transactions."},
-                            },
-                            TransactionDescriptionString()),
-                            {
-                                {RPCResult::Type::BOOL, "abandoned", "'true' if the transaction has been abandoned (inputs are respendable)."},
-                                {RPCResult::Type::STR, "label", /*optional=*/true, "A comment for the address/transaction, if any"},
-                            })},
+                            {RPCResult::Type::OBJ, "", "", ListSinceBlockTxFields()},
                         }},
                         {RPCResult::Type::ARR, "removed", /*optional=*/true, "<structure is the same as \"transactions\" above, only present if include_removed=true>\n"
-                            "Note: transactions that were re-added in the active chain will appear as-is in this array, and may thus have a positive confirmation count."
-                        , {{RPCResult::Type::ELISION, "", ""},}},
+                            "Note: transactions that were re-added in the active chain will appear as-is in this array, and may thus have a positive confirmation count.",
+                        {
+                            {RPCResult::Type::OBJ, "", "", ListSinceBlockTxFields(), {.print_elision = std::string{}}},
+                        }},
                         {RPCResult::Type::STR_HEX, "lastblock", "The hash of the block (target_confirmations-1) from the best block on the main chain, or the genesis hash if the referenced block does not exist yet. This is typically used to feed back into listsinceblock the next time you call it. So you would generally use a target_confirmations of say 6, so you will be continually re-notified of transactions until they've reached 6 confirmations plus any new ones"},
                     }
                 },
diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
index dad8aef39dc5..0759e2d5220a 100644
--- a/src/wallet/scriptpubkeyman.cpp
+++ b/src/wallet/scriptpubkeyman.cpp
@@ -628,19 +628,28 @@ std::optional<MigrationData> LegacyDataSPKM::MigrateToDescriptor()
 
     bool can_support_hd_split_feature = m_hd_chain.nVersion >= CHDChain::VERSION_HD_CHAIN_SPLIT;
 
+    std::set<CExtPubKey> master_xpubs;
     for (const CHDChain& chain : chains) {
+        if (chain.seed_id.IsNull()) continue;
+
+        // Get the master xprv
+        CKey seed_key;
+        if (!GetKey(chain.seed_id, seed_key)) {
+            assert(false);
+        }
+        CExtKey master_key;
+        master_key.SetSeed(seed_key);
+
+        // Get the xpub and verify that we haven't already seen this xpub before
+        CExtPubKey master_xpub = master_key.Neuter();
+        const auto& [_, inserted] = master_xpubs.insert(master_xpub);
+        if (!inserted) continue;
+
         for (int i = 0; i < 2; ++i) {
             // Skip if doing internal chain and split chain is not supported
-            if (chain.seed_id.IsNull() || (i == 1 && !can_support_hd_split_feature)) {
+            if (i == 1 && !can_support_hd_split_feature) {
                 continue;
             }
-            // Get the master xprv
-            CKey seed_key;
-            if (!GetKey(chain.seed_id, seed_key)) {
-                assert(false);
-            }
-            CExtKey master_key;
-            master_key.SetSeed(seed_key);
 
             // Make the combo descriptor
             std::string xpub = EncodeExtPubKey(master_key.Neuter());
diff --git a/src/wallet/scriptpubkeyman.h b/src/wallet/scriptpubkeyman.h
index 9a5554d94b02..6cebae052bf5 100644
--- a/src/wallet/scriptpubkeyman.h
+++ b/src/wallet/scriptpubkeyman.h
@@ -6,7 +6,6 @@
 #define BITCOIN_WALLET_SCRIPTPUBKEYMAN_H
 
 #include <addresstype.h>
-#include <btcsignals.h>
 #include <common/messages.h>
 #include <common/signmessage.h>
 #include <common/types.h>
@@ -16,6 +15,7 @@
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/signingprovider.h>
+#include <util/btcsignals.h>
 #include <util/hasher.h>
 #include <util/log.h>
 #include <util/result.h>
diff --git a/src/wallet/spend.cpp b/src/wallet/spend.cpp
index 9384299d9a1b..dba7b8829595 100644
--- a/src/wallet/spend.cpp
+++ b/src/wallet/spend.cpp
@@ -210,10 +210,6 @@ std::vector<COutput> CoinsResult::All() const
     return all;
 }
 
-void CoinsResult::Clear() {
-    coins.clear();
-}
-
 void CoinsResult::Erase(const std::unordered_set<COutPoint, SaltedOutpointHasher>& coins_to_remove)
 {
     for (auto& [type, vec] : coins) {
diff --git a/src/wallet/spend.h b/src/wallet/spend.h
index 925111dce031..b013a3fabdf9 100644
--- a/src/wallet/spend.h
+++ b/src/wallet/spend.h
@@ -40,7 +40,7 @@ TxSize CalculateMaximumSignedTxSize(const CTransaction& tx, const CWallet* walle
  * This struct is really just a wrapper around OutputType vectors with a convenient
  * method for concatenating and returning all COutputs as one vector.
  *
- * Size(), Clear(), Erase(), Shuffle(), and Add() methods are implemented to
+ * Size(), Erase(), Shuffle(), and Add() methods are implemented to
  * allow easy interaction with the struct.
  */
 struct CoinsResult {
@@ -54,7 +54,6 @@ struct CoinsResult {
     size_t Size() const;
     /** Return how many different output types this struct stores */
     size_t TypesCount() const { return coins.size(); }
-    void Clear();
     void Erase(const std::unordered_set<COutPoint, SaltedOutpointHasher>& coins_to_remove);
     void Shuffle(FastRandomContext& rng_fast);
     void Add(OutputType type, const COutput& out);
diff --git a/src/wallet/test/coinselector_tests.cpp b/src/wallet/test/coinselector_tests.cpp
index 17278a685179..2d493795f13b 100644
--- a/src/wallet/test/coinselector_tests.cpp
+++ b/src/wallet/test/coinselector_tests.cpp
@@ -203,7 +203,7 @@ BOOST_AUTO_TEST_CASE(bnb_search_test)
         BOOST_CHECK(!SelectCoinsBnB(GroupCoins(available_coins.All()), 1 * CENT, coin_selection_params_bnb.m_cost_of_change));
 
         // Test fees subtracted from output:
-        available_coins.Clear();
+        available_coins = {};
         add_coin(available_coins, *wallet, 1 * CENT, coin_selection_params_bnb.m_effective_feerate);
         available_coins.All().at(0).input_bytes = 40;
         const auto result9 = SelectCoinsBnB(GroupCoins(available_coins.All()), 1 * CENT, coin_selection_params_bnb.m_cost_of_change);
@@ -352,7 +352,7 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
     // test multiple times to allow for differences in the shuffle order
     for (int i = 0; i < RUN_TESTS; i++)
     {
-        available_coins.Clear();
+        available_coins = {};
 
         // with an empty wallet we can't even pay one cent
         BOOST_CHECK(!KnapsackSolver(KnapsackGroupOutputs(available_coins, *wallet, filter_standard), 1 * CENT, CENT));
@@ -421,7 +421,7 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
         BOOST_CHECK_EQUAL(result8->GetInputSet().size(), 1U);
 
         // now clear out the wallet and start again to test choosing between subsets of smaller coins and the next biggest coin
-        available_coins.Clear();
+        available_coins = {};
 
         add_coin(available_coins, *wallet,  6*CENT);
         add_coin(available_coins, *wallet,  7*CENT);
@@ -479,7 +479,7 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
 
         // empty the wallet and start again, now with fractions of a cent, to test small change avoidance
 
-        available_coins.Clear();
+        available_coins = {};
         add_coin(available_coins, *wallet, CENT * 1 / 10);
         add_coin(available_coins, *wallet, CENT * 2 / 10);
         add_coin(available_coins, *wallet, CENT * 3 / 10);
@@ -511,7 +511,7 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
 
         // run the 'mtgox' test (see https://blockexplorer.com/tx/29a3efd3ef04f9153d47a990bd7b048a4b2d213daaa5fb8ed670fb85f13bdbcf)
         // they tried to consolidate 10 50k coins into one 500k coin, and ended up with 50k in change
-        available_coins.Clear();
+        available_coins = {};
         for (int j = 0; j < 20; j++)
             add_coin(available_coins, *wallet, 50000 * COIN);
 
@@ -524,7 +524,7 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
         // we need to try finding an exact subset anyway
 
         // sometimes it will fail, and so we use the next biggest coin:
-        available_coins.Clear();
+        available_coins = {};
         add_coin(available_coins, *wallet, CENT * 5 / 10);
         add_coin(available_coins, *wallet, CENT * 6 / 10);
         add_coin(available_coins, *wallet, CENT * 7 / 10);
@@ -535,7 +535,7 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
         BOOST_CHECK_EQUAL(result20->GetInputSet().size(), 1U);
 
         // but sometimes it's possible, and we use an exact subset (0.4 + 0.6 = 1.0)
-        available_coins.Clear();
+        available_coins = {};
         add_coin(available_coins, *wallet, CENT * 4 / 10);
         add_coin(available_coins, *wallet, CENT * 6 / 10);
         add_coin(available_coins, *wallet, CENT * 8 / 10);
@@ -546,7 +546,7 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
         BOOST_CHECK_EQUAL(result21->GetInputSet().size(), 2U); // in two coins 0.4+0.6
 
         // test avoiding small change
-        available_coins.Clear();
+        available_coins = {};
         add_coin(available_coins, *wallet, CENT * 5 / 100);
         add_coin(available_coins, *wallet, CENT * 1);
         add_coin(available_coins, *wallet, CENT * 100);
@@ -566,7 +566,7 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
 
     // test with many inputs
     for (CAmount amt=1500; amt < COIN; amt*=10) {
-        available_coins.Clear();
+        available_coins = {};
         // Create 676 inputs (=  (old MAX_STANDARD_TX_SIZE == 100000)  / 148 bytes per input)
         for (uint16_t j = 0; j < 676; j++)
             add_coin(available_coins, *wallet, amt);
@@ -592,7 +592,7 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
 
     // test randomness
     {
-        available_coins.Clear();
+        available_coins = {};
         for (int i2 = 0; i2 < 100; i2++)
             add_coin(available_coins, *wallet, COIN);
 
diff --git a/src/wallet/test/fuzz/fees.cpp b/src/wallet/test/fuzz/fees.cpp
index 0d332c5908ba..36c1f56b0a99 100644
--- a/src/wallet/test/fuzz/fees.cpp
+++ b/src/wallet/test/fuzz/fees.cpp
@@ -63,7 +63,7 @@ FUZZ_TARGET(wallet_fees, .init = initialize_setup)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     auto& node{g_setup->m_node};
     Chainstate* chainstate = &node.chainman->ActiveChainstate();
 
diff --git a/src/wallet/test/fuzz/scriptpubkeyman.cpp b/src/wallet/test/fuzz/scriptpubkeyman.cpp
index b6b3c5d55973..fb3ea004c4ce 100644
--- a/src/wallet/test/fuzz/scriptpubkeyman.cpp
+++ b/src/wallet/test/fuzz/scriptpubkeyman.cpp
@@ -93,7 +93,7 @@ FUZZ_TARGET(scriptpubkeyman, .init = initialize_spkm)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     const auto& node{g_setup->m_node};
     Chainstate& chainstate{node.chainman->ActiveChainstate()};
     std::unique_ptr<CWallet> wallet_ptr{std::make_unique<CWallet>(node.chain.get(), "", CreateMockableWalletDatabase())};
@@ -218,7 +218,7 @@ FUZZ_TARGET(spkm_migration, .init = initialize_spkm_migration)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     const auto& node{g_setup->m_node};
     Chainstate& chainstate{node.chainman->ActiveChainstate()};
 
@@ -257,10 +257,10 @@ FUZZ_TARGET(spkm_migration, .init = initialize_spkm_migration)
 
     bool add_inactive_hd_chain{fuzzed_data_provider.ConsumeBool() && !keys.empty()};
     if (add_inactive_hd_chain) {
-        hd_key = PickValue(fuzzed_data_provider, keys);
+        CKey inactive_hd_key = PickValue(fuzzed_data_provider, keys);
         hd_chain.nVersion = fuzzed_data_provider.ConsumeBool() ? CHDChain::VERSION_HD_CHAIN_SPLIT : CHDChain::VERSION_HD_BASE;
-        bool dup_chain = hd_chain.seed_id == hd_key.GetPubKey().GetID();
-        hd_chain.seed_id = hd_key.GetPubKey().GetID();
+        bool dup_chain = hd_key.IsValid() && std::equal(hd_key.begin(), hd_key.end(), inactive_hd_key.begin());
+        hd_chain.seed_id = inactive_hd_key.GetPubKey().GetID();
         legacy_data.AddInactiveHDChain(hd_chain);
         if (!dup_chain) added_chains++;
     }
diff --git a/src/wallet/test/fuzz/spend.cpp b/src/wallet/test/fuzz/spend.cpp
index e9a6bea71ef0..56ddaa9cb75e 100644
--- a/src/wallet/test/fuzz/spend.cpp
+++ b/src/wallet/test/fuzz/spend.cpp
@@ -34,7 +34,7 @@ FUZZ_TARGET(wallet_create_transaction, .init = initialize_setup)
 {
     SeedRandomStateForTest(SeedRand::ZEROS);
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
-    NodeClockContext clock_ctx{ConsumeTime(fuzzed_data_provider)};
+    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
     const auto& node = g_setup->m_node;
     Chainstate& chainstate{node.chainman->ActiveChainstate()};
     ArgsManager& args = *node.args;
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index 9d890c8f9971..9a0531ca7d1b 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -213,6 +213,36 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
     }
 }
 
+BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions_abort, TestChain100Setup)
+{
+    CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());
+    uint256 genesis_hash;
+    {
+        LOCK(wallet.cs_wallet);
+        LOCK(Assert(m_node.chainman)->GetMutex());
+        wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
+        wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());
+        genesis_hash = m_node.chainman->ActiveChain().Genesis()->GetBlockHash();
+    }
+
+    // An abort requested while no rescan is held is stale and must
+    // not cancel a later scan.
+    wallet.AbortRescan();
+    WalletRescanReserver reserver(wallet);
+    BOOST_CHECK(reserver.reserve());
+    BOOST_CHECK(!wallet.IsAbortingRescan());
+
+    // An abort requested after the reservation but before the scan starts
+    // (e.g. while importdescriptors is still deriving keys) must cancel the
+    // scan.
+    wallet.AbortRescan();
+    CWallet::ScanResult result = wallet.ScanForWalletTransactions(genesis_hash, /*start_height=*/0, /*max_height=*/{}, reserver, /*save_progress=*/false);
+    BOOST_CHECK_EQUAL(result.status, CWallet::ScanResult::USER_ABORT);
+    BOOST_CHECK(result.last_scanned_block.IsNull());
+    BOOST_CHECK(!result.last_scanned_height);
+    BOOST_CHECK(result.last_failed_block.IsNull());
+}
+
 // This test verifies that wallet settings can be added and removed
 // concurrently, ensuring no race conditions occur during either process.
 BOOST_FIXTURE_TEST_CASE(write_wallet_settings_concurrently, TestingSetup)
@@ -246,12 +276,12 @@ BOOST_FIXTURE_TEST_CASE(write_wallet_settings_concurrently, TestingSetup)
                             /*num_expected_wallets=*/0);
 }
 
-static int64_t AddTx(ChainstateManager& chainman, CWallet& wallet, uint32_t lockTime, int64_t mockTime, int64_t blockTime)
+static int64_t AddTx(ChainstateManager& chainman, CWallet& wallet, uint32_t lockTime, std::chrono::seconds mock_time, int64_t blockTime)
 {
     CMutableTransaction tx;
     TxState state = TxStateInactive{};
     tx.nLockTime = lockTime;
-    SetMockTime(mockTime);
+    FakeNodeClock clock{mock_time};
     CBlockIndex* block = nullptr;
     if (blockTime > 0) {
         LOCK(cs_main);
@@ -277,24 +307,24 @@ static int64_t AddTx(ChainstateManager& chainman, CWallet& wallet, uint32_t lock
 BOOST_AUTO_TEST_CASE(ComputeTimeSmart)
 {
     // New transaction should use clock time if lower than block time.
-    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 1, 100, 120), 100);
+    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 1, 100s, 120), 100);
 
     // Test that updating existing transaction does not change smart time.
-    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 1, 200, 220), 100);
+    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 1, 200s, 220), 100);
 
     // New transaction should use clock time if there's no block time.
-    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 2, 300, 0), 300);
+    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 2, 300s, 0), 300);
 
     // New transaction should use block time if lower than clock time.
-    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 3, 420, 400), 400);
+    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 3, 420s, 400), 400);
 
     // New transaction should use latest entry time if higher than
     // min(block time, clock time).
-    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 4, 500, 390), 400);
+    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 4, 500s, 390), 400);
 
     // If there are future entries, new transaction should use time of the
     // newest entry that is no more than 300 seconds ahead of the clock time.
-    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 5, 50, 600), 300);
+    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 5, 50s, 600), 300);
 }
 
 void TestLoadWallet(const std::string& name, DatabaseFormat format, std::function<void(std::shared_ptr<CWallet>)> f)
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index bb79dd471e95..8d502049287d 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -1884,7 +1884,6 @@ CWallet::ScanResult CWallet::ScanForWalletTransactions(const uint256& start_bloc
     WalletLogPrintf("Rescan started from block %s... (%s)\n", start_block.ToString(),
                     fast_rescan_filter ? "fast variant using block filters" : "slow variant inspecting all blocks");
 
-    fAbortRescan = false;
     ShowProgress(strprintf("[%s] %s", DisplayName(), _("Rescanning…")), 0); // show rescan progress in GUI as dialog or on splashscreen, if rescan required on startup (e.g. due to corruption)
     uint256 tip_hash = WITH_LOCK(cs_wallet, return GetLastBlockHash());
     uint256 end_hash = tip_hash;
@@ -2006,10 +2005,10 @@ CWallet::ScanResult CWallet::ScanForWalletTransactions(const uint256& start_bloc
         WITH_LOCK(cs_wallet, chain().requestMempoolTransactions(*this));
     }
     ShowProgress(strprintf("[%s] %s", DisplayName(), _("Rescanning…")), 100); // hide progress dialog in GUI
-    if (block_height && fAbortRescan) {
+    if (fAbortRescan) {
         WalletLogPrintf("Rescan aborted at block %d. Progress=%f\n", block_height, progress_current);
         result.status = ScanResult::USER_ABORT;
-    } else if (block_height && chain().shutdownRequested()) {
+    } else if (chain().shutdownRequested()) {
         WalletLogPrintf("Rescan interrupted by shutdown request at block %d. Progress=%f\n", block_height, progress_current);
         result.status = ScanResult::USER_ABORT;
     } else {
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 54bc60f5c404..47701d7e3a90 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -7,7 +7,6 @@
 #define BITCOIN_WALLET_WALLET_H
 
 #include <addresstype.h>
-#include <btcsignals.h>
 #include <consensus/amount.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
@@ -23,6 +22,7 @@
 #include <sync.h>
 #include <tinyformat.h>
 #include <uint256.h>
+#include <util/btcsignals.h>
 #include <util/fs.h>
 #include <util/hasher.h>
 #include <util/log.h>
@@ -1103,6 +1103,10 @@ class WalletRescanReserver
         if (m_wallet.fScanningWallet.exchange(true)) {
             return false;
         }
+        // Discard any abort request left over from previous reservation, so
+        // that an abort requested while the reservation is held always applies
+        // to abort this rescan, even if it arrives before the scan loop starts.
+        m_wallet.fAbortRescan = false;
         m_wallet.m_scanning_with_passphrase.exchange(with_passphrase);
         m_wallet.m_scanning_start = SteadyClock::now();
         m_wallet.m_scanning_progress = 0;
diff --git a/test/README.md b/test/README.md
index 162815d6488a..0b34f52c1e61 100644
--- a/test/README.md
+++ b/test/README.md
@@ -318,26 +318,6 @@ Often while debugging RPC calls in functional tests, the test might time out bef
 process can return a response. Use `--timeout-factor 0` to disable all RPC timeouts for that particular
 functional test. Ex: `build/test/functional/wallet_hd.py --timeout-factor 0`.
 
-##### Profiling
-
-An easy way to profile node performance during functional tests is provided
-for Linux platforms using `perf`.
-
-Perf will sample the running node and will generate profile data in the node's
-datadir. The profile data can then be presented using `perf report` or a graphical
-tool like [hotspot](https://github.com/KDAB/hotspot).
-
-To generate a profile during test suite runs, use the `--perf` flag.
-
-To see render the output to text, run
-
-```sh
-perf report -i /path/to/datadir/send-big-msgs.perf.data.xxxx --stdio | c++filt | less
-```
-
-For ways to generate more granular profiles, see the README in
-[test/functional](/test/functional).
-
 ### Lint tests
 
 See the README in [test/lint](/test/lint).
diff --git a/test/functional/README.md b/test/functional/README.md
index cf0f2fd0e372..2de034500f8a 100644
--- a/test/functional/README.md
+++ b/test/functional/README.md
@@ -164,36 +164,3 @@ Test-only secp256k1 elliptic curve implementation
 
 #### [blocktools.py](test_framework/blocktools.py)
 Helper functions for creating blocks and transactions.
-
-### Benchmarking with perf
-
-An easy way to profile node performance during functional tests is provided
-for Linux platforms using `perf`.
-
-Perf will sample the running node and will generate profile data in the node's
-datadir. The profile data can then be presented using `perf report` or a graphical
-tool like [hotspot](https://github.com/KDAB/hotspot).
-
-There are two ways of invoking perf: one is to use the `--perf` flag when
-running tests, which will profile each node during the entire test run: perf
-begins to profile when the node starts and ends when it shuts down. The other
-way is the use the `profile_with_perf` context manager, e.g.
-
-```python
-with node.profile_with_perf("send-big-msgs"):
-    # Perform activity on the node you're interested in profiling, e.g.:
-    for _ in range(10000):
-        node.p2ps[0].send_without_ping(some_large_message)
-```
-
-To see useful textual output, run
-
-```sh
-perf report -i /path/to/datadir/send-big-msgs.perf.data.xxxx --stdio | c++filt | less
-```
-
-#### See also:
-
-- [Installing perf](https://askubuntu.com/q/50145)
-- [Perf examples](https://www.brendangregg.com/perf.html)
-- [Hotspot](https://github.com/KDAB/hotspot): a GUI for perf output analysis
diff --git a/test/functional/feature_init.py b/test/functional/feature_init.py
index 259e07b18695..ad20e39cda88 100755
--- a/test/functional/feature_init.py
+++ b/test/functional/feature_init.py
@@ -77,10 +77,10 @@ def sigterm_node():
             b'net thread start',
             b'addcon thread start',
             b'initload thread start',
-            b'txindex thread start',
-            b'block filter index thread start',
-            b'coinstatsindex thread start',
-            b'txospenderindex thread start',
+            b'txidx thread start',
+            b'blkfltbscidx thread start',
+            b'coinstatsidx thread start',
+            b'txospenderidx thread start',
             b'msghand thread start',
             b'net thread start',
             b'addcon thread start',
@@ -323,12 +323,48 @@ def init_empty_test(self):
         for option in options:
             self.restart_node(1, option)
 
+    def restart_node_with_fd_limit(self, limit):
+        """Restart node 1 with a given soft RLIMIT_NOFILE. Skips if the limit cannot be set."""
+        import resource
+        soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
+        try:
+            resource.setrlimit(resource.RLIMIT_NOFILE, (limit, hard))
+        except (ValueError, OSError):
+            self.log.info(f"Skipping rlimit test: cannot set soft limit (hard={hard})")
+            return
+        try:
+            self.restart_node(1)
+            self.log.debug(f"Node started successfully with RLIM_INFINITY limit (soft={limit})")
+        finally:
+            resource.setrlimit(resource.RLIMIT_NOFILE, (soft, hard))
+            self.log.debug(f"Restored previous RLIMIT_NOFILE limits (soft={soft}, hard={hard})")
+
+    def init_rlimit_test(self):
+        """Test that bitcoind starts correctly when the soft RLIMIT_NOFILE limit is RLIM_INFINITY."""
+        if self.RLIM_INFINITY is None:
+            self.log.info("Skipping: resource module not available")
+            return
+
+        self.log.info("Testing node startup with RLIM_INFINITY fd limit")
+        self.restart_node_with_fd_limit(self.RLIM_INFINITY)
+
+    def init_rlimit_large_test(self):
+        """Test that bitcoind starts correctly when the soft RLIMIT_NOFILE limit is above INT_MAX."""
+        if self.RLIM_INFINITY is None:
+            self.log.info("Skipping: resource module not available")
+            return
+
+        self.log.info("Testing node startup with fd limit above INT_MAX")
+        self.restart_node_with_fd_limit(1 << 31)
+
     def run_test(self):
         self.init_pid_test()
         self.init_stress_test_interrupt()
         self.init_stress_test_removals()
         self.break_wait_test()
         self.init_empty_test()
+        self.init_rlimit_test()
+        self.init_rlimit_large_test()
 
 
 if __name__ == '__main__':
diff --git a/test/functional/feature_prune_stale_fork.py b/test/functional/feature_prune_stale_fork.py
new file mode 100755
index 000000000000..5badca0a7cfc
--- /dev/null
+++ b/test/functional/feature_prune_stale_fork.py
@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026-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.
+"""Test node restart with a pruned stale-fork block whose parent has no transactions."""
+
+from test_framework.blocktools import create_empty_fork
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal, assert_raises_rpc_error
+
+
+class FeaturePruneStaleForkTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.extra_args = [["-prune=1", "-fastprune"]]
+
+    def run_test(self):
+        node = self.nodes[0]
+
+        self.log.info("Create a 2-block stale fork: parent has no transactions, child has transactions")
+        [side_parent, side_child] = create_empty_fork(node, 2)
+
+        node.submitheader(side_parent.serialize().hex())
+        node.submitblock(side_child.serialize().hex())
+        assert_equal(node.getblockheader(side_parent.hash_hex)["nTx"], 0)
+        assert_equal(node.getblockheader(side_child.hash_hex)["nTx"], 1)
+
+        self.log.info("Advance and prune so the stale-fork child's block data is removed from disk")
+        self.generate(node, 500)
+        node.pruneblockchain(node.getblockcount() - 100)
+        assert_raises_rpc_error(-1, "Block not available (pruned data)", node.getblock, side_child.hash_hex)
+
+        self.log.info("Restart and mine; node must reload cleanly after the stale-fork child was pruned")
+        self.restart_node(0)
+        self.generate(node, 1)
+
+
+if __name__ == '__main__':
+    FeaturePruneStaleForkTest(__file__).main()
diff --git a/test/functional/feature_settings.py b/test/functional/feature_settings.py
index 9a4138b93602..0585e056ff42 100755
--- a/test/functional/feature_settings.py
+++ b/test/functional/feature_settings.py
@@ -73,7 +73,7 @@ def run_test(self):
         # Test invalid json
         with settings.open("w") as fp:
             fp.write("invalid json")
-        node.assert_start_raises_init_error(expected_msg='does not contain valid JSON. This is probably caused by disk corruption or a crash', match=ErrorMatch.PARTIAL_REGEX)
+        node.assert_start_raises_init_error(expected_msg='does not contain valid JSON. This may be caused by a crash, power loss, full disk, or storage error', match=ErrorMatch.PARTIAL_REGEX)
 
         # Test invalid json object
         with settings.open("w") as fp:
diff --git a/test/functional/mempool_cluster.py b/test/functional/mempool_cluster.py
index 0dfa6b09ef3f..a05377ab7602 100755
--- a/test/functional/mempool_cluster.py
+++ b/test/functional/mempool_cluster.py
@@ -30,13 +30,12 @@ def weight_to_vsize(weight):
 
 def cleanup(func):
     def wrapper(self, *args, **kwargs):
-        try:
-            func(self, *args, **kwargs)
-        finally:
-            # Mine blocks to clear the mempool and replenish the wallet's confirmed UTXOs.
-            while (len(self.nodes[0].getrawmempool()) > 0):
-                self.generate(self.nodes[0], 1)
-            self.wallet.rescan_utxos(include_mempool=True)
+        func(self, *args, **kwargs)
+
+        # Mine blocks to clear the mempool and replenish the wallet's confirmed UTXOs.
+        while (len(self.nodes[0].getrawmempool()) > 0):
+            self.generate(self.nodes[0], 1)
+        self.wallet.rescan_utxos(include_mempool=True)
     return wrapper
 
 class MempoolClusterTest(BitcoinTestFramework):
diff --git a/test/functional/mempool_truc.py b/test/functional/mempool_truc.py
index e3abe039344c..96de2ca93ccc 100755
--- a/test/functional/mempool_truc.py
+++ b/test/functional/mempool_truc.py
@@ -29,15 +29,14 @@
 def cleanup(extra_args=None):
     def decorator(func):
         def wrapper(self):
-            try:
-                if extra_args is not None:
-                    self.restart_node(0, extra_args=extra_args)
-                func(self)
-            finally:
-                # Clear mempool again after test
-                self.generate(self.nodes[0], 1)
-                if extra_args is not None:
-                    self.restart_node(0)
+            if extra_args is not None:
+                self.restart_node(0, extra_args=extra_args)
+            func(self)
+
+            # Clear mempool again after test
+            self.generate(self.nodes[0], 1)
+            if extra_args is not None:
+                self.restart_node(0)
         return wrapper
     return decorator
 
diff --git a/test/functional/p2p_bip434_feature.py b/test/functional/p2p_bip434_feature.py
new file mode 100755
index 000000000000..ccb8144a91b3
--- /dev/null
+++ b/test/functional/p2p_bip434_feature.py
@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+# 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.
+
+"""Test BIP434 feature negotiation."""
+
+from test_framework.messages import (
+    msg_version,
+    ser_compact_size,
+)
+from test_framework.p2p import (
+    P2PInterface,
+    P2P_SERVICES,
+    P2P_SUBVERSION,
+    P2P_VERSION_RELAY,
+)
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal
+
+# Pre-BIP434 protocol version
+PRE_FEATURE_VERSION = 70016
+# Protocol version which enables BIP434 FEATURE negotiation
+FEATURE_VERSION = 70017
+# BIP434 wire-format limits
+MIN_FEATUREID_LENGTH = 4
+MAX_FEATUREID_LENGTH = 80
+MAX_FEATUREDATA_LENGTH = 512
+
+
+class RawFeature:
+    """A FEATURE message with a hand-crafted payload."""
+    msgtype = b"feature"
+
+    def __init__(self, payload):
+        self.payload = payload
+
+    def serialize(self):
+        return self.payload
+
+    def __repr__(self):
+        return f"RawFeature(payload_len={len(self.payload)})"
+
+
+def feature_wire(feature_id, feature_data, *, trailing=b""):
+    """Build a FEATURE payload plus optional trailing bytes."""
+    if isinstance(feature_id, str):
+        feature_id = feature_id.encode()
+    return (ser_compact_size(len(feature_id)) + feature_id
+            + ser_compact_size(len(feature_data)) + feature_data
+            + trailing)
+
+
+def _version_msg(nversion):
+    v = msg_version()
+    v.nVersion = nversion
+    v.strSubVer = P2P_SUBVERSION
+    v.nServices = P2P_SERVICES
+    v.relay = P2P_VERSION_RELAY
+    return v
+
+
+class FeaturePeer(P2PInterface):
+    """P2PInterface that counts FEATURE messages received."""
+
+    def __init__(self):
+        super().__init__()
+        self.got_feature_count = 0
+        self.last_feature = None
+
+    def on_feature(self, message):
+        self.got_feature_count += 1
+        self.last_feature = message
+
+
+class FeaturePeerNoVerack(FeaturePeer):
+    """Peer that records but does not auto-reply to the node's VERSION, so the
+    node stays in the post-VERSION / pre-VERACK window where FEATURE messages
+    are valid to send."""
+
+    def on_version(self, message):
+        self.nServices = message.nServices
+        self.relay = message.relay
+
+
+class P2PBIP434FeatureTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+        # peertimeout=999 prevents the node from kicking the peer for being idle
+        self.extra_args = [["-debug=net", "-peertimeout=999"]]
+
+    def run_test(self):
+        self.test_advertised_version()
+        self.test_no_feature_to_pre_70017_peer()
+        self.test_features_announced_to_modern_peer()
+        self.test_feature_after_verack_disconnects()
+        self.test_feature_before_version_ignored()
+        self.test_feature_id_length_boundaries()
+        self.test_feature_data_length_boundaries()
+        self.test_trailing_bytes_disconnect()
+        self.test_truncated_feature_id_disconnect()
+        self.test_truncated_feature_data_disconnect()
+        self.test_non_ascii_feature_id_accepted()
+        self.test_many_features_in_handshake()
+        self.test_recv_feature_from_pre_70017_peer()
+
+    def _silent_peer(self, *, nversion=FEATURE_VERSION):
+        peer = self.nodes[0].add_p2p_connection(
+            FeaturePeerNoVerack(),
+            send_version=False, wait_for_verack=False,
+        )
+        peer.send_without_ping(_version_msg(nversion))
+        peer.wait_for_verack()
+        return peer
+
+    def _expect_accept(self, payload, *, log_substring="unknown feature advertised",
+                      nversion=FEATURE_VERSION):
+        peer = self._silent_peer(nversion=nversion)
+        with self.nodes[0].assert_debug_log([log_substring], timeout=2):
+            peer.send_without_ping(RawFeature(payload))
+        assert peer.is_connected, "peer disconnected after a well-formed FEATURE"
+        self.nodes[0].disconnect_p2ps()
+
+    def _expect_disconnect(self, payload, *, log_substring="invalid feature payload",
+                          nversion=FEATURE_VERSION):
+        peer = self._silent_peer(nversion=nversion)
+        with self.nodes[0].assert_debug_log([log_substring], timeout=2):
+            peer.send_without_ping(RawFeature(payload))
+            peer.wait_for_disconnect()
+
+    def test_advertised_version(self):
+        self.log.info("Test that node advertises FEATURE to peer with protocol version 70017")
+        peer = self.nodes[0].add_p2p_connection(FeaturePeer())
+        assert_equal(peer.last_message["version"].nVersion, FEATURE_VERSION)
+        self.nodes[0].disconnect_p2ps()
+
+    def test_no_feature_to_pre_70017_peer(self):
+        self.log.info("Test that node doesn't send FEATURE to a peer with protocol version <70017")
+        peer = self.nodes[0].add_p2p_connection(
+            FeaturePeer(), send_version=False, wait_for_verack=False,
+        )
+        peer.send_without_ping(_version_msg(PRE_FEATURE_VERSION))
+        peer.wait_for_verack()
+        # The node's full handshake has now been delivered to us; if any
+        # FEATURE would have been sent it would be in last_message by now.
+        assert_equal(peer.got_feature_count, 0)
+        self.nodes[0].disconnect_p2ps()
+
+    def test_features_announced_to_modern_peer(self):
+        self.log.info("Test that node announces correct number of features to a 70017 peer")
+        peer = self.nodes[0].add_p2p_connection(FeaturePeer())
+        assert_equal(peer.got_feature_count, 0)
+        self.nodes[0].disconnect_p2ps()
+
+    def test_feature_after_verack_disconnects(self):
+        self.log.info("Test that FEATURE after VERACK triggers disconnect")
+        peer = self.nodes[0].add_p2p_connection(FeaturePeer())
+        peer.sync_with_ping()  # ensure node has set fSuccessfullyConnected
+        with self.nodes[0].assert_debug_log(["feature received after verack"], timeout=2):
+            peer.send_without_ping(RawFeature(feature_wire(b"abcd", b"")))
+            peer.wait_for_disconnect()
+
+    def test_feature_before_version_ignored(self):
+        self.log.info("Test that FEATURE before any VERSION is silently ignored")
+        peer = self.nodes[0].add_p2p_connection(
+            FeaturePeer(), send_version=False, wait_for_verack=False,
+        )
+        with self.nodes[0].assert_debug_log(
+            ["non-version message before version handshake"], timeout=2,
+        ):
+            peer.send_without_ping(RawFeature(feature_wire(b"abcd", b"")))
+        assert peer.is_connected
+        self.nodes[0].disconnect_p2ps()
+
+    def test_feature_id_length_boundaries(self):
+        self.log.info("Test feature_id length boundaries")
+        for length, accept in [(0, False),
+                               (3, False),
+                               (MIN_FEATUREID_LENGTH, True),
+                               (MAX_FEATUREID_LENGTH, True),
+                               (MAX_FEATUREID_LENGTH + 1, False)]:
+            payload = feature_wire(b"a" * length, b"")
+            if accept:
+                self._expect_accept(payload)
+            else:
+                self._expect_disconnect(payload)
+
+    def test_feature_data_length_boundaries(self):
+        self.log.info("Test feature_data length boundaries")
+        for length, accept in [(0, True),
+                               (MAX_FEATUREDATA_LENGTH, True),
+                               (MAX_FEATUREDATA_LENGTH + 1, False)]:
+            payload = feature_wire(b"abcd", b"\x00" * length)
+            if accept:
+                self._expect_accept(payload)
+            else:
+                self._expect_disconnect(payload)
+
+    def test_trailing_bytes_disconnect(self):
+        self.log.info("Test that trailing bytes after data triggers disconnect")
+        self._expect_disconnect(
+            feature_wire(b"abcd", b"", trailing=b"\x00"),
+        )
+
+    def test_truncated_feature_id_disconnect(self):
+        self.log.info("Test that truncated feature_id triggers disconnect")
+        payload = ser_compact_size(10) + b"abcde"
+        self._expect_disconnect(payload)
+
+    def test_truncated_feature_data_disconnect(self):
+        self.log.info("Test that truncated feature_data triggers disconnect")
+        payload = (ser_compact_size(MIN_FEATUREID_LENGTH) + b"abcd"
+                   + ser_compact_size(10) + b"xx")
+        self._expect_disconnect(payload)
+
+    def test_non_ascii_feature_id_accepted(self):
+        self.log.info("Test that feature_id with non-ASCII bytes is still accepted")
+        # BIP says SHOULD, not MUST, on this
+        self._expect_accept(feature_wire(b"\x00\xff\x01\x7f", b""))
+
+    def test_many_features_in_handshake(self):
+        self.log.info("Test multiple FEATURE advertisements")
+        peer = self._silent_peer()
+        with self.nodes[0].assert_debug_log(["unknown feature advertised"], timeout=2):
+            for i in range(16):
+                peer.send_without_ping(
+                    RawFeature(feature_wire(f"feat{i:04d}".encode(), b""))
+                )
+        assert peer.is_connected
+        self.nodes[0].disconnect_p2ps()
+
+    def test_recv_feature_from_pre_70017_peer(self):
+        self.log.info("Test that FEATURE from <70017 peer triggers disconnect")
+        self._expect_disconnect(
+            feature_wire(b"abcd", b""),
+            log_substring="feature received with incompatible version",
+            nversion=PRE_FEATURE_VERSION,
+        )
+
+
+if __name__ == "__main__":
+    P2PBIP434FeatureTest(__file__).main()
diff --git a/test/functional/p2p_leak.py b/test/functional/p2p_leak.py
index ec7b9dc209fc..71046edb4b9c 100755
--- a/test/functional/p2p_leak.py
+++ b/test/functional/p2p_leak.py
@@ -5,7 +5,7 @@
 """Test message sending before handshake completion.
 
 Before receiving a VERACK, a node should not send anything but VERSION/VERACK
-and feature negotiation messages (WTXIDRELAY, SENDADDRV2).
+and feature negotiation messages (WTXIDRELAY, SENDADDRV2, FEATURE).
 
 This test connects to a node and sends it a few messages, trying to entice it
 into sending us something it shouldn't."""
@@ -39,6 +39,7 @@ def __init__(self):
         self.ever_connected = False
         self.got_wtxidrelay = False
         self.got_sendaddrv2 = False
+        self.got_feature = False
 
     def bad_message(self, message):
         self.unexpected_msg = True
@@ -70,6 +71,7 @@ def on_getblocktxn(self, message): self.bad_message(message)
     def on_blocktxn(self, message): self.bad_message(message)
     def on_wtxidrelay(self, message): self.got_wtxidrelay = True
     def on_sendaddrv2(self, message): self.got_sendaddrv2 = True
+    def on_feature(self, message): self.got_feature = True
 
 
 # Peer that sends a version but not a verack.
@@ -119,7 +121,7 @@ def run_test(self):
         no_verack_idle_peer = self.nodes[0].add_p2p_connection(NoVerackIdlePeer(), wait_for_verack=False)
 
         # Pre-wtxidRelay peer that sends a version but not a verack and does not support feature negotiation
-        # messages which start at nVersion == 70016
+        # messages which start at nVersion >= 70016
         pre_wtxidrelay_peer = self.nodes[0].add_p2p_connection(NoVerackIdlePeer(), send_version=False, wait_for_verack=False)
         pre_wtxidrelay_peer.send_without_ping(self.create_old_version(70015))
 
@@ -145,14 +147,17 @@ def run_test(self):
         assert not no_version_idle_peer.unexpected_msg
         assert not no_version_idle_peer.got_wtxidrelay
         assert not no_version_idle_peer.got_sendaddrv2
+        assert not no_version_idle_peer.got_feature
 
         assert not no_verack_idle_peer.unexpected_msg
         assert no_verack_idle_peer.got_wtxidrelay
         assert no_verack_idle_peer.got_sendaddrv2
+        #assert no_verack_idle_peer.got_feature ## uncomment once a feature message is supported
 
         assert not pre_wtxidrelay_peer.unexpected_msg
         assert not pre_wtxidrelay_peer.got_wtxidrelay
         assert not pre_wtxidrelay_peer.got_sendaddrv2
+        assert not pre_wtxidrelay_peer.got_feature
 
         # Expect peers to be disconnected due to timeout
         assert not no_version_idle_peer.is_connected
diff --git a/test/functional/p2p_opportunistic_1p1c.py b/test/functional/p2p_opportunistic_1p1c.py
index ef4440b9ecb6..77616de13e57 100755
--- a/test/functional/p2p_opportunistic_1p1c.py
+++ b/test/functional/p2p_opportunistic_1p1c.py
@@ -58,18 +58,17 @@
 
 def cleanup(func):
     def wrapper(self, *args, **kwargs):
-        try:
-            func(self, *args, **kwargs)
-        finally:
-            self.nodes[0].disconnect_p2ps()
-            # Do not clear the node's mempool, as each test requires mempool min feerate > min
-            # relay feerate. However, do check that this is the case.
-            assert self.nodes[0].getmempoolinfo()["mempoolminfee"] > self.nodes[0].getnetworkinfo()["relayfee"]
-            # Ensure we do not try to spend the same UTXOs in subsequent tests, as they will look like RBF attempts.
-            self.wallet.rescan_utxos(include_mempool=True)
-
-            # Resets if mocktime was used
-            self.nodes[0].setmocktime(0)
+        func(self, *args, **kwargs)
+
+        self.nodes[0].disconnect_p2ps()
+        # Do not clear the node's mempool, as each test requires mempool min feerate > min
+        # relay feerate. However, do check that this is the case.
+        assert_greater_than(self.nodes[0].getmempoolinfo()["mempoolminfee"], self.nodes[0].getnetworkinfo()["relayfee"])
+        # Ensure we do not try to spend the same UTXOs in subsequent tests, as they will look like RBF attempts.
+        self.wallet.rescan_utxos(include_mempool=True)
+
+        # Resets if mocktime was used
+        self.nodes[0].setmocktime(0)
     return wrapper
 
 class PackageRelayTest(BitcoinTestFramework):
diff --git a/test/functional/p2p_orphan_handling.py b/test/functional/p2p_orphan_handling.py
index 4cd59f8ff14b..3d94f0338a23 100755
--- a/test/functional/p2p_orphan_handling.py
+++ b/test/functional/p2p_orphan_handling.py
@@ -50,20 +50,19 @@
 
 def cleanup(func):
     def wrapper(self):
-        try:
-            func(self)
-        finally:
-            # Clear mempool
-            self.generate(self.nodes[0], 1)
-            self.nodes[0].disconnect_p2ps()
-            # Check that mempool and orphanage have been cleared
-            self.wait_until(lambda: len(self.nodes[0].getorphantxs()) == 0)
-            assert_equal(0, len(self.nodes[0].getrawmempool()))
-
-            self.restart_node(0, extra_args=["-persistmempool=0"])
-            # Allow use of bumpmocktime again
-            self.nodes[0].setmocktime(int(time.time()))
-            self.wallet.rescan_utxos(include_mempool=True)
+        func(self)
+
+        # Clear mempool
+        self.generate(self.nodes[0], 1)
+        self.nodes[0].disconnect_p2ps()
+        # Check that mempool and orphanage have been cleared
+        self.wait_until(lambda: len(self.nodes[0].getorphantxs()) == 0)
+        assert_equal(0, len(self.nodes[0].getrawmempool()))
+
+        self.restart_node(0, extra_args=["-persistmempool=0"])
+        # Allow use of bumpmocktime again
+        self.nodes[0].setmocktime(int(time.time()))
+        self.wallet.rescan_utxos(include_mempool=True)
     return wrapper
 
 class PeerTxRelayer(P2PTxInvStore):
diff --git a/test/functional/p2p_private_broadcast.py b/test/functional/p2p_private_broadcast.py
index e8eaee6f3939..638028af192a 100755
--- a/test/functional/p2p_private_broadcast.py
+++ b/test/functional/p2p_private_broadcast.py
@@ -14,7 +14,6 @@
     P2PDataStore,
     P2PInterface,
     P2P_SERVICES,
-    P2P_VERSION,
     start_p2p_listener,
 )
 from test_framework.messages import (
@@ -46,6 +45,7 @@
     MiniWallet,
 )
 
+P2P_PRIVATE_VERSION = 70016
 NUM_PRIVATE_BROADCAST_PER_TX = 3
 
 
@@ -195,7 +195,7 @@ def get_destinations_len():
             })
             dummy_address = CAddress()
             dummy_address.nServices = 0
-            assert_equal(peer.last_message["version"].nVersion, P2P_VERSION)
+            assert_equal(peer.last_message["version"].nVersion, P2P_PRIVATE_VERSION)
             assert_equal(peer.last_message["version"].nServices, 0)
             assert_equal(peer.last_message["version"].nTime, 0)
             assert_equal(peer.last_message["version"].addrTo, dummy_address)
@@ -223,6 +223,12 @@ def run_test(self):
         tx_receiver = self.nodes[1]
         far_observer = tx_receiver.add_p2p_connection(P2PInterface())
 
+        self.log.info("Test getprivatebroadcastinfo and abortprivatebroadcast fails if the node is running without -privatebroadcast set")
+        assert_raises_rpc_error(-32601, "Private broadcast is not enabled. Ensure you're running Bitcoin Core with -privatebroadcast=1.",
+            tx_receiver.getprivatebroadcastinfo)
+        assert_raises_rpc_error(-32601, "Private broadcast is not enabled. Ensure you're running Bitcoin Core with -privatebroadcast=1.",
+            tx_receiver.abortprivatebroadcast, "00" * 32)
+
         self.fill_node_addrman(node_index=0, address_types_to_add=[CAddress.NET_IPV4, CAddress.NET_IPV6, CAddress.NET_TORV3, CAddress.NET_I2P, CAddress.NET_CJDNS])
 
         wallet = MiniWallet(tx_originator)
diff --git a/test/functional/rpc_blockchain.py b/test/functional/rpc_blockchain.py
index bf7c7d117aae..d731907fd8ca 100755
--- a/test/functional/rpc_blockchain.py
+++ b/test/functional/rpc_blockchain.py
@@ -290,6 +290,8 @@ def _test_y2106(self):
         self.log.info("Check that block timestamps work until year 2106")
         self.generate(self.nodes[0], 8)[-1]
         time_2106 = 2**32 - 1
+        assert_raises_rpc_error(-8, f"Mocktime must be in the range [0, {time_2106}], not -1.", self.nodes[0].setmocktime, -1)
+        assert_raises_rpc_error(-8, f"Mocktime must be in the range [0, {time_2106}], not {time_2106 + 1}.", self.nodes[0].setmocktime, time_2106 + 1)
         self.nodes[0].setmocktime(time_2106)
         last = self.generate(self.nodes[0], 6)[-1]
         assert_equal(self.nodes[0].getblockheader(last)["mediantime"], time_2106)
diff --git a/test/functional/rpc_uptime.py b/test/functional/rpc_uptime.py
index 48256e2f9ebe..96c2fcb3bcad 100755
--- a/test/functional/rpc_uptime.py
+++ b/test/functional/rpc_uptime.py
@@ -10,7 +10,6 @@
 import time
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_raises_rpc_error
 
 
 class UptimeTest(BitcoinTestFramework):
@@ -19,12 +18,8 @@ def set_test_params(self):
         self.setup_clean_chain = True
 
     def run_test(self):
-        self._test_negative_time()
         self._test_uptime()
 
-    def _test_negative_time(self):
-        assert_raises_rpc_error(-8, "Mocktime must be in the range [0, 9223372036], not -1.", self.nodes[0].setmocktime, -1)
-
     def _test_uptime(self):
         time.sleep(1) # Do some work before checking uptime
         uptime_before = self.nodes[0].uptime()
diff --git a/test/functional/test-shell.md b/test/functional/test-shell.md
index 526c67f69050..0c2b7d3d43a3 100644
--- a/test/functional/test-shell.md
+++ b/test/functional/test-shell.md
@@ -180,7 +180,6 @@ can be called after the TestShell is shut down.
 | `loglevel` | `INFO` | Logs events at this level and higher. Can be set to `DEBUG`, `INFO`, `WARNING`, `ERROR` or `CRITICAL`. |
 | `nocleanup` | `False` | Cleans up temporary test directory if set to `True` during `shutdown`. |
 | `num_nodes` | `1` | Sets the number of initialized bitcoind processes. |
-| `perf` | False | Profiles running nodes with `perf` for the duration of the test if set to `True`. |
 | `rpc_timeout` | `60` | Sets the RPC server timeout for the underlying bitcoind processes. |
 | `setup_clean_chain` | `False` | A 200-block-long chain is initialized from cache by default. Instead, `setup_clean_chain` initializes an empty blockchain if set to `True`. |
 | `randomseed` | Random Integer | `TestShell().options.randomseed` is a member of `TestShell` which can be accessed during a test to seed a random generator. User can override default with a constant value for reproducible test runs. |
diff --git a/test/functional/test_framework/authproxy.py b/test/functional/test_framework/authproxy.py
index 0377414acceb..100372a4a456 100644
--- a/test/functional/test_framework/authproxy.py
+++ b/test/functional/test_framework/authproxy.py
@@ -169,7 +169,7 @@ def _get_response(self):
                 'message': '%r RPC took longer than %f seconds. Consider '
                            'using larger timeout for calls that take '
                            'longer to return.' % (self._service_name,
-                                                  self.__conn.timeout)})
+                                                  self.__conn.timeout)}) from None
         if http_response is None:
             raise JSONRPCException({
                 'code': -342, 'message': 'missing HTTP response from server'})
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index a0f2a1740236..07abd5b6eb09 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -1928,6 +1928,28 @@ def __repr__(self):
         return "msg_sendtxrcncl(version=%lu, salt=%lu)" %\
             (self.version, self.salt)
 
+class msg_feature:
+    """FEATURE message for negotiating optional features."""
+    __slots__ = ("feature_id", "feature_data")
+    msgtype = b"feature"
+
+    def __init__(self, feature_id="", feature_data=b""):
+        self.feature_id = feature_id
+        self.feature_data = feature_data
+
+    def deserialize(self, f):
+        self.feature_id = deser_string(f).decode()
+        self.feature_data = deser_string(f)
+
+    def serialize(self):
+        r = ser_string(self.feature_id.encode())
+        r += ser_string(self.feature_data)
+        return r
+
+    def __repr__(self):
+        return f"msg_feature(feature_id={self.feature_id}, data={self.feature_data.hex()})"
+
+
 class TestFrameworkScript(unittest.TestCase):
     def test_addrv2_encode_decode(self):
         def check_addrv2(ip, net):
diff --git a/test/functional/test_framework/p2p.py b/test/functional/test_framework/p2p.py
index 4d812ce3b19d..803194791bfa 100755
--- a/test/functional/test_framework/p2p.py
+++ b/test/functional/test_framework/p2p.py
@@ -43,6 +43,7 @@
     msg_cfheaders,
     msg_cfilter,
     msg_cmpctblock,
+    msg_feature,
     msg_feefilter,
     msg_filteradd,
     msg_filterclear,
@@ -99,7 +100,8 @@
 MIN_P2P_VERSION_SUPPORTED = 60001
 # The P2P version that this test framework implements and sends in its `version` message
 # Version 70016 supports wtxid relay
-P2P_VERSION = 70016
+# Version 70017 supports feature
+P2P_VERSION = 70017
 # The services that this test framework offers in its `version` message
 P2P_SERVICES = NODE_NETWORK | NODE_WITNESS
 # The P2P user agent string that this test framework sends in its `version` message
@@ -124,6 +126,7 @@
     b"cfheaders": msg_cfheaders,
     b"cfilter": msg_cfilter,
     b"cmpctblock": msg_cmpctblock,
+    b"feature": msg_feature,
     b"feefilter": msg_feefilter,
     b"filteradd": msg_filteradd,
     b"filterclear": msg_filterclear,
@@ -543,6 +546,7 @@ def on_cfcheckpt(self, message): pass
     def on_cfheaders(self, message): pass
     def on_cfilter(self, message): pass
     def on_cmpctblock(self, message): pass
+    def on_feature(self, message): pass
     def on_feefilter(self, message): pass
     def on_filteradd(self, message): pass
     def on_filterclear(self, message): pass
diff --git a/test/functional/test_framework/test_framework.py b/test/functional/test_framework/test_framework.py
index 1e2ac6339669..64dcbfd7ec58 100755
--- a/test/functional/test_framework/test_framework.py
+++ b/test/functional/test_framework/test_framework.py
@@ -8,6 +8,7 @@
 from enum import Enum
 import argparse
 from datetime import datetime, timezone
+from importlib.util import find_spec
 import logging
 import os
 from pathlib import Path
@@ -191,8 +192,6 @@ def parse_args(self, test_file):
                             help="Attach a python debugger if test fails")
         parser.add_argument("--usecli", dest="usecli", default=False, action="store_true",
                             help="use bitcoin-cli instead of RPC for all commands")
-        parser.add_argument("--perf", dest="perf", default=False, action="store_true",
-                            help="profile running nodes with perf for the duration of the test")
         parser.add_argument("--valgrind", dest="valgrind", default=False, action="store_true",
                             help="Run binaries under the valgrind memory error detector: Expect at least a ~10x slowdown. Does not apply to previous release binaries.")
         parser.add_argument("--randomseed", type=int,
@@ -292,15 +291,11 @@ def shutdown(self):
 
         should_clean_up = (
             not self.options.nocleanup and
-            self.success != TestStatus.FAILED and
-            not self.options.perf
+            self.success != TestStatus.FAILED
         )
         if should_clean_up:
             self.log.info("Cleaning up {} on exit".format(self.options.tmpdir))
             cleanup_tree_on_exit = True
-        elif self.options.perf:
-            self.log.warning("Not cleaning up dir {} due to perf data".format(self.options.tmpdir))
-            cleanup_tree_on_exit = False
         else:
             self.log.warning("Not cleaning up dir {}".format(self.options.tmpdir))
             cleanup_tree_on_exit = False
@@ -482,7 +477,6 @@ def bin_dir_from_version(version):
                 extra_conf=extra_confs[i],
                 extra_args=args,
                 use_cli=self.options.usecli,
-                start_perf=self.options.perf,
                 v2transport=self.options.v2transport,
                 uses_wallet=self.uses_wallet,
             )
@@ -1089,6 +1083,17 @@ def skip_if_no_previous_releases(self):
         if not self.has_previous_releases():
             raise SkipTest("previous releases not available or disabled")
 
+    def has_resource_module(self):
+        """Checks whether the resource module is available."""
+        return find_spec('resource') is not None
+
+    @property
+    def RLIM_INFINITY(self):
+        if not self.has_resource_module():
+            return None
+        import resource
+        return resource.RLIM_INFINITY
+
     def has_previous_releases(self):
         """Checks whether previous releases are present and enabled."""
         if not os.path.isdir(self.options.previous_releases_path):
diff --git a/test/functional/test_framework/test_node.py b/test/functional/test_framework/test_node.py
index 22d76cacbcf6..77a7fcb4c8b4 100755
--- a/test/functional/test_framework/test_node.py
+++ b/test/functional/test_framework/test_node.py
@@ -18,7 +18,6 @@
 import time
 import urllib.parse
 import collections
-import shlex
 import sys
 from collections.abc import Iterable
 from pathlib import Path
@@ -109,18 +108,11 @@ def __init__(
         extra_conf=None,
         extra_args=None,
         use_cli=False,
-        start_perf=False,
         version=None,
         v2transport=False,
         uses_wallet=False,
         ipcbind=False,
     ):
-        """
-        Kwargs:
-            start_perf (bool): If True, begin profiling the node with `perf` as soon as
-                the node starts.
-        """
-
         self.index = i
         self.datadir_path = datadir_path
         self.bitcoinconf = self.datadir_path / "bitcoin.conf"
@@ -191,7 +183,6 @@ def __init__(
 
         self.cli = None
         self.use_cli = use_cli
-        self.start_perf = start_perf
 
         self.running = False
         self.process = None
@@ -200,8 +191,6 @@ def __init__(
         self.reuse_http_connections = True # Must be set before create_new_rpc_connection(), i.e. before restarting node
         self.url = None
         self.log = logging.getLogger('TestFramework.node%d' % i)
-        # Cache perf subprocesses here by their data output filename.
-        self.perf_subprocesses = {}
 
         self.p2ps = []
 
@@ -298,9 +287,6 @@ def start(self, extra_args=None, *, cwd=None, stdout=None, stderr=None, env=None
         self.running = True
         self.log.debug("bitcoind started, waiting for RPC to come up")
 
-        if self.start_perf:
-            self._start_perf()
-
     def create_new_rpc_connection(self, *, mode="AUTO", client_timeout=None):
         """Create an additional RPC connection, likely to be used in a new thread."""
         mode = RPCConnectionType[mode]
@@ -490,10 +476,6 @@ def stop_node(self, expected_stderr='', *, wait=0, wait_until_stopped=True):
         else:
             self.stop()
 
-        # If there are any running perf processes, stop them.
-        for profile_name in tuple(self.perf_subprocesses.keys()):
-            self._stop_perf(profile_name)
-
         del self.p2ps[:]
 
         assert (not expected_stderr) or wait_until_stopped  # Must wait to check stderr
@@ -679,84 +661,6 @@ def get_highest_peer_id():
         yield
         self.wait_until(lambda: get_highest_peer_id() > initial_peer_id, timeout=timeout)
 
-    @contextlib.contextmanager
-    def profile_with_perf(self, profile_name: str):
-        """
-        Context manager that allows easy profiling of node activity using `perf`.
-
-        See `test/functional/README.md` for details on perf usage.
-
-        Args:
-            profile_name: This string will be appended to the
-                profile data filename generated by perf.
-        """
-        subp = self._start_perf(profile_name)
-
-        yield
-
-        if subp:
-            self._stop_perf(profile_name)
-
-    def _start_perf(self, profile_name=None):
-        """Start a perf process to profile this node.
-
-        Returns the subprocess running perf."""
-        subp = None
-
-        def test_success(cmd):
-            return subprocess.call(
-                # shell=True required for pipe use below
-                cmd, shell=True,
-                stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL) == 0
-
-        if platform.system() != 'Linux':
-            self.log.warning("Can't profile with perf; only available on Linux platforms")
-            return None
-
-        if not test_success('which perf'):
-            self.log.warning("Can't profile with perf; must install perf-tools")
-            return None
-
-        if not test_success('readelf -S {} | grep .debug_str'.format(shlex.quote(self.binary))):
-            self.log.warning(
-                "perf output won't be very useful without debug symbols compiled into bitcoind")
-
-        output_path = tempfile.NamedTemporaryFile(
-            dir=self.datadir_path,
-            prefix="{}.perf.data.".format(profile_name or 'test'),
-            delete=False,
-        ).name
-
-        cmd = [
-            'perf', 'record',
-            '-g',                     # Record the callgraph.
-            '--call-graph', 'dwarf',  # Compatibility for gcc's --fomit-frame-pointer.
-            '-F', '101',              # Sampling frequency in Hz.
-            '-p', str(self.process.pid),
-            '-o', output_path,
-        ]
-        subp = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        self.perf_subprocesses[profile_name] = subp
-
-        return subp
-
-    def _stop_perf(self, profile_name):
-        """Stop (and pop) a perf subprocess."""
-        subp = self.perf_subprocesses.pop(profile_name)
-        output_path = subp.args[subp.args.index('-o') + 1]
-
-        subp.terminate()
-        subp.wait(timeout=10)
-
-        stderr = subp.stderr.read().decode()
-        if 'Consider tweaking /proc/sys/kernel/perf_event_paranoid' in stderr:
-            self.log.warning(
-                "perf couldn't collect data! Try "
-                "'sudo sysctl -w kernel.perf_event_paranoid=-1'")
-        else:
-            report_cmd = "perf report -i {}".format(output_path)
-            self.log.info("See perf output by running '{}'".format(report_cmd))
-
     def assert_start_raises_init_error(self, extra_args=None, expected_msg=None, match=ErrorMatch.FULL_TEXT, *args, **kwargs):
         """Attempt to start the node and expect it to raise an error.
 
diff --git a/test/functional/test_framework/v2_p2p.py b/test/functional/test_framework/v2_p2p.py
index 087b885ae027..4057fd9a8823 100644
--- a/test/functional/test_framework/v2_p2p.py
+++ b/test/functional/test_framework/v2_p2p.py
@@ -50,6 +50,7 @@
     26: b"getcfcheckpt",
     27: b"cfcheckpt",
     28: b"addrv2",
+    37: b"feature",
 }
 
 # Dictionary which contains short message type ID for the P2P message
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 545c50726282..5bfc7d86239b 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -301,6 +301,8 @@
     'wallet_listsinceblock.py',
     'wallet_listdescriptors.py',
     'p2p_leak.py',
+    'p2p_bip434_feature.py',
+    'p2p_bip434_feature.py --v2transport',
     'wallet_encryption.py',
     'feature_dersig.py',
     'feature_reindex_init.py',
@@ -371,6 +373,7 @@
     'wallet_startup.py',
     'p2p_private_broadcast_retry_v1.py',
     'feature_remove_pruned_files_on_startup.py',
+    'feature_prune_stale_fork.py',
     'p2p_i2p_ports.py',
     'p2p_i2p_sessions.py',
     'feature_presegwit_node_upgrade.py',
diff --git a/test/functional/wallet_assumeutxo.py b/test/functional/wallet_assumeutxo.py
index 3f28e36c8050..9c647fa22d83 100755
--- a/test/functional/wallet_assumeutxo.py
+++ b/test/functional/wallet_assumeutxo.py
@@ -215,12 +215,18 @@ def loading_error(height):
         wallet_name = "w1"
         n1.createwallet(wallet_name, disable_private_keys=True)
         key = get_generate_key()
-        time = n1.getblockchaininfo()['time']
+        block_info = n1.getblockchaininfo()
+        time = block_info["time"]
+        def expected_rescan_error(timestamp):
+            return f"Rescan failed for descriptor with timestamp {timestamp}. There was an error reading a block from time {time}, which is after or within 7200 seconds of key creation, and could contain transactions pertaining to the desc. As a result, transactions and coins using this desc may not appear in the wallet. This error is likely caused by an in-progress assumeutxo background sync. Check logs or getchainstates RPC for assumeutxo background sync progress and try again later."
         timestamp = 0
-        expected_error_message = f"Rescan failed for descriptor with timestamp {timestamp}. There was an error reading a block from time {time}, which is after or within 7200 seconds of key creation, and could contain transactions pertaining to the desc. As a result, transactions and coins using this desc may not appear in the wallet. This error is likely caused by an in-progress assumeutxo background sync. Check logs or getchainstates RPC for assumeutxo background sync progress and try again later."
         result = self.import_descriptor(n1, wallet_name, key, timestamp)
         assert_equal(result[0]['error']['code'], -1)
-        assert_equal(result[0]['error']['message'], expected_error_message)
+        assert_equal(result[0]['error']['message'], expected_rescan_error(timestamp))
+        now_timestamp = block_info["mediantime"]
+        result = self.import_descriptor(n1, wallet_name, get_generate_key(), "now")
+        assert_equal(result[0]['error']['code'], -1)
+        assert_equal(result[0]['error']['message'], expected_rescan_error(now_timestamp))
 
         self.log.info("Test that rescanning blocks from before the snapshot fails when blocks are not available from the background sync yet")
         w1 = n1.get_wallet_rpc(wallet_name)
diff --git a/test/functional/wallet_importdescriptors.py b/test/functional/wallet_importdescriptors.py
index 9a3a18029828..f9429079bbdb 100755
--- a/test/functional/wallet_importdescriptors.py
+++ b/test/functional/wallet_importdescriptors.py
@@ -16,6 +16,7 @@
   and test the values returned."""
 
 import concurrent.futures
+import threading
 import time
 
 from test_framework.blocktools import COINBASE_MATURITY
@@ -117,6 +118,82 @@ def test_import_unused_noprivs(self):
                              wallet=wallet)
         wallet.unloadwallet()
 
+    def test_rescan_fails_import(self):
+        xpriv = "tprv8ZgxMBicQKsPeuVhWwi6wuMQGfPKi9Li5GtX35jVNknACgqe3CY4g5xgkfDDJcmtF7o1QnxWDRYw4H5P26PXq7sbcUkEqeR4fg3Kxp2tigg"
+
+        self.log.info("Test importdescriptors fails when wallet is already rescanning")
+        wallet_name = "rescan_wallet"
+        self.nodes[0].createwallet(wallet_name=wallet_name, blank=True)
+        other_desc = descsum_create("pkh(" + get_generate_key().privkey + ")")
+
+        w_import = self.nodes[0].create_new_rpc_connection(mode="AUTHPROXY") / f"wallet/{wallet_name}"
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=2) as thread:
+            w_rescan = self.nodes[0].create_new_rpc_connection(mode="AUTHPROXY") / f"wallet/{wallet_name}"
+            w_conflict = self.nodes[0].create_new_rpc_connection(mode="AUTHPROXY") / f"wallet/{wallet_name}"
+            # Use an xprv with timestamp=0 and a large key-range to trigger a slow full rescan that stays in-flight
+            slow_desc = [{"desc": descsum_create("pkh(" + xpriv + "/0h/*h)"),
+            "timestamp": 0, "range": [0, 10000]}]
+            conflicting_desc = [{"desc": descsum_create("pkh(" + xpriv + "/1h/*h)"),
+            "timestamp": 0, "range": [0, 10000]}]
+
+            start = threading.Barrier(3)
+
+            def import_after_barrier(wallet, descriptors):
+                start.wait(timeout=10)
+                return wallet.importdescriptors(descriptors)
+
+            imports = [
+                thread.submit(import_after_barrier, w_rescan, slow_desc),
+                thread.submit(import_after_barrier, w_conflict, conflicting_desc),
+            ]
+            start.wait(timeout=10)
+
+            # One importdescriptor call must hold WalletRescanReserver while the other fails immediately.
+            num_errors = 0
+            num_success = 0
+            for future in concurrent.futures.as_completed(imports, timeout=30 * self.options.timeout_factor):
+                try:
+                    assert_equal(future.result(), [{'success': True}])
+                    num_success += 1
+                except JSONRPCException as e:
+                    assert_equal(e.error["code"], -4)
+                    assert_equal(e.error["message"], "Wallet is currently rescanning. Abort existing rescan or wait.")
+                    num_errors += 1
+
+            assert_equal(num_success, 1)
+            assert_equal(num_errors, 1)
+
+        # After the rescan finishes, any importdescriptors should succeed.
+        result = w_import.importdescriptors([{"desc": other_desc, "timestamp": "now"}])
+        assert_equal(result[0]['success'], True)
+
+        self.log.info("Aborting an importdescriptors rescan should fail the RPC call")
+        wallet_name = "abort_import_wallet"
+        self.nodes[0].createwallet(wallet_name, blank=True)
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as thread:
+            w_import = self.nodes[0].create_new_rpc_connection(mode="AUTHPROXY") / f"wallet/{wallet_name}"
+            abort_rpc = self.nodes[0].create_new_rpc_connection(mode="AUTHPROXY") / f"wallet/{wallet_name}"
+            descriptor = [{"desc": descsum_create("pkh(" + xpriv + "/2h/*h)"),
+            "timestamp": 0, "range": [0, 4000]}]
+
+            importing = thread.submit(w_import.importdescriptors, descriptor)
+
+            # Keep trying because an abort before ScanForWalletTransactions starts
+            # is reset when the scan loop begins.
+            abort_succeeded = False
+            abort_deadline = time.time() + 30 * self.options.timeout_factor
+            while not importing.done() and time.time() < abort_deadline:
+                abort_succeeded = abort_rpc.abortrescan() or abort_succeeded
+
+            assert_equal(abort_succeeded, True)
+            try:
+                importing.result(timeout=30 * self.options.timeout_factor)
+                raise AssertionError("importdescriptors unexpectedly succeeded")
+            except JSONRPCException as e:
+                assert_equal(e.error["code"], -1)
+                assert_equal(e.error["message"], "Rescan aborted by user.")
 
     def run_test(self):
         self.log.info('Setting up wallets')
@@ -762,6 +839,10 @@ def run_test(self):
         self.nodes[0].createwallet("encrypted_wallet", blank=True, passphrase="passphrase")
         encrypted_wallet = self.nodes[0].get_wallet_rpc("encrypted_wallet")
 
+        self.log.info("Wallet must be unlocked to import a descriptor")
+        assert_raises_rpc_error(-13, "Error: Please enter the wallet passphrase with walletpassphrase first.",
+            encrypted_wallet.importdescriptors, [descriptor])
+
         descriptor["timestamp"] = 0
         descriptor["next_index"] = 0
 
@@ -878,6 +959,7 @@ def run_test(self):
         self.test_import_unused_key()
         self.test_import_unused_key_existing()
         self.test_import_unused_noprivs()
+        self.test_rescan_fails_import()
 
 if __name__ == '__main__':
     ImportDescriptorsTest(__file__).main()
diff --git a/test/functional/wallet_multisig_descriptor_psbt.py b/test/functional/wallet_multisig_descriptor_psbt.py
index 85051c34ab81..527215fa3648 100755
--- a/test/functional/wallet_multisig_descriptor_psbt.py
+++ b/test/functional/wallet_multisig_descriptor_psbt.py
@@ -16,10 +16,9 @@
 
 class WalletMultisigDescriptorPSBTTest(BitcoinTestFramework):
     def set_test_params(self):
-        self.num_nodes = 3
+        self.num_nodes = 1
         self.setup_clean_chain = True
-        self.wallet_names = []
-        self.extra_args = [["-keypool=100"]] * self.num_nodes
+        self.extra_args = [["-keypool=100"]]
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
@@ -47,9 +46,9 @@ def _check_psbt(psbt, to, value, multisig):
 
     def participants_create_multisigs(self, xpubs):
         """The multisig is created by importing the following descriptors. The resulting wallet is watch-only and every participant can do this."""
-        for i, node in enumerate(self.nodes):
-            node.createwallet(wallet_name=f"{self.name}_{i}", blank=True, disable_private_keys=True)
-            multisig = node.get_wallet_rpc(f"{self.name}_{i}")
+        for i in range(self.N):
+            self.node.createwallet(wallet_name=f"{self.name}_{i}", blank=True, disable_private_keys=True)
+            multisig = self.node.get_wallet_rpc(f"{self.name}_{i}")
             multisig_desc = f"wsh(sortedmulti({self.M},{','.join(xpubs)}))"
             checksum = multisig.getdescriptorinfo(multisig_desc)["checksum"]
             result = multisig.importdescriptors([
@@ -64,14 +63,15 @@ def participants_create_multisigs(self, xpubs):
 
     def run_test(self):
         self.M = 2
-        self.N = self.num_nodes
+        self.N = 3
+        self.node = self.nodes[0]
         self.name = f"{self.M}_of_{self.N}_multisig"
         self.log.info(f"Testing {self.name}...")
 
         participants = {
             # Every participant generates an xpub. The most straightforward way is to create a new descriptor wallet.
             # This wallet will be the participant's `signer` for the resulting multisig. Avoid reusing this wallet for any other purpose (for privacy reasons).
-            "signers": [node.get_wallet_rpc(node.createwallet(wallet_name=f"participant_{self.nodes.index(node)}")["name"]) for node in self.nodes],
+            "signers": [self.node.get_wallet_rpc(self.node.createwallet(wallet_name=f"participant_{i}")["name"]) for i in range(self.N)],
             # After participants generate and exchange their xpubs they will each create their own watch-only multisig.
             # Note: these multisigs are all the same, this just highlights that each participant can independently verify everything on their own node.
             "multisigs": []
@@ -94,13 +94,13 @@ def run_test(self):
 
         self.log.info("Get a mature utxo to send to the multisig...")
         coordinator_wallet = participants["signers"][0]
-        self.generatetoaddress(self.nodes[0], 101, coordinator_wallet.getnewaddress())
+        self.generatetoaddress(self.node, 101, coordinator_wallet.getnewaddress())
 
         deposit_amount = 6.15
         multisig_receiving_address = participants["multisigs"][0].getnewaddress()
         self.log.info("Send funds to the resulting multisig receiving address...")
         coordinator_wallet.sendtoaddress(multisig_receiving_address, deposit_amount)
-        self.generate(self.nodes[0], 1)
+        self.generate(self.node, 1)
         for participant in participants["multisigs"]:
             assert_approx(participant.getbalance(), deposit_amount, vspan=0.001)
 
@@ -125,7 +125,7 @@ def run_test(self):
         coordinator_wallet.sendrawtransaction(finalized["hex"])
 
         self.log.info("Check that balances are correct after the transaction has been included in a block.")
-        self.generate(self.nodes[0], 1)
+        self.generate(self.node, 1)
         assert_approx(participants["multisigs"][0].getbalance(), deposit_amount - value, vspan=0.001)
         assert_equal(participants["signers"][self.N - 1].getbalance(), value)
 
@@ -140,7 +140,7 @@ def run_test(self):
         coordinator_wallet.sendrawtransaction(psbt["hex"])
 
         self.log.info("Check that balances are correct after the transaction has been included in a block.")
-        self.generate(self.nodes[0], 1)
+        self.generate(self.node, 1)
         assert_approx(participants["multisigs"][0].getbalance(), deposit_amount - (value * 2), vspan=0.001)
         assert_equal(participants["signers"][self.N - 1].getbalance(), value * 2)
 
diff --git a/test/functional/wallet_musig.py b/test/functional/wallet_musig.py
index c392abaf86a9..fbf0558ec99c 100755
--- a/test/functional/wallet_musig.py
+++ b/test/functional/wallet_musig.py
@@ -112,7 +112,7 @@ def setup_musig_scenario(self, pat):
 
         return wallets, psbt
 
-    def assert_musig_signer_data(self, first, second, different_key):
+    def assert_musig_signer_data(self, first, second, different_field):
         assert_equal(first["participant_pubkey"], second["participant_pubkey"])
         assert_equal(first["aggregate_pubkey"], second["aggregate_pubkey"])
         if "leaf_hash" in first:
@@ -120,7 +120,7 @@ def assert_musig_signer_data(self, first, second, different_key):
         else:
             assert "leaf_hash" not in second
 
-        assert_not_equal(first[different_key], second[different_key])
+        assert_not_equal(first[different_field], second[different_field])
 
     def assert_musig_aggregate_in_script(self, signer_data, pattern, psbtin):
         pubkey = signer_data["aggregate_pubkey"][2:]
@@ -290,8 +290,7 @@ def test_success_case(self, comment, pattern, sighash_type=None, scriptpath=Fals
 
         dec_psbt = self.nodes[0].decodepsbt(comb_nonce_psbt)
         dec_psbt2 = self.nodes[0].decodepsbt(comb_nonce_psbt2)
-        assert_equal(len(dec_psbt["inputs"][0]["musig2_pubnonces"]), expected_pubnonces)
-        assert_equal(len(dec_psbt2["inputs"][0]["musig2_pubnonces"]), expected_pubnonces)
+        assert_equal(len(dec_psbt["inputs"][0]["musig2_pubnonces"]), len(dec_psbt2["inputs"][0]["musig2_pubnonces"]), expected_pubnonces)
         for pn, pn2 in zip(dec_psbt["inputs"][0]["musig2_pubnonces"], dec_psbt2["inputs"][0]["musig2_pubnonces"]):
             self.assert_musig_signer_data(pn, pn2, "pubnonce")
             self.assert_musig_aggregate_in_script(pn, pattern, dec_psbt["inputs"][0])
@@ -312,8 +311,7 @@ def test_success_case(self, comment, pattern, sighash_type=None, scriptpath=Fals
 
         dec_psbt = self.nodes[0].decodepsbt(comb_psig_psbt)
         dec_psbt2 = self.nodes[0].decodepsbt(comb_psig_psbt2)
-        assert_equal(len(dec_psbt["inputs"][0]["musig2_partial_sigs"]), expected_partial_sigs)
-        assert_equal(len(dec_psbt2["inputs"][0]["musig2_partial_sigs"]), expected_partial_sigs)
+        assert_equal(len(dec_psbt["inputs"][0]["musig2_partial_sigs"]), len(dec_psbt2["inputs"][0]["musig2_partial_sigs"]), expected_partial_sigs)
         for ps, ps2 in zip(dec_psbt["inputs"][0]["musig2_partial_sigs"], dec_psbt2["inputs"][0]["musig2_partial_sigs"]):
             self.assert_musig_signer_data(ps, ps2, "partial_sig")
             self.assert_musig_aggregate_in_script(ps, pattern, dec_psbt["inputs"][0])
diff --git a/test/functional/wallet_sendall.py b/test/functional/wallet_sendall.py
index 657cdace2d7c..dec7173ca00e 100755
--- a/test/functional/wallet_sendall.py
+++ b/test/functional/wallet_sendall.py
@@ -18,12 +18,11 @@
 # Decorator to reset activewallet to zero utxos
 def cleanup(func):
     def wrapper(self):
-        try:
-            func(self)
-        finally:
-            if 0 < self.wallet.getbalances()["mine"]["trusted"]:
-                self.wallet.sendall([self.remainder_target])
-            assert_equal(0, self.wallet.getbalances()["mine"]["trusted"]) # wallet is empty
+        func(self)
+
+        if 0 < self.wallet.getbalances()["mine"]["trusted"]:
+            self.wallet.sendall([self.remainder_target])
+        assert_equal(0, self.wallet.getbalances()["mine"]["trusted"]) # wallet is empty
     return wrapper
 
 class SendallTest(BitcoinTestFramework):
diff --git a/test/functional/wallet_v3_txs.py b/test/functional/wallet_v3_txs.py
index 6ba30de4a3f7..8ba422f2572b 100755
--- a/test/functional/wallet_v3_txs.py
+++ b/test/functional/wallet_v3_txs.py
@@ -38,28 +38,27 @@
 # sweep alice and bob's wallets and clear the mempool
 def cleanup(func):
     def wrapper(self, *args):
-        try:
-            self.generate(self.nodes[0], 1)
-            func(self, *args)
-        finally:
-            self.generate(self.nodes[0], 1)
-            for wallet in [self.alice, self.bob]:
-                txs = set(tx["txid"] for tx in wallet.listtransactions("*", 1000) if tx["confirmations"] == 0 and not tx["abandoned"])
-                for tx in txs:
-                    wallet.abandontransaction(tx)
-                try:
-                    wallet.sendall([self.charlie.getnewaddress()])
-                except JSONRPCException as e:
-                    assert "Total value of UTXO pool too low to pay for transaction" in e.error['message']
-            self.generate(self.nodes[0], 1)
-
-            for wallet in [self.alice, self.bob]:
-                balance = wallet.getbalances()["mine"]
-                for balance_type in ["untrusted_pending", "trusted", "immature", "nonmempool"]:
-                    assert_equal(balance[balance_type], 0)
-
-            assert_equal(self.alice.getrawmempool(), [])
-            assert_equal(self.bob.getrawmempool(), [])
+        self.generate(self.nodes[0], 1)
+        func(self, *args)
+
+        self.generate(self.nodes[0], 1)
+        for wallet in [self.alice, self.bob]:
+            txs = set(tx["txid"] for tx in wallet.listtransactions("*", 1000) if tx["confirmations"] == 0 and not tx["abandoned"])
+            for tx in txs:
+                wallet.abandontransaction(tx)
+            try:
+                wallet.sendall([self.charlie.getnewaddress()])
+            except JSONRPCException as e:
+                assert "Total value of UTXO pool too low to pay for transaction" in e.error['message']
+        self.generate(self.nodes[0], 1)
+
+        for wallet in [self.alice, self.bob]:
+            balance = wallet.getbalances()["mine"]
+            for balance_type in ["untrusted_pending", "trusted", "immature", "nonmempool"]:
+                assert_equal(balance[balance_type], 0)
+
+        assert_equal(self.alice.getrawmempool(), [])
+        assert_equal(self.bob.getrawmempool(), [])
 
     return wrapper
 
diff --git a/test/lint/commit-script-check.sh b/test/lint/commit-script-check.sh
index af7a0d2f535c..94b0708faa9a 100755
--- a/test/lint/commit-script-check.sh
+++ b/test/lint/commit-script-check.sh
@@ -41,7 +41,7 @@ for commit in $(git rev-list --reverse "$1"); do
         else
             echo "Running script for: $commit" >&2
             echo "$SCRIPT" >&2
-            (eval "$SCRIPT")
+            (eval "$SCRIPT") && \
             git --no-pager diff --exit-code "$commit" && echo "OK" >&2 || (echo "Failed" >&2; false) || RET=1
         fi
         git reset --quiet --hard HEAD
diff --git a/test/lint/lint-tests.py b/test/lint/lint-tests.py
index c7354bc41228..10015e6d1ce9 100755
--- a/test/lint/lint-tests.py
+++ b/test/lint/lint-tests.py
@@ -13,12 +13,12 @@
 import sys
 
 
-def grep_boost_fixture_test_suite():
+def grep_boost_test_suites():
     command = [
         "git",
         "grep",
         "-E",
-        r"^BOOST_FIXTURE_TEST_SUITE\(",
+        r"^(BOOST_FIXTURE_TEST_SUITE|BOOST_AUTO_TEST_SUITE)\(",
         "--",
         "src/ipc/test/**.cpp",
         "src/test/**.cpp",
@@ -27,11 +27,12 @@ def grep_boost_fixture_test_suite():
     return subprocess.check_output(command, text=True)
 
 
-def check_matching_test_names(test_suite_list):
+def main():
+    test_suite_list = grep_boost_test_suites().splitlines()
     not_matching = [
         x
         for x in test_suite_list
-        if re.search(r"/(.*?)\.cpp:BOOST_FIXTURE_TEST_SUITE\(\1(_[a-z0-9]+)?, .*\)", x) is None
+        if re.search(r"/(.*?)\.cpp:(?:BOOST_FIXTURE_TEST_SUITE|BOOST_AUTO_TEST_SUITE)\(\1(_[a-z0-9]+)?[,)]", x) is None
     ]
     if len(not_matching) > 0:
         not_matching = "\n".join(not_matching)
@@ -42,46 +43,7 @@ def check_matching_test_names(test_suite_list):
             f"{not_matching}\n"
         )
         print(error_msg)
-        return 1
-    return 0
-
-
-def get_duplicates(input_list):
-    """
-    From https://stackoverflow.com/a/9835819
-    """
-    seen = set()
-    dupes = set()
-    for x in input_list:
-        if x in seen:
-            dupes.add(x)
-        else:
-            seen.add(x)
-    return dupes
-
-
-def check_unique_test_names(test_suite_list):
-    output = [re.search(r"\((.*?),", x) for x in test_suite_list]
-    output = [x.group(1) for x in output if x is not None]
-    output = get_duplicates(output)
-    output = sorted(list(output))
-
-    if len(output) > 0:
-        output = "\n".join(output)
-        error_msg = (
-            "Test suite names must be unique. The following test suite names\n"
-            f"appear to be used more than once:\n\n{output}"
-        )
-        print(error_msg)
-        return 1
-    return 0
-
-
-def main():
-    test_suite_list = grep_boost_fixture_test_suite().splitlines()
-    exit_code = check_matching_test_names(test_suite_list)
-    exit_code |= check_unique_test_names(test_suite_list)
-    sys.exit(exit_code)
+        sys.exit(1)
 
 
 if __name__ == "__main__":
diff --git a/test/sanitizer_suppressions/tsan b/test/sanitizer_suppressions/tsan
index 661571018b36..34004c6768ba 100644
--- a/test/sanitizer_suppressions/tsan
+++ b/test/sanitizer_suppressions/tsan
@@ -3,11 +3,6 @@
 #
 # https://github.com/google/sanitizers/wiki/ThreadSanitizerSuppressions
 
-# deadlock (TODO fix)
-# To reproduce, see:
-# https://github.com/bitcoin/bitcoin/issues/19303#issuecomment-1514926359
-deadlock:Chainstate::ConnectTip
-
 # Intentional deadlock in tests
 deadlock:sync_tests::potential_deadlock_detected
 
diff --git a/test/sanitizer_suppressions/valgrind.supp b/test/sanitizer_suppressions/valgrind.supp
index 8bcad9140e31..27bbce8354e7 100644
--- a/test/sanitizer_suppressions/valgrind.supp
+++ b/test/sanitizer_suppressions/valgrind.supp
@@ -12,7 +12,7 @@
 #       --error-limit=no build/bin/test_bitcoin
 #
 # Note that suppressions may depend on OS and/or library versions.
-# Tested on Debian Trixie system libs,
+# Tested on Ubuntu 26.04 system libs,
 # * using clang (only x86_64, see https://bugs.kde.org/show_bug.cgi?id=485276),
 # * and GCC (only -O1, see https://bugs.kde.org/show_bug.cgi?id=472329),
 # without gui (because it only passes with a DEBUG=1 depends build).