diff --git a/depend/bitcoin/.github/workflows/ci.yml b/depend/bitcoin/.github/workflows/ci.yml
index 2563c2e0..5e5b0c48 100644
--- a/depend/bitcoin/.github/workflows/ci.yml
+++ b/depend/bitcoin/.github/workflows/ci.yml
@@ -30,7 +30,7 @@ defaults:
 
 jobs:
   runners:
-    name: 'determine runners'
+    name: '[meta] determine runners'
     runs-on: ubuntu-latest
     outputs:
       provider: ${{ steps.runners.outputs.provider }}
@@ -66,7 +66,7 @@ jobs:
       - name: Determine fetch depth
         run: echo "FETCH_DEPTH=$((${{ github.event.pull_request.commits }} + 2))" >> "$GITHUB_ENV"
       - *ANNOTATION_PR_NUMBER
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           ref: ${{ github.event.pull_request.head.sha }}
           fetch-depth: ${{ env.FETCH_DEPTH }}
@@ -148,7 +148,7 @@ jobs:
 
       - &CHECKOUT
         name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         with:
           # Ensure the latest merged pull request state is used, even on re-runs.
           ref: &CHECKOUT_REF_TMPL ${{ github.event_name == 'pull_request' && github.ref || '' }}
@@ -343,9 +343,23 @@ jobs:
         run: |
           py -3 test/fuzz/test_runner.py --par $NUMBER_OF_PROCESSORS --loglevel DEBUG "${RUNNER_TEMP}/qa-assets/fuzz_corpora"
 
+  record-frozen-commit:
+    # Record frozen commit, so that the native tests on cross-builds can run on
+    # the exact same commit id of the build.
+    name: '[meta] record frozen commit'
+    runs-on: ubuntu-latest
+    outputs:
+      commit: ${{ steps.record-commit.outputs.commit }}
+    steps:
+      - *ANNOTATION_PR_NUMBER
+      - *CHECKOUT
+      - name: Record commit
+        id: record-commit
+        run: echo "commit=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
+
   windows-cross:
     name: 'Windows-cross to x86_64, ${{ matrix.crt }}'
-    needs: runners
+    needs: [runners, record-frozen-commit]
     runs-on: ${{ needs.runners.outputs.provider == 'cirrus' && 'ghcr.io/cirruslabs/ubuntu-runner-amd64:24.04-sm' || 'ubuntu-24.04' }}
     if: ${{ vars.SKIP_BRANCH_PUSH != 'true' || github.event_name == 'pull_request' }}
 
@@ -368,7 +382,10 @@ jobs:
     steps:
       - *ANNOTATION_PR_NUMBER
 
-      - *CHECKOUT
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ needs.record-frozen-commit.outputs.commit }}
 
       - name: Configure environment
         uses: ./.github/actions/configure-environment
@@ -402,7 +419,7 @@ jobs:
   windows-native-test:
     name: 'Windows, ${{ matrix.crt }}, test cross-built'
     runs-on: windows-2022
-    needs: windows-cross
+    needs: [windows-cross, record-frozen-commit]
 
     strategy:
       fail-fast: false
@@ -421,7 +438,10 @@ jobs:
     steps:
       - *ANNOTATION_PR_NUMBER
 
-      - *CHECKOUT
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ needs.record-frozen-commit.outputs.commit }}
 
       - name: Download built executables
         uses: actions/download-artifact@v5
@@ -502,6 +522,12 @@ jobs:
       fail-fast: false
       matrix:
         include:
+          - name: 'iwyu'
+            cirrus-runner: 'ghcr.io/cirruslabs/ubuntu-runner-amd64:24.04-md'
+            fallback-runner: 'ubuntu-24.04'
+            timeout-minutes: 120
+            file-env: './ci/test/00_setup_env_native_iwyu.sh'
+
           - name: '32 bit ARM'
             cirrus-runner: 'ubuntu-24.04-arm' # Cirrus' Arm runners are Apple (with virtual Linux aarch64), which doesn't support 32-bit mode
             fallback-runner: 'ubuntu-24.04-arm'
@@ -637,7 +663,7 @@ jobs:
       - *ANNOTATION_PR_NUMBER
 
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         with:
           ref: *CHECKOUT_REF_TMPL
           fetch-depth: 0
diff --git a/depend/bitcoin/.gitignore b/depend/bitcoin/.gitignore
index 3b22e358..b92988f6 100644
--- a/depend/bitcoin/.gitignore
+++ b/depend/bitcoin/.gitignore
@@ -12,6 +12,7 @@
 
 # Only ignore unexpected patches
 *.patch
+!ci/test/*.patch
 !contrib/guix/patches/*.patch
 !depends/patches/**/*.patch
 
diff --git a/depend/bitcoin/ci/lint/01_install.sh b/depend/bitcoin/ci/lint/01_install.sh
index fc422675..0cf9fbb4 100755
--- a/depend/bitcoin/ci/lint/01_install.sh
+++ b/depend/bitcoin/ci/lint/01_install.sh
@@ -40,7 +40,6 @@ command -v python3
 python3 --version
 
 ${CI_RETRY_EXE} pip3 install \
-  codespell==2.4.1 \
   lief==0.16.6 \
   mypy==1.18.2 \
   pyzmq==27.1.0 \
diff --git a/depend/bitcoin/ci/test/00_setup_env_native_iwyu.sh b/depend/bitcoin/ci/test/00_setup_env_native_iwyu.sh
new file mode 100755
index 00000000..3868510d
--- /dev/null
+++ b/depend/bitcoin/ci/test/00_setup_env_native_iwyu.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+#
+# Copyright (c) 2023-present The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+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 CONTAINER_NAME=ci_native_iwyu
+export TIDY_LLVM_V="21"
+export APT_LLVM_V="${TIDY_LLVM_V}"
+export PACKAGES="clang-${TIDY_LLVM_V} clang-format-${TIDY_LLVM_V} libclang-${TIDY_LLVM_V}-dev llvm-${TIDY_LLVM_V}-dev jq libevent-dev libboost-dev libzmq3-dev systemtap-sdt-dev qt6-base-dev qt6-tools-dev qt6-l10n-tools libqrencode-dev libsqlite3-dev libcapnp-dev capnproto"
+export NO_DEPENDS=1
+export RUN_UNIT_TESTS=false
+export RUN_FUNCTIONAL_TESTS=false
+export RUN_FUZZ_TESTS=false
+export RUN_CHECK_DEPS=false
+export RUN_IWYU=true
+export GOAL="codegen"
+export BITCOIN_CONFIG="\
+ --preset dev-mode -DBUILD_GUI=OFF \
+ -DCMAKE_C_COMPILER=clang-${TIDY_LLVM_V} \
+ -DCMAKE_CXX_COMPILER=clang++-${TIDY_LLVM_V} \
+"
diff --git a/depend/bitcoin/ci/test/01_base_install.sh b/depend/bitcoin/ci/test/01_base_install.sh
index a0f4164b..0ac56208 100755
--- a/depend/bitcoin/ci/test/01_base_install.sh
+++ b/depend/bitcoin/ci/test/01_base_install.sh
@@ -79,8 +79,9 @@ if [[ -n "${USE_INSTRUMENTED_LIBCPP}" ]]; then
   rm -rf /llvm-project
 fi
 
-if [[ "${RUN_TIDY}" == "true" ]]; then
+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_"${TIDY_LLVM_V}" /include-what-you-use
+  (cd /include-what-you-use && patch -p1 < /ci_container_base/ci/test/01_iwyu.patch)
   cmake -B /iwyu-build/ -G 'Unix Makefiles' -DCMAKE_PREFIX_PATH=/usr/lib/llvm-"${TIDY_LLVM_V}" -S /include-what-you-use
   make -C /iwyu-build/ install "$MAKEJOBS"
 fi
diff --git a/depend/bitcoin/ci/test/01_iwyu.patch b/depend/bitcoin/ci/test/01_iwyu.patch
new file mode 100644
index 00000000..e14316bf
--- /dev/null
+++ b/depend/bitcoin/ci/test/01_iwyu.patch
@@ -0,0 +1,598 @@
+Prefer angled brackets over quotes for include directives.
+See: https://en.cppreference.com/w/cpp/preprocessor/include.html.
+
+--- a/iwyu_path_util.cc
++++ b/iwyu_path_util.cc
+@@ -211,7 +211,7 @@ bool IsQuotedInclude(const string& s) {
+ }
+
+ string AddQuotes(string include_name, bool angled) {
+-  if (angled) {
++  if (true) {
+       return "<" + include_name + ">";
+   }
+   return "\"" + include_name + "\"";
+
+
+Prefer C++ headers over C counterparts.
+See: https://github.com/include-what-you-use/include-what-you-use/blob/clang_21/iwyu_include_picker.cc#L587-L629.
+
+--- a/iwyu_include_picker.cc
++++ b/iwyu_include_picker.cc
+@@ -100,20 +100,20 @@ const IncludeMapEntry libc_symbol_map[] = {
+   // equal.  The visibility on the symbol-name is ignored; by convention
+   // we always set it to kPrivate.
+   { "_POSIX_VDISABLE", kPrivate, "<unistd.h>", kPublic },
+-  { "abort", kPrivate, "<stdlib.h>", kPublic },
++  { "abort", kPrivate, "<stdlib.h>", kPrivate },
+   { "aiocb", kPrivate, "<aio.h>", kPublic },
+   { "blkcnt_t", kPrivate, "<sys/types.h>", kPublic },
+   { "blksize_t", kPrivate, "<sys/types.h>", kPublic },
+   { "cc_t", kPrivate, "<termios.h>", kPublic },
+-  { "clock_t", kPrivate, "<time.h>", kPublic },
++  { "clock_t", kPrivate, "<time.h>", kPrivate },
+   { "clock_t", kPrivate, "<sys/types.h>", kPublic },
+   { "clockid_t", kPrivate, "<sys/types.h>", kPublic },
+-  { "ctermid", kPrivate, "<stdio.h>", kPublic },
++  { "ctermid", kPrivate, "<stdio.h>", kPrivate },
+   { "daddr_t", kPrivate, "<sys/types.h>", kPublic },
+   { "dev_t", kPrivate, "<sys/types.h>", kPublic },
+-  { "div_t", kPrivate, "<stdlib.h>", kPublic },
+-  { "double_t", kPrivate, "<math.h>", kPublic },
+-  { "error_t", kPrivate, "<errno.h>", kPublic },
++  { "div_t", kPrivate, "<stdlib.h>", kPrivate },
++  { "double_t", kPrivate, "<math.h>", kPrivate },
++  { "error_t", kPrivate, "<errno.h>", kPrivate },
+   { "error_t", kPrivate, "<argp.h>", kPublic },
+   { "error_t", kPrivate, "<argz.h>", kPublic },
+   { "FD_CLR", kPrivate, "<sys/select.h>", kPublic },
+@@ -122,10 +122,10 @@ const IncludeMapEntry libc_symbol_map[] = {
+   { "fd_set", kPrivate, "<sys/select.h>", kPublic },
+   { "FD_SETSIZE", kPrivate, "<sys/select.h>", kPublic },
+   { "FD_ZERO", kPrivate, "<sys/select.h>", kPublic },
+-  { "fenv_t", kPrivate, "<fenv.h>", kPublic },
+-  { "fexcept_t", kPrivate, "<fenv.h>", kPublic },
+-  { "FILE", kPrivate, "<stdio.h>", kPublic },
+-  { "float_t", kPrivate, "<math.h>", kPublic },
++  { "fenv_t", kPrivate, "<fenv.h>", kPrivate },
++  { "fexcept_t", kPrivate, "<fenv.h>", kPrivate },
++  { "FILE", kPrivate, "<stdio.h>", kPrivate },
++  { "float_t", kPrivate, "<math.h>", kPrivate },
+   { "fsblkcnt_t", kPrivate, "<sys/types.h>", kPublic },
+   { "fsfilcnt_t", kPrivate, "<sys/types.h>", kPublic },
+   { "getopt", kPrivate, "<unistd.h>", kPublic },
+@@ -135,31 +135,31 @@ const IncludeMapEntry libc_symbol_map[] = {
+   { "in_addr_t", kPrivate, "<netinet/in.h>", kPublic },
+   { "in_port_t", kPrivate, "<netinet/in.h>", kPublic },
+   { "id_t", kPrivate, "<sys/types.h>", kPublic },
+-  { "imaxdiv_t", kPrivate, "<inttypes.h>", kPublic },
+-  { "intmax_t", kPrivate, "<stdint.h>", kPublic },
+-  { "uintmax_t", kPrivate, "<stdint.h>", kPublic },
++  { "imaxdiv_t", kPrivate, "<inttypes.h>", kPrivate },
++  { "intmax_t", kPrivate, "<stdint.h>", kPrivate },
++  { "uintmax_t", kPrivate, "<stdint.h>", kPrivate },
+   { "ino64_t", kPrivate, "<sys/types.h>", kPublic },
+   { "ino_t", kPrivate, "<sys/types.h>", kPublic },
+-  { "int8_t", kPrivate, "<stdint.h>", kPublic },
+-  { "int16_t", kPrivate, "<stdint.h>", kPublic },
+-  { "int32_t", kPrivate, "<stdint.h>", kPublic },
+-  { "int64_t", kPrivate, "<stdint.h>", kPublic },
+-  { "uint8_t", kPrivate, "<stdint.h>", kPublic },
+-  { "uint16_t", kPrivate, "<stdint.h>", kPublic },
+-  { "uint32_t", kPrivate, "<stdint.h>", kPublic },
+-  { "uint64_t", kPrivate, "<stdint.h>", kPublic },
+-  { "intptr_t", kPrivate, "<stdint.h>", kPublic },
+-  { "uintptr_t", kPrivate, "<stdint.h>", kPublic },
++  { "int8_t", kPrivate, "<stdint.h>", kPrivate },
++  { "int16_t", kPrivate, "<stdint.h>", kPrivate },
++  { "int32_t", kPrivate, "<stdint.h>", kPrivate },
++  { "int64_t", kPrivate, "<stdint.h>", kPrivate },
++  { "uint8_t", kPrivate, "<stdint.h>", kPrivate },
++  { "uint16_t", kPrivate, "<stdint.h>", kPrivate },
++  { "uint32_t", kPrivate, "<stdint.h>", kPrivate },
++  { "uint64_t", kPrivate, "<stdint.h>", kPrivate },
++  { "intptr_t", kPrivate, "<stdint.h>", kPrivate },
++  { "uintptr_t", kPrivate, "<stdint.h>", kPrivate },
+   { "iovec", kPrivate, "<sys/uio.h>", kPublic },
+-  { "itimerspec", kPrivate, "<time.h>", kPublic },
++  { "itimerspec", kPrivate, "<time.h>", kPrivate },
+   { "key_t", kPrivate, "<sys/types.h>", kPublic },
+-  { "L_ctermid", kPrivate, "<stdio.h>", kPublic },
+-  { "lconv", kPrivate, "<locale.h>", kPublic },
+-  { "ldiv_t", kPrivate, "<stdlib.h>", kPublic },
+-  { "lldiv_t", kPrivate, "<stdlib.h>", kPublic },
+-  { "locale_t", kPrivate, "<locale.h>", kPublic },
+-  { "max_align_t", kPrivate, "<stddef.h>", kPublic },
+-  { "mbstate_t", kPrivate, "<wchar.h>", kPublic },
++  { "L_ctermid", kPrivate, "<stdio.h>", kPrivate },
++  { "lconv", kPrivate, "<locale.h>", kPrivate },
++  { "ldiv_t", kPrivate, "<stdlib.h>", kPrivate },
++  { "lldiv_t", kPrivate, "<stdlib.h>", kPrivate },
++  { "locale_t", kPrivate, "<locale.h>", kPrivate },
++  { "max_align_t", kPrivate, "<stddef.h>", kPrivate },
++  { "mbstate_t", kPrivate, "<wchar.h>", kPrivate },
+   { "mcontext_t", kPrivate, "<ucontext.h>", kPublic },
+   { "mode_t", kPrivate, "<sys/types.h>", kPublic },
+   { "nl_item", kPrivate, "<nl_types.h>", kPublic },
+@@ -175,8 +175,8 @@ const IncludeMapEntry libc_symbol_map[] = {
+   { "optind", kPrivate, "<unistd.h>", kPublic },
+   { "optopt", kPrivate, "<unistd.h>", kPublic },
+   { "pid_t", kPrivate, "<sys/types.h>", kPublic },
+-  { "posix_memalign", kPrivate, "<stdlib.h>", kPublic },
+-  { "printf", kPrivate, "<stdio.h>", kPublic },
++  { "posix_memalign", kPrivate, "<stdlib.h>", kPrivate },
++  { "printf", kPrivate, "<stdio.h>", kPrivate },
+   { "pthread_attr_t", kPrivate, "<pthread.h>", kPublic },
+   { "pthread_cond_t", kPrivate, "<pthread.h>", kPublic },
+   { "pthread_condattr_t", kPrivate, "<pthread.h>", kPublic },
+@@ -187,7 +187,7 @@ const IncludeMapEntry libc_symbol_map[] = {
+   { "pthread_rwlock_t", kPrivate, "<pthread.h>", kPublic },
+   { "pthread_rwlockattr_t", kPrivate, "<pthread.h>", kPublic },
+   { "pthread_t", kPrivate, "<pthread.h>", kPublic },
+-  { "ptrdiff_t", kPrivate, "<stddef.h>", kPublic },
++  { "ptrdiff_t", kPrivate, "<stddef.h>", kPrivate },
+   { "regex_t", kPrivate, "<regex.h>", kPublic },
+   { "regmatch_t", kPrivate, "<regex.h>", kPublic },
+   { "regoff_t", kPrivate, "<regex.h>", kPublic },
+@@ -218,51 +218,51 @@ const IncludeMapEntry libc_symbol_map[] = {
+   { "SCHED_FIFO", kPrivate, "<sched.h>", kPublic },
+   { "SCHED_OTHER", kPrivate, "<sched.h>", kPublic },
+   { "SCHED_RR", kPrivate, "<sched.h>", kPublic },
+-  { "SEEK_CUR", kPrivate, "<stdio.h>", kPublic },
+-  { "SEEK_END", kPrivate, "<stdio.h>", kPublic },
+-  { "SEEK_SET", kPrivate, "<stdio.h>", kPublic },
+-  { "sig_atomic_t", kPrivate, "<signal.h>", kPublic },
+-  { "sigevent", kPrivate, "<signal.h>", kPublic },
+-  { "siginfo_t", kPrivate, "<signal.h>", kPublic },
+-  { "sigset_t", kPrivate, "<signal.h>", kPublic },
+-  { "sigval", kPrivate, "<signal.h>", kPublic },
++  { "SEEK_CUR", kPrivate, "<stdio.h>", kPrivate },
++  { "SEEK_END", kPrivate, "<stdio.h>", kPrivate },
++  { "SEEK_SET", kPrivate, "<stdio.h>", kPrivate },
++  { "sig_atomic_t", kPrivate, "<signal.h>", kPrivate },
++  { "sigevent", kPrivate, "<signal.h>", kPrivate },
++  { "siginfo_t", kPrivate, "<signal.h>", kPrivate },
++  { "sigset_t", kPrivate, "<signal.h>", kPrivate },
++  { "sigval", kPrivate, "<signal.h>", kPrivate },
+   { "sockaddr", kPrivate, "<sys/socket.h>", kPublic },
+   { "socklen_t", kPrivate, "<sys/socket.h>", kPublic },
+   { "ssize_t", kPrivate, "<sys/types.h>", kPublic },
+-  { "stack_t", kPrivate, "<signal.h>", kPublic },
++  { "stack_t", kPrivate, "<signal.h>", kPrivate },
+   { "stat", kPrivate, "<sys/stat.h>", kPublic },
+   { "suseconds_t", kPrivate, "<sys/types.h>", kPublic },
+-  { "time_t", kPrivate, "<time.h>", kPublic },
++  { "time_t", kPrivate, "<time.h>", kPrivate },
+   { "time_t", kPrivate, "<sys/types.h>", kPublic },
+   { "timer_t", kPrivate, "<sys/types.h>", kPublic },
+-  { "timespec", kPrivate, "<time.h>", kPublic },
++  { "timespec", kPrivate, "<time.h>", kPrivate },
+   { "timeval", kPrivate, "<sys/time.h>", kPublic },
+-  { "tm", kPrivate, "<time.h>", kPublic },
++  { "tm", kPrivate, "<time.h>", kPrivate },
+   { "u_char", kPrivate, "<sys/types.h>", kPublic },
+   { "ucontext_t", kPrivate, "<ucontext.h>", kPublic },
+   { "uid_t", kPrivate, "<sys/types.h>", kPublic },
+   { "useconds_t", kPrivate, "<sys/types.h>", kPublic },
+-  { "wchar_t", kPrivate, "<stddef.h>", kPublic },
+-  { "wctrans_t", kPrivate, "<wctype.h>", kPublic },
+-  { "wctype_t", kPrivate, "<wctype.h>", kPublic },
++  { "wchar_t", kPrivate, "<stddef.h>", kPrivate },
++  { "wctrans_t", kPrivate, "<wctype.h>", kPrivate },
++  { "wctype_t", kPrivate, "<wctype.h>", kPrivate },
+   { "winsize", kPrivate, "<termios.h>", kPublic },
+-  { "wint_t", kPrivate, "<wchar.h>", kPublic },
++  { "wint_t", kPrivate, "<wchar.h>", kPrivate },
+   // It is unspecified if the cname headers provide ::size_t.
+   // <locale.h> is the one header which defines NULL but not size_t.
+-  { "size_t", kPrivate, "<stddef.h>", kPublic },  // 'canonical' location for size_t
+-  { "size_t", kPrivate, "<signal.h>", kPublic },
+-  { "size_t", kPrivate, "<stdio.h>", kPublic },
+-  { "size_t", kPrivate, "<stdlib.h>", kPublic },
+-  { "size_t", kPrivate, "<string.h>", kPublic },
+-  { "size_t", kPrivate, "<time.h>", kPublic },
+-  { "size_t", kPrivate, "<uchar.h>", kPublic },
+-  { "size_t", kPrivate, "<wchar.h>", kPublic },
++  { "size_t", kPrivate, "<stddef.h>", kPrivate },  // 'canonical' location for size_t
++  { "size_t", kPrivate, "<signal.h>", kPrivate },
++  { "size_t", kPrivate, "<stdio.h>", kPrivate },
++  { "size_t", kPrivate, "<stdlib.h>", kPrivate },
++  { "size_t", kPrivate, "<string.h>", kPrivate },
++  { "size_t", kPrivate, "<time.h>", kPrivate },
++  { "size_t", kPrivate, "<uchar.h>", kPrivate },
++  { "size_t", kPrivate, "<wchar.h>", kPrivate },
+   // Macros that can be defined in more than one file, don't have the
+   // same __foo_defined guard that other types do, so the grep above
+   // doesn't discover them.  Until I figure out a better way, I just
+   // add them in by hand as I discover them.
+-  { "EOF", kPrivate, "<stdio.h>", kPublic },
+-  { "FILE", kPrivate, "<stdio.h>", kPublic },
++  { "EOF", kPrivate, "<stdio.h>", kPrivate },
++  { "FILE", kPrivate, "<stdio.h>", kPrivate },
+   { "IBSHIFT", kPrivate, "<asm/termbits.h>", kPublic },
+   { "MAP_POPULATE", kPrivate, "<sys/mman.h>", kPublic },
+   { "MAP_POPULATE", kPrivate, "<linux/mman.h>", kPublic },
+@@ -270,22 +270,22 @@ const IncludeMapEntry libc_symbol_map[] = {
+   { "MAP_STACK", kPrivate, "<linux/mman.h>", kPublic },
+   { "MAXHOSTNAMELEN", kPrivate, "<sys/param.h>", kPublic },
+   { "MAXHOSTNAMELEN", kPrivate, "<protocols/timed.h>", kPublic },
+-  { "SIGABRT", kPrivate, "<signal.h>", kPublic },
+-  { "SIGCHLD", kPrivate, "<signal.h>", kPublic },
+-  { "va_arg", kPrivate, "<stdarg.h>", kPublic },
+-  { "va_copy", kPrivate, "<stdarg.h>", kPublic },
+-  { "va_end", kPrivate, "<stdarg.h>", kPublic },
+-  { "va_list", kPrivate, "<stdarg.h>", kPublic },
+-  { "va_start", kPrivate, "<stdarg.h>", kPublic },
+-  { "WEOF", kPrivate, "<wchar.h>", kPublic },
++  { "SIGABRT", kPrivate, "<signal.h>", kPrivate },
++  { "SIGCHLD", kPrivate, "<signal.h>", kPrivate },
++  { "va_arg", kPrivate, "<stdarg.h>", kPrivate },
++  { "va_copy", kPrivate, "<stdarg.h>", kPrivate },
++  { "va_end", kPrivate, "<stdarg.h>", kPrivate },
++  { "va_list", kPrivate, "<stdarg.h>", kPrivate },
++  { "va_start", kPrivate, "<stdarg.h>", kPrivate },
++  { "WEOF", kPrivate, "<wchar.h>", kPrivate },
+   // These are symbols that could be defined in either stdlib.h or
+   // malloc.h, but we always want the stdlib location.
+-  { "malloc", kPrivate, "<stdlib.h>", kPublic },
+-  { "calloc", kPrivate, "<stdlib.h>", kPublic },
+-  { "realloc", kPrivate, "<stdlib.h>", kPublic },
+-  { "free", kPrivate, "<stdlib.h>", kPublic },
++  { "malloc", kPrivate, "<stdlib.h>", kPrivate },
++  { "calloc", kPrivate, "<stdlib.h>", kPrivate },
++  { "realloc", kPrivate, "<stdlib.h>", kPrivate },
++  { "free", kPrivate, "<stdlib.h>", kPrivate },
+   // Entries for NULL
+-  { "NULL", kPrivate, "<stddef.h>", kPublic },  // 'canonical' location for NULL
++  { "NULL", kPrivate, "<stddef.h>", kPrivate },  // 'canonical' location for NULL
+   { "NULL", kPrivate, "<clocale>", kPublic },
+   { "NULL", kPrivate, "<cstddef>", kPublic },
+   { "NULL", kPrivate, "<cstdio>", kPublic },
+@@ -293,13 +293,13 @@ const IncludeMapEntry libc_symbol_map[] = {
+   { "NULL", kPrivate, "<cstring>", kPublic },
+   { "NULL", kPrivate, "<ctime>", kPublic },
+   { "NULL", kPrivate, "<cwchar>", kPublic },
+-  { "NULL", kPrivate, "<locale.h>", kPublic },
+-  { "NULL", kPrivate, "<stdio.h>", kPublic },
+-  { "NULL", kPrivate, "<stdlib.h>", kPublic },
+-  { "NULL", kPrivate, "<string.h>", kPublic },
+-  { "NULL", kPrivate, "<time.h>", kPublic },
+-  { "NULL", kPrivate, "<wchar.h>", kPublic },
+-  { "offsetof", kPrivate, "<stddef.h>", kPublic },
++  { "NULL", kPrivate, "<locale.h>", kPrivate },
++  { "NULL", kPrivate, "<stdio.h>", kPrivate },
++  { "NULL", kPrivate, "<stdlib.h>", kPrivate },
++  { "NULL", kPrivate, "<string.h>", kPrivate },
++  { "NULL", kPrivate, "<time.h>", kPrivate },
++  { "NULL", kPrivate, "<wchar.h>", kPrivate },
++  { "offsetof", kPrivate, "<stddef.h>", kPrivate },
+ };
+ 
+ // Common kludges for C++ standard libraries
+@@ -355,7 +355,7 @@ const IncludeMapEntry libc_include_map[] = {
+   { "<bits/a.out.h>", kPrivate, "<a.out.h>", kPublic },
+   { "<bits/auxv.h>", kPrivate, "<sys/auxv.h>", kPublic },
+   { "<bits/byteswap.h>", kPrivate, "<byteswap.h>", kPublic },
+-  { "<bits/cmathcalls.h>", kPrivate, "<complex.h>", kPublic },
++  { "<bits/cmathcalls.h>", kPrivate, "<complex.h>", kPrivate },
+   { "<bits/confname.h>", kPrivate, "<unistd.h>", kPublic },
+   { "<bits/dirent.h>", kPrivate, "<dirent.h>", kPublic },
+   { "<bits/dlfcn.h>", kPrivate, "<dlfcn.h>", kPublic },
+@@ -363,18 +363,18 @@ const IncludeMapEntry libc_include_map[] = {
+   { "<bits/endian.h>", kPrivate, "<endian.h>", kPublic },
+   { "<bits/environments.h>", kPrivate, "<unistd.h>", kPublic },
+   { "<bits/epoll.h>", kPrivate, "<sys/epoll.h>", kPublic },
+-  { "<bits/errno.h>", kPrivate, "<errno.h>", kPublic },
++  { "<bits/errno.h>", kPrivate, "<errno.h>", kPrivate },
+   { "<bits/error.h>", kPrivate, "<error.h>", kPublic },
+   { "<bits/eventfd.h>", kPrivate, "<sys/eventfd.h>", kPublic },
+   { "<bits/fcntl.h>", kPrivate, "<fcntl.h>", kPublic },
+   { "<bits/fcntl2.h>", kPrivate, "<fcntl.h>", kPublic },
+-  { "<bits/fenv.h>", kPrivate, "<fenv.h>", kPublic },
+-  { "<bits/fenvinline.h>", kPrivate, "<fenv.h>", kPublic },
+-  { "<bits/huge_val.h>", kPrivate, "<math.h>", kPublic },
+-  { "<bits/huge_valf.h>", kPrivate, "<math.h>", kPublic },
+-  { "<bits/huge_vall.h>", kPrivate, "<math.h>", kPublic },
++  { "<bits/fenv.h>", kPrivate, "<fenv.h>", kPrivate },
++  { "<bits/fenvinline.h>", kPrivate, "<fenv.h>", kPrivate },
++  { "<bits/huge_val.h>", kPrivate, "<math.h>", kPrivate },
++  { "<bits/huge_valf.h>", kPrivate, "<math.h>", kPrivate },
++  { "<bits/huge_vall.h>", kPrivate, "<math.h>", kPrivate },
+   { "<bits/hwcap.h>", kPrivate, "<sys/auxv.h>", kPublic },
+-  { "<bits/inf.h>", kPrivate, "<math.h>", kPublic },
++  { "<bits/inf.h>", kPrivate, "<math.h>", kPrivate },
+   { "<bits/inotify.h>", kPrivate, "<sys/inotify.h>", kPublic },
+   { "<bits/ioctl-types.h>", kPrivate, "<sys/ioctl.h>", kPublic },
+   { "<bits/ioctls.h>", kPrivate, "<sys/ioctl.h>", kPublic },
+@@ -382,24 +382,24 @@ const IncludeMapEntry libc_include_map[] = {
+   { "<bits/ipctypes.h>", kPrivate, "<sys/ipc.h>", kPublic },
+   { "<bits/libio-ldbl.h>", kPrivate, "<libio.h>", kPublic },
+   { "<bits/link.h>", kPrivate, "<link.h>", kPublic },
+-  { "<bits/locale.h>", kPrivate, "<locale.h>", kPublic },
+-  { "<bits/math-finite.h>", kPrivate, "<math.h>", kPublic },
+-  { "<bits/mathcalls.h>", kPrivate, "<math.h>", kPublic },
+-  { "<bits/mathdef.h>", kPrivate, "<math.h>", kPublic },
+-  { "<bits/mathinline.h>", kPrivate, "<math.h>", kPublic },
++  { "<bits/locale.h>", kPrivate, "<locale.h>", kPrivate },
++  { "<bits/math-finite.h>", kPrivate, "<math.h>", kPrivate },
++  { "<bits/mathcalls.h>", kPrivate, "<math.h>", kPrivate },
++  { "<bits/mathdef.h>", kPrivate, "<math.h>", kPrivate },
++  { "<bits/mathinline.h>", kPrivate, "<math.h>", kPrivate },
+   { "<bits/mman.h>", kPrivate, "<sys/mman.h>", kPublic },
+   { "<bits/mman-shared.h>", kPrivate, "<sys/mman.h>", kPublic },
+   { "<bits/monetary-ldbl.h>", kPrivate, "<monetary.h>", kPublic },
+   { "<bits/mqueue.h>", kPrivate, "<mqueue.h>", kPublic },
+   { "<bits/mqueue2.h>", kPrivate, "<mqueue.h>", kPublic },
+   { "<bits/msq.h>", kPrivate, "<sys/msg.h>", kPublic },
+-  { "<bits/nan.h>", kPrivate, "<math.h>", kPublic },
++  { "<bits/nan.h>", kPrivate, "<math.h>", kPrivate },
+   { "<bits/netdb.h>", kPrivate, "<netdb.h>", kPublic },
+   { "<bits/param.h>", kPrivate, "<sys/param.h>", kPublic },
+   { "<bits/poll.h>", kPrivate, "<sys/poll.h>", kPrivate },
+   { "<bits/poll2.h>", kPrivate, "<sys/poll.h>", kPrivate },
+-  { "<bits/posix1_lim.h>", kPrivate, "<limits.h>", kPublic },
+-  { "<bits/posix2_lim.h>", kPrivate, "<limits.h>", kPublic },
++  { "<bits/posix1_lim.h>", kPrivate, "<limits.h>", kPrivate },
++  { "<bits/posix2_lim.h>", kPrivate, "<limits.h>", kPrivate },
+   { "<bits/posix_opt.h>", kPrivate, "<unistd.h>", kPublic },
+   { "<bits/printf-ldbl.h>", kPrivate, "<printf.h>", kPublic },
+   { "<bits/pthreadtypes.h>", kPrivate, "<pthread.h>", kPublic },
+@@ -409,17 +409,17 @@ const IncludeMapEntry libc_include_map[] = {
+   { "<bits/select2.h>", kPrivate, "<sys/select.h>", kPublic },
+   { "<bits/sem.h>", kPrivate, "<sys/sem.h>", kPublic },
+   { "<bits/semaphore.h>", kPrivate, "<semaphore.h>", kPublic },
+-  { "<bits/setjmp.h>", kPrivate, "<setjmp.h>", kPublic },
+-  { "<bits/setjmp2.h>", kPrivate, "<setjmp.h>", kPublic },
++  { "<bits/setjmp.h>", kPrivate, "<setjmp.h>", kPrivate },
++  { "<bits/setjmp2.h>", kPrivate, "<setjmp.h>", kPrivate },
+   { "<bits/shm.h>", kPrivate, "<sys/shm.h>", kPublic },
+-  { "<bits/sigaction.h>", kPrivate, "<signal.h>", kPublic },
+-  { "<bits/sigcontext.h>", kPrivate, "<signal.h>", kPublic },
+-  { "<bits/siginfo.h>", kPrivate, "<signal.h>", kPublic },
+-  { "<bits/signum.h>", kPrivate, "<signal.h>", kPublic },
+-  { "<bits/signum-arch.h>", kPrivate, "<signal.h>", kPublic },
+-  { "<bits/sigset.h>", kPrivate, "<signal.h>", kPublic },
+-  { "<bits/sigstack.h>", kPrivate, "<signal.h>", kPublic },
+-  { "<bits/sigthread.h>", kPrivate, "<signal.h>", kPublic },
++  { "<bits/sigaction.h>", kPrivate, "<signal.h>", kPrivate },
++  { "<bits/sigcontext.h>", kPrivate, "<signal.h>", kPrivate },
++  { "<bits/siginfo.h>", kPrivate, "<signal.h>", kPrivate },
++  { "<bits/signum.h>", kPrivate, "<signal.h>", kPrivate },
++  { "<bits/signum-arch.h>", kPrivate, "<signal.h>", kPrivate },
++  { "<bits/sigset.h>", kPrivate, "<signal.h>", kPrivate },
++  { "<bits/sigstack.h>", kPrivate, "<signal.h>", kPrivate },
++  { "<bits/sigthread.h>", kPrivate, "<signal.h>", kPrivate },
+   { "<bits/sockaddr.h>", kPrivate, "<sys/un.h>", kPublic },
+   { "<bits/socket.h>", kPrivate, "<sys/socket.h>", kPublic },
+   { "<bits/socket2.h>", kPrivate, "<sys/socket.h>", kPublic },
+@@ -429,22 +429,22 @@ const IncludeMapEntry libc_include_map[] = {
+   { "<bits/statfs.h>", kPrivate, "<sys/statfs.h>", kPublic },
+   { "<bits/statvfs.h>", kPrivate, "<sys/statvfs.h>", kPublic },
+   { "<bits/statx-generic.h>", kPrivate, "<sys/stat.h>", kPublic },
+-  { "<bits/stdio-ldbl.h>", kPrivate, "<stdio.h>", kPublic },
++  { "<bits/stdio-ldbl.h>", kPrivate, "<stdio.h>", kPrivate },
+   { "<bits/stdio-lock.h>", kPrivate, "<libio.h>", kPublic },
+-  { "<bits/stdio.h>", kPrivate, "<stdio.h>", kPublic },
+-  { "<bits/stdio2.h>", kPrivate, "<stdio.h>", kPublic },
+-  { "<bits/stdio_lim.h>", kPrivate, "<stdio.h>", kPublic },
+-  { "<bits/stdlib-bsearch.h>", kPrivate, "<stdlib.h>", kPublic },
+-  { "<bits/stdlib-float.h>", kPrivate, "<stdlib.h>", kPublic },
+-  { "<bits/stdlib-ldbl.h>", kPrivate, "<stdlib.h>", kPublic },
+-  { "<bits/stdlib.h>", kPrivate, "<stdlib.h>", kPublic },
+-  { "<bits/string.h>", kPrivate, "<string.h>", kPublic },
+-  { "<bits/string2.h>", kPrivate, "<string.h>", kPublic },
+-  { "<bits/string3.h>", kPrivate, "<string.h>", kPublic },
++  { "<bits/stdio.h>", kPrivate, "<stdio.h>", kPrivate },
++  { "<bits/stdio2.h>", kPrivate, "<stdio.h>", kPrivate },
++  { "<bits/stdio_lim.h>", kPrivate, "<stdio.h>", kPrivate },
++  { "<bits/stdlib-bsearch.h>", kPrivate, "<stdlib.h>", kPrivate },
++  { "<bits/stdlib-float.h>", kPrivate, "<stdlib.h>", kPrivate },
++  { "<bits/stdlib-ldbl.h>", kPrivate, "<stdlib.h>", kPrivate },
++  { "<bits/stdlib.h>", kPrivate, "<stdlib.h>", kPrivate },
++  { "<bits/string.h>", kPrivate, "<string.h>", kPrivate },
++  { "<bits/string2.h>", kPrivate, "<string.h>", kPrivate },
++  { "<bits/string3.h>", kPrivate, "<string.h>", kPrivate },
+   { "<bits/stropts.h>", kPrivate, "<stropts.h>", kPublic },
+   { "<bits/struct_stat.h>", kPrivate, "<sys/stat.h>", kPublic },
+   { "<bits/struct_stat.h>", kPrivate, "<ftw.h>", kPublic },
+-  { "<bits/sys_errlist.h>", kPrivate, "<stdio.h>", kPublic },
++  { "<bits/sys_errlist.h>", kPrivate, "<stdio.h>", kPrivate },
+   { "<bits/syscall.h>", kPrivate, "<sys/syscall.h>", kPublic },
+   { "<bits/sysctl.h>", kPrivate, "<sys/sysctl.h>", kPublic },
+   { "<bits/syslog-ldbl.h>", kPrivate, "<sys/syslog.h>", kPrivate },
+@@ -459,12 +459,12 @@ const IncludeMapEntry libc_include_map[] = {
+   { "<bits/termios-struct.h>", kPrivate, "<termios.h>", kPublic },
+   { "<bits/termios-tcflow.h>", kPrivate, "<termios.h>", kPublic },
+   { "<bits/termios.h>", kPrivate, "<termios.h>", kPublic },
+-  { "<bits/time.h>", kPrivate, "<time.h>", kPublic },
++  { "<bits/time.h>", kPrivate, "<time.h>", kPrivate },
+   { "<bits/time.h>", kPrivate, "<sys/time.h>", kPublic },
+   { "<bits/timerfd.h>", kPrivate, "<sys/timerfd.h>", kPublic },
+   { "<bits/timex.h>", kPrivate, "<sys/timex.h>", kPublic },
+   { "<bits/types.h>", kPrivate, "<sys/types.h>", kPublic },
+-  { "<bits/types/siginfo_t.h>", kPrivate, "<signal.h>", kPublic },
++  { "<bits/types/siginfo_t.h>", kPrivate, "<signal.h>", kPrivate },
+   { "<bits/types/siginfo_t.h>", kPrivate, "<sys/wait.h>", kPublic },
+   { "<bits/uio.h>", kPrivate, "<sys/uio.h>", kPublic },
+   { "<bits/unistd.h>", kPrivate, "<unistd.h>", kPublic },
+@@ -474,11 +474,11 @@ const IncludeMapEntry libc_include_map[] = {
+   { "<bits/utsname.h>", kPrivate, "<sys/utsname.h>", kPublic },
+   { "<bits/waitflags.h>", kPrivate, "<sys/wait.h>", kPublic },
+   { "<bits/waitstatus.h>", kPrivate, "<sys/wait.h>", kPublic },
+-  { "<bits/wchar-ldbl.h>", kPrivate, "<wchar.h>", kPublic },
+-  { "<bits/wchar.h>", kPrivate, "<wchar.h>", kPublic },
+-  { "<bits/wchar2.h>", kPrivate, "<wchar.h>", kPublic },
+-  { "<bits/wordsize.h>", kPrivate, "<limits.h>", kPublic },
+-  { "<bits/xopen_lim.h>", kPrivate, "<limits.h>", kPublic },
++  { "<bits/wchar-ldbl.h>", kPrivate, "<wchar.h>", kPrivate },
++  { "<bits/wchar.h>", kPrivate, "<wchar.h>", kPrivate },
++  { "<bits/wchar2.h>", kPrivate, "<wchar.h>", kPrivate },
++  { "<bits/wordsize.h>", kPrivate, "<limits.h>", kPrivate },
++  { "<bits/xopen_lim.h>", kPrivate, "<limits.h>", kPrivate },
+   { "<bits/xtitypes.h>", kPrivate, "<stropts.h>", kPublic },
+   // Sometimes libc tells you what mapping to do via an '#error':
+   // # error "Never use <bits/dlfcn.h> directly; include <dlfcn.h> instead."
+@@ -488,7 +488,7 @@ const IncludeMapEntry libc_include_map[] = {
+   { "<bits/a.out.h>", kPrivate, "<a.out.h>", kPublic },
+   { "<bits/byteswap-16.h>", kPrivate, "<byteswap.h>", kPublic },
+   { "<bits/byteswap.h>", kPrivate, "<byteswap.h>", kPublic },
+-  { "<bits/cmathcalls.h>", kPrivate, "<complex.h>", kPublic },
++  { "<bits/cmathcalls.h>", kPrivate, "<complex.h>", kPrivate },
+   { "<bits/confname.h>", kPrivate, "<unistd.h>", kPublic },
+   { "<bits/dirent.h>", kPrivate, "<dirent.h>", kPublic },
+   { "<bits/dlfcn.h>", kPrivate, "<dlfcn.h>", kPublic },
+@@ -498,38 +498,38 @@ const IncludeMapEntry libc_include_map[] = {
+   { "<bits/eventfd.h>", kPrivate, "<sys/eventfd.h>", kPublic },
+   { "<bits/fcntl-linux.h>", kPrivate, "<fcntl.h>", kPublic },
+   { "<bits/fcntl.h>", kPrivate, "<fcntl.h>", kPublic },
+-  { "<bits/fenv.h>", kPrivate, "<fenv.h>", kPublic },
+-  { "<bits/huge_val.h>", kPrivate, "<math.h>", kPublic },
+-  { "<bits/huge_valf.h>", kPrivate, "<math.h>", kPublic },
+-  { "<bits/huge_vall.h>", kPrivate, "<math.h>", kPublic },
++  { "<bits/fenv.h>", kPrivate, "<fenv.h>", kPrivate },
++  { "<bits/huge_val.h>", kPrivate, "<math.h>", kPrivate },
++  { "<bits/huge_valf.h>", kPrivate, "<math.h>", kPrivate },
++  { "<bits/huge_vall.h>", kPrivate, "<math.h>", kPrivate },
+   { "<bits/in.h>", kPrivate, "<netinet/in.h>", kPublic },
+-  { "<bits/inf.h>", kPrivate, "<math.h>", kPublic },
++  { "<bits/inf.h>", kPrivate, "<math.h>", kPrivate },
+   { "<bits/inotify.h>", kPrivate, "<sys/inotify.h>", kPublic },
+   { "<bits/ioctl-types.h>", kPrivate, "<sys/ioctl.h>", kPublic },
+   { "<bits/ioctls.h>", kPrivate, "<sys/ioctl.h>", kPublic },
+   { "<bits/ipc.h>", kPrivate, "<sys/ipc.h>", kPublic },
+   { "<bits/ipctypes.h>", kPrivate, "<sys/ipc.h>", kPublic },
+-  { "<bits/locale.h>", kPrivate, "<locale.h>", kPublic },
+-  { "<bits/math-finite.h>", kPrivate, "<math.h>", kPublic },
+-  { "<bits/mathdef.h>", kPrivate, "<math.h>", kPublic },
+-  { "<bits/mathinline.h>", kPrivate, "<math.h>", kPublic },
++  { "<bits/locale.h>", kPrivate, "<locale.h>", kPrivate },
++  { "<bits/math-finite.h>", kPrivate, "<math.h>", kPrivate },
++  { "<bits/mathdef.h>", kPrivate, "<math.h>", kPrivate },
++  { "<bits/mathinline.h>", kPrivate, "<math.h>", kPrivate },
+   { "<bits/mman-linux.h>", kPrivate, "<sys/mman.h>", kPublic },
+   { "<bits/mman.h>", kPrivate, "<sys/mman.h>", kPublic },
+   { "<bits/mqueue.h>", kPrivate, "<mqueue.h>", kPublic },
+   { "<bits/msq.h>", kPrivate, "<sys/msg.h>", kPublic },
+-  { "<bits/nan.h>", kPrivate, "<math.h>", kPublic },
++  { "<bits/nan.h>", kPrivate, "<math.h>", kPrivate },
+   { "<bits/param.h>", kPrivate, "<sys/param.h>", kPublic },
+   { "<bits/poll.h>", kPrivate, "<sys/poll.h>", kPrivate },
+   { "<bits/predefs.h>", kPrivate, "<features.h>", kPublic },
+   { "<bits/resource.h>", kPrivate, "<sys/resource.h>", kPublic },
+   { "<bits/select.h>", kPrivate, "<sys/select.h>", kPublic },
+   { "<bits/semaphore.h>", kPrivate, "<semaphore.h>", kPublic },
+-  { "<bits/sigcontext.h>", kPrivate, "<signal.h>", kPublic },
++  { "<bits/sigcontext.h>", kPrivate, "<signal.h>", kPrivate },
+   { "<bits/signalfd.h>", kPrivate, "<sys/signalfd.h>", kPublic },
+-  { "<bits/stdlib-float.h>", kPrivate, "<stdlib.h>", kPublic },
+-  { "<bits/string.h>", kPrivate, "<string.h>", kPublic },
+-  { "<bits/string2.h>", kPrivate, "<string.h>", kPublic },
+-  { "<bits/string3.h>", kPrivate, "<string.h>", kPublic },
++  { "<bits/stdlib-float.h>", kPrivate, "<stdlib.h>", kPrivate },
++  { "<bits/string.h>", kPrivate, "<string.h>", kPrivate },
++  { "<bits/string2.h>", kPrivate, "<string.h>", kPrivate },
++  { "<bits/string3.h>", kPrivate, "<string.h>", kPrivate },
+   { "<bits/timerfd.h>", kPrivate, "<sys/timerfd.h>", kPublic },
+   { "<bits/typesizes.h>", kPrivate, "<sys/types.h>", kPublic },
+   // Top-level #includes that just forward to another file:
+@@ -541,13 +541,13 @@ const IncludeMapEntry libc_include_map[] = {
+   // on the POSIX.1-2024 list, I just choose the top-level one.
+   { "<sys/aio.h>", kPrivate, "<aio.h>", kPublic },
+   { "<sys/dirent.h>", kPrivate, "<dirent.h>", kPublic },
+-  { "<sys/errno.h>", kPrivate, "<errno.h>", kPublic },
++  { "<sys/errno.h>", kPrivate, "<errno.h>", kPrivate },
+   { "<sys/fcntl.h>", kPrivate, "<fcntl.h>", kPublic },
+   { "<sys/poll.h>", kPrivate, "<poll.h>", kPublic },
+   { "<sys/semaphore.h>", kPrivate, "<semaphore.h>", kPublic },
+-  { "<sys/signal.h>", kPrivate, "<signal.h>", kPublic },
++  { "<sys/signal.h>", kPrivate, "<signal.h>", kPrivate },
+   { "<sys/spawn.h>", kPrivate, "<spawn.h>", kPublic },
+-  { "<sys/stdio.h>", kPrivate, "<stdio.h>", kPublic },
++  { "<sys/stdio.h>", kPrivate, "<stdio.h>", kPrivate },
+   { "<sys/syslog.h>", kPrivate, "<syslog.h>", kPublic },
+   { "<sys/termios.h>", kPrivate, "<termios.h>", kPublic },
+   { "<sys/unistd.h>", kPrivate, "<unistd.h>", kPublic },
+@@ -567,21 +567,21 @@ const IncludeMapEntry libc_include_map[] = {
+   { "<asm/unistd_64.h>", kPrivate, "<asm/unistd.h>", kPrivate },
+   // I don't know what grep would have found these.  I found them
+   // via user report.
+-  { "<asm/errno.h>", kPrivate, "<errno.h>", kPublic },
+-  { "<asm/errno-base.h>", kPrivate, "<errno.h>", kPublic },
++  { "<asm/errno.h>", kPrivate, "<errno.h>", kPrivate },
++  { "<asm/errno-base.h>", kPrivate, "<errno.h>", kPrivate },
+   { "<asm/ptrace-abi.h>", kPrivate, "<asm/ptrace.h>", kPublic },
+   { "<asm/unistd.h>", kPrivate, "<sys/syscall.h>", kPublic },
+-  { "<linux/limits.h>", kPrivate, "<limits.h>", kPublic },   // PATH_MAX
++  { "<linux/limits.h>", kPrivate, "<limits.h>", kPrivate },   // PATH_MAX
+   { "<linux/prctl.h>", kPrivate, "<sys/prctl.h>", kPublic },
+   { "<sys/ucontext.h>", kPrivate, "<ucontext.h>", kPublic },
+   // System headers available on AIX, BSD, Solaris and other Unix systems
+   { "<sys/dtrace.h>", kPrivate, "<dtrace.h>", kPublic },
+   { "<sys/paths.h>", kPrivate, "<paths.h>", kPublic },
+-  { "<sys/syslimits.h>", kPrivate, "<limits.h>", kPublic },
++  { "<sys/syslimits.h>", kPrivate, "<limits.h>", kPrivate },
+   { "<sys/ttycom.h>", kPrivate, "<sys/ioctl.h>", kPublic },
+   { "<sys/ustat.h>", kPrivate, "<ustat.h>", kPublic },
+   // Exports guaranteed by the C standard
+-  { "<stdint.h>", kPublic, "<inttypes.h>", kPublic },
++  { "<stdint.h>", kPrivate, "<inttypes.h>", kPrivate },
+ };
+ 
+ const IncludeMapEntry stdlib_c_include_map[] = {
+@@ -601,31 +601,31 @@ const IncludeMapEntry stdlib_c_include_map[] = {
+   //
+   // $ curl -s -N https://raw.githubusercontent.com/cplusplus/draft/c%2B%2B20/source/lib-intro.tex | sed -n '/begin{multicolfloattable}.*{headers.cpp.c}/,/end{multicolfloattable}/p' | grep tcode | perl -nle 'm/tcode{<c(.*)>}/ && print qq@  { "<$1.h>", kPublic, "<c$1>", kPublic },@' | sort
+   { "<assert.h>", kPublic, "<cassert>", kPublic },
+-  { "<complex.h>", kPublic, "<ccomplex>", kPublic },
+-  { "<ctype.h>", kPublic, "<cctype>", kPublic },
+-  { "<errno.h>", kPublic, "<cerrno>", kPublic },
+-  { "<fenv.h>", kPublic, "<cfenv>", kPublic },
+-  { "<float.h>", kPublic, "<cfloat>", kPublic },
+-  { "<inttypes.h>", kPublic, "<cinttypes>", kPublic },
+-  { "<iso646.h>", kPublic, "<ciso646>", kPublic },
+-  { "<limits.h>", kPublic, "<climits>", kPublic },
+-  { "<locale.h>", kPublic, "<clocale>", kPublic },
+-  { "<math.h>", kPublic, "<cmath>", kPublic },
+-  { "<setjmp.h>", kPublic, "<csetjmp>", kPublic },
+-  { "<signal.h>", kPublic, "<csignal>", kPublic },
+-  { "<stdalign.h>", kPublic, "<cstdalign>", kPublic },
+-  { "<stdarg.h>", kPublic, "<cstdarg>", kPublic },
+-  { "<stdbool.h>", kPublic, "<cstdbool>", kPublic },
+-  { "<stddef.h>", kPublic, "<cstddef>", kPublic },
+-  { "<stdint.h>", kPublic, "<cstdint>", kPublic },
+-  { "<stdio.h>", kPublic, "<cstdio>", kPublic },
+-  { "<stdlib.h>", kPublic, "<cstdlib>", kPublic },
+-  { "<string.h>", kPublic, "<cstring>", kPublic },
+-  { "<tgmath.h>", kPublic, "<ctgmath>", kPublic },
+-  { "<time.h>", kPublic, "<ctime>", kPublic },
+-  { "<uchar.h>", kPublic, "<cuchar>", kPublic },
+-  { "<wchar.h>", kPublic, "<cwchar>", kPublic },
+-  { "<wctype.h>", kPublic, "<cwctype>", kPublic },
++  { "<complex.h>", kPrivate, "<ccomplex>", kPublic },
++  { "<ctype.h>", kPrivate, "<cctype>", kPublic },
++  { "<errno.h>", kPrivate, "<cerrno>", kPublic },
++  { "<fenv.h>", kPrivate, "<cfenv>", kPublic },
++  { "<float.h>", kPrivate, "<cfloat>", kPublic },
++  { "<inttypes.h>", kPrivate, "<cinttypes>", kPublic },
++  { "<iso646.h>", kPrivate, "<ciso646>", kPublic },
++  { "<limits.h>", kPrivate, "<climits>", kPublic },
++  { "<locale.h>", kPrivate, "<clocale>", kPublic },
++  { "<math.h>", kPrivate, "<cmath>", kPublic },
++  { "<setjmp.h>", kPrivate, "<csetjmp>", kPublic },
++  { "<signal.h>", kPrivate, "<csignal>", kPublic },
++  { "<stdalign.h>", kPrivate, "<cstdalign>", kPublic },
++  { "<stdarg.h>", kPrivate, "<cstdarg>", kPublic },
++  { "<stdbool.h>", kPrivate, "<cstdbool>", kPublic },
++  { "<stddef.h>", kPrivate, "<cstddef>", kPublic },
++  { "<stdint.h>", kPrivate, "<cstdint>", kPublic },
++  { "<stdio.h>", kPrivate, "<cstdio>", kPublic },
++  { "<stdlib.h>", kPrivate, "<cstdlib>", kPublic },
++  { "<string.h>", kPrivate, "<cstring>", kPublic },
++  { "<tgmath.h>", kPrivate, "<ctgmath>", kPublic },
++  { "<time.h>", kPrivate, "<ctime>", kPublic },
++  { "<uchar.h>", kPrivate, "<cuchar>", kPublic },
++  { "<wchar.h>", kPrivate, "<cwchar>", kPublic },
++  { "<wctype.h>", kPrivate, "<cwctype>", kPublic },
+ };
+ 
+ const char* stdlib_cpp_public_headers[] = {
diff --git a/depend/bitcoin/ci/test/02_run_container.py b/depend/bitcoin/ci/test/02_run_container.py
index 311fe923..64077c4b 100755
--- a/depend/bitcoin/ci/test/02_run_container.py
+++ b/depend/bitcoin/ci/test/02_run_container.py
@@ -47,7 +47,26 @@ def main():
                 file.write(f"{k}={v}\n")
     run(["cat", env_file])
 
-    if not os.getenv("DANGER_RUN_CI_ON_HOST"):
+    if os.getenv("DANGER_RUN_CI_ON_HOST"):
+        print("Running on host system without docker wrapper")
+        print("Create missing folders")
+        for create_dir in [
+                os.environ["CCACHE_DIR"],
+                os.environ["PREVIOUS_RELEASES_DIR"],
+        ]:
+            Path(create_dir).mkdir(parents=True, exist_ok=True)
+
+        # Modify PATH to prepend the retry script, needed for CI_RETRY_EXE
+        os.environ["PATH"] = f"{os.environ['BASE_ROOT_DIR']}/ci/retry:{os.environ['PATH']}"
+        # GNU getopt is required for the CI_RETRY_EXE script
+        if os.getenv("CI_OS_NAME") == "macos":
+            prefix = run(
+                ["brew", "--prefix", "gnu-getopt"],
+                stdout=subprocess.PIPE,
+                text=True,
+            ).stdout.strip()
+            os.environ["IN_GETOPT_BIN"] = f"{prefix}/bin/getopt"
+    else:
         CI_IMAGE_LABEL = "bitcoin-ci-test"
 
         # Use buildx unconditionally
@@ -142,18 +161,31 @@ def main():
             stdout=subprocess.PIPE,
             text=True,
         ).stdout.strip()
-        os.environ["CI_CONTAINER_ID"] = container_id
 
-    # GNU getopt is required for the CI_RETRY_EXE script
-    if os.getenv("CI_OS_NAME") == "macos":
-        prefix = run(
-            ["brew", "--prefix", "gnu-getopt"],
-            stdout=subprocess.PIPE,
-            text=True,
-        ).stdout.strip()
-        os.environ["IN_GETOPT_BIN"] = f"{prefix}/bin/getopt"
+    def ci_exec(cmd_inner, **kwargs):
+        if os.getenv("DANGER_RUN_CI_ON_HOST"):
+            prefix = []
+        else:
+            prefix = ["docker", "exec", container_id]
+
+        return run([*prefix, *cmd_inner], **kwargs)
+
+    # Normalize all folders to BASE_ROOT_DIR
+    ci_exec([
+        "rsync",
+        "--recursive",
+        "--perms",
+        "--stats",
+        "--human-readable",
+        f"{os.environ['BASE_READ_ONLY_DIR']}/",
+        f"{os.environ['BASE_ROOT_DIR']}",
+    ])
+    ci_exec([f"{os.environ['BASE_ROOT_DIR']}/ci/test/01_base_install.sh"])
+    ci_exec([f"{os.environ['BASE_ROOT_DIR']}/ci/test/03_test_script.sh"])
 
-    run(["./ci/test/02_run_container.sh"])  # run the remainder
+    if not os.getenv("DANGER_RUN_CI_ON_HOST"):
+        print("Stop and remove CI container by ID")
+        run(["docker", "container", "kill", container_id])
 
 
 if __name__ == "__main__":
diff --git a/depend/bitcoin/ci/test/02_run_container.sh b/depend/bitcoin/ci/test/02_run_container.sh
deleted file mode 100755
index 41128b5c..00000000
--- a/depend/bitcoin/ci/test/02_run_container.sh
+++ /dev/null
@@ -1,33 +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
-
-set -o errexit -o pipefail -o xtrace
-
-if [ -z "$DANGER_RUN_CI_ON_HOST" ]; then
-  export CI_EXEC_CMD_PREFIX="docker exec ${CI_CONTAINER_ID}"
-else
-  echo "Running on host system without docker wrapper"
-  echo "Create missing folders"
-  mkdir -p "${CCACHE_DIR}"
-  mkdir -p "${PREVIOUS_RELEASES_DIR}"
-fi
-
-CI_EXEC () {
-  $CI_EXEC_CMD_PREFIX bash -c "export PATH=\"/path_with space:${BASE_ROOT_DIR}/ci/retry:\$PATH\" && cd \"${BASE_ROOT_DIR}\" && $*"
-}
-export -f CI_EXEC
-
-# Normalize all folders to BASE_ROOT_DIR
-CI_EXEC rsync --recursive --perms --stats --human-readable "${BASE_READ_ONLY_DIR}/" "${BASE_ROOT_DIR}" || echo "Nothing to copy from ${BASE_READ_ONLY_DIR}/"
-CI_EXEC "${BASE_ROOT_DIR}/ci/test/01_base_install.sh"
-CI_EXEC "${BASE_ROOT_DIR}/ci/test/03_test_script.sh"
-
-if [ -z "$DANGER_RUN_CI_ON_HOST" ]; then
-  echo "Stop and remove CI container by ID"
-  docker container kill "${CI_CONTAINER_ID}"
-fi
diff --git a/depend/bitcoin/ci/test/03_test_script.sh b/depend/bitcoin/ci/test/03_test_script.sh
index e61dc33e..1cf9eb23 100755
--- a/depend/bitcoin/ci/test/03_test_script.sh
+++ b/depend/bitcoin/ci/test/03_test_script.sh
@@ -8,6 +8,9 @@ export LC_ALL=C.UTF-8
 
 set -ex
 
+cd "${BASE_ROOT_DIR}"
+
+export PATH="/path_with space:${PATH}"
 export ASAN_OPTIONS="detect_leaks=1:detect_stack_use_after_return=1:check_initialization_order=1:strict_init_order=1"
 export LSAN_OPTIONS="suppressions=${BASE_ROOT_DIR}/test/sanitizer_suppressions/lsan"
 export TSAN_OPTIONS="suppressions=${BASE_ROOT_DIR}/test/sanitizer_suppressions/tsan:halt_on_error=1:second_deadlock_stack=1"
@@ -41,10 +44,10 @@ echo "=== BEGIN env ==="
 env
 echo "=== END env ==="
 
-# Don't apply patches in the tidy job, because it relies on the `git diff`
-# command to detect IWYU errors. It is safe to skip this patch in the tidy job
+# Don't apply patches in the iwyu job, because it relies on the `git diff`
+# command to detect IWYU errors. It is safe to skip this patch in the iwyu job
 # because it doesn't run a UB detector.
-if [ "$RUN_TIDY" != "true" ]; then
+if [[ "${RUN_IWYU}" != true ]]; then
   # compact->outputs[i].file_size is uninitialized memory, so reading it is UB.
   # The statistic bytes_written is only used for logging, which is disabled in
   # CI, so as a temporary minimal fix to work around UB and CI failures, leave
@@ -120,7 +123,7 @@ BASE_BUILD_DIR=${BASE_BUILD_DIR:-$BASE_SCRATCH_DIR/build-$HOST}
 
 BITCOIN_CONFIG_ALL="$BITCOIN_CONFIG_ALL -DCMAKE_INSTALL_PREFIX=$BASE_OUTDIR -Werror=dev"
 
-if [[ "${RUN_TIDY}" == "true" ]]; then
+if [[ "${RUN_IWYU}" == true || "${RUN_TIDY}" == true ]]; then
   BITCOIN_CONFIG_ALL="$BITCOIN_CONFIG_ALL -DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
 fi
 
@@ -132,11 +135,15 @@ cmake -S "$BASE_ROOT_DIR" -B "$BASE_BUILD_DIR" "${CMAKE_ARGS[@]}" || (
   false
 )
 
+if [[ "${GOAL}" != all && "${GOAL}" != codegen ]]; then
+  GOAL="all ${GOAL}"
+fi
+
 # shellcheck disable=SC2086
-cmake --build "${BASE_BUILD_DIR}" "$MAKEJOBS" --target all $GOAL || (
+cmake --build "${BASE_BUILD_DIR}" "$MAKEJOBS" --target $GOAL || (
   echo "Build failure. Verbose build follows."
   # shellcheck disable=SC2086
-  cmake --build "${BASE_BUILD_DIR}" -j1 --target all $GOAL --verbose
+  cmake --build "${BASE_BUILD_DIR}" -j1 --target $GOAL --verbose
   false
 )
 
@@ -204,9 +211,11 @@ if [ "${RUN_TIDY}" = "true" ]; then
     echo "^^^ ⚠️ Failure generated from clang-tidy"
     false
   fi
+fi
 
+if [[ "${RUN_IWYU}" == true ]]; then
   # TODO: Consider enforcing IWYU across the entire codebase.
-  FILES_WITH_ENFORCED_IWYU="/src/(crypto|index)/.*\\.cpp"
+  FILES_WITH_ENFORCED_IWYU="/src/((crypto|index)/.*\\.cpp|node/blockstorage.cpp|node/utxo_snapshot.cpp|core_read.cpp|signet.cpp|kernel/chain.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"
 
@@ -220,6 +229,7 @@ if [ "${RUN_TIDY}" = "true" ]; then
              -Xiwyu --max_line_length=160 \
              2>&1 | tee /tmp/iwyu_ci.out
     python3 "/include-what-you-use/fix_includes.py" --nosafe_headers < /tmp/iwyu_ci.out
+    git diff -U0 | ./contrib/devtools/clang-format-diff.py -binary="clang-format-${TIDY_LLVM_V}" -p1 -i -v
   }
 
   run_iwyu "compile_commands_iwyu_errors.json"
diff --git a/depend/bitcoin/ci/test_imagefile b/depend/bitcoin/ci/test_imagefile
index a0e1714e..93494cc1 100644
--- a/depend/bitcoin/ci/test_imagefile
+++ b/depend/bitcoin/ci/test_imagefile
@@ -14,8 +14,9 @@ ENV FILE_ENV=${FILE_ENV}
 ARG BASE_ROOT_DIR
 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_container_base/ci/test/
+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/
 
 # Bash is required, so install it when missing
 RUN sh -c "bash -c 'true' || ( apk update && apk add --no-cache bash )"
diff --git a/depend/bitcoin/cmake/libmultiprocess.cmake b/depend/bitcoin/cmake/libmultiprocess.cmake
index 5db8f4e9..027109a9 100644
--- a/depend/bitcoin/cmake/libmultiprocess.cmake
+++ b/depend/bitcoin/cmake/libmultiprocess.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2025 The Bitcoin Core developers
+# Copyright (c) 2025-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or https://opensource.org/license/mit/.
 
@@ -27,7 +27,7 @@ function(add_libmultiprocess subdir)
   mark_as_advanced(CapnProto_kj-tls_IMPORTED_LOCATION)
   if(BUILD_TESTS)
     # Add tests to "all" target so ctest can run them
-    set_target_properties(mptests PROPERTIES EXCLUDE_FROM_ALL OFF)
+    set_target_properties(mptest PROPERTIES EXCLUDE_FROM_ALL OFF)
   endif()
   # Exclude examples from compilation database, because the examples are not
   # built by default, and they contain generated c++ code. Without this
diff --git a/depend/bitcoin/cmake/module/AddBoostIfNeeded.cmake b/depend/bitcoin/cmake/module/AddBoostIfNeeded.cmake
index e2eaf556..b3f24800 100644
--- a/depend/bitcoin/cmake/module/AddBoostIfNeeded.cmake
+++ b/depend/bitcoin/cmake/module/AddBoostIfNeeded.cmake
@@ -29,7 +29,7 @@ function(add_boost_if_needed)
     endif()
   endif()
 
-  find_package(Boost 1.73.0 REQUIRED CONFIG)
+  find_package(Boost 1.74.0 REQUIRED CONFIG)
   mark_as_advanced(Boost_INCLUDE_DIR boost_headers_DIR)
   # Workaround for a bug in NetBSD pkgsrc.
   # See: https://github.com/NetBSD/pkgsrc/issues/167.
diff --git a/depend/bitcoin/contrib/asmap/asmap-tool.py b/depend/bitcoin/contrib/asmap/asmap-tool.py
index c679ab15..b594e479 100755
--- a/depend/bitcoin/contrib/asmap/asmap-tool.py
+++ b/depend/bitcoin/contrib/asmap/asmap-tool.py
@@ -131,6 +131,8 @@ def main():
     if args.subcommand is None:
         parser.print_help()
     elif args.subcommand == "encode":
+        if args.outfile.isatty():
+            sys.exit("Not much use in writing binary to a TTY. Please specify an output file or pipe output to another process.")
         state = load_file(args.infile)
         save_binary(args.outfile, state, fill=args.fill)
     elif args.subcommand == "decode":
diff --git a/depend/bitcoin/contrib/completions/bash/bitcoin-cli.bash b/depend/bitcoin/contrib/completions/bash/bitcoin-cli.bash
index 3018d076..ff34ad9f 100644
--- a/depend/bitcoin/contrib/completions/bash/bitcoin-cli.bash
+++ b/depend/bitcoin/contrib/completions/bash/bitcoin-cli.bash
@@ -1,5 +1,5 @@
 # bash programmable completion for bitcoin-cli(1)
-# Copyright (c) 2012-2022 The Bitcoin Core developers
+# Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/contrib/completions/bash/bitcoin-tx.bash b/depend/bitcoin/contrib/completions/bash/bitcoin-tx.bash
index 51a9fe31..28359bfd 100644
--- a/depend/bitcoin/contrib/completions/bash/bitcoin-tx.bash
+++ b/depend/bitcoin/contrib/completions/bash/bitcoin-tx.bash
@@ -1,5 +1,5 @@
 # bash programmable completion for bitcoin-tx(1)
-# Copyright (c) 2016-2022 The Bitcoin Core developers
+# Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/contrib/completions/bash/bitcoind.bash b/depend/bitcoin/contrib/completions/bash/bitcoind.bash
index c11d99ef..78e4d4e5 100644
--- a/depend/bitcoin/contrib/completions/bash/bitcoind.bash
+++ b/depend/bitcoin/contrib/completions/bash/bitcoind.bash
@@ -1,5 +1,5 @@
 # bash programmable completion for bitcoind(1) and bitcoin-qt(1)
-# Copyright (c) 2012-2022 The Bitcoin Core developers
+# Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/contrib/devtools/gen-bitcoin-conf.sh b/depend/bitcoin/contrib/devtools/gen-bitcoin-conf.sh
index d31f5462..05618252 100755
--- a/depend/bitcoin/contrib/devtools/gen-bitcoin-conf.sh
+++ b/depend/bitcoin/contrib/devtools/gen-bitcoin-conf.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Copyright (c) 2021 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/contrib/devtools/gen-manpages.py b/depend/bitcoin/contrib/devtools/gen-manpages.py
index 02e5f839..94187944 100755
--- a/depend/bitcoin/contrib/devtools/gen-manpages.py
+++ b/depend/bitcoin/contrib/devtools/gen-manpages.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 import os
diff --git a/depend/bitcoin/contrib/devtools/iwyu/bitcoin.core.imp b/depend/bitcoin/contrib/devtools/iwyu/bitcoin.core.imp
index c3195e51..9067bc32 100644
--- a/depend/bitcoin/contrib/devtools/iwyu/bitcoin.core.imp
+++ b/depend/bitcoin/contrib/devtools/iwyu/bitcoin.core.imp
@@ -13,4 +13,8 @@
   { "symbol": ["SEEK_CUR", "private", "<cstdio>", "public"] },
   { "symbol": ["SEEK_END", "private", "<cstdio>", "public"] },
   { "symbol": ["SEEK_SET", "private", "<cstdio>", "public"] },
+
+  # IWYU bug.
+  # See: https://github.com/include-what-you-use/include-what-you-use/issues/1863.
+  { "symbol": ["std::vector", "private", "<vector>", "public"] },
 ]
diff --git a/depend/bitcoin/contrib/devtools/utils.py b/depend/bitcoin/contrib/devtools/utils.py
index 8b4c67c6..7f37c607 100755
--- a/depend/bitcoin/contrib/devtools/utils.py
+++ b/depend/bitcoin/contrib/devtools/utils.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 '''
diff --git a/depend/bitcoin/contrib/guix/libexec/build.sh b/depend/bitcoin/contrib/guix/libexec/build.sh
index 48301841..f4db25f4 100755
--- a/depend/bitcoin/contrib/guix/libexec/build.sh
+++ b/depend/bitcoin/contrib/guix/libexec/build.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Copyright (c) 2019-2022 The Bitcoin Core developers
+# Copyright (c) 2019-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
diff --git a/depend/bitcoin/contrib/guix/libexec/codesign.sh b/depend/bitcoin/contrib/guix/libexec/codesign.sh
index fe860653..9ea683b9 100755
--- a/depend/bitcoin/contrib/guix/libexec/codesign.sh
+++ b/depend/bitcoin/contrib/guix/libexec/codesign.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Copyright (c) 2021-2022 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 export LC_ALL=C
diff --git a/depend/bitcoin/contrib/guix/security-check.py b/depend/bitcoin/contrib/guix/security-check.py
index be2e0cfb..2a6e26b6 100755
--- a/depend/bitcoin/contrib/guix/security-check.py
+++ b/depend/bitcoin/contrib/guix/security-check.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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.
 '''
diff --git a/depend/bitcoin/contrib/macdeploy/detached-sig-create.sh b/depend/bitcoin/contrib/macdeploy/detached-sig-create.sh
index b558784e..efb0d247 100755
--- a/depend/bitcoin/contrib/macdeploy/detached-sig-create.sh
+++ b/depend/bitcoin/contrib/macdeploy/detached-sig-create.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/contrib/qos/tc.sh b/depend/bitcoin/contrib/qos/tc.sh
index 7ebcbf22..2c48fc2a 100755
--- a/depend/bitcoin/contrib/qos/tc.sh
+++ b/depend/bitcoin/contrib/qos/tc.sh
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 #
-# Copyright (c) 2017-2021 The Bitcoin Core developers
+# Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/contrib/seeds/generate-seeds.py b/depend/bitcoin/contrib/seeds/generate-seeds.py
index 9ad48805..2dfad0c7 100755
--- a/depend/bitcoin/contrib/seeds/generate-seeds.py
+++ b/depend/bitcoin/contrib/seeds/generate-seeds.py
@@ -160,6 +160,9 @@ def main():
         sys.exit(1)
     g = sys.stdout
     indir = sys.argv[1]
+    g.write('// Copyright (c) The Bitcoin Core developers\n')
+    g.write('// Distributed under the MIT software license, see the accompanying\n')
+    g.write('// file COPYING or https://opensource.org/license/mit.\n\n')
     g.write('#ifndef BITCOIN_CHAINPARAMSSEEDS_H\n')
     g.write('#define BITCOIN_CHAINPARAMSSEEDS_H\n')
     g.write('/**\n')
diff --git a/depend/bitcoin/contrib/signet/getcoins.py b/depend/bitcoin/contrib/signet/getcoins.py
index 75430e5b..b58ed04a 100755
--- a/depend/bitcoin/contrib/signet/getcoins.py
+++ b/depend/bitcoin/contrib/signet/getcoins.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2022 The Bitcoin Core developers
+# Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/contrib/signet/miner b/depend/bitcoin/contrib/signet/miner
index 8c7edc56..f46d88b5 100755
--- a/depend/bitcoin/contrib/signet/miner
+++ b/depend/bitcoin/contrib/signet/miner
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020 The Bitcoin Core developers
+# Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/contrib/testgen/gen_key_io_test_vectors.py b/depend/bitcoin/contrib/testgen/gen_key_io_test_vectors.py
index 7bfb1d76..ceefd7a8 100755
--- a/depend/bitcoin/contrib/testgen/gen_key_io_test_vectors.py
+++ b/depend/bitcoin/contrib/testgen/gen_key_io_test_vectors.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2012-2022 The Bitcoin Core developers
+# Copyright (c) 2012-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.
 '''
diff --git a/depend/bitcoin/contrib/tracing/log_raw_p2p_msgs.py b/depend/bitcoin/contrib/tracing/log_raw_p2p_msgs.py
index 1c0f03e1..ff181b00 100755
--- a/depend/bitcoin/contrib/tracing/log_raw_p2p_msgs.py
+++ b/depend/bitcoin/contrib/tracing/log_raw_p2p_msgs.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/contrib/tracing/log_utxocache_flush.py b/depend/bitcoin/contrib/tracing/log_utxocache_flush.py
index 8ff9cd5e..230b38e9 100755
--- a/depend/bitcoin/contrib/tracing/log_utxocache_flush.py
+++ b/depend/bitcoin/contrib/tracing/log_utxocache_flush.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021-2022 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/contrib/tracing/mempool_monitor.py b/depend/bitcoin/contrib/tracing/mempool_monitor.py
index c5f672fb..03c5c59f 100755
--- a/depend/bitcoin/contrib/tracing/mempool_monitor.py
+++ b/depend/bitcoin/contrib/tracing/mempool_monitor.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/contrib/tracing/p2p_monitor.py b/depend/bitcoin/contrib/tracing/p2p_monitor.py
index 51af6037..d486f566 100755
--- a/depend/bitcoin/contrib/tracing/p2p_monitor.py
+++ b/depend/bitcoin/contrib/tracing/p2p_monitor.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/contrib/verify-commits/gpg.sh b/depend/bitcoin/contrib/verify-commits/gpg.sh
index cfd68e45..3579a70a 100755
--- a/depend/bitcoin/contrib/verify-commits/gpg.sh
+++ b/depend/bitcoin/contrib/verify-commits/gpg.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# Copyright (c) 2014-2019 The Bitcoin Core developers
+# Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/contrib/verify-commits/pre-push-hook.sh b/depend/bitcoin/contrib/verify-commits/pre-push-hook.sh
index 99532483..a532bf74 100755
--- a/depend/bitcoin/contrib/verify-commits/pre-push-hook.sh
+++ b/depend/bitcoin/contrib/verify-commits/pre-push-hook.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Copyright (c) 2014-2021 The Bitcoin Core developers
+# Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/contrib/windeploy/detached-sig-create.sh b/depend/bitcoin/contrib/windeploy/detached-sig-create.sh
index 4ec72653..f417b046 100755
--- a/depend/bitcoin/contrib/windeploy/detached-sig-create.sh
+++ b/depend/bitcoin/contrib/windeploy/detached-sig-create.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# Copyright (c) 2014-2021 The Bitcoin Core developers
+# Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/contrib/zmq/zmq_sub.py b/depend/bitcoin/contrib/zmq/zmq_sub.py
index b2290a6c..59639c45 100755
--- a/depend/bitcoin/contrib/zmq/zmq_sub.py
+++ b/depend/bitcoin/contrib/zmq/zmq_sub.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2021 The Bitcoin Core developers
+# Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/doc/dependencies.md b/depend/bitcoin/doc/dependencies.md
index 3ff306f8..0d7d8b3a 100644
--- a/depend/bitcoin/doc/dependencies.md
+++ b/depend/bitcoin/doc/dependencies.md
@@ -19,7 +19,7 @@ Bitcoin Core requires one of the following compilers.
 
 | Dependency | Releases | Minimum required |
 | --- | --- | --- |
-| [Boost](../depends/packages/boost.mk) | [link](https://www.boost.org/users/download/) | [1.73.0](https://github.com/bitcoin/bitcoin/pull/29066) |
+| [Boost](../depends/packages/boost.mk) | [link](https://www.boost.org/users/download/) | [1.74.0](https://github.com/bitcoin/bitcoin/pull/34107) |
 | CMake | [link](https://cmake.org/) | [3.22](https://github.com/bitcoin/bitcoin/pull/30454) |
 | [libevent](../depends/packages/libevent.mk) | [link](https://github.com/libevent/libevent/releases) | [2.1.8](https://github.com/bitcoin/bitcoin/pull/24681) |
 
diff --git a/depend/bitcoin/doc/design/assumeutxo.md b/depend/bitcoin/doc/design/assumeutxo.md
index 123c02ac..9f04a52b 100644
--- a/depend/bitcoin/doc/design/assumeutxo.md
+++ b/depend/bitcoin/doc/design/assumeutxo.md
@@ -63,7 +63,7 @@ chainstate and a sync to tip begins. A new chainstate directory is created in th
 datadir for the snapshot chainstate called `chainstate_snapshot`.
 
 When this directory is present in the datadir, the snapshot chainstate will be detected
-and loaded as active on node startup (via `DetectSnapshotChainstate()`).
+and loaded as active on node startup (via `LoadAssumeutxoChainstate()`).
 
 A special file is created within that directory, `base_blockhash`, which contains the
 serialized `uint256` of the base block of the snapshot. This is used to reinitialize
@@ -97,14 +97,13 @@ sequentially.
 ### Background chainstate hits snapshot base block
 
 Once the tip of the background chainstate hits the base block of the snapshot
-chainstate, we stop use of the background chainstate by setting `m_disabled`, in
-`MaybeCompleteSnapshotValidation()`, which is checked in `ActivateBestChain()`). We hash the
+chainstate, we hash the
 background chainstate's UTXO set contents and ensure it matches the compiled value in
 `CMainParams::m_assumeutxo_data`.
 
 |    |    |
 | ---------- | ----------- |
-| number of chainstates | 2 (ibd has `m_disabled=true`) |
+| number of chainstates | 2 |
 | active chainstate | snapshot |
 
 The background chainstate data lingers on disk until the program is restarted.
diff --git a/depend/bitcoin/doc/fuzzing.md b/depend/bitcoin/doc/fuzzing.md
index 564245b7..7564bbd7 100644
--- a/depend/bitcoin/doc/fuzzing.md
+++ b/depend/bitcoin/doc/fuzzing.md
@@ -82,7 +82,7 @@ of the test. Just make sure to use double-dash to distinguish them from the
 fuzzer's own arguments:
 
 ```sh
-$ FUZZ=address_deserialize_v2 build_fuzz/bin/fuzz -runs=1 fuzz_corpora/address_deserialize_v2 --checkaddrman=5 --printtoconsole=1
+$ FUZZ=address_deserialize build_fuzz/bin/fuzz -runs=1 fuzz_corpora/address_deserialize --checkaddrman=5 --printtoconsole=1
 ```
 
 ## Fuzzing corpora
diff --git a/depend/bitcoin/doc/policy/packages.md b/depend/bitcoin/doc/policy/packages.md
index 4795f715..d48afed4 100644
--- a/depend/bitcoin/doc/policy/packages.md
+++ b/depend/bitcoin/doc/policy/packages.md
@@ -99,14 +99,6 @@ submitted as a package.
 transaction (i.e. in which a replacement transaction with a higher fee cannot be signed) being
 rejected from the mempool when transaction volume is high and the mempool minimum feerate rises.
 
-Note: Package feerate cannot be used to meet the minimum relay feerate (`-minrelaytxfee`)
-requirement. For example, if the mempool minimum feerate is 5sat/vB and the minimum relay feerate is
-set to 5sat/vB, a 1sat/vB parent transaction with a high-feerate child will not be accepted, even if
-submitted as a package. Note that this rule does not apply to
-[TRUC transactions](https://github.com/bitcoin/bips/blob/master/bip-0431.mediawiki) as an individual
-TRUC transaction is permitted to be below the mempool min relay feerate, assuming it is considered within
-a package that meets the mempool's feerate requirements.
-
 *Rationale*: Avoid situations in which the mempool contains non-bumped transactions below min relay
 feerate (which we consider to have pay 0 fees and thus receiving free relay). While package
 submission would ensure these transactions are bumped at the time of entry, it is not guaranteed
diff --git a/depend/bitcoin/doc/release-notes-33657.md b/depend/bitcoin/doc/release-notes-33657.md
index f9e6841b..a9821323 100644
--- a/depend/bitcoin/doc/release-notes-33657.md
+++ b/depend/bitcoin/doc/release-notes-33657.md
@@ -1,5 +1,5 @@
 New REST API
 ------------
 
-- A new REST API endpoint (`/rest/blockpart/BLOCKHASH.bin?offset=X&size=Y`) has been introduced
-  for efficiently fetching a range of bytes from block `BLOCKHASH`.
+- A new REST API endpoint (`/rest/blockpart/<BLOCK-HASH>.<bin|hex>?offset=<OFFSET>&size=<SIZE>`) has been introduced
+  for efficiently fetching a range of bytes from block `<BLOCK-HASH>`.
diff --git a/depend/bitcoin/doc/release-notes-33892.md b/depend/bitcoin/doc/release-notes-33892.md
new file mode 100644
index 00000000..e9d41b80
--- /dev/null
+++ b/depend/bitcoin/doc/release-notes-33892.md
@@ -0,0 +1,8 @@
+P2P and network changes
+-----------------------
+
+- Transactions participating in one-parent-one-child package relay can now have the parent
+    with a feerate lower than the `-minrelaytxfee` feerate, even 0 fee. This expands the change
+    from 28.0 to also cover packages of non-TRUC transactions. Note that in general the
+    package child can have additional unconfirmed parents, but they must already be
+    in-mempool for the new package to be relayed. (#33892)
diff --git a/depend/bitcoin/doc/release-notes-34088.md b/depend/bitcoin/doc/release-notes-34088.md
new file mode 100644
index 00000000..5aa8a9d9
--- /dev/null
+++ b/depend/bitcoin/doc/release-notes-34088.md
@@ -0,0 +1,2 @@
+- When `-logsourcelocations` is enabled, the log output now contains just the
+  function name instead of the entire function signature. (#34088)
diff --git a/depend/bitcoin/share/qt/translate.cmake b/depend/bitcoin/share/qt/translate.cmake
index ed32c6dd..2ac8c7f0 100644
--- a/depend/bitcoin/share/qt/translate.cmake
+++ b/depend/bitcoin/share/qt/translate.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2025 The Bitcoin Core developers
+# Copyright (c) 2025-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/share/rpcauth/rpcauth.py b/depend/bitcoin/share/rpcauth/rpcauth.py
index 506fcf9d..ba91e0bc 100755
--- a/depend/bitcoin/share/rpcauth/rpcauth.py
+++ b/depend/bitcoin/share/rpcauth/rpcauth.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2021 The Bitcoin Core developers
+# Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/.clang-format b/depend/bitcoin/src/.clang-format
index c5fcd0b4..4db09138 100644
--- a/depend/bitcoin/src/.clang-format
+++ b/depend/bitcoin/src/.clang-format
@@ -97,7 +97,7 @@ ForEachMacros:
   - BOOST_FOREACH
 IfMacros:
   - KJ_IF_MAYBE
-IncludeBlocks:   Preserve
+IncludeBlocks:   Regroup
 IncludeCategories:
   - Regex:           '^<bitcoin-build-config\.h>'
     Priority:        -1
diff --git a/depend/bitcoin/src/.clang-tidy b/depend/bitcoin/src/.clang-tidy
index da53a588..01153649 100644
--- a/depend/bitcoin/src/.clang-tidy
+++ b/depend/bitcoin/src/.clang-tidy
@@ -25,6 +25,7 @@ performance-*,
 -performance-noexcept-move-constructor,
 -performance-unnecessary-value-param,
 readability-const-return-type,
+readability-container-contains,
 readability-redundant-declaration,
 readability-redundant-string-init,
 '
diff --git a/depend/bitcoin/src/CMakeLists.txt b/depend/bitcoin/src/CMakeLists.txt
index 47aee937..43d67f40 100644
--- a/depend/bitcoin/src/CMakeLists.txt
+++ b/depend/bitcoin/src/CMakeLists.txt
@@ -43,7 +43,7 @@ add_custom_target(generate_build_info
   COMMENT "Generating bitcoin-build-info.h"
   VERBATIM
 )
-add_library(bitcoin_clientversion STATIC EXCLUDE_FROM_ALL
+add_library(bitcoin_clientversion STATIC
   clientversion.cpp
 )
 target_link_libraries(bitcoin_clientversion
diff --git a/depend/bitcoin/src/addrdb.h b/depend/bitcoin/src/addrdb.h
index cc3014dc..44e51ce8 100644
--- a/depend/bitcoin/src/addrdb.h
+++ b/depend/bitcoin/src/addrdb.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/addresstype.cpp b/depend/bitcoin/src/addresstype.cpp
index 67e64394..410879b4 100644
--- a/depend/bitcoin/src/addresstype.cpp
+++ b/depend/bitcoin/src/addresstype.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/addresstype.h b/depend/bitcoin/src/addresstype.h
index 78d3126d..862049de 100644
--- a/depend/bitcoin/src/addresstype.h
+++ b/depend/bitcoin/src/addresstype.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/addrman.cpp b/depend/bitcoin/src/addrman.cpp
index 5cd1d41f..206b5411 100644
--- a/depend/bitcoin/src/addrman.cpp
+++ b/depend/bitcoin/src/addrman.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2012 Pieter Wuille
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
@@ -457,7 +457,7 @@ void AddrManImpl::Delete(nid_type nId)
 {
     AssertLockHeld(cs);
 
-    assert(mapInfo.count(nId) != 0);
+    assert(mapInfo.contains(nId));
     AddrInfo& info = mapInfo[nId];
     assert(!info.fInTried);
     assert(info.nRefCount == 0);
@@ -516,7 +516,7 @@ void AddrManImpl::MakeTried(AddrInfo& info, nid_type nId)
     if (vvTried[nKBucket][nKBucketPos] != -1) {
         // find an item to evict
         nid_type nIdEvict = vvTried[nKBucket][nKBucketPos];
-        assert(mapInfo.count(nIdEvict) == 1);
+        assert(mapInfo.contains(nIdEvict));
         AddrInfo& infoOld = mapInfo[nIdEvict];
 
         // Remove the to-be-evicted item from the tried set.
@@ -919,7 +919,7 @@ void AddrManImpl::ResolveCollisions_()
         bool erase_collision = false;
 
         // If id_new not found in mapInfo remove it from m_tried_collisions
-        if (mapInfo.count(id_new) != 1) {
+        if (!mapInfo.contains(id_new)) {
             erase_collision = true;
         } else {
             AddrInfo& info_new = mapInfo[id_new];
@@ -985,7 +985,7 @@ std::pair<CAddress, NodeSeconds> AddrManImpl::SelectTriedCollision_()
     nid_type id_new = *it;
 
     // If id_new not found in mapInfo remove it from m_tried_collisions
-    if (mapInfo.count(id_new) != 1) {
+    if (!mapInfo.contains(id_new)) {
         m_tried_collisions.erase(it);
         return {};
     }
@@ -1115,7 +1115,7 @@ int AddrManImpl::CheckAddrman() const
     for (int n = 0; n < ADDRMAN_TRIED_BUCKET_COUNT; n++) {
         for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {
             if (vvTried[n][i] != -1) {
-                if (!setTried.count(vvTried[n][i]))
+                if (!setTried.contains(vvTried[n][i]))
                     return -11;
                 const auto it{mapInfo.find(vvTried[n][i])};
                 if (it == mapInfo.end() || it->second.GetTriedBucket(nKey, m_netgroupman) != n) {
@@ -1132,7 +1132,7 @@ int AddrManImpl::CheckAddrman() const
     for (int n = 0; n < ADDRMAN_NEW_BUCKET_COUNT; n++) {
         for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {
             if (vvNew[n][i] != -1) {
-                if (!mapNew.count(vvNew[n][i]))
+                if (!mapNew.contains(vvNew[n][i]))
                     return -12;
                 const auto it{mapInfo.find(vvNew[n][i])};
                 if (it == mapInfo.end() || it->second.GetBucketPosition(nKey, true, n) != i) {
diff --git a/depend/bitcoin/src/addrman.h b/depend/bitcoin/src/addrman.h
index 2ddf1468..3a323014 100644
--- a/depend/bitcoin/src/addrman.h
+++ b/depend/bitcoin/src/addrman.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2012 Pieter Wuille
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/addrman_impl.h b/depend/bitcoin/src/addrman_impl.h
index a0390b71..f825d20b 100644
--- a/depend/bitcoin/src/addrman_impl.h
+++ b/depend/bitcoin/src/addrman_impl.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/arith_uint256.cpp b/depend/bitcoin/src/arith_uint256.cpp
index 850fc624..392f052c 100644
--- a/depend/bitcoin/src/arith_uint256.cpp
+++ b/depend/bitcoin/src/arith_uint256.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/attributes.h b/depend/bitcoin/src/attributes.h
index a4603b02..275dad9f 100644
--- a/depend/bitcoin/src/attributes.h
+++ b/depend/bitcoin/src/attributes.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/banman.cpp b/depend/bitcoin/src/banman.cpp
index 32a3cda6..499595a4 100644
--- a/depend/bitcoin/src/banman.cpp
+++ b/depend/bitcoin/src/banman.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/bench/addrman.cpp b/depend/bitcoin/src/bench/addrman.cpp
index ceef6c29..4ba02242 100644
--- a/depend/bitcoin/src/bench/addrman.cpp
+++ b/depend/bitcoin/src/bench/addrman.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/bench/base58.cpp b/depend/bitcoin/src/bench/base58.cpp
index f078c339..bc82d739 100644
--- a/depend/bitcoin/src/bench/base58.cpp
+++ b/depend/bitcoin/src/bench/base58.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/bench/bech32.cpp b/depend/bitcoin/src/bench/bech32.cpp
index 6aa73bd0..065ee9e7 100644
--- a/depend/bitcoin/src/bench/bech32.cpp
+++ b/depend/bitcoin/src/bench/bech32.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/bench/bench.cpp b/depend/bitcoin/src/bench/bench.cpp
index 9cc1f30f..3eb99ab5 100644
--- a/depend/bitcoin/src/bench/bench.cpp
+++ b/depend/bitcoin/src/bench/bench.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/bench/bench.h b/depend/bitcoin/src/bench/bench.h
index 2df203ce..f6c41486 100644
--- a/depend/bitcoin/src/bench/bench.h
+++ b/depend/bitcoin/src/bench/bench.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/bench/bench_bitcoin.cpp b/depend/bitcoin/src/bench/bench_bitcoin.cpp
index 88afe68a..841d6258 100644
--- a/depend/bitcoin/src/bench/bench_bitcoin.cpp
+++ b/depend/bitcoin/src/bench/bench_bitcoin.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/bench/bip324_ecdh.cpp b/depend/bitcoin/src/bench/bip324_ecdh.cpp
index e6a614da..b94c2bd2 100644
--- a/depend/bitcoin/src/bench/bip324_ecdh.cpp
+++ b/depend/bitcoin/src/bench/bip324_ecdh.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/bench/block_assemble.cpp b/depend/bitcoin/src/bench/block_assemble.cpp
index 00102aef..4214d635 100644
--- a/depend/bitcoin/src/bench/block_assemble.cpp
+++ b/depend/bitcoin/src/bench/block_assemble.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/bench/ccoins_caching.cpp b/depend/bitcoin/src/bench/ccoins_caching.cpp
index 35186153..26d15fc2 100644
--- a/depend/bitcoin/src/bench/ccoins_caching.cpp
+++ b/depend/bitcoin/src/bench/ccoins_caching.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/bench/chacha20.cpp b/depend/bitcoin/src/bench/chacha20.cpp
index f154d8c6..cc029b1b 100644
--- a/depend/bitcoin/src/bench/chacha20.cpp
+++ b/depend/bitcoin/src/bench/chacha20.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/bench/checkblock.cpp b/depend/bitcoin/src/bench/checkblock.cpp
index 9558d64f..acf29767 100644
--- a/depend/bitcoin/src/bench/checkblock.cpp
+++ b/depend/bitcoin/src/bench/checkblock.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/bench/checkqueue.cpp b/depend/bitcoin/src/bench/checkqueue.cpp
index c7aed5b7..2aa715cb 100644
--- a/depend/bitcoin/src/bench/checkqueue.cpp
+++ b/depend/bitcoin/src/bench/checkqueue.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/bench/cluster_linearize.cpp b/depend/bitcoin/src/bench/cluster_linearize.cpp
index 1cd36b53..a856d247 100644
--- a/depend/bitcoin/src/bench/cluster_linearize.cpp
+++ b/depend/bitcoin/src/bench/cluster_linearize.cpp
@@ -18,21 +18,6 @@ using namespace util::hex_literals;
 
 namespace {
 
-/** Construct a linear graph. These are pessimal for AncestorCandidateFinder, as they maximize
- *  the number of ancestor set feerate updates. The best ancestor set is always the topmost
- *  remaining transaction, whose removal requires updating all remaining transactions' ancestor
- *  set feerates. */
-template<typename SetType>
-DepGraph<SetType> MakeLinearGraph(DepGraphIndex ntx)
-{
-    DepGraph<SetType> depgraph;
-    for (DepGraphIndex i = 0; i < ntx; ++i) {
-        depgraph.AddTransaction({-int32_t(i), 1});
-        if (i > 0) depgraph.AddDependencies(SetType::Singleton(i - 1), i);
-    }
-    return depgraph;
-}
-
 /** Construct a wide graph (one root, with N-1 children that are otherwise unrelated, with
  *  increasing feerates). These graphs are pessimal for the LIMO step in Linearize, because
  *  rechunking is needed after every candidate (the last transaction gets picked every time).
@@ -48,136 +33,6 @@ DepGraph<SetType> MakeWideGraph(DepGraphIndex ntx)
     return depgraph;
 }
 
-// Construct a difficult graph. These need at least sqrt(2^(n-1)) iterations in the implemented
-// algorithm (purely empirically determined).
-template<typename SetType>
-DepGraph<SetType> MakeHardGraph(DepGraphIndex ntx)
-{
-    DepGraph<SetType> depgraph;
-    for (DepGraphIndex i = 0; i < ntx; ++i) {
-        if (ntx & 1) {
-            // Odd cluster size.
-            //
-            // Mermaid diagram code for the resulting cluster for 11 transactions:
-            // ```mermaid
-            // graph BT
-            // T0["T0: 1/2"];T1["T1: 14/2"];T2["T2: 6/1"];T3["T3: 5/1"];T4["T4: 7/1"];
-            // T5["T5: 5/1"];T6["T6: 7/1"];T7["T7: 5/1"];T8["T8: 7/1"];T9["T9: 5/1"];
-            // T10["T10: 7/1"];
-            // T1-->T0;T1-->T2;T3-->T2;T4-->T3;T4-->T5;T6-->T5;T4-->T7;T8-->T7;T4-->T9;T10-->T9;
-            // ```
-            if (i == 0) {
-                depgraph.AddTransaction({1, 2});
-            } else if (i == 1) {
-                depgraph.AddTransaction({14, 2});
-                depgraph.AddDependencies(SetType::Singleton(0), 1);
-            } else if (i == 2) {
-                depgraph.AddTransaction({6, 1});
-                depgraph.AddDependencies(SetType::Singleton(2), 1);
-            } else if (i == 3) {
-                depgraph.AddTransaction({5, 1});
-                depgraph.AddDependencies(SetType::Singleton(2), 3);
-            } else if ((i & 1) == 0) {
-                depgraph.AddTransaction({7, 1});
-                depgraph.AddDependencies(SetType::Singleton(i - 1), i);
-            } else {
-                depgraph.AddTransaction({5, 1});
-                depgraph.AddDependencies(SetType::Singleton(i), 4);
-            }
-        } else {
-            // Even cluster size.
-            //
-            // Mermaid diagram code for the resulting cluster for 10 transactions:
-            // ```mermaid
-            // graph BT
-            // T0["T0: 1"];T1["T1: 3"];T2["T2: 1"];T3["T3: 4"];T4["T4: 0"];T5["T5: 4"];T6["T6: 0"];
-            // T7["T7: 4"];T8["T8: 0"];T9["T9: 4"];
-            // T1-->T0;T2-->T0;T3-->T2;T3-->T4;T5-->T4;T3-->T6;T7-->T6;T3-->T8;T9-->T8;
-            // ```
-            if (i == 0) {
-                depgraph.AddTransaction({1, 1});
-            } else if (i == 1) {
-                depgraph.AddTransaction({3, 1});
-                depgraph.AddDependencies(SetType::Singleton(0), 1);
-            } else if (i == 2) {
-                depgraph.AddTransaction({1, 1});
-                depgraph.AddDependencies(SetType::Singleton(0), 2);
-            } else if (i & 1) {
-                depgraph.AddTransaction({4, 1});
-                depgraph.AddDependencies(SetType::Singleton(i - 1), i);
-            } else {
-                depgraph.AddTransaction({0, 1});
-                depgraph.AddDependencies(SetType::Singleton(i), 3);
-            }
-        }
-    }
-    return depgraph;
-}
-
-/** Benchmark that does search-based candidate finding with a specified number of iterations.
- *
- * Its goal is measuring how much time every additional search iteration in linearization costs,
- * by running with a low and a high count, subtracting the results, and divided by the number
- * iterations difference.
- */
-template<typename SetType>
-void BenchLinearizeWorstCase(DepGraphIndex ntx, benchmark::Bench& bench, uint64_t iter_limit)
-{
-    const auto depgraph = MakeHardGraph<SetType>(ntx);
-    uint64_t rng_seed = 0;
-    bench.run([&] {
-        SearchCandidateFinder finder(depgraph, rng_seed++);
-        auto [candidate, iters_performed] = finder.FindCandidateSet(iter_limit, {});
-        assert(iters_performed == iter_limit);
-    });
-}
-
-/** Benchmark for linearization improvement of a trivial linear graph using just ancestor sort.
- *
- * Its goal is measuring how much time linearization may take without any search iterations.
- *
- * If P is the benchmarked per-iteration count (obtained by running BenchLinearizeWorstCase for a
- * high and a low iteration count, subtracting them, and dividing by the difference in count), and
- * N is the resulting time of BenchLinearizeNoItersWorstCase*, then an invocation of Linearize with
- * max_iterations=m should take no more than roughly N+m*P time. This may however be an
- * overestimate, as the worst cases do not coincide (the ones that are worst for linearization
- * without any search happen to be ones that do not need many search iterations).
- *
- * This benchmark exercises a worst case for AncestorCandidateFinder, but for which improvement is
- * cheap.
- */
-template<typename SetType>
-void BenchLinearizeNoItersWorstCaseAnc(DepGraphIndex ntx, benchmark::Bench& bench)
-{
-    const auto depgraph = MakeLinearGraph<SetType>(ntx);
-    uint64_t rng_seed = 0;
-    std::vector<DepGraphIndex> old_lin(ntx);
-    for (DepGraphIndex i = 0; i < ntx; ++i) old_lin[i] = i;
-    bench.run([&] {
-        Linearize(depgraph, /*max_iterations=*/0, rng_seed++, old_lin);
-    });
-}
-
-/** Benchmark for linearization improvement of a trivial wide graph using just ancestor sort.
- *
- * Its goal is measuring how much time improving a linearization may take without any search
- * iterations, similar to the previous function.
- *
- * This benchmark exercises a worst case for improving an existing linearization, but for which
- * AncestorCandidateFinder is cheap.
- */
-template<typename SetType>
-void BenchLinearizeNoItersWorstCaseLIMO(DepGraphIndex ntx, benchmark::Bench& bench)
-{
-    const auto depgraph = MakeWideGraph<SetType>(ntx);
-    uint64_t rng_seed = 0;
-    std::vector<DepGraphIndex> old_lin(ntx);
-    for (DepGraphIndex i = 0; i < ntx; ++i) old_lin[i] = i;
-    bench.run([&] {
-        Linearize(depgraph, /*max_iterations=*/0, rng_seed++, old_lin);
-    });
-}
-
 template<typename SetType>
 void BenchPostLinearizeWorstCase(DepGraphIndex ntx, benchmark::Bench& bench)
 {
@@ -189,92 +44,52 @@ void BenchPostLinearizeWorstCase(DepGraphIndex ntx, benchmark::Bench& bench)
     });
 }
 
-template<typename SetType>
-void BenchMergeLinearizationsWorstCase(DepGraphIndex ntx, benchmark::Bench& bench)
-{
-    DepGraph<SetType> depgraph;
-    for (DepGraphIndex i = 0; i < ntx; ++i) {
-        depgraph.AddTransaction({i, 1});
-        if (i) depgraph.AddDependencies(SetType::Singleton(0), i);
-    }
-    std::vector<DepGraphIndex> lin1;
-    std::vector<DepGraphIndex> lin2;
-    lin1.push_back(0);
-    lin2.push_back(0);
-    for (DepGraphIndex i = 1; i < ntx; ++i) {
-        lin1.push_back(i);
-        lin2.push_back(ntx - i);
-    }
-    bench.run([&] {
-        MergeLinearizations(depgraph, lin1, lin2);
-    });
-}
-
-template<size_t N>
-void BenchLinearizeOptimally(benchmark::Bench& bench, const std::array<uint8_t, N>& serialized)
+void BenchLinearizeOptimallyTotal(benchmark::Bench& bench, const std::string& name, const std::vector<std::vector<uint8_t>>& serializeds)
 {
-    // Determine how many transactions the serialized cluster has.
-    DepGraphIndex num_tx{0};
-    {
+    for (const auto& serialized : serializeds) {
         SpanReader reader{serialized};
-        DepGraph<BitSet<128>> depgraph;
+        DepGraph<BitSet<64>> depgraph;
         reader >> Using<DepGraphFormatter>(depgraph);
-        num_tx = depgraph.TxCount();
-        assert(num_tx < 128);
-    }
+        auto bench_name = strprintf("%s_%utx_%udep", name, depgraph.TxCount(), depgraph.CountDependencies());
 
-    SpanReader reader{serialized};
-    auto runner_fn = [&]<typename SetType>() noexcept {
-        DepGraph<SetType> depgraph;
-        reader >> Using<DepGraphFormatter>(depgraph);
+        // Benchmark the total time to optimal.
         uint64_t rng_seed = 0;
-        bench.run([&] {
+        bench.name(bench_name).run([&] {
             auto [_lin, optimal, _cost] = Linearize(depgraph, /*max_iterations=*/10000000, rng_seed++);
             assert(optimal);
         });
-    };
-
-    if (num_tx <= 32) {
-        runner_fn.template operator()<BitSet<32>>();
-    } else if (num_tx <= 64) {
-        runner_fn.template operator()<BitSet<64>>();
-    } else if (num_tx <= 96) {
-        runner_fn.template operator()<BitSet<96>>();
-    } else if (num_tx <= 128) {
-        runner_fn.template operator()<BitSet<128>>();
-    } else {
-        assert(false);
     }
 }
 
-} // namespace
+void BenchLinearizeOptimallyPerCost(benchmark::Bench& bench, const std::string& name, const std::vector<std::vector<uint8_t>>& serializeds)
+{
+    for (const auto& serialized : serializeds) {
+        SpanReader reader{serialized};
+        DepGraph<BitSet<64>> depgraph;
+        reader >> Using<DepGraphFormatter>(depgraph);
+        auto bench_name = strprintf("%s_%utx_%udep", name, depgraph.TxCount(), depgraph.CountDependencies());
 
-static void Linearize16TxWorstCase20Iters(benchmark::Bench& bench) { BenchLinearizeWorstCase<BitSet<16>>(16, bench, 20); }
-static void Linearize16TxWorstCase120Iters(benchmark::Bench& bench) { BenchLinearizeWorstCase<BitSet<16>>(16, bench, 120); }
-static void Linearize32TxWorstCase5000Iters(benchmark::Bench& bench) { BenchLinearizeWorstCase<BitSet<32>>(32, bench, 5000); }
-static void Linearize32TxWorstCase15000Iters(benchmark::Bench& bench) { BenchLinearizeWorstCase<BitSet<32>>(32, bench, 15000); }
-static void Linearize48TxWorstCase5000Iters(benchmark::Bench& bench) { BenchLinearizeWorstCase<BitSet<48>>(48, bench, 5000); }
-static void Linearize48TxWorstCase15000Iters(benchmark::Bench& bench) { BenchLinearizeWorstCase<BitSet<48>>(48, bench, 15000); }
-static void Linearize64TxWorstCase5000Iters(benchmark::Bench& bench) { BenchLinearizeWorstCase<BitSet<64>>(64, bench, 5000); }
-static void Linearize64TxWorstCase15000Iters(benchmark::Bench& bench) { BenchLinearizeWorstCase<BitSet<64>>(64, bench, 15000); }
-static void Linearize75TxWorstCase5000Iters(benchmark::Bench& bench) { BenchLinearizeWorstCase<BitSet<75>>(75, bench, 5000); }
-static void Linearize75TxWorstCase15000Iters(benchmark::Bench& bench) { BenchLinearizeWorstCase<BitSet<75>>(75, bench, 15000); }
-static void Linearize99TxWorstCase5000Iters(benchmark::Bench& bench) { BenchLinearizeWorstCase<BitSet<99>>(99, bench, 5000); }
-static void Linearize99TxWorstCase15000Iters(benchmark::Bench& bench) { BenchLinearizeWorstCase<BitSet<99>>(99, bench, 15000); }
+        // Determine the cost of 100 rng_seeds.
+        uint64_t total_cost = 0;
+        for (uint64_t iter = 0; iter < 100; ++iter) {
+            auto [_lin, optimal, cost] = Linearize(depgraph, /*max_iterations=*/10000000, /*rng_seed=*/iter);
+            total_cost += cost;
+        }
 
-static void LinearizeNoIters16TxWorstCaseAnc(benchmark::Bench& bench) { BenchLinearizeNoItersWorstCaseAnc<BitSet<16>>(16, bench); }
-static void LinearizeNoIters32TxWorstCaseAnc(benchmark::Bench& bench) { BenchLinearizeNoItersWorstCaseAnc<BitSet<32>>(32, bench); }
-static void LinearizeNoIters48TxWorstCaseAnc(benchmark::Bench& bench) { BenchLinearizeNoItersWorstCaseAnc<BitSet<48>>(48, bench); }
-static void LinearizeNoIters64TxWorstCaseAnc(benchmark::Bench& bench) { BenchLinearizeNoItersWorstCaseAnc<BitSet<64>>(64, bench); }
-static void LinearizeNoIters75TxWorstCaseAnc(benchmark::Bench& bench) { BenchLinearizeNoItersWorstCaseAnc<BitSet<75>>(75, bench); }
-static void LinearizeNoIters99TxWorstCaseAnc(benchmark::Bench& bench) { BenchLinearizeNoItersWorstCaseAnc<BitSet<99>>(99, bench); }
+        // Benchmark the time per cost.
+        bench.name(bench_name).unit("cost").batch(total_cost).run([&] {
+            uint64_t recompute_cost = 0;
+            for (uint64_t iter = 0; iter < 100; ++iter) {
+                auto [_lin, optimal, cost] = Linearize(depgraph, /*max_iterations=*/10000000, /*rng_seed=*/iter);
+                assert(optimal);
+                recompute_cost += cost;
+            }
+            assert(total_cost == recompute_cost);
+        });
+    }
+}
 
-static void LinearizeNoIters16TxWorstCaseLIMO(benchmark::Bench& bench) { BenchLinearizeNoItersWorstCaseLIMO<BitSet<16>>(16, bench); }
-static void LinearizeNoIters32TxWorstCaseLIMO(benchmark::Bench& bench) { BenchLinearizeNoItersWorstCaseLIMO<BitSet<32>>(32, bench); }
-static void LinearizeNoIters48TxWorstCaseLIMO(benchmark::Bench& bench) { BenchLinearizeNoItersWorstCaseLIMO<BitSet<48>>(48, bench); }
-static void LinearizeNoIters64TxWorstCaseLIMO(benchmark::Bench& bench) { BenchLinearizeNoItersWorstCaseLIMO<BitSet<64>>(64, bench); }
-static void LinearizeNoIters75TxWorstCaseLIMO(benchmark::Bench& bench) { BenchLinearizeNoItersWorstCaseLIMO<BitSet<75>>(75, bench); }
-static void LinearizeNoIters99TxWorstCaseLIMO(benchmark::Bench& bench) { BenchLinearizeNoItersWorstCaseLIMO<BitSet<99>>(99, bench); }
+} // namespace
 
 static void PostLinearize16TxWorstCase(benchmark::Bench& bench) { BenchPostLinearizeWorstCase<BitSet<16>>(16, bench); }
 static void PostLinearize32TxWorstCase(benchmark::Bench& bench) { BenchPostLinearizeWorstCase<BitSet<32>>(32, bench); }
@@ -283,105 +98,57 @@ static void PostLinearize64TxWorstCase(benchmark::Bench& bench) { BenchPostLinea
 static void PostLinearize75TxWorstCase(benchmark::Bench& bench) { BenchPostLinearizeWorstCase<BitSet<75>>(75, bench); }
 static void PostLinearize99TxWorstCase(benchmark::Bench& bench) { BenchPostLinearizeWorstCase<BitSet<99>>(99, bench); }
 
-static void MergeLinearizations16TxWorstCase(benchmark::Bench& bench) { BenchMergeLinearizationsWorstCase<BitSet<16>>(16, bench); }
-static void MergeLinearizations32TxWorstCase(benchmark::Bench& bench) { BenchMergeLinearizationsWorstCase<BitSet<32>>(32, bench); }
-static void MergeLinearizations48TxWorstCase(benchmark::Bench& bench) { BenchMergeLinearizationsWorstCase<BitSet<48>>(48, bench); }
-static void MergeLinearizations64TxWorstCase(benchmark::Bench& bench) { BenchMergeLinearizationsWorstCase<BitSet<64>>(64, bench); }
-static void MergeLinearizations75TxWorstCase(benchmark::Bench& bench) { BenchMergeLinearizationsWorstCase<BitSet<75>>(75, bench); }
-static void MergeLinearizations99TxWorstCase(benchmark::Bench& bench) { BenchMergeLinearizationsWorstCase<BitSet<99>>(99, bench); }
-
-// The following example clusters were constructed by replaying historical mempool activity, and
-// selecting for ones that take many iterations (after the introduction of some but not all
-// linearization algorithm optimizations).
-
-/* 2023-05-05T23:12:21Z 71, 521780, 543141,*/
-static constexpr auto BENCH_EXAMPLE_00 = "801081a5360092239efc6201810982ab58029b6b98c86803800eed7804800ecb7e058f2f878778068030d43407853e81902a08962a81d176098010b6620a8010b2280b8010da3a0c9f069da9580d800db11e0e9d719ad37a0f967897ed5210990e99fc0e11812c81982012804685823e0f0a893982b6040a10804682c146110a6e80db5c120a8010819806130a8079858f0c140a8054829a120c12803483a1760c116f81843c0d11718189000e11800d81ac2c0f11800d81e50e10117181c77c1111822e87f2601012815983d17211127180f2121212811584a21e1312800e80d1781412813c83e81815126f80ef5016126f80ff6c16126f80f66017126e80fd541812800d81942a1912800e80dd781a12800d81f96c1b12805282e7581b127180fd721c1271a918230b805fc11a220d8118a15a2d036f80e5002011817684d8241e346f80e1181c37805082fc04260024800d81f8621734803382b354270b12805182ca2e162f800e80d52e0d32803dc360201b850e818c400b318c49808a5a290210805181d65823142a800d81a34e0850800e81fb3c0851886994fc0a280b00082c805482d208032e28805e83ba380059801081cd4a0159811884f770002e0015e17280e49024300a0000000000000031803dcb48014200"_hex_u8;
-/* 2023-12-06T09:30:01Z 81, 141675, 647053,*/
-static constexpr auto BENCH_EXAMPLE_01 = "b348f1fc4000f365818a9e2c01b44cf7ca0002b004f0b02003b33ef8ae3004b334f9e87005800d81c85e06b368fae26007b05ef2e14208be1a8093a50409b15cf5ee500a802c80a1420b802dea440c802ce50a0d802cdc320e802cd7220f802dd72210805380f74a118174f370126e96b32812127182c4701312817389d26414128035848c221512800e82bf3816126f81e4341712801082b228181280518af57418128040859a0019127182d0401a12803e858b641b127182c4421c126f82b3481d12811486b6301e12821d89e7281f126e8a8b421f127182d6642012806284c12021126e81d34822126e86a76222126e86d8102212805187b6542312800d82fc002412803d848e0e2512801082d27a26126e8589642612800e83a9602712800e83bd0028126e81ef1a29116e858d7228126f82db5e2912801083843c2a127181c93c2b126e85d0162b127181c5622c126e84f8262c12800f8392202d12800e82b66c2e126e81d0082f12803282d50430126e84f9003012805f84be6c3112846e88df0e2b12804080d44c340a8b31898808350a800ed760350b801083a1182b517182817e2a51800e82b6582951803583cb52420030806284cb6c204f7181d300204f82688ce0303e001d800e82bb200f488010808a182822a3289cd63041000a6fcd100a408a7caaa7024800002f803584e0741e27288f3386dd783b001000802683f27e004b8c44bcd0763f0000000000000000000100000e00"_hex_u8;
-/* 2023-04-04T00:26:50Z 90, 99930, 529375,*/
-static constexpr auto BENCH_EXAMPLE_02 = "815b80b61e00800da63001cd378da70e028010991a03800e9d3e0480109708058010991a068010973a07da738fa72408de7491831009b35b88f0080a9d4485de180b71974e0c71974e0d80108e500eb27988a75a0f719632108061a56c11801087761280108a1413807893441480538c1415a606828806168010893e1780548c40188e4b80bb2c196eab3e1718805ed60e18188051c97a19188010cf781a1871b11e1b1871c5281c1880508080581d186e80b13c1e188035cf421f18805fe0482018804caa661f198035a9001f156e80cb701d1871a2281e1871ad281f18817380a16020186f98642118805ee04821198010b6702219800ea12623196eb67024198035808b0025196fa65c26198054ba1c2719807680bf7c28198053cd782919803d80b80429198051db5a2a198040d3742b19976584bb1c28196efc1c281971b21a29198052bc762a1971a2502b196eb73c2c19976381ab0c2a18806290543409862081c3423b00336fbc70224d80109e7c1c52805ebd5c1942800eb57016468034ba423405158118da28350416927480f4743000159f6a81c9462e00188051ec5e380e00800e9e420775800d9e26007c906c82f754251d0025870480f12c14280023800d9e26027e9e1385ed08102900001a804fac7a018001719856028001800da87e0180039b1a868b60064102246e9f42018005800da87e028005850d81d600026d862381a2200e0008230015831480a5480342000524803eeb32006e873582a4700a0100351300"_hex_u8;
-/* 2023-05-08T15:51:59Z 87, 76869, 505222,*/
-static constexpr auto BENCH_EXAMPLE_03 = "c040b9e15a00b10eac842601805f85931802c104bae17403ae50aaa336049d76a9bf7005c55bbeab6606ae2aa9c72c07805e81992e08af7dab817a096e80a7e4520909803e92bd780a097185c76c0b096e98e7380b09850bb9953c0c09803389f6260d096f859d620e09803f88d3000f0971829c6e1009837690f6481109806285931811097181f56814076ea09b74120980408eb73213096f87853214096f86e2701509803f8c860016098a6fe6c3721709814f92a204180980628a8a441909803285df681a0980348498661b096e8290781c096e978e081c097187da1a1d097186c05c1e097185893c1f09805f8ad9002009800d84e74e21097183a67a22097182e23423097184b53a23096ea393062309840faddd46240980618eb732250980548bee6a2609807986883c2709718298402809815388b6582909805384ec742a097181b9142b096e97b5262b096e85e14e2c0980518abb5c2d09805489e75a2e09803187e3382f097180eb1c34046f87c34a2f098309a5c54430097186911831098054899c083209801083bc1033097081e02a3409805f848f0c35096e80d4343a057180c37040006f80a22438097180a0503f03816f8381444003803f80ef003f05800580a4283f066ef72845016efb91663e09923d808d8216470041803584837c46012f9247dc86684501268267a09610450222862184db68440712803585ea40440113835d97887805800b8723c7a40a4b00022f81529ae2143c0c1f80548b8f381b311980408e955c055e802589dc10037e801083b54602658010848130006700"_hex_u8;
-/* 2023-05-01T19:32:10Z 35, 55747, 504128,*/
-static constexpr auto BENCH_EXAMPLE_04 = "801af95c00801af72801801af95c02873e85f2180202873e85f2180202873e85f21802028018fb2802068018fb2803068018fb2804068018fb2805068018fb2806068018fb2807068018fb2808068018fb2809068018fb280a068018fb280a058018fb280b058018fb280c058018fb280d058018fb280e058018fb280f058018fb2810058018fb2811058018fb2812058018fb2813058018fb2814058018fb2815058018fb2815048018fb2816048018fb2817048018fb2818048018fb2819048018fb281a048018fb281b04810d80d9481f00000100"_hex_u8;
-/* 2023-02-27T17:06:38Z 60, 55680, 502749,*/
-static constexpr auto BENCH_EXAMPLE_05 = "b5108ab56600b26d89f85601b07383b01602b22683c96003b34a83d82e04b12f83b53a05b20e83c75a066e80840a06068040be0007066fb10608066fb2120906800eba320a06842b80b05a0a066eff420b067199300b068124c3140c0680618085180d066faa1c0e068010b4440f068051af541006800da1781106857881946812066eee1613068052b31014068324808d361506806180885c150671b03216066ef11017068052b63218066ef3521806803f80865419066e93441a068035a13e1b0680628085181c06806ec4481d068117e72c1e06719c721f068077c42420068159808d1821066eef0c21058010b90022056f9908230571993024058010b00a25058010b00a260580608087402705803fc10027068032b42828068051b6322906800db11e212a8324808d361933803ff400192f826381a7141a2f8032ac08152a800db54c044e8323808d3630010002018158d84000042d821cea12002807853580d462002d01891181d022002e00"_hex_u8;
-/* 2023-04-20T22:25:49Z 99, 49100, 578622,*/
-static constexpr auto BENCH_EXAMPLE_06 = "bf3c87c14c008010955a01b21d85e07002800d946c036e8e3404b77f86c26605b33c85f55e06bd06879852078010970a08bd4b87cf00098123a7720ab2158687680b8054d4440b0a8062fa4c0c0a71ac400d0a80628081540e0a8010a2580f0a8054b676100a8032b85c110a6e9a40120a6e809012130a817f80c31e140a8175808674150a719d46160a8172d86415098033c1481609800da4181709800ada2e1809803dc85219098034b4041a096ef5501b098052d67c1c098051d3281d09800ebc4a1e098175808c641f098061c55020098078c85021096e8081141f0b6faf1e200b8061da68210b8062f000220b800ebc20230b8035d058240b8053de32250b8050b610250b6fad32260b803dc276270b803d80a610280b6ef812290b8052b6322a0b800eb57e2b0b8052bd062c0b719e522d0b71a3762e0b8010bb1e2f0b80109a78310a80109962320a8051a60c330a6f9f3e320b6e808b24330b719e40340b8117cc50350b803d80971a360b8051b930370b6f9e0a380b719b10390b8052a6003a0b6e808c76390a7195603a0a6f935c3b0a8054a31a3c0a803ce30c3b0b803fa3003c0b800dbe2a3d0b8f3480a84244058005851a44069d1bf824400b83098f284507719c723d4f6f9c1c3449719c722f4f6eb23c304f8061c5502e528061da682b4e8118bb724e022a8054b35028476e941c1d51815be02c4f01148557808e3a4f070e8104af464e001180329d364e010d805f9f6a421b9c3387aa744c0d4d71ac400b800881748098444710338173809b780b80008054d444292c12821dc040550403078b4682b4664517003f00"_hex_u8;
-/* 2023-06-05T19:56:12Z 52, 44896, 540514,*/
-static constexpr auto BENCH_EXAMPLE_07 = "b317998a4000b40098d53e01b45b99814802b7289b940003b3699a9d1204b6619a807a05814682cb78050571d854060571d8540705800e808d7a0805803480c06a09056e8189280a056ffd060b05800d80ea7a0c05803c80b80c0c03803e80d86e0d036ed2280e03811581804a0f036fd34e1003805380eb6811036e81f60e12038010ec101204805f80e83a13048033809534140471e00a15048010f95816046e81fa301704805180a74c1705800d808f1018056fd55c1905800e8091481a056e80a76e1b05805f80e2741c0571809b021c05826382c8401d0571df201e05800e809d2c1f05850083e87c1f05811580af68200571f20a21056ff9042205803e80df1e23056e81956c24056e9f542604805180e83829000e800e8080621325803380b0402a020d6ef8100e2c8c4889a96a2c000f803580ce4c2c000b6e9f54062a803480c96406260500"_hex_u8;
-/* 2023-12-05T23:48:44Z 69, 44283, 586734,*/
-static constexpr auto BENCH_EXAMPLE_08 = "83728ce80000b90befca1001806083b24002b40de6da3203b545e9c35c04b34beede3005b068e8883006d41c80b1e14c07b337e7841208b26beadb2e096e83892e090980518487380a096e82815c0a096e81ce3c0b097181db200c097181d4020d09810084ed600e096e96b0100f0971819a0210086e93da2e0f09803583ee5e1009803583c66c1109800d82bb6e1209800d81d56a1309803c82e622140971819f521509803d84a55c15057181d6161605806283ac5217056e949c5a18056e89e8641806815889e23419067181de321a066e8af2641a076e82a70a1b07803583f2081c076f81e76e1d076e81d33e1e07800d83b8761e086e82a5541f087181de302008805f84ad0021086e81c74022086e81bd3e23086e9288182408806184b3102409803283816025096e91ed662609830a88e70827096e81d14a27097181ce6028096e8cf03829097181883832016f81835c3103806181e0103203804180b8103204863584fe183304800de66434046e9e4c34056e81d6742f429213c0eb602e3d6483b06c283a6e81d73c263d6e82f9581831805485ab360e37805080c62609398b3189880838010603916db1f3583a03000110873199f8623c000000011100"_hex_u8;
-/* 2023-04-14T19:36:52Z 77, 20418, 501117,*/
-static constexpr auto BENCH_EXAMPLE_09 = "bf2989d00400815bca5c01af1e86f97602800d9d6c03800d8a3404b47988866e05b36287f92e0680109f68078010991a08805ecf1208076e80933e09078062d01c0a078054b6760b078053b6760c076f9c1c0d078054b6760e0771af260f0771b17e10078032f57011078035d56812078054e1581307886b83dc301407817480d13013068005a6001406803d80821a15066ef3201606800ea2181706800da628180671ab1219068054db0c1a06719b001b06815b80a11c1c068050b9301d066fac2a1e068033ab481f06719b1020068035ab721e07803dc2761f0771ae3c20078040f60e210771ce282207800ea4322307882a81a66024078035ad4625076efe7e26078162808e1827078118bb7228076eac7428088010bf58290871a04c2a0871bc722b086fa8382c08803d80a0142d088035d6282e088051c30c2f086efc623008800d9f6231086f986432088117bb7237028010a63034068010c84e2740800ea64c2237832c80933e1f3b830880c454390208813c80955c3905068032c73611348010a03c093c837a808a101b278050ac34093a8051ac34291b8f3b8187401d28881a82cb3a3a0a37977b86d20843000028996686a7083f030f8078d3761b27106e995a08499070839b5a1131000b00"_hex_u8;
-/* 2023-11-07T17:59:35Z 48, 4792, 498995,*/
-static constexpr auto BENCH_EXAMPLE_10 = "875f89aa1000b51ec09d7201c55cc7a72e02a11aa1fb3203b233a7f95204800ef56205b33ea9d13006803e80b26e07d90ec9dd4008b45eabbe6c09806080ca000a815984e8680a0a6f80925e0a0a803f80e1660c09937c94b7420d086e82f5640a086e80997e0b086f808d320c08800580a5640d086f8089100e08804080c9060f088115819a1c10086e82961a0f0a805f81bc0a100a6ff826110a6ef53e120a807584c60c110a6e818f32120a803c81c246130a805481d508140a8159838410150a7180a55c160a6f80821c170a6fe6101c066fe6101d06805080f854190a6e81b27c1a0a8155819c701e06805180ae0c21046e8b9a222501805180f53422001680f26880f8a62a220116803580da582007058153838e6e21000c800d80a712033a807681ae1c23000308834a82d36023020205815981e03a051a08001700"_hex_u8;
-/* 2023-11-16T10:47:08Z 77, 473962, 486863,*/
-static constexpr auto BENCH_EXAMPLE_11 = "801980c06000801980c06001801980c06002801980c06003801980c06004801980c06005801980c06006801980c06007801980c06008801980c06009801980c0600a801980c0600b801980c0600c801980c0600d801980c0600e801980c0600f801980c060108019d12c11800f80b1601111800f80b1601111801080b1601111800f80b160100e800f80b160100f801980c060110f800f80b160140d801180b1601111801180b160100d801180b160120c801180b1600f10801180b1600f11801980c0601011800f80b160140e800f80b160110f801980c060170a801180b1601210801980c060140f800f80b1601311801980c0602005801180b1601f07800f80b1601b0c800fca7c1611812081f9601638812081f9601637812081fb001636801080b160142f801980c0600e2a801080b1600f2a801180b1600d25801980c0600e25800f80b1600d27801980c0600e27801980c0600d27801180b1600e26812080b1500c27812081f960201025812081f960200f27812081fc201d101c812081fc201d101d812081fc201d0f1f812081fc201d0f20812081f9601b1016800f80b1600a35800f80b1600a36800f80b1600e32801080b160122f812081f960280040812081fc20121d1b812081f960112713812081f960160d37812081fc20140d2b812081f960130d2d812081fc20130c2c812081fb001b0157812081fb001a0245812081fc20140030812081fc20092747812081fb000b152500"_hex_u8;
-/* 2023-10-06T20:44:09Z 40, 341438, 341438,*/
-static constexpr auto BENCH_EXAMPLE_12 = "80318f4c0080318f4c0180318f4c0280318f4c0380318f4c0480318f4c0580318f4c0680318f4c078033a57807078033a57807078033a57807078033a57807078033a57807078033a57807078033a57807078033a578070780318f4c0e0180318f4c0d0380318f4c0c0580318f4c0b078033a57803128033a57803128033a57803128033a578031280318f4c0412810b9c28140300810c9c281303028033a57802188033a57802188033a5780218810c9c280b01108033a578001c810c9c2807050f8033a578001b810c98040700158033a578001c810c98040301158033a5780019806ca1240101118033a578001300"_hex_u8;
-/* 2023-11-15T21:40:46Z 96, 23608, 138286,*/
-static constexpr auto BENCH_EXAMPLE_13 = "8060829f4000b157bab07a01b27cc2b16802b22fbce54603826480a95804803da81a05bc7bcac93806800de55207800daf0608805bc71809805bc7180a800d9d4a0b805bbc700c8152d7180d805bb9380e850a8886260f800d80d33410bf38d3d55011b41dc4eb6012bd70d2ce2e138d3596af7812137180cd501313805e81f7281413718092001513803d81f90016136e8b916c1713801081861a17106e80cd2a18106f80cc3c19106e80cf161911800d80fe781b107180d87c1c106e80fb081d10803e8286701d11800d81c4781f10804082a6002010801081912e21107180ff0021116e81da4a2310850b8b864023116e89db3224116e84ff7e2610897c95993427106f80bb1a240b803581c272250b8032828c10260b6e80d42a270b804082b35a280b800d80fe3e290b805cc0282312821d8697022b0b6e8add562c0b805281c8063007811883f1082313800d80fe3e24137180c9142513800d8380102613803382c00e2713805eb32228136e8494542913800e8186742913806082b74c2a1380528285782b13800d818f7a2c136e84a5562d1380508286702e136f80a46e3e04803f8191364102805481ad4c3d076e809a5a3e077180fe4032136e838b7233138c4790cf384106853584ab624206805b80932a4801806280966c48028168ef04400b7181bd524903806282db5c375b9316acbf703a599c68c5a454385c6e81d63e364a6f80ff64334e817485a6784f023171819536234e800d81826e1e498053829a12420018834c87cb14291d2e840e8bc94c1d2825800d81b7220368811783fe0e271f1f811783e758380f001ecd55809edf6e56000000003a815984ba76008010d54d80aebb4e2c22000000000000002c807682f150007a00"_hex_u8;
-/* 2023-12-06T09:18:20Z 93, 68130, 122830,*/
-static constexpr auto BENCH_EXAMPLE_14 = "b26beadb2e00800d80ca0a01d41c80b1e14c02b068e8883003800d81af1604b34beede30056e80b14006b151f5d46c07b93e8085b02608b30cf98b1009b14ef6b3040ab176f6ab480bb7078082b8640c800d81c6460d802c80a8080e802c80a8080f802c80a14210802ce50a11802cd722127181ce6012126e81d14a13126e9b8b00141282428dd42c15128051828408150e6e81bd3e150f805f84ad00160f7181de30170f6e81c740180f800d83b876190f6e82a5541a0f6e81d33e1a106e82a70a1b106f81e76e1c10803583f2081d106e82d9401e106e96e4441f107181de321e12815889e2341f127182d60c20126e979d4e21126e8282262410800d82972c25106f838a5822126f82842a23127182d24a2412803e84bc2a2512800d83c81a26126e84f8142712805085a22c27126e889e6a2812801083aa50281280348598102912801082d5522a126e85865c2b127182c7602b1282468c82042c126e84972c2d12805485d93a2d12801083c7322e12815386e1582f126e84fb0c30126f82eb6c3011813a85b47a3111803f869f5c3211805181ed30370d6e84bf0a3411804180e1383809815883aa183a08815a8392203e05807681f140380c6e9e4c4005805485ab363255805183856030406e82f9582c45805185c1001b4f82418df1001a4e803283c50e430026800d83a6201a4b836886be3044010b8b318988084c0101803183a6120776800d828a1e087682338ae050301c33873199f8624d010032813986bc663c1034800d83a5220a6f800d82be52048000805183e364084907800d83cc4a018005815987b41e1832000017884b9dce72035035803284c11e00800885769d9538192f0000000002001000"_hex_u8;
-/* 2023-12-14T02:02:29Z 55, 247754, 247754,*/
-static constexpr auto BENCH_EXAMPLE_15 = "801980c06000801980c06001801980c06002801980c06003801980c06004801980c06005801980c06006801980c06007801980c06008801980c06009801980c0600a801980c0600b801980c0600c801980c0600d801980c0600e801180b1600e0e801180b1600e0e801180b1600e0e801180b1600e0e801180b1600e0e801180b1600e0e801180b1600d07801180b1600f06801180b1600c0a801180b1600f08801180b1600c0c801180b1600c0d801180b1600c0e801180b160100b801180b1601309812081fc200e2a812081fc200e29812081fc200e28812081fc200e0e18812081fc200e0e17801980c060042e812081fc200e0d07812081fc200e0d08812081fc200e0c0a812081fc200e0d0a801980c060081e812081fc200f0c0c812081fc200f0c0d812081fc200f0c0e801180b160083a801180b1600426801980c0600b20801980c0600a22812081fc200f0b30801180b160022b801180b160022b812081fc20062422812081fc2006220b812081fc200c0a1e812081fc2012041a00"_hex_u8;
-/* 2023-12-14T15:17:20Z 76, 102600, 103935,*/
-static constexpr auto BENCH_EXAMPLE_16 = "801980c06000801980c06001801980c06002801980c06003801980c06004801180b1600404801180b1600404801180b1600404801980c0600504801980c0600802801980c0600803801180b1600704801980c0600804801280b1600804812081fc200810812081fc20080f812081fc20080e801180b160080c800f80b160080d801980c060090d801180b160090e801980c0600a0e812181fc200a0c801180b1600a0d812181fd400a0c801980c0600a1c801980c0600916801180b1600719801180b160061b801980c0600d15801980c0600717812081fc200718801980c0600716801180b160072d801180b1600722801180b1600525801980c060091b801980c060071e801080b160071f801280b160061d812081fc20063a812181f960160815801280b1600525801980c0600625801180b1600626801980c0600726801980c0600536801180b160032b801980c060042b801280b160032d801980c060033e801180b160043e812181fc20100c27801080b160042f801980c0600342801180b1600442812081fc20150d25800f80b1600245812081fd40120619812081fc20040243812081fc20120c2c812081fd40120a1d812181fb00100623812081fc20030347812081fc20072126801980c0600236812081fc20040d2b812081fc20120328801980c0600237801180b1600337812081fc20052230801180b1600239812081fc2008242c812081fd4005112d812081fb00070b32812081f96011034700"_hex_u8;
-/* 2023-12-15T07:12:29Z 98, 112693, 112730,*/
-static constexpr auto BENCH_EXAMPLE_17 = "801980c06000801980c06001801980c06002801980c06003801980c06004801980c06005801980c06006801180b1600606801180b1600606801180b1600606801180b1600606801280b1600606801180b1600606801180b1600606801980c0600d00801980c0600b03801980c0600b04801980c0600f01812081fc200a16812081fc200a15812081fc200a14812081fc200a13812081fd400a12812181fc200a11812181fc200a0f801180b1600a10801180b1600a10801980c0600a10801180b1600b10801180b1600b10801980c0600621801980c0600915801980c060041b801180b160051b801980c0600f12801980c0600f13801980c0600d15801980c0600c17801980c060072e800f80b160082e812181fc200d150e801980c0600922801180b1600923801980c0600823801180b1600623801180b1600a20801180b1600e1c801180b1600b20801180b1600b21801980c0600a3e800f80b1600b3e801980c0600931801180b1600a31812181fc20140325801180b1600a30801180b160054c801180b160043b801980c0600336812181fc200253812081f960090944812081fc2007003c801980c0600339801180b1600433801980c0600453801980c0600340801980c060033d801080b160043d812081f960070854801980c060045a801180b160055a801180b1600545801980c0600643801980c0600641801280b1600739801180b1600562812081fc20121f27812181fc20210137812181fc2016112f801980c0600259801980c0600156812181fc20053a31801180b160025c801180b1600257801980c0600357812081fc200d2d1e812181fc20102444812181fc20035a801180b160035b801980c0600751812181fc2007392a812181fc20025f801980c060045e801180b1600350812081fc20070f6f801180b1600263812181fc201b1322812181fc2011283b812081fc2002442100"_hex_u8;
-/* 2023-12-16T02:25:33Z 99, 112399, 112399,*/
-static constexpr auto BENCH_EXAMPLE_18 = "801980c06000801980c06001801980c06002801980c06003801980c06004801980c06005801980c06006801980c06007801180b16008801180b16009801180b1600a801180b1600a0a801180b1600a0a801180b1600a0a801180b1600a0a801980c0600d06801180b1600b09801980c0601005801180b1600c0a801980c0600d0a801980c0601106801180b1600e0a801980c0601207801980c0601207801180b160100a812081e668100a812081e668100a812081e668100a801980c0601407801980c0601606812081fc201226812081fc201225812081fc201224812081fc201223801180b1600e21801980c0600b1e801180b1600c1e801180b1601316801980c060091b801980c0601312801980c0600a1c801180b160190e801180b1601315801180b1600e1b801180b1601713801180b1600f1c801980c0600d34801980c0600d30801980c060102e801980c060122d801980c0600b2a801980c0600b2a801980c0600b2b801180b1601122801180b1600e26801180b1601025801180b1600f26812081fc20280032812081fc20270034812081fc20250034801180b1600d4b801980c0600d457a809a000d46801980c0601044801980c0600e46801180b1600f43801180b160123f801180b160123e801180b1601130801180b1601131801180b1601131812081fc20230a36801980c0600a5a801180b1600a5b801980c0600a5b801180b1600b5b801980c0600b5a801180b1600f57801180b1600d3f801980c0600669801980c0600568801980c0600466801180b1600945801180b1600649801180b1600945812081fc2018234b812081fc20142534812081fc20142532812081fc20142530801180b160074d801180b1600a4b801180b1600a4a812081fc20221662812081fc200c0472812081fc20072e42812081fc20062c23812081fc20100572812081fc200f036c812081fc2001345100"_hex_u8;
-/* 2023-03-31T19:24:02Z 78, 90393, 152832,*/
-static constexpr auto BENCH_EXAMPLE_19 = "800dd042008028b13c018028b13c028028b13c038029b13c048029b13c058029b13c0680299948078029b13c088029b13c09802899480a802899480b8028b13c0c80299e700d802899480e802999480f8029b13c10802999481180299948128028b13c138029b13c1480289e701580289948168028b13c1780289948188028994819802899481a802999481b802999481c802899481d802999481e8028b13c1f8029b13c20802999482180299948228028b13c2380298c242480289948258029b13c2680288c242780298c242880299e70298f5a80ea762a824780aa00292a82038090402429813fcf00152a8203809040142a813ff700112982038090402d002d813ff70028002c8203809040270024824780aa00270025820380904025002882038090401e022a82038090401d042782038090401c01298203809040190029813ff700170028813ff700140128807b9258120128841280f6402c01002e82038090402b00062b820380904027000031813ff70011192d82038090401d000129851981a9403a0000003b82038090400c182e813ff7000b0f2982038090401314141b807b925805192b84568190001121000334807bdd400149824780aa00001f2a813ff700003d0b8203809040050d1915807bdd4001498728828f400b010004050501000a050c851981a9400104050b061a0400"_hex_u8;
-
-static void LinearizeOptimallyExample00(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_00); }
-static void LinearizeOptimallyExample01(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_01); }
-static void LinearizeOptimallyExample02(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_02); }
-static void LinearizeOptimallyExample03(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_03); }
-static void LinearizeOptimallyExample04(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_04); }
-static void LinearizeOptimallyExample05(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_05); }
-static void LinearizeOptimallyExample06(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_06); }
-static void LinearizeOptimallyExample07(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_07); }
-static void LinearizeOptimallyExample08(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_08); }
-static void LinearizeOptimallyExample09(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_09); }
-static void LinearizeOptimallyExample10(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_10); }
-static void LinearizeOptimallyExample11(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_11); }
-static void LinearizeOptimallyExample12(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_12); }
-static void LinearizeOptimallyExample13(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_13); }
-static void LinearizeOptimallyExample14(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_14); }
-static void LinearizeOptimallyExample15(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_15); }
-static void LinearizeOptimallyExample16(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_16); }
-static void LinearizeOptimallyExample17(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_17); }
-static void LinearizeOptimallyExample18(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_18); }
-static void LinearizeOptimallyExample19(benchmark::Bench& bench) { BenchLinearizeOptimally(bench, BENCH_EXAMPLE_19); }
-
-BENCHMARK(Linearize16TxWorstCase20Iters, benchmark::PriorityLevel::HIGH);
-BENCHMARK(Linearize16TxWorstCase120Iters, benchmark::PriorityLevel::HIGH);
-BENCHMARK(Linearize32TxWorstCase5000Iters, benchmark::PriorityLevel::HIGH);
-BENCHMARK(Linearize32TxWorstCase15000Iters, benchmark::PriorityLevel::HIGH);
-BENCHMARK(Linearize48TxWorstCase5000Iters, benchmark::PriorityLevel::HIGH);
-BENCHMARK(Linearize48TxWorstCase15000Iters, benchmark::PriorityLevel::HIGH);
-BENCHMARK(Linearize64TxWorstCase5000Iters, benchmark::PriorityLevel::HIGH);
-BENCHMARK(Linearize64TxWorstCase15000Iters, benchmark::PriorityLevel::HIGH);
-BENCHMARK(Linearize75TxWorstCase5000Iters, benchmark::PriorityLevel::HIGH);
-BENCHMARK(Linearize75TxWorstCase15000Iters, benchmark::PriorityLevel::HIGH);
-BENCHMARK(Linearize99TxWorstCase5000Iters, benchmark::PriorityLevel::HIGH);
-BENCHMARK(Linearize99TxWorstCase15000Iters, benchmark::PriorityLevel::HIGH);
-
-BENCHMARK(LinearizeNoIters16TxWorstCaseAnc, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeNoIters32TxWorstCaseAnc, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeNoIters48TxWorstCaseAnc, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeNoIters64TxWorstCaseAnc, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeNoIters75TxWorstCaseAnc, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeNoIters99TxWorstCaseAnc, benchmark::PriorityLevel::HIGH);
+// Constructed from replayed historical mempool activity, selecting for clusters that are slow
+// to linearize from scratch, with increasing number of transactions (9 to 63).
+static const std::vector<std::vector<uint8_t>> CLUSTERS_HISTORICAL = {
+    "8540e93a008331c66a018331c66a028331c66a038331c66a048331c66a058331c66a068f1b84a1060000000000000007995e888c04010000000000000000"_hex_v_u8,
+    "8e4886a46000835c819a100000835d819c000100835f819c000200837581a7200300835f819c000400835c819a1005008360819c000600836e81a3400700835f819c0008009c728d813000000000000000000000854e88df0600008e48a9c5700100835f8bfd40000183608bfd40010100"_hex_v_u8,
+    "836880bf4000834c80b6600000836880bf400100834c80b6600001836880bf400101834c80b6600002836880bf400102834c80b6600003836880bf400103834c80b6600004836880bf400104834c80b6600005836880bf400105836880bf400006834c80b6600106836880bf400106834c80b6600206836880bf400107834c80b6600207823c80bf400108834c80b660020800"_hex_v_u8,
+    "81b0708db03800ef7a84a6700180c57b87c87802f24f83fc7e0381a3688ce20a04cb0d82a27205b40481887e068331965207d84384a07a0880850887b31609d57a83b62a09098865c82e0707c84083a736060009932d8098240a00058c1edf48070503f55a85fc560803058b6ddf660e0002e67d858d68090107921a81a1560d0302857cb32206148235986406149a5680e67c0b000106854cc12001118578e228001281cf6499b350120000000000108578e22801128578e228001300"_hex_v_u8,
+    "80df2a87e05c00f62883d34801f23983c02c02808e0784ca280380c35b86d64c0480956584f1080580a91b85d20c06808c4b84c27c0780b473868c4408f54983cf7c0980aa5385d9380a80b00285f4140b80804f8487100c8099308582700d80b3138683640efe1183fa640fa734849e28000000000000000000000000000000000fc82788ce48010000000000000000000000000000000fa92b84be300200000000000000000000000000000000ab3b84e1460300000000000000000000000000000000833dc93c0102833dc93c02028331c14402038540e12603038431cc3405028335c50e030a8331c7760506930880af020307833dc07605068331be0205068335be3a05078d09fb76030d842dcb6e030d00"_hex_v_u8,
+    "8368903600836890360183689036028368903603836890360483689036058368903606836890360783689036088368903609836890360a836890360b836890360c836890361b836890360e836890360f83689036228368903611836890361283689036138359900a13158359900a13158359900a13158359900a13158359900a13158359900a13158359900a13158359900a13158359900a13158359900a13158359900a13158359900a13158359900a12148359900a12148359900a11138359900a11138359900a11138359900a1113a42281a91012000000000000000000000000000000000000002600"_hex_v_u8,
+    "83689220008734a05001836892200283689220038368922004854e99400583689220068368922007836892200406836892200306836892200207854e994009000983689220030c854e9940080107836892200309854e99400b0101836892200416854e9940070209854e994005060c854e9940020c0e854e9940030804854e9940030706891aa770070207854e9940040413854e994006020d854e99400311836892200310836892200217836892200113854e994003070d854e9940020410854e994002020d8734a05006010b854e9940050612854e994002128734a0500014854e9940050015836892200114854e994001090e854e99400507148734a050020b058734a0500210836892200222854e994004090e854e9940041200"_hex_v_u8,
+    "db3284df6200e45386c550018235a906028235a906038236a906048235a906058600da0005058578d94c06058236a104070582429e10080582429b040905831d982e0a05854181e1040b058f1880f2240c058235a5040d058236a9060e05823581c3080f058235a90610058235a9061105857c80804012058235ab0613058235a90613058236a90614058236990215058474ca6e16058470ca6e17058a5480df0418058470ca6e19058316a43e1b04847c8088701b0586088086481d048236af061d058235a9061e058235a9061f058235b10620058236b10621058236b10622058236b1062305847080870224058546b34425058234b30626058235838f3227058242a504212a8241a9061b2d824181be76192d875282ad702b00168242ab061929845085af4c2d000f824181e448102b860480885c25168d0884c76e1b100000000100"_hex_v_u8,
+    "8514fd1a00851480d02801903183803e028368e154038368e154048368e63c058368e63c068368e154078e4b82da4e08903181ec440983688187580a83688185240b83688185240c903181db100d8e4b8391180c0d8e4b84b4760c078361e566090b8361e5660b0a8363e1020d098363e1020f088363e1020c0c8e4b81be5614058e4b81dd6e0c0d835f8184200c0d835f8181700c0d835f8181700c0d8c6686a8100b24d63b93ea661205128e4b8391180d1d937d82d740071d8e4b81dd6e071c90318dce1604338e4b848d78042c8e4b82e234042c8d1e83f106052b8e4b81dd6e05258e4b85a9700333921785880c03328e4482e03c04308e4b8687380237920f85ab68020317178e4b86dd1a001c16d77ed4c56c020e0700000000068e4b8687380100318e4b868f1e00328e4b86ae3600328f2385f62a01181a836880fe100132845a81ab1e0033836881a93001338e438ffd30031c836881a9300135835f81a5400235835f81a5400137921790ba2c023697498dfd280800180019903189f81a003900"_hex_v_u8,
+    "836280c06000836180c06001836280c06002836180c06003834280b1600303836180c0600403834280b1600403836180c0600503834280b1600503836280c0600603834280b1600603877e81fc20060c833a80b160060c836280c060070c877f81fc20070b834180b160070b877e81fc20070a836280c060070a834180b160080a880381fc200809836180c060081a834280b1600719836280c0600716836180c0600614834380b1600612836180c0600511834180b1600527834380b160041f834280b160041c836180c0600617836280c0600618834080b1600516877f81fc200531880281f960140414836280c060041e836280c060041f834280b160051f834580b160071e836280c060053b834280b1600422834880b1600423836180c0600622834280b1600343836180c0600443880281fc200f091d833e80b1600328834280b1600249836280c0600345877f81fc20140b23833b80b1600149877e81fc20020345877f81fc2011081f877e81fd400e0a12880281fb00110316877e81fc2003024a877f81fc20061b1c877f81fc200e0420877f81fc20040c1d877e81fc20021e20877f81fc20041d1f877e81fd40030e1c877f81fb00030a20877e81f9600c033200"_hex_v_u8
+};
+
+// Randomly generated clusters, selected for slow linearization, from 28 to 64 transactions.
+// The first 10 are selected for long total runtime, the last 10 for high runtime per cost.
+static const std::vector<std::vector<uint8_t>> CLUSTERS_SYNTHETIC = {
+    "85058a7c008473b22d018706c70102873bd55303805e857b048732973005811487690686739032078260950508866b52098603a056000000000000000000000a8305986b0100000000000000000008852fa1260200000000000000000005855d8a0c03000000000000000000048468a9260400000000000000000004811f8449050000000000000000000483529f3e06000000000000000000048645962d07000000000000000000048333802a0800000000000000000001807187380900000000000000000001832f98220a000000000000000000018635a6380b00000000000000000001827c812c0c00000000000000000001844382700d00000000000000000000837d80410e00000000000000000000834ca16d0f00000000000000000000872d932c10000000000000000000008619b159110000000000000000000000"_hex_v_u8,
+    "8040810400864384650184599d6902806c802903853fa502048332a25b058627cb6b068024897307861080790883469c7a098458b10f0a846bab240b8406a1770c8526b2290d870c710e840d8c630f8608926f108646af49118426a123128747c74213813b837d0000000000000000000000000000000000000000148629c81b010000000000000000000000000000000000000012865a857b020000000000000000000000000000000000000011866c8d3d03000000000000000000000000000000000000000f71871404000000000000000000000000000000000000000a86509a1805000000000000000000000000000000000000000a863e8c4b060000000000000000000000000000000000000009871db86a070000000000000000000000000000000000000006807b930a08000000000000000000000000000000000000000585779a2a090000000000000000000000000000000000000002831584430a00000000000000000000000000000000000000018156804a0b000000000000000000000000000000000000000100"_hex_v_u8,
+    "8630852c008029804601864fb81d028602ae03038633af710481358b7a058559ad75068461a43b07865dd10a088516a42809810c8a250a821fa3150b812093470c805a85450d8708c27d0e8477aa770f8152850210806b892711810e805112821a904b13820582160000000000000000000000000000000000000000128114935f0100000000000000000000000000000000000000128179863902000000000000000000000000000000000000000e8064861103000000000000000000000000000000000000000d856a816c04000000000000000000000000000000000000000d8671b17405000000000000000000000000000000000000000d80368b0806000000000000000000000000000000000000000c847e881507000000000000000000000000000000000000000c8713811808000000000000000000000000000000000000000c801b89620900000000000000000000000000000000000000098139802b0a0000000000000000000000000000000000000009801d85440b00000000000000000000000000000000000000098161994d0c000000000000000000000000000000000000000882448c4b0d0000000000000000000000000000000000000008862b9c040e00000000000000000000000000000000000000068738e1580f000000000000000000000000000000000000000100"_hex_v_u8,
+    "8345803600823fa12101862acf45028611882c038115953e0482748b51058606af0f068619a55f078436b76f086482440983358a380a846abb680b8164991f0c8142931b0d8535b1590e846d8d6d0f8400977b10811f8d6211857bc24f12857daf3300000000000000000000000000000000000000138262a8700100000000000000000000000000000000000011821d91240200000000000000000000000000000000000010870aa538030000000000000000000000000000000000001080788d68040000000000000000000000000000000000000b8240940e0500000000000000000000000000000000000009872f863c060000000000000000000000000000000000000781568460070000000000000000000000000000000000000282138e350800000000000000000000000000000000000002871c991609000000000000000000000000000000000000028072942a0a00000000000000000000000000000000000002835d0a0b00000000000000000000000000000000000002830b824f0c0000000000000000000000000000000000000282608e110d000000000000000000000000000000000000028071842f0e00000000000000000000000000000000000002837287410f00000000000000000000000000000000000001810e88671000000000000000000000000000000000000001867c977f11000000000000000000000000000000000000018704932612000000000000000000000000000000000000018724b61b13000000000000000000000000000000000000018339a072140000000000000000000000000000000000000100"_hex_v_u8,
+    "8240952700865eb9710184219a7202863d8b2503833c9855048748b66705817ea16106814f8b1b07841f9349088717c90c09800d8d2d0a815190220b860bb4680c866d93250d81109a490e8075813e0f83388b3b1083268a7d118640c00f128727ae2813807b87781480428d5315833aaf6d168213a71d178623cc63188542a9531981796e1a855db8390000000000000000000000000000000000000000000000000000001b64883e0100000000000000000000000000000000000000000000000000001686638627020000000000000000000000000000000000000000000000000000168370871a03000000000000000000000000000000000000000000000000000015871b990104000000000000000000000000000000000000000000000000000014810e99080500000000000000000000000000000000000000000000000000000f80668e720600000000000000000000000000000000000000000000000000000f85738c240700000000000000000000000000000000000000000000000000000e803c8f660800000000000000000000000000000000000000000000000000000e873cb8200900000000000000000000000000000000000000000000000000000d8606cc3c0a00000000000000000000000000000000000000000000000000000b826f99050b000000000000000000000000000000000000000000000000000006815597400c000000000000000000000000000000000000000000000000000005860b955a0d00000000000000000000000000000000000000000000000000000581018f6b0e0000000000000000000000000000000000000000000000000000028644882e0f00000000000000000000000000000000000000000000000000000282048e0b1000000000000000000000000000000000000000000000000000000200"_hex_v_u8,
+    "8041853f008115953c01866ea90e02816ba407038101870b04854eda0505841d995a06854ad1690783528b5e0886208a3709873de6580a8454af370b8732d21e0c846ecd410d822d9b190e8335b0440f80348137108278866d11874bd81d1284788d741385389e20148501cf0c15813b81251681108971000000000000000000000000000000000000000000000017813a9d7201000000000000000000000000000000000000000000001782448a6b020000000000000000000000000000000000000000000017855cb361030000000000000000000000000000000000000000000013833da46c04000000000000000000000000000000000000000000001281349c230500000000000000000000000000000000000000000000108367a120060000000000000000000000000000000000000000000010803b8b7c07000000000000000000000000000000000000000000000e8375864508000000000000000000000000000000000000000000000e874b901609000000000000000000000000000000000000000000000e8209942e0a000000000000000000000000000000000000000000000d83248e700b000000000000000000000000000000000000000000000d840d8b040c000000000000000000000000000000000000000000000d8619c2360d000000000000000000000000000000000000000000000d8027824f0e000000000000000000000000000000000000000000000d8135841e0f000000000000000000000000000000000000000000000d85349f0510000000000000000000000000000000000000000000000c8476a00611000000000000000000000000000000000000000000000b831caa4f12000000000000000000000000000000000000000000000b84318b7e13000000000000000000000000000000000000000000000b83319f3b1400000000000000000000000000000000000000000000048701b76515000000000000000000000000000000000000000000000481558c461600000000000000000000000000000000000000000000038529be4e170000000000000000000000000000000000000000000003835da02018000000000000000000000000000000000000000000000200"_hex_v_u8,
+    "8639bf23008029863b0180539159028614c6330387408e22046782250582129117068365ad3a078075912708866e8a090982799c050a8474bf220b8548ba060c840eac020d850186460e815c85170f81628a301082369942118250a13b128644b74d13832da43314835c874f15800a8d5a00000000000000000000000000000000000000000000148707af630100000000000000000000000000000000000000000014806c993f020000000000000000000000000000000000000000001480288572030000000000000000000000000000000000000000001281449d7b04000000000000000000000000000000000000000000108505c536050000000000000000000000000000000000000000000f813e924b060000000000000000000000000000000000000000000f8510a24a070000000000000000000000000000000000000000000f8533875a080000000000000000000000000000000000000000000b8056800f090000000000000000000000000000000000000000000b870f8b0b0a0000000000000000000000000000000000000000000a87188b7a0b000000000000000000000000000000000000000000098417a87c0c00000000000000000000000000000000000000000009803d832c0d000000000000000000000000000000000000000000078663dd330e000000000000000000000000000000000000000000078511b21d0f000000000000000000000000000000000000000000058168992610000000000000000000000000000000000000000000058473bc4c110000000000000000000000000000000000000000000580428925120000000000000000000000000000000000000000000580408b61130000000000000000000000000000000000000000000581138d2814000000000000000000000000000000000000000000048647de091500000000000000000000000000000000000000000004817a85161600000000000000000000000000000000000000000004832d9d431700000000000000000000000000000000000000000003830b9512180000000000000000000000000000000000000000000382499e001900000000000000000000000000000000000000000003852d865e1a0000000000000000000000000000000000000000000380708f341b000000000000000000000000000000000000000000018555c1001c00000000000000000000000000000000000000000001822c886f1d0000000000000000000000000000000000000000000100"_hex_v_u8,
+    "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"_hex_v_u8,
+    "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"_hex_v_u8,
+    "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"_hex_v_u8,
+    "80578c04008734c974018654a51d02856aae0d038719973c0106807f904f04018430913d000a871a985d0500018374965f030109867466000e86479a690203038735c80d0109836997010700000003840ea121080000000082699354030310803a520702000483019f2709000000108159881f0703000e847d8f10060400128128901604070e851e8f1109020100801c820f01090009803d884a040101000000010f850e8f610202000106800b880606000200000100832e826f040100000000000009856fba6002020100000008865f9a0e06000000000000000100"_hex_v_u8,
+    "81088137008624a1750180398f1602807a892b0102866bd12302028049450301803282010300076e880205000280068133050002810880170401088306997c05000002852e9e020401000282239424060001000166863504010000000d8135804d0601000000098227952105000100000a851a855e06000100000a8628a34b07000100000180038015070000010008801c8a7307000000010585168d210702000000000a821a6c03000202058329981f000200098507a21a000d8723bd13000417845cab5804020000000000000f83028f260201030380106e02010315842dac580501010012873bc37e040101001a8214973b060001000a80368d7902010100001900"_hex_v_u8,
+    "820ea20c0083308407018237a67a02821fa37900048320ab4a0202844db6210401811b98490008830b931701068676ba5d030100058317997504000386259140020402857cc2410402000a8001832d010c81078d35060200068149960708010004863ea83505040d83498656070200038320a77503050111830b822f070200010681018041060302008232863b090200000085619c03030502088524a00c030002078545a04602050002028100921a0405000200008473c1530900000101000e845a8d080500020100000017867087460502010000000f7489310401010102018216a16a0104000001078427af750501000000010585458b43040202000002872cda4f0304010000068209851d010200000000138321827a01000000000f8356a908010000002200"_hex_v_u8,
+    "833a8843008449995c01810a873000038066934d02018616c04d0202843a87600401826a864d0402855f8779050007863d936903038572d02d040204867cc61604030180098b69020509832792510601010581798e06040504833b9439070101000d851f946f01128147927d02030014866baa5d070201000c805f854f070300010b81579177090201000483209f7a0404020283678e420400050d8340981e080101000100048070816d07000101020c85578f010b01000000000004821a972605010204000010831c94280a01000000010001812d906c0303060882599e120505000200000a80638c5707020103844d9f04080004000000000e802b8c3107010300001b83189062020703000d872cb306080202000000098370a61e0600040000010d800a870f01010401000982369a1e030204000000058747c40c0102000317854e9e1c010300000000001a873eb04001020000002500"_hex_v_u8,
+    "83778b4c00834c932901853ed03202834a844c00048716a22d02038529c429020103843ebe7f0300048135944b040002810f9704040005850b9463010980628e700501000a80238d380502078739843b080000008405896304000f80094c04010d807d9739070000000c8218a32304030109853a9d460500020f817b9412030600000987498636010014850e8104060400000b80378b5407030001000b8659d87f05040001000b831e8f740a000100000009844c9f7d040501188203964806040101038201946806050000188406bd48060600000014860e9c4f0b010000000f8549c114040500030f813b82510406000218842da63e0800030115811d9b5a0501010003001c84208029070004000d832a95220500010101010022852b9b24030401010000001a857f8107050104000000000f853e9525080100000000000109821f9507050101000104827aa04602030220834f803405000201001c8268aa1603030000000001008475b43202000300000005827b93560202000100002900"_hex_v_u8,
+    "812d9c7200852fd301018170943702824a9e630387272402048353b33102038556b159020481599b00010883528735030381718370030107842cbf77050103816c8a1c0600048422c55d04078321a409090000000982688622050508806f8c090017873c5b08010004817fa04a050201048567c15f0505011082219f00080201118135892e07060000078360af6d0309138031824c0608001185739b080a020101000582018d0a0a000311813d860109010f8452bc6400060411825a8e2b050702098246a769012484049d3c07070100138313853a06080000158553b84b0b0203000000000010817da176030d1883388476040314852381580405050020830e966a0100042585128a3e08000001000121836f870403000700010000000025862cad000207020001128742d7180701010200010001088606da7c06000400010001000b84699b2d06030101000000010000138418b6250602030000001f84155c0401050013846a81610101030106873fd029020101000001000e82508521010300010d862ec12700000000001500"_hex_v_u8,
+    "7d836f008521bb6b018061934b0285118b7903802285670203850f8b5201058221a327030287369342060080188c340601802d8f68060003840fb2400700028227a713070100028747c93d06010007874b99630503010281779f3103060380228e000602000f802f831a09000106857781300803000000108707a45d080001010011830a9132030811821aa471080301000010864aca7c0602021185758d640702000110843c8a2306000214850ec3040a01020100000082568231030a00000d810e927503000a0d8001803e070001021980209041010c0005822f9c6205070005835cbf50030b000011852bb20f0a0400000000001d83179f210c010101000000001a806a967c05030403208212980d0404030302832ca5660902020000001f852e9e39080303020000028572ca5208010203020013816192320e010000010000228672ef1d06060100011082419e6a050701021f8424b26e05040104010c8420bf780406030000000000855ac63c0b00010100000000000c8426ae25030501030016874a9330030104030019871be924060200010000000000118644cd2103010302010f8345ad03000401010d81379c2102000100010030837f810901010000000e832bb24f0100000600"_hex_v_u8,
+    "816ba22900836f867101873c8056028511815803815497480205804283330105807e1d020383028a6100058533cc7b0100086a893d040003822493090302000b86108056020a854cbe4b05010483128c2d090000000182359815010c7281540800010002810889440602000e8518d60f09000000108563e05b0602020e8544ba220b000001018655da2105041382438a0c080202000381138a2b0702031085508f2904080004867ecb6709020002048375b142080103011a867bcc450508011983368a0b0c0200000a8420a84a0b03020000098312af7d0606020000088443c4550502050200068524b179090300000002001981188579030a00000217806d8f0a0c000005000d8076851a0800020003021581359369060101060103846eae34070203000200010022832a86670d0100000000000102830891620a00010100030000000001810592140900020001000003278712eb5d090500000100011f813f921a05020402128212ac1607010000090a870fc33001041981708e7a000903010a835ba272020900010001001884618f680207000101010118850bb168070301020000000680779a6f0406000002001f8670843605010500011e842e904709010003010000000d8222ae010205020128866086120702020000000000001082029c35010101030b82639c7802010300000100328138801001020102002000"_hex_v_u8,
+    "815e9a23008324a10d01825bb246028470af1301048737ba3202048264aa000304843383590403857ba37c05028351be6805028123965a0700098567c53f0307854fde3e04000e825aa8790305098259b529020f8365985d0505068246ac510800010e83448c410215801b8464011c85548a540705010f840c9d10050800118472bb480211821aa7510d010000000010823b9d50010c108533a8030607020007804e90030d0000000a80799051060701078717900106070000168511962d0209000209806c801c060603001a8347a86607060102000f8245924309030001031a8177a513070504001b81348064080a0000000002856ce16106010902000f850088600701090200048044847b09040301010020842189140d04010000010000168210a91b02000609208618ae420609020000000b8257951b0b00070100000009855d8b7b0902030520810190300a0701000000000000028254ae7b0700060001031f8748bf21040902108264af760f0004000001000a813587660c0005000100000000002d8256a04a080a00000000246a8526030a06001780068011050a000403866ecf5a080a03000000008603c30509020000050f8250916201070306000025825385380e00000200000000348210836504090200010100048334b97a060502000201012c84088e520705020002010105814a8c65050507011a8178a15e05010101000000003680448c190200020300010100003280388f2c03000000010000000000002600"_hex_v_u8,
+    "824da926008527804e01871bca36028604b04f038558d62c04804a960f02048513d87301068229897103058675a07e03000b843c8311050201814e5d02030c87029e020109841dc65a0601038227a325070101088334801c06030102853ee538070005688b0d080200010d8406a94d0b000000000b852bbf050a020000000a811380750d0000000005825c935d0b000200000a871bcb700902020109824187140f00000000098614ec7f0d000003078621942b080800058454bb1c0e030000000a847e630d030001000b8601e07e0c0002030c8655bf0b030f00018306bb5705010c1487038e071200000000001b856f816f1000000100020018820a9a530a0208000a81398a74001321853a944a060a03000117835aaf1c09030701118529b8690709020201248621bd330e010001010202148022800104100981428234090800030100188517cd2007060100020305836dc031020209022782449b69040c0100000001108651ac0a0607010101000000022a8337c0610505040202000001228547cd7c0d02000102020000000d843eba2a0b0501000000020025810f94010b0002030101000000010e803c921006000008041b8453bb3a0a0600030000000000000017841bae620708030100000016813f9924110100000200000000000000000c8637f36205060200050006857eb53f08020900000000002d810b9e580c0005000201000000000786459b700207060101188536b7790a0601000000010000000006854d905f08070201000000001680578f6a09030200030031837c8419080006000000022e8518a8500500040501000028861dd07e0801010300003b8743b97202000002000105003b8545b730010200010000000000001f00"_hex_v_u8
+};
+
+static void LinearizeOptimallyTotal(benchmark::Bench& bench)
+{
+    BenchLinearizeOptimallyTotal(bench, "LinearizeOptimallyHistoricalTotal", CLUSTERS_HISTORICAL);
+    BenchLinearizeOptimallyTotal(bench, "LinearizeOptimallySyntheticTotal", CLUSTERS_SYNTHETIC);
+}
 
-BENCHMARK(LinearizeNoIters16TxWorstCaseLIMO, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeNoIters32TxWorstCaseLIMO, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeNoIters48TxWorstCaseLIMO, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeNoIters64TxWorstCaseLIMO, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeNoIters75TxWorstCaseLIMO, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeNoIters99TxWorstCaseLIMO, benchmark::PriorityLevel::HIGH);
+static void LinearizeOptimallyPerCost(benchmark::Bench& bench)
+{
+    BenchLinearizeOptimallyPerCost(bench, "LinearizeOptimallyHistoricalPerCost", CLUSTERS_HISTORICAL);
+    BenchLinearizeOptimallyPerCost(bench, "LinearizeOptimallySyntheticPerCost", CLUSTERS_SYNTHETIC);
+}
 
 BENCHMARK(PostLinearize16TxWorstCase, benchmark::PriorityLevel::HIGH);
 BENCHMARK(PostLinearize32TxWorstCase, benchmark::PriorityLevel::HIGH);
@@ -390,30 +157,5 @@ BENCHMARK(PostLinearize64TxWorstCase, benchmark::PriorityLevel::HIGH);
 BENCHMARK(PostLinearize75TxWorstCase, benchmark::PriorityLevel::HIGH);
 BENCHMARK(PostLinearize99TxWorstCase, benchmark::PriorityLevel::HIGH);
 
-BENCHMARK(MergeLinearizations16TxWorstCase, benchmark::PriorityLevel::HIGH);
-BENCHMARK(MergeLinearizations32TxWorstCase, benchmark::PriorityLevel::HIGH);
-BENCHMARK(MergeLinearizations48TxWorstCase, benchmark::PriorityLevel::HIGH);
-BENCHMARK(MergeLinearizations64TxWorstCase, benchmark::PriorityLevel::HIGH);
-BENCHMARK(MergeLinearizations75TxWorstCase, benchmark::PriorityLevel::HIGH);
-BENCHMARK(MergeLinearizations99TxWorstCase, benchmark::PriorityLevel::HIGH);
-
-BENCHMARK(LinearizeOptimallyExample00, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample01, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample02, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample03, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample04, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample05, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample06, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample07, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample08, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample09, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample10, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample11, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample12, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample13, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample14, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample15, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample16, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample17, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample18, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyExample19, benchmark::PriorityLevel::HIGH);
+BENCHMARK(LinearizeOptimallyTotal, benchmark::PriorityLevel::HIGH);
+BENCHMARK(LinearizeOptimallyPerCost, benchmark::PriorityLevel::HIGH);
diff --git a/depend/bitcoin/src/bench/coin_selection.cpp b/depend/bitcoin/src/bench/coin_selection.cpp
index 2150d800..41d01dfc 100644
--- a/depend/bitcoin/src/bench/coin_selection.cpp
+++ b/depend/bitcoin/src/bench/coin_selection.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/bench/connectblock.cpp b/depend/bitcoin/src/bench/connectblock.cpp
index 3746ea29..cc972966 100644
--- a/depend/bitcoin/src/bench/connectblock.cpp
+++ b/depend/bitcoin/src/bench/connectblock.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2025 The Bitcoin Core developers
+// Copyright (c) 2025-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/bench/crypto_hash.cpp b/depend/bitcoin/src/bench/crypto_hash.cpp
index 05c7788d..0fd7245b 100644
--- a/depend/bitcoin/src/bench/crypto_hash.cpp
+++ b/depend/bitcoin/src/bench/crypto_hash.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/bench/descriptors.cpp b/depend/bitcoin/src/bench/descriptors.cpp
index ac5580a4..719e69e3 100644
--- a/depend/bitcoin/src/bench/descriptors.cpp
+++ b/depend/bitcoin/src/bench/descriptors.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/bench/disconnected_transactions.cpp b/depend/bitcoin/src/bench/disconnected_transactions.cpp
index 7c3c34bb..e4c72aa5 100644
--- a/depend/bitcoin/src/bench/disconnected_transactions.cpp
+++ b/depend/bitcoin/src/bench/disconnected_transactions.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/bench/duplicate_inputs.cpp b/depend/bitcoin/src/bench/duplicate_inputs.cpp
index 9f22fa36..9bd7551d 100644
--- a/depend/bitcoin/src/bench/duplicate_inputs.cpp
+++ b/depend/bitcoin/src/bench/duplicate_inputs.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/bench/ellswift.cpp b/depend/bitcoin/src/bench/ellswift.cpp
index 4dfef0e9..21868fb8 100644
--- a/depend/bitcoin/src/bench/ellswift.cpp
+++ b/depend/bitcoin/src/bench/ellswift.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022-2023 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/bench/gcs_filter.cpp b/depend/bitcoin/src/bench/gcs_filter.cpp
index e6cc3d4d..d66402da 100644
--- a/depend/bitcoin/src/bench/gcs_filter.cpp
+++ b/depend/bitcoin/src/bench/gcs_filter.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/bench/hashpadding.cpp b/depend/bitcoin/src/bench/hashpadding.cpp
index cca5c075..74047a0c 100644
--- a/depend/bitcoin/src/bench/hashpadding.cpp
+++ b/depend/bitcoin/src/bench/hashpadding.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/bench/lockedpool.cpp b/depend/bitcoin/src/bench/lockedpool.cpp
index 5f39ddc4..5f8834f5 100644
--- a/depend/bitcoin/src/bench/lockedpool.cpp
+++ b/depend/bitcoin/src/bench/lockedpool.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/bench/logging.cpp b/depend/bitcoin/src/bench/logging.cpp
index 3bf2b7ed..487ddcf3 100644
--- a/depend/bitcoin/src/bench/logging.cpp
+++ b/depend/bitcoin/src/bench/logging.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/bench/mempool_ephemeral_spends.cpp b/depend/bitcoin/src/bench/mempool_ephemeral_spends.cpp
index c973c783..a572d945 100644
--- a/depend/bitcoin/src/bench/mempool_ephemeral_spends.cpp
+++ b/depend/bitcoin/src/bench/mempool_ephemeral_spends.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/bench/mempool_eviction.cpp b/depend/bitcoin/src/bench/mempool_eviction.cpp
index dcbe1245..7e64592d 100644
--- a/depend/bitcoin/src/bench/mempool_eviction.cpp
+++ b/depend/bitcoin/src/bench/mempool_eviction.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/bench/mempool_stress.cpp b/depend/bitcoin/src/bench/mempool_stress.cpp
index 8bdeb75c..3e83b2c2 100644
--- a/depend/bitcoin/src/bench/mempool_stress.cpp
+++ b/depend/bitcoin/src/bench/mempool_stress.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/bench/merkle_root.cpp b/depend/bitcoin/src/bench/merkle_root.cpp
index 98ce197e..f9c933ec 100644
--- a/depend/bitcoin/src/bench/merkle_root.cpp
+++ b/depend/bitcoin/src/bench/merkle_root.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/bench/nanobench.cpp b/depend/bitcoin/src/bench/nanobench.cpp
index fcdd8649..aa5b5527 100644
--- a/depend/bitcoin/src/bench/nanobench.cpp
+++ b/depend/bitcoin/src/bench/nanobench.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2020 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/bench/peer_eviction.cpp b/depend/bitcoin/src/bench/peer_eviction.cpp
index 5b08cc75..43d819cc 100644
--- a/depend/bitcoin/src/bench/peer_eviction.cpp
+++ b/depend/bitcoin/src/bench/peer_eviction.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/bench/poly1305.cpp b/depend/bitcoin/src/bench/poly1305.cpp
index f58afe98..eaa7857f 100644
--- a/depend/bitcoin/src/bench/poly1305.cpp
+++ b/depend/bitcoin/src/bench/poly1305.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/bench/pool.cpp b/depend/bitcoin/src/bench/pool.cpp
index 40b098f5..b31046cf 100644
--- a/depend/bitcoin/src/bench/pool.cpp
+++ b/depend/bitcoin/src/bench/pool.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/bench/prevector.cpp b/depend/bitcoin/src/bench/prevector.cpp
index 2d4e19cf..85ef196e 100644
--- a/depend/bitcoin/src/bench/prevector.cpp
+++ b/depend/bitcoin/src/bench/prevector.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/bench/readwriteblock.cpp b/depend/bitcoin/src/bench/readwriteblock.cpp
index a742a1e8..d756789b 100644
--- a/depend/bitcoin/src/bench/readwriteblock.cpp
+++ b/depend/bitcoin/src/bench/readwriteblock.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/bench/rollingbloom.cpp b/depend/bitcoin/src/bench/rollingbloom.cpp
index 6b3e1c43..a9b7806e 100644
--- a/depend/bitcoin/src/bench/rollingbloom.cpp
+++ b/depend/bitcoin/src/bench/rollingbloom.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/bench/rpc_blockchain.cpp b/depend/bitcoin/src/bench/rpc_blockchain.cpp
index 52916242..0dc217ea 100644
--- a/depend/bitcoin/src/bench/rpc_blockchain.cpp
+++ b/depend/bitcoin/src/bench/rpc_blockchain.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/bench/rpc_mempool.cpp b/depend/bitcoin/src/bench/rpc_mempool.cpp
index 069230f0..c710c2c8 100644
--- a/depend/bitcoin/src/bench/rpc_mempool.cpp
+++ b/depend/bitcoin/src/bench/rpc_mempool.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/bench/sign_transaction.cpp b/depend/bitcoin/src/bench/sign_transaction.cpp
index 40219458..f4294389 100644
--- a/depend/bitcoin/src/bench/sign_transaction.cpp
+++ b/depend/bitcoin/src/bench/sign_transaction.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/bench/streams_findbyte.cpp b/depend/bitcoin/src/bench/streams_findbyte.cpp
index 1f6f4d44..9c52a72a 100644
--- a/depend/bitcoin/src/bench/streams_findbyte.cpp
+++ b/depend/bitcoin/src/bench/streams_findbyte.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/bench/strencodings.cpp b/depend/bitcoin/src/bench/strencodings.cpp
index dd5829ca..38af7ad7 100644
--- a/depend/bitcoin/src/bench/strencodings.cpp
+++ b/depend/bitcoin/src/bench/strencodings.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/bench/util_time.cpp b/depend/bitcoin/src/bench/util_time.cpp
index 4cbc0dfb..a4f30516 100644
--- a/depend/bitcoin/src/bench/util_time.cpp
+++ b/depend/bitcoin/src/bench/util_time.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/bench/verify_script.cpp b/depend/bitcoin/src/bench/verify_script.cpp
index 062f9a01..1266f6dd 100644
--- a/depend/bitcoin/src/bench/verify_script.cpp
+++ b/depend/bitcoin/src/bench/verify_script.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/bench/wallet_balance.cpp b/depend/bitcoin/src/bench/wallet_balance.cpp
index 8d3f7f96..5f3711ad 100644
--- a/depend/bitcoin/src/bench/wallet_balance.cpp
+++ b/depend/bitcoin/src/bench/wallet_balance.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/bench/wallet_create_tx.cpp b/depend/bitcoin/src/bench/wallet_create_tx.cpp
index 7fb535f4..cd9ffd10 100644
--- a/depend/bitcoin/src/bench/wallet_create_tx.cpp
+++ b/depend/bitcoin/src/bench/wallet_create_tx.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
@@ -11,6 +11,7 @@
 #include <consensus/merkle.h>
 #include <interfaces/chain.h>
 #include <kernel/chain.h>
+#include <kernel/types.h>
 #include <node/blockstorage.h>
 #include <outputtype.h>
 #include <policy/feerate.h>
@@ -39,6 +40,7 @@
 #include <utility>
 #include <vector>
 
+using kernel::ChainstateRole;
 using wallet::CWallet;
 using wallet::CreateMockableWalletDatabase;
 using wallet::WALLET_FLAG_DESCRIPTORS;
@@ -101,7 +103,7 @@ void generateFakeBlock(const CChainParams& params,
 
     // notify wallet
     const auto& pindex = WITH_LOCK(::cs_main, return context.chainman->ActiveChain().Tip());
-    wallet.blockConnected(ChainstateRole::NORMAL, kernel::MakeBlockInfo(pindex, &block));
+    wallet.blockConnected(ChainstateRole{}, kernel::MakeBlockInfo(pindex, &block));
 }
 
 struct PreSelectInputs {
diff --git a/depend/bitcoin/src/bench/wallet_ismine.cpp b/depend/bitcoin/src/bench/wallet_ismine.cpp
index 6eef1efd..aa0fd276 100644
--- a/depend/bitcoin/src/bench/wallet_ismine.cpp
+++ b/depend/bitcoin/src/bench/wallet_ismine.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/bench/wallet_loading.cpp b/depend/bitcoin/src/bench/wallet_loading.cpp
index 3397fb00..dffc76e1 100644
--- a/depend/bitcoin/src/bench/wallet_loading.cpp
+++ b/depend/bitcoin/src/bench/wallet_loading.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/bench/wallet_migration.cpp b/depend/bitcoin/src/bench/wallet_migration.cpp
index 0ce23a49..f38f2165 100644
--- a/depend/bitcoin/src/bench/wallet_migration.cpp
+++ b/depend/bitcoin/src/bench/wallet_migration.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2024 The Bitcoin Core developers
+// Copyright (c) 2024-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
@@ -6,6 +6,7 @@
 #include <interfaces/chain.h>
 #include <interfaces/wallet.h>
 #include <kernel/chain.h>
+#include <kernel/types.h>
 #include <node/context.h>
 #include <test/util/mining.h>
 #include <test/util/setup_common.h>
diff --git a/depend/bitcoin/src/bitcoin-chainstate.cpp b/depend/bitcoin/src/bitcoin-chainstate.cpp
index 310ca95c..91c5639e 100644
--- a/depend/bitcoin/src/bitcoin-chainstate.cpp
+++ b/depend/bitcoin/src/bitcoin-chainstate.cpp
@@ -1,3 +1,16 @@
+// Copyright (c) 2022-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.
+//
+// The bitcoin-chainstate executable serves to surface the dependencies required
+// by a program wishing to use Bitcoin Core's consensus engine as it is right
+// now.
+//
+// DEVELOPER NOTE: Since this is a "demo-only", experimental, etc. executable,
+//                 it may diverge from Bitcoin Core's coding style.
+//
+// It is part of the libbitcoinkernel project.
+
 #include <kernel/bitcoinkernel_wrapper.h>
 
 #include <cassert>
diff --git a/depend/bitcoin/src/bitcoin-cli.cpp b/depend/bitcoin/src/bitcoin-cli.cpp
index d6fcaa84..88d0665e 100644
--- a/depend/bitcoin/src/bitcoin-cli.cpp
+++ b/depend/bitcoin/src/bitcoin-cli.cpp
@@ -1128,7 +1128,7 @@ static void ParseGetInfoResult(UniValue& result)
         const std::string proxy = network["proxy"].getValStr();
         if (proxy.empty()) continue;
         // Add proxy to ordered_proxy if has not been processed
-        if (proxy_networks.find(proxy) == proxy_networks.end()) ordered_proxies.push_back(proxy);
+        if (!proxy_networks.contains(proxy)) ordered_proxies.push_back(proxy);
 
         proxy_networks[proxy].push_back(network["name"].getValStr());
     }
diff --git a/depend/bitcoin/src/bitcoin-tx.cpp b/depend/bitcoin/src/bitcoin-tx.cpp
index 937db68e..fdff656f 100644
--- a/depend/bitcoin/src/bitcoin-tx.cpp
+++ b/depend/bitcoin/src/bitcoin-tx.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
@@ -588,7 +588,7 @@ static void MutateTxSign(CMutableTransaction& tx, const std::string& flagStr)
     CCoinsView viewDummy;
     CCoinsViewCache view(&viewDummy);
 
-    if (!registers.count("privatekeys"))
+    if (!registers.contains("privatekeys"))
         throw std::runtime_error("privatekeys register variable must be set.");
     FillableSigningProvider tempKeystore;
     UniValue keysObj = registers["privatekeys"];
@@ -604,7 +604,7 @@ static void MutateTxSign(CMutableTransaction& tx, const std::string& flagStr)
     }
 
     // Add previous txouts given in the RPC call:
-    if (!registers.count("prevtxs"))
+    if (!registers.contains("prevtxs"))
         throw std::runtime_error("prevtxs register variable must be set.");
     UniValue prevtxsObj = registers["prevtxs"];
     {
diff --git a/depend/bitcoin/src/bitcoin-util.cpp b/depend/bitcoin/src/bitcoin-util.cpp
index 10967bd5..a6fd026b 100644
--- a/depend/bitcoin/src/bitcoin-util.cpp
+++ b/depend/bitcoin/src/bitcoin-util.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/bitcoin.cpp b/depend/bitcoin/src/bitcoin.cpp
index 37b6fdca..5d42bb04 100644
--- a/depend/bitcoin/src/bitcoin.cpp
+++ b/depend/bitcoin/src/bitcoin.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2025 The Bitcoin Core developers
+// Copyright (c) 2025-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/bitcoind.cpp b/depend/bitcoin/src/bitcoind.cpp
index 37cacb2a..323e7577 100644
--- a/depend/bitcoin/src/bitcoind.cpp
+++ b/depend/bitcoin/src/bitcoind.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/blockencodings.cpp b/depend/bitcoin/src/blockencodings.cpp
index d48ba400..49900482 100644
--- a/depend/bitcoin/src/blockencodings.cpp
+++ b/depend/bitcoin/src/blockencodings.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/blockencodings.h b/depend/bitcoin/src/blockencodings.h
index 124df50a..603cbea6 100644
--- a/depend/bitcoin/src/blockencodings.h
+++ b/depend/bitcoin/src/blockencodings.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/blockfilter.cpp b/depend/bitcoin/src/blockfilter.cpp
index 94bcc497..44d08440 100644
--- a/depend/bitcoin/src/blockfilter.cpp
+++ b/depend/bitcoin/src/blockfilter.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/blockfilter.h b/depend/bitcoin/src/blockfilter.h
index b70afb90..225d3b16 100644
--- a/depend/bitcoin/src/blockfilter.h
+++ b/depend/bitcoin/src/blockfilter.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/chain.cpp b/depend/bitcoin/src/chain.cpp
index 94be7180..64ea44bb 100644
--- a/depend/bitcoin/src/chain.cpp
+++ b/depend/bitcoin/src/chain.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/chain.h b/depend/bitcoin/src/chain.h
index 64c86357..466276c0 100644
--- a/depend/bitcoin/src/chain.h
+++ b/depend/bitcoin/src/chain.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
@@ -39,14 +39,6 @@ static constexpr int64_t TIMESTAMP_WINDOW = MAX_FUTURE_BLOCK_TIME;
 static constexpr int32_t SEQ_ID_BEST_CHAIN_FROM_DISK = 0;
 static constexpr int32_t SEQ_ID_INIT_FROM_DISK = 1;
 
-/**
- * Maximum gap between node time and block time used
- * for the "Catching up..." mode in GUI.
- *
- * Ref: https://github.com/bitcoin/bitcoin/pull/1026
- */
-static constexpr int64_t MAX_BLOCK_TIME_GAP = 90 * 60;
-
 enum BlockStatus : uint32_t {
     //! Unused.
     BLOCK_VALID_UNKNOWN      =    0,
diff --git a/depend/bitcoin/src/chainparams.cpp b/depend/bitcoin/src/chainparams.cpp
index eb915b0b..32c3bff7 100644
--- a/depend/bitcoin/src/chainparams.cpp
+++ b/depend/bitcoin/src/chainparams.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/chainparams.h b/depend/bitcoin/src/chainparams.h
index 4743e022..571e9e17 100644
--- a/depend/bitcoin/src/chainparams.h
+++ b/depend/bitcoin/src/chainparams.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/chainparamsbase.h b/depend/bitcoin/src/chainparamsbase.h
index adbd6a51..37e69b32 100644
--- a/depend/bitcoin/src/chainparamsbase.h
+++ b/depend/bitcoin/src/chainparamsbase.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2020 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/checkqueue.h b/depend/bitcoin/src/checkqueue.h
index 5920d293..037023ee 100644
--- a/depend/bitcoin/src/checkqueue.h
+++ b/depend/bitcoin/src/checkqueue.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/clientversion.h b/depend/bitcoin/src/clientversion.h
index a8eabb85..9d09e502 100644
--- a/depend/bitcoin/src/clientversion.h
+++ b/depend/bitcoin/src/clientversion.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/cluster_linearize.h b/depend/bitcoin/src/cluster_linearize.h
index 73c8a037..d65e61d4 100644
--- a/depend/bitcoin/src/cluster_linearize.h
+++ b/depend/bitcoin/src/cluster_linearize.h
@@ -334,6 +334,15 @@ class DepGraph
         return true;
     }
 
+    unsigned CountDependencies() const noexcept
+    {
+        unsigned ret = 0;
+        for (auto i : Positions()) {
+            ret += GetReducedParents(i).Count();
+        }
+        return ret;
+    }
+
     /** Reduce memory usage if possible. No observable effect. */
     void Compact() noexcept
     {
@@ -386,11 +395,20 @@ struct SetInfo
         return *this;
     }
 
-    /** Construct a new SetInfo equal to this, with more transactions added (which may overlap
-     *  with the existing transactions in the SetInfo). */
-    [[nodiscard]] SetInfo Add(const DepGraph<SetType>& depgraph, const SetType& txn) const noexcept
+    /** Remove the transactions of other from this SetInfo (which must be a subset). */
+    SetInfo& operator-=(const SetInfo& other) noexcept
+    {
+        Assume(other.transactions.IsSubsetOf(transactions));
+        transactions -= other.transactions;
+        feerate -= other.feerate;
+        return *this;
+    }
+
+    /** Compute the difference between this and other SetInfo (which must be a subset). */
+    SetInfo operator-(const SetInfo& other) const noexcept
     {
-        return {transactions | txn, feerate + depgraph.FeeRate(txn - transactions)};
+        Assume(other.transactions.IsSubsetOf(transactions));
+        return {transactions - other.transactions, feerate - other.feerate};
     }
 
     /** Swap two SetInfo objects. */
@@ -404,7 +422,27 @@ struct SetInfo
     friend bool operator==(const SetInfo&, const SetInfo&) noexcept = default;
 };
 
-/** Compute the feerates of the chunks of linearization. */
+/** Compute the chunks of linearization as SetInfos. */
+template<typename SetType>
+std::vector<SetInfo<SetType>> ChunkLinearizationInfo(const DepGraph<SetType>& depgraph, std::span<const DepGraphIndex> linearization) noexcept
+{
+    std::vector<SetInfo<SetType>> ret;
+    for (DepGraphIndex i : linearization) {
+        /** The new chunk to be added, initially a singleton. */
+        SetInfo<SetType> new_chunk(depgraph, i);
+        // As long as the new chunk has a higher feerate than the last chunk so far, absorb it.
+        while (!ret.empty() && new_chunk.feerate >> ret.back().feerate) {
+            new_chunk |= ret.back();
+            ret.pop_back();
+        }
+        // Actually move that new chunk into the chunking.
+        ret.emplace_back(std::move(new_chunk));
+    }
+    return ret;
+}
+
+/** Compute the feerates of the chunks of linearization. Identical to ChunkLinearizationInfo, but
+ *  only returns the chunk feerates, not the corresponding transaction sets. */
 template<typename SetType>
 std::vector<FeeFrac> ChunkLinearization(const DepGraph<SetType>& depgraph, std::span<const DepGraphIndex> linearization) noexcept
 {
@@ -423,620 +461,880 @@ std::vector<FeeFrac> ChunkLinearization(const DepGraph<SetType>& depgraph, std::
     return ret;
 }
 
-/** Data structure encapsulating the chunking of a linearization, permitting removal of subsets. */
+/** Class to represent the internal state of the spanning-forest linearization (SFL) algorithm.
+ *
+ * At all times, each dependency is marked as either "active" or "inactive". The subset of active
+ * dependencies is the state of the SFL algorithm. The implementation maintains several other
+ * values to speed up operations, but everything is ultimately a function of what that subset of
+ * active dependencies is.
+ *
+ * Given such a subset, define a chunk as the set of transactions that are connected through active
+ * dependencies (ignoring their parent/child direction). Thus, every state implies a particular
+ * partitioning of the graph into chunks (including potential singletons). In the extreme, each
+ * transaction may be in its own chunk, or in the other extreme all transactions may form a single
+ * chunk. A chunk's feerate is its total fee divided by its total size.
+ *
+ * The algorithm consists of switching dependencies between active and inactive. The final
+ * linearization that is produced at the end consists of these chunks, sorted from high to low
+ * feerate, each individually sorted in an arbitrary but topological (= no child before parent)
+ * way.
+ *
+ * We define three quality properties the state can have, each being stronger than the previous:
+ *
+ * - acyclic: The state is acyclic whenever no cycle of active dependencies exists within the
+ *            graph, ignoring the parent/child direction. This is equivalent to saying that within
+ *            each chunk the set of active dependencies form a tree, and thus the overall set of
+ *            active dependencies in the graph form a spanning forest, giving the algorithm its
+ *            name. Being acyclic is also equivalent to every chunk of N transactions having
+ *            exactly N-1 active dependencies.
+ *
+ *            For example in a diamond graph, D->{B,C}->A, the 4 dependencies cannot be
+ *            simultaneously active. If at least one is inactive, the state is acyclic.
+ *
+ *            The algorithm maintains an acyclic state at *all* times as an invariant. This implies
+ *            that activating a dependency always corresponds to merging two chunks, and that
+ *            deactivating one always corresponds to splitting two chunks.
+ *
+ * - topological: We say the state is topological whenever it is acyclic and no inactive dependency
+ *                exists between two distinct chunks such that the child chunk has higher or equal
+ *                feerate than the parent chunk.
+ *
+ *                The relevance is that whenever the state is topological, the produced output
+ *                linearization will be topological too (i.e., not have children before parents).
+ *                Note that the "or equal" part of the definition matters: if not, one can end up
+ *                in a situation with mutually-dependent equal-feerate chunks that cannot be
+ *                linearized. For example C->{A,B} and D->{A,B}, with C->A and D->B active. The AC
+ *                chunk depends on DB through C->B, and the BD chunk depends on AC through D->A.
+ *                Merging them into a single ABCD chunk fixes this.
+ *
+ *                The algorithm attempts to keep the state topological as much as possible, so it
+ *                can be interrupted to produce an output whenever, but will sometimes need to
+ *                temporarily deviate from it when improving the state.
+ *
+ * - optimal: For every active dependency, define its top and bottom set as the set of transactions
+ *            in the chunks that would result if the dependency were deactivated; the top being the
+ *            one with the dependency's parent, and the bottom being the one with the child. Note
+ *            that due to acyclicity, every deactivation splits a chunk exactly in two.
+ *
+ *            We say the state is optimal whenever it is topological and it has no active
+ *            dependency whose top feerate is strictly higher than its bottom feerate. The
+ *            relevance is that it can be proven that whenever the state is optimal, the produced
+ *            linearization will also be optimal (in the convexified feerate diagram sense). It can
+ *            also be proven that for every graph at least one optimal state exists.
+ *
+ *            Note that it is possible for the SFL state to not be optimal, but the produced
+ *            linearization to still be optimal. This happens when the chunks of a state are
+ *            identical to those of an optimal state, but the exact set of active dependencies
+ *            within a chunk differ in such a way that the state optimality condition is not
+ *            satisfied. Thus, the state being optimal is more a "the eventual output is *known*
+ *            to be optimal".
+ *
+ *            The algorithm terminates whenever an optimal state is reached.
+ *
+ *
+ * This leads to the following high-level algorithm:
+ * - Start with all dependencies inactive, and thus all transactions in their own chunk. This is
+ *   definitely acyclic.
+ * - Activate dependencies (merging chunks) until the state is topological.
+ * - Loop until optimal (no dependencies with higher-feerate top than bottom), or time runs out:
+ *   - Deactivate a violating dependency, potentially making the state non-topological.
+ *   - Activate other dependencies to make the state topological again.
+ * - Output the chunks from high to low feerate, each internally sorted topologically.
+ *
+ * When merging, we always either:
+ * - Merge upwards: merge a chunk with the lowest-feerate other chunk it depends on, among those
+ *                  with lower or equal feerate than itself.
+ * - Merge downwards: merge a chunk with the highest-feerate other chunk that depends on it, among
+ *                    those with higher or equal feerate than itself.
+ *
+ * Using these strategies in the improvement loop above guarantees that the output linearization
+ * after a deactivate + merge step is never worse or incomparable (in the convexified feerate
+ * diagram sense) than the output linearization that would be produced before the step. With that,
+ * we can refine the high-level algorithm to:
+ * - Start with all dependencies inactive.
+ * - Perform merges as described until none are possible anymore, making the state topological.
+ * - Loop until optimal or time runs out:
+ *   - Pick a dependency D to deactivate among those with higher feerate top than bottom.
+ *   - Deactivate D, causing the chunk it is in to split into top T and bottom B.
+ *   - Do an upwards merge of T, if possible. If so, repeat the same with the merged result.
+ *   - Do a downwards merge of B, if possible. If so, repeat the same with the merged result.
+ * - Output the chunks from high to low feerate, each internally sorted topologically.
+ *
+ * Instead of performing merges arbitrarily to make the initial state topological, it is possible
+ * to do so guided by an existing linearization. This has the advantage that the state's would-be
+ * output linearization is immediately as good as the existing linearization it was based on:
+ * - Start with all dependencies inactive.
+ * - For each transaction t in the existing linearization:
+ *   - Find the chunk C that transaction is in (which will be singleton).
+ *   - Do an upwards merge of C, if possible. If so, repeat the same with the merged result.
+ * No downwards merges are needed in this case.
+ *
+ * What remains to be specified are a number of heuristics:
+ *
+ * - How to decide which chunks to merge:
+ *   - The merge upwards and downward rules specify that the lowest-feerate respectively
+ *     highest-feerate candidate chunk is merged with, but if there are multiple equal-feerate
+ *     candidates, a uniformly random one among them is picked.
+ *
+ * - How to decide what dependency to activate (when merging chunks):
+ *   - After picking two chunks to be merged (see above), a uniformly random dependency between the
+ *     two chunks is activated.
+ *
+ * - How to decide which chunk to find a dependency to split in:
+ *   - A round-robin queue of chunks to improve is maintained. The initial ordering of this queue
+ *     is uniformly randomly permuted.
+ *
+ * - How to decide what dependency to deactivate (when splitting chunks):
+ *   - Inside the selected chunk (see above), among the dependencies whose top feerate is strictly
+ *     higher than its bottom feerate in the selected chunk, if any, a uniformly random dependency
+ *     is deactivated.
+ *
+ * - How to decide the exact output linearization:
+ *   - When there are multiple equal-feerate chunks with no dependencies between them, output a
+ *     uniformly random one among the ones with no missing dependent chunks first.
+ *   - Within chunks, repeatedly pick a uniformly random transaction among those with no missing
+ *     dependencies.
+ */
 template<typename SetType>
-class LinearizationChunking
+class SpanningForestState
 {
-    /** The depgraph this linearization is for. */
-    const DepGraph<SetType>& m_depgraph;
-
-    /** The linearization we started from, possibly with removed prefix stripped. */
-    std::span<const DepGraphIndex> m_linearization;
-
-    /** Chunk sets and their feerates, of what remains of the linearization. */
-    std::vector<SetInfo<SetType>> m_chunks;
+private:
+    /** Internal RNG. */
+    InsecureRandomContext m_rng;
 
-    /** How large a prefix of m_chunks corresponds to removed transactions. */
-    DepGraphIndex m_chunks_skip{0};
+    /** Data type to represent indexing into m_tx_data. */
+    using TxIdx = uint32_t;
+    /** Data type to represent indexing into m_dep_data. */
+    using DepIdx = uint32_t;
+
+    /** Structure with information about a single transaction. For transactions that are the
+     *  representative for the chunk they are in, this also stores chunk information. */
+    struct TxData {
+        /** The dependencies to children of this transaction. Immutable after construction. */
+        std::vector<DepIdx> child_deps;
+        /** The set of parent transactions of this transaction. Immutable after construction. */
+        SetType parents;
+        /** The set of child transactions of this transaction. Immutable after construction. */
+        SetType children;
+        /** Which transaction holds the chunk_setinfo for the chunk this transaction is in
+         *  (the representative for the chunk). */
+        TxIdx chunk_rep;
+        /** (Only if this transaction is the representative for the chunk it is in) the total
+         *  chunk set and feerate. */
+        SetInfo<SetType> chunk_setinfo;
+    };
 
-    /** Which transactions remain in the linearization. */
-    SetType m_todo;
+    /** Structure with information about a single dependency. */
+    struct DepData {
+        /** Whether this dependency is active. */
+        bool active;
+        /** What the parent and child transactions are. Immutable after construction. */
+        TxIdx parent, child;
+        /** (Only if this dependency is active) the would-be top chunk and its feerate that would
+         *  be formed if this dependency were to be deactivated. */
+        SetInfo<SetType> top_setinfo;
+    };
 
-    /** Fill the m_chunks variable, and remove the done prefix of m_linearization. */
-    void BuildChunks() noexcept
+    /** The set of all TxIdx's of transactions in the cluster indexing into m_tx_data. */
+    SetType m_transaction_idxs;
+    /** Information about each transaction (and chunks). Keeps the "holes" from DepGraph during
+     *  construction. Indexed by TxIdx. */
+    std::vector<TxData> m_tx_data;
+    /** Information about each dependency. Indexed by DepIdx. */
+    std::vector<DepData> m_dep_data;
+    /** A FIFO of chunk representatives of chunks that may be improved still. */
+    VecDeque<TxIdx> m_suboptimal_chunks;
+
+    /** The number of updated transactions in activations/deactivations. */
+    uint64_t m_cost{0};
+
+    /** Update a chunk:
+     *  - All transactions have their chunk representative set to `chunk_rep`.
+     *  - All dependencies which have `query` in their top_setinfo get `dep_change` added to it
+     *    (if `!Subtract`) or removed from it (if `Subtract`).
+     */
+    template<bool Subtract>
+    void UpdateChunk(const SetType& chunk, TxIdx query, TxIdx chunk_rep, const SetInfo<SetType>& dep_change) noexcept
     {
-        // Caller must clear m_chunks.
-        Assume(m_chunks.empty());
-
-        // Chop off the initial part of m_linearization that is already done.
-        while (!m_linearization.empty() && !m_todo[m_linearization.front()]) {
-            m_linearization = m_linearization.subspan(1);
-        }
-
-        // Iterate over the remaining entries in m_linearization. This is effectively the same
-        // algorithm as ChunkLinearization, but supports skipping parts of the linearization and
-        // keeps track of the sets themselves instead of just their feerates.
-        for (auto idx : m_linearization) {
-            if (!m_todo[idx]) continue;
-            // Start with an initial chunk containing just element idx.
-            SetInfo add(m_depgraph, idx);
-            // Absorb existing final chunks into add while they have lower feerate.
-            while (!m_chunks.empty() && add.feerate >> m_chunks.back().feerate) {
-                add |= m_chunks.back();
-                m_chunks.pop_back();
+        // Iterate over all the chunk's transactions.
+        for (auto tx_idx : chunk) {
+            auto& tx_data = m_tx_data[tx_idx];
+            // Update the chunk representative.
+            tx_data.chunk_rep = chunk_rep;
+            // Iterate over all active dependencies with tx_idx as parent. Combined with the outer
+            // loop this iterates over all internal active dependencies of the chunk.
+            auto child_deps = std::span{tx_data.child_deps};
+            for (auto dep_idx : child_deps) {
+                auto& dep_entry = m_dep_data[dep_idx];
+                Assume(dep_entry.parent == tx_idx);
+                // Skip inactive dependencies.
+                if (!dep_entry.active) continue;
+                // If this dependency's top_setinfo contains query, update it to add/remove
+                // dep_change.
+                if (dep_entry.top_setinfo.transactions[query]) {
+                    if constexpr (Subtract) {
+                        dep_entry.top_setinfo -= dep_change;
+                    } else {
+                        dep_entry.top_setinfo |= dep_change;
+                    }
+                }
             }
-            // Remember new chunk.
-            m_chunks.push_back(std::move(add));
         }
     }
 
-public:
-    /** Initialize a LinearizationSubset object for a given length of linearization. */
-    explicit LinearizationChunking(const DepGraph<SetType>& depgraph LIFETIMEBOUND, std::span<const DepGraphIndex> lin LIFETIMEBOUND) noexcept :
-        m_depgraph(depgraph), m_linearization(lin)
+    /** Make a specified inactive dependency active. Returns the merged chunk representative. */
+    TxIdx Activate(DepIdx dep_idx) noexcept
     {
-        // Mark everything in lin as todo still.
-        for (auto i : m_linearization) m_todo.Set(i);
-        // Compute the initial chunking.
-        m_chunks.reserve(depgraph.TxCount());
-        BuildChunks();
+        auto& dep_data = m_dep_data[dep_idx];
+        Assume(!dep_data.active);
+        auto& child_tx_data = m_tx_data[dep_data.child];
+        auto& parent_tx_data = m_tx_data[dep_data.parent];
+
+        // Gather information about the parent and child chunks.
+        Assume(parent_tx_data.chunk_rep != child_tx_data.chunk_rep);
+        auto& par_chunk_data = m_tx_data[parent_tx_data.chunk_rep];
+        auto& chl_chunk_data = m_tx_data[child_tx_data.chunk_rep];
+        TxIdx top_rep = parent_tx_data.chunk_rep;
+        auto top_part = par_chunk_data.chunk_setinfo;
+        auto bottom_part = chl_chunk_data.chunk_setinfo;
+        // Update the parent chunk to also contain the child.
+        par_chunk_data.chunk_setinfo |= bottom_part;
+        m_cost += par_chunk_data.chunk_setinfo.transactions.Count();
+
+        // Consider the following example:
+        //
+        //    A           A     There are two chunks, ABC and DEF, and the inactive E->C dependency
+        //   / \         / \    is activated, resulting in a single chunk ABCDEF.
+        //  B   C       B   C
+        //      :  ==>      |   Dependency | top set before | top set after | change
+        //  D   E       D   E   B->A       | AC             | ACDEF         | +DEF
+        //   \ /         \ /    C->A       | AB             | AB            |
+        //    F           F     F->D       | D              | D             |
+        //                      F->E       | E              | ABCE          | +ABC
+        //
+        // The common pattern here is that any dependency which has the parent or child of the
+        // dependency being activated (E->C here) in its top set, will have the opposite part added
+        // to it. This is true for B->A and F->E, but not for C->A and F->D.
+        //
+        // Let UpdateChunk traverse the old parent chunk top_part (ABC in example), and add
+        // bottom_part (DEF) to every dependency's top_set which has the parent (C) in it. The
+        // representative of each of these transactions was already top_rep, so that is not being
+        // changed here.
+        UpdateChunk<false>(/*chunk=*/top_part.transactions, /*query=*/dep_data.parent,
+                           /*chunk_rep=*/top_rep, /*dep_change=*/bottom_part);
+        // Let UpdateChunk traverse the old child chunk bottom_part (DEF in example), and add
+        // top_part (ABC) to every dependency's top_set which has the child (E) in it. At the same
+        // time, change the representative of each of these transactions to be top_rep, which
+        // becomes the representative for the merged chunk.
+        UpdateChunk<false>(/*chunk=*/bottom_part.transactions, /*query=*/dep_data.child,
+                           /*chunk_rep=*/top_rep, /*dep_change=*/top_part);
+        // Make active.
+        dep_data.active = true;
+        dep_data.top_setinfo = top_part;
+        return top_rep;
     }
 
-    /** Determine how many chunks remain in the linearization. */
-    DepGraphIndex NumChunksLeft() const noexcept { return m_chunks.size() - m_chunks_skip; }
-
-    /** Access a chunk. Chunk 0 is the highest-feerate prefix of what remains. */
-    const SetInfo<SetType>& GetChunk(DepGraphIndex n) const noexcept
+    /** Make a specified active dependency inactive. */
+    void Deactivate(DepIdx dep_idx) noexcept
     {
-        Assume(n + m_chunks_skip < m_chunks.size());
-        return m_chunks[n + m_chunks_skip];
+        auto& dep_data = m_dep_data[dep_idx];
+        Assume(dep_data.active);
+        auto& parent_tx_data = m_tx_data[dep_data.parent];
+        // Make inactive.
+        dep_data.active = false;
+        // Update representatives.
+        auto& chunk_data = m_tx_data[parent_tx_data.chunk_rep];
+        m_cost += chunk_data.chunk_setinfo.transactions.Count();
+        auto top_part = dep_data.top_setinfo;
+        auto bottom_part = chunk_data.chunk_setinfo - top_part;
+        TxIdx bottom_rep = dep_data.child;
+        auto& bottom_chunk_data = m_tx_data[bottom_rep];
+        bottom_chunk_data.chunk_setinfo = bottom_part;
+        TxIdx top_rep = dep_data.parent;
+        auto& top_chunk_data = m_tx_data[top_rep];
+        top_chunk_data.chunk_setinfo = top_part;
+
+        // See the comment above in Activate(). We perform the opposite operations here,
+        // removing instead of adding.
+        //
+        // Let UpdateChunk traverse the old parent chunk top_part, and remove bottom_part from
+        // every dependency's top_set which has the parent in it. At the same time, change the
+        // representative of each of these transactions to be top_rep.
+        UpdateChunk<true>(/*chunk=*/top_part.transactions, /*query=*/dep_data.parent,
+                          /*chunk_rep=*/top_rep, /*dep_change=*/bottom_part);
+        // Let UpdateChunk traverse the old child chunk bottom_part, and remove top_part from every
+        // dependency's top_set which has the child in it. At the same time, change the
+        // representative of each of these transactions to be bottom_rep.
+        UpdateChunk<true>(/*chunk=*/bottom_part.transactions, /*query=*/dep_data.child,
+                          /*chunk_rep=*/bottom_rep, /*dep_change=*/top_part);
     }
 
-    /** Remove some subset of transactions from the linearization. */
-    void MarkDone(SetType subset) noexcept
+    /** Activate a dependency from the chunk represented by bottom_rep to the chunk represented by
+     *  top_rep, which must exist. Return the representative of the merged chunk. */
+    TxIdx MergeChunks(TxIdx top_rep, TxIdx bottom_rep) noexcept
     {
-        Assume(subset.Any());
-        Assume(subset.IsSubsetOf(m_todo));
-        m_todo -= subset;
-        if (GetChunk(0).transactions == subset) {
-            // If the newly done transactions exactly match the first chunk of the remainder of
-            // the linearization, we do not need to rechunk; just remember to skip one
-            // additional chunk.
-            ++m_chunks_skip;
-            // With subset marked done, some prefix of m_linearization will be done now. How long
-            // that prefix is depends on how many done elements were interspersed with subset,
-            // but at least as many transactions as there are in subset.
-            m_linearization = m_linearization.subspan(subset.Count());
-        } else {
-            // Otherwise rechunk what remains of m_linearization.
-            m_chunks.clear();
-            m_chunks_skip = 0;
-            BuildChunks();
+        auto& top_chunk = m_tx_data[top_rep];
+        Assume(top_chunk.chunk_rep == top_rep);
+        auto& bottom_chunk = m_tx_data[bottom_rep];
+        Assume(bottom_chunk.chunk_rep == bottom_rep);
+        // Count the number of dependencies between bottom_chunk and top_chunk.
+        TxIdx num_deps{0};
+        for (auto tx : top_chunk.chunk_setinfo.transactions) {
+            auto& tx_data = m_tx_data[tx];
+            num_deps += (tx_data.children & bottom_chunk.chunk_setinfo.transactions).Count();
         }
+        Assume(num_deps > 0);
+        // Uniformly randomly pick one of them and activate it.
+        TxIdx pick = m_rng.randrange(num_deps);
+        for (auto tx : top_chunk.chunk_setinfo.transactions) {
+            auto& tx_data = m_tx_data[tx];
+            auto intersect = tx_data.children & bottom_chunk.chunk_setinfo.transactions;
+            auto count = intersect.Count();
+            if (pick < count) {
+                for (auto dep : tx_data.child_deps) {
+                    auto& dep_data = m_dep_data[dep];
+                    if (bottom_chunk.chunk_setinfo.transactions[dep_data.child]) {
+                        if (pick == 0) return Activate(dep);
+                        --pick;
+                    }
+                }
+                break;
+            }
+            pick -= count;
+        }
+        Assume(false);
+        return TxIdx(-1);
     }
 
-    /** Find the shortest intersection between subset and the prefixes of remaining chunks
-     *  of the linearization that has a feerate not below subset's.
-     *
-     * This is a crucial operation in guaranteeing improvements to linearizations. If subset has
-     * a feerate not below GetChunk(0)'s, then moving IntersectPrefixes(subset) to the front of
-     * (what remains of) the linearization is guaranteed not to make it worse at any point.
-     *
-     * See https://delvingbitcoin.org/t/introduction-to-cluster-linearization/1032 for background.
-     */
-    SetInfo<SetType> IntersectPrefixes(const SetInfo<SetType>& subset) const noexcept
+    /** Perform an upward or downward merge step, on the specified chunk representative. Returns
+     *  the representative of the merged chunk, or TxIdx(-1) if no merge took place. */
+    template<bool DownWard>
+    TxIdx MergeStep(TxIdx chunk_rep) noexcept
     {
-        Assume(subset.transactions.IsSubsetOf(m_todo));
-        SetInfo<SetType> accumulator;
-        // Iterate over all chunks of the remaining linearization.
-        for (DepGraphIndex i = 0; i < NumChunksLeft(); ++i) {
-            // Find what (if any) intersection the chunk has with subset.
-            const SetType to_add = GetChunk(i).transactions & subset.transactions;
-            if (to_add.Any()) {
-                // If adding that to accumulator makes us hit all of subset, we are done as no
-                // shorter intersection with higher/equal feerate exists.
-                accumulator.transactions |= to_add;
-                if (accumulator.transactions == subset.transactions) break;
-                // Otherwise update the accumulator feerate.
-                accumulator.feerate += m_depgraph.FeeRate(to_add);
-                // If that does result in something better, or something with the same feerate but
-                // smaller, return that. Even if a longer, higher-feerate intersection exists, it
-                // does not hurt to return the shorter one (the remainder of the longer intersection
-                // will generally be found in the next call to Intersect, but even if not, it is not
-                // required for the improvement guarantee this function makes).
-                if (!(accumulator.feerate << subset.feerate)) return accumulator;
+        /** Information about the chunk that tx_idx is currently in. */
+        auto& chunk_data = m_tx_data[chunk_rep];
+        SetType chunk_txn = chunk_data.chunk_setinfo.transactions;
+        // Iterate over all transactions in the chunk, figuring out which other chunk each
+        // depends on, but only testing each other chunk once. For those depended-on chunks,
+        // remember the highest-feerate (if DownWard) or lowest-feerate (if !DownWard) one.
+        // If multiple equal-feerate candidate chunks to merge with exist, pick a random one
+        // among them.
+
+        /** Which transactions have been reached from this chunk already. Initialize with the
+         *  chunk itself, so internal dependencies within the chunk are ignored. */
+        SetType explored = chunk_txn;
+        /** The minimum feerate (if downward) or maximum feerate (if upward) to consider when
+         *  looking for candidate chunks to merge with. Initially, this is the original chunk's
+         *  feerate, but is updated to be the current best candidate whenever one is found. */
+        FeeFrac best_other_chunk_feerate = chunk_data.chunk_setinfo.feerate;
+        /** The representative for the best candidate chunk to merge with. -1 if none. */
+        TxIdx best_other_chunk_rep = TxIdx(-1);
+        /** We generate random tiebreak values to pick between equal-feerate candidate chunks.
+         *  This variable stores the tiebreak of the current best candidate. */
+        uint64_t best_other_chunk_tiebreak{0};
+        for (auto tx : chunk_txn) {
+            auto& tx_data = m_tx_data[tx];
+            /** The transactions reached by following dependencies from tx that have not been
+             *  explored before. */
+            auto newly_reached = (DownWard ? tx_data.children : tx_data.parents) - explored;
+            explored |= newly_reached;
+            while (newly_reached.Any()) {
+                // Find a chunk inside newly_reached, and remove it from newly_reached.
+                auto reached_chunk_rep = m_tx_data[newly_reached.First()].chunk_rep;
+                auto& reached_chunk = m_tx_data[reached_chunk_rep].chunk_setinfo;
+                newly_reached -= reached_chunk.transactions;
+                // See if it has an acceptable feerate.
+                auto cmp = DownWard ? FeeRateCompare(best_other_chunk_feerate, reached_chunk.feerate)
+                                    : FeeRateCompare(reached_chunk.feerate, best_other_chunk_feerate);
+                if (cmp > 0) continue;
+                uint64_t tiebreak = m_rng.rand64();
+                if (cmp < 0 || tiebreak >= best_other_chunk_tiebreak) {
+                    best_other_chunk_feerate = reached_chunk.feerate;
+                    best_other_chunk_rep = reached_chunk_rep;
+                    best_other_chunk_tiebreak = tiebreak;
+                }
             }
         }
-        return subset;
+        // Stop if there are no candidate chunks to merge with.
+        if (best_other_chunk_rep == TxIdx(-1)) return TxIdx(-1);
+        if constexpr (DownWard) {
+            chunk_rep = MergeChunks(chunk_rep, best_other_chunk_rep);
+        } else {
+            chunk_rep = MergeChunks(best_other_chunk_rep, chunk_rep);
+        }
+        Assume(chunk_rep != TxIdx(-1));
+        return chunk_rep;
     }
-};
 
-/** Class encapsulating the state needed to find the best remaining ancestor set.
- *
- * It is initialized for an entire DepGraph, and parts of the graph can be dropped by calling
- * MarkDone.
- *
- * As long as any part of the graph remains, FindCandidateSet() can be called which will return a
- * SetInfo with the highest-feerate ancestor set that remains (an ancestor set is a single
- * transaction together with all its remaining ancestors).
- */
-template<typename SetType>
-class AncestorCandidateFinder
-{
-    /** Internal dependency graph. */
-    const DepGraph<SetType>& m_depgraph;
-    /** Which transaction are left to include. */
-    SetType m_todo;
-    /** Precomputed ancestor-set feerates (only kept up-to-date for indices in m_todo). */
-    std::vector<FeeFrac> m_ancestor_set_feerates;
 
-public:
-    /** Construct an AncestorCandidateFinder for a given cluster.
-     *
-     * Complexity: O(N^2) where N=depgraph.TxCount().
-     */
-    AncestorCandidateFinder(const DepGraph<SetType>& depgraph LIFETIMEBOUND) noexcept :
-        m_depgraph(depgraph),
-        m_todo{depgraph.Positions()},
-        m_ancestor_set_feerates(depgraph.PositionRange())
+    /** Perform an upward or downward merge sequence on the specified transaction. */
+    template<bool DownWard>
+    void MergeSequence(TxIdx tx_idx) noexcept
     {
-        // Precompute ancestor-set feerates.
-        for (DepGraphIndex i : m_depgraph.Positions()) {
-            /** The remaining ancestors for transaction i. */
-            SetType anc_to_add = m_depgraph.Ancestors(i);
-            FeeFrac anc_feerate;
-            // Reuse accumulated feerate from first ancestor, if usable.
-            Assume(anc_to_add.Any());
-            DepGraphIndex first = anc_to_add.First();
-            if (first < i) {
-                anc_feerate = m_ancestor_set_feerates[first];
-                Assume(!anc_feerate.IsEmpty());
-                anc_to_add -= m_depgraph.Ancestors(first);
-            }
-            // Add in other ancestors (which necessarily include i itself).
-            Assume(anc_to_add[i]);
-            anc_feerate += m_depgraph.FeeRate(anc_to_add);
-            // Store the result.
-            m_ancestor_set_feerates[i] = anc_feerate;
+        auto chunk_rep = m_tx_data[tx_idx].chunk_rep;
+        while (true) {
+            auto merged_rep = MergeStep<DownWard>(chunk_rep);
+            if (merged_rep == TxIdx(-1)) break;
+            chunk_rep = merged_rep;
         }
+        // Add the chunk to the queue of improvable chunks.
+        m_suboptimal_chunks.push_back(chunk_rep);
     }
 
-    /** Remove a set of transactions from the set of to-be-linearized ones.
-     *
-     * The same transaction may not be MarkDone()'d twice.
-     *
-     * Complexity: O(N*M) where N=depgraph.TxCount(), M=select.Count().
-     */
-    void MarkDone(SetType select) noexcept
+    /** Split a chunk, and then merge the resulting two chunks to make the graph topological
+     *  again. */
+    void Improve(DepIdx dep_idx) noexcept
+    {
+        auto& dep_data = m_dep_data[dep_idx];
+        Assume(dep_data.active);
+        // Deactivate the specified dependency, splitting it into two new chunks: a top containing
+        // the parent, and a bottom containing the child. The top should have a higher feerate.
+        Deactivate(dep_idx);
+
+        // At this point we have exactly two chunks which may violate topology constraints (the
+        // parent chunk and child chunk that were produced by deactivating dep_idx). We can fix
+        // these using just merge sequences, one upwards and one downwards, avoiding the need for a
+        // full MakeTopological.
+
+        // Merge the top chunk with lower-feerate chunks it depends on (which may be the bottom it
+        // was just split from, or other pre-existing chunks).
+        MergeSequence<false>(dep_data.parent);
+        // Merge the bottom chunk with higher-feerate chunks that depend on it.
+        MergeSequence<true>(dep_data.child);
+    }
+
+public:
+    /** Construct a spanning forest for the given DepGraph, with every transaction in its own chunk
+     *  (not topological). */
+    explicit SpanningForestState(const DepGraph<SetType>& depgraph, uint64_t rng_seed) noexcept : m_rng(rng_seed)
     {
-        Assume(select.Any());
-        Assume(select.IsSubsetOf(m_todo));
-        m_todo -= select;
-        for (auto i : select) {
-            auto feerate = m_depgraph.FeeRate(i);
-            for (auto j : m_depgraph.Descendants(i) & m_todo) {
-                m_ancestor_set_feerates[j] -= feerate;
+        m_transaction_idxs = depgraph.Positions();
+        auto num_transactions = m_transaction_idxs.Count();
+        m_tx_data.resize(depgraph.PositionRange());
+        // Reserve the maximum number of (reserved) dependencies the cluster can have, so
+        // m_dep_data won't need any reallocations during construction. For a cluster with N
+        // transactions, the worst case consists of two sets of transactions, the parents and the
+        // children, where each child depends on each parent and nothing else. For even N, both
+        // sets can be sized N/2, which means N^2/4 dependencies. For odd N, one can be (N + 1)/2
+        // and the other can be (N - 1)/2, meaning (N^2 - 1)/4 dependencies. Because N^2 is odd in
+        // this case, N^2/4 (with rounding-down division) is the correct value in both cases.
+        m_dep_data.reserve((num_transactions * num_transactions) / 4);
+        for (auto tx : m_transaction_idxs) {
+            // Fill in transaction data.
+            auto& tx_data = m_tx_data[tx];
+            tx_data.chunk_rep = tx;
+            tx_data.chunk_setinfo.transactions = SetType::Singleton(tx);
+            tx_data.chunk_setinfo.feerate = depgraph.FeeRate(tx);
+            // Add its dependencies.
+            SetType parents = depgraph.GetReducedParents(tx);
+            for (auto par : parents) {
+                auto& par_tx_data = m_tx_data[par];
+                auto dep_idx = m_dep_data.size();
+                // Construct new dependency.
+                auto& dep = m_dep_data.emplace_back();
+                dep.active = false;
+                dep.parent = par;
+                dep.child = tx;
+                // Add it as parent of the child.
+                tx_data.parents.Set(par);
+                // Add it as child of the parent.
+                par_tx_data.child_deps.push_back(dep_idx);
+                par_tx_data.children.Set(tx);
             }
         }
     }
 
-    /** Check whether any unlinearized transactions remain. */
-    bool AllDone() const noexcept
+    /** Load an existing linearization. Must be called immediately after constructor. The result is
+     *  topological if the linearization is valid. Otherwise, MakeTopological still needs to be
+     *  called. */
+    void LoadLinearization(std::span<const DepGraphIndex> old_linearization) noexcept
     {
-        return m_todo.None();
+        // Add transactions one by one, in order of existing linearization.
+        for (DepGraphIndex tx : old_linearization) {
+            auto chunk_rep = m_tx_data[tx].chunk_rep;
+            // Merge the chunk upwards, as long as merging succeeds.
+            while (true) {
+                chunk_rep = MergeStep<false>(chunk_rep);
+                if (chunk_rep == TxIdx(-1)) break;
+            }
+        }
     }
 
-    /** Count the number of remaining unlinearized transactions. */
-    DepGraphIndex NumRemaining() const noexcept
+    /** Make state topological. Can be called after constructing, or after LoadLinearization. */
+    void MakeTopological() noexcept
     {
-        return m_todo.Count();
+        for (auto tx : m_transaction_idxs) {
+            auto& tx_data = m_tx_data[tx];
+            if (tx_data.chunk_rep == tx) {
+                m_suboptimal_chunks.emplace_back(tx);
+                // Randomize the initial order of suboptimal chunks in the queue.
+                TxIdx j = m_rng.randrange<TxIdx>(m_suboptimal_chunks.size());
+                if (j != m_suboptimal_chunks.size() - 1) {
+                    std::swap(m_suboptimal_chunks.back(), m_suboptimal_chunks[j]);
+                }
+            }
+        }
+        while (!m_suboptimal_chunks.empty()) {
+            // Pop an entry from the potentially-suboptimal chunk queue.
+            TxIdx chunk = m_suboptimal_chunks.front();
+            m_suboptimal_chunks.pop_front();
+            auto& chunk_data = m_tx_data[chunk];
+            // If what was popped is not currently a chunk representative, continue. This may
+            // happen when it was merged with something else since being added.
+            if (chunk_data.chunk_rep != chunk) continue;
+            int flip = m_rng.randbool();
+            for (int i = 0; i < 2; ++i) {
+                if (i ^ flip) {
+                    // Attempt to merge the chunk upwards.
+                    auto result_up = MergeStep<false>(chunk);
+                    if (result_up != TxIdx(-1)) {
+                        m_suboptimal_chunks.push_back(result_up);
+                        break;
+                    }
+                } else {
+                    // Attempt to merge the chunk downwards.
+                    auto result_down = MergeStep<true>(chunk);
+                    if (result_down != TxIdx(-1)) {
+                        m_suboptimal_chunks.push_back(result_down);
+                        break;
+                    }
+                }
+            }
+        }
     }
 
-    /** Find the best (highest-feerate, smallest among those in case of a tie) ancestor set
-     *  among the remaining transactions. Requires !AllDone().
-     *
-     * Complexity: O(N) where N=depgraph.TxCount();
-     */
-    SetInfo<SetType> FindCandidateSet() const noexcept
+    /** Initialize the data structure for optimization. It must be topological already. */
+    void StartOptimizing() noexcept
     {
-        Assume(!AllDone());
-        std::optional<DepGraphIndex> best;
-        for (auto i : m_todo) {
-            if (best.has_value()) {
-                Assume(!m_ancestor_set_feerates[i].IsEmpty());
-                if (!(m_ancestor_set_feerates[i] > m_ancestor_set_feerates[*best])) continue;
+        // Mark chunks suboptimal.
+        for (auto tx : m_transaction_idxs) {
+            auto& tx_data = m_tx_data[tx];
+            if (tx_data.chunk_rep == tx) {
+                m_suboptimal_chunks.push_back(tx);
+                // Randomize the initial order of suboptimal chunks in the queue.
+                TxIdx j = m_rng.randrange<TxIdx>(m_suboptimal_chunks.size());
+                if (j != m_suboptimal_chunks.size() - 1) {
+                    std::swap(m_suboptimal_chunks.back(), m_suboptimal_chunks[j]);
+                }
             }
-            best = i;
         }
-        Assume(best.has_value());
-        return {m_depgraph.Ancestors(*best) & m_todo, m_ancestor_set_feerates[*best]};
     }
-};
 
-/** Class encapsulating the state needed to perform search for good candidate sets.
- *
- * It is initialized for an entire DepGraph, and parts of the graph can be dropped by calling
- * MarkDone().
- *
- * As long as any part of the graph remains, FindCandidateSet() can be called to perform a search
- * over the set of topologically-valid subsets of that remainder, with a limit on how many
- * combinations are tried.
- */
-template<typename SetType>
-class SearchCandidateFinder
-{
-    /** Internal RNG. */
-    InsecureRandomContext m_rng;
-    /** m_sorted_to_original[i] is the original position that sorted transaction position i had. */
-    std::vector<DepGraphIndex> m_sorted_to_original;
-    /** m_original_to_sorted[i] is the sorted position original transaction position i has. */
-    std::vector<DepGraphIndex> m_original_to_sorted;
-    /** Internal dependency graph for the cluster (with transactions in decreasing individual
-     *  feerate order). */
-    DepGraph<SetType> m_sorted_depgraph;
-    /** Which transactions are left to do (indices in m_sorted_depgraph's order). */
-    SetType m_todo;
-
-    /** Given a set of transactions with sorted indices, get their original indices. */
-    SetType SortedToOriginal(const SetType& arg) const noexcept
+    /** Try to improve the forest. Returns false if it is optimal, true otherwise. */
+    bool OptimizeStep() noexcept
     {
-        SetType ret;
-        for (auto pos : arg) ret.Set(m_sorted_to_original[pos]);
-        return ret;
+        while (!m_suboptimal_chunks.empty()) {
+            // Pop an entry from the potentially-suboptimal chunk queue.
+            TxIdx chunk = m_suboptimal_chunks.front();
+            m_suboptimal_chunks.pop_front();
+            auto& chunk_data = m_tx_data[chunk];
+            // If what was popped is not currently a chunk representative, continue. This may
+            // happen when a split chunk merges in Improve() with one or more existing chunks that
+            // are themselves on the suboptimal queue already.
+            if (chunk_data.chunk_rep != chunk) continue;
+            // Remember the best dependency seen so far.
+            DepIdx candidate_dep = DepIdx(-1);
+            uint64_t candidate_tiebreak = 0;
+            // Iterate over all transactions.
+            for (auto tx : chunk_data.chunk_setinfo.transactions) {
+                const auto& tx_data = m_tx_data[tx];
+                // Iterate over all active child dependencies of the transaction.
+                const auto children = std::span{tx_data.child_deps};
+                for (DepIdx dep_idx : children) {
+                    const auto& dep_data = m_dep_data[dep_idx];
+                    if (!dep_data.active) continue;
+                    // Skip if this dependency is ineligible (the top chunk that would be created
+                    // does not have higher feerate than the chunk it is currently part of).
+                    auto cmp = FeeRateCompare(dep_data.top_setinfo.feerate, chunk_data.chunk_setinfo.feerate);
+                    if (cmp <= 0) continue;
+                    // Generate a random tiebreak for this dependency, and reject it if its tiebreak
+                    // is worse than the best so far. This means that among all eligible
+                    // dependencies, a uniformly random one will be chosen.
+                    uint64_t tiebreak = m_rng.rand64();
+                    if (tiebreak < candidate_tiebreak) continue;
+                    // Remember this as our (new) candidate dependency.
+                    candidate_dep = dep_idx;
+                    candidate_tiebreak = tiebreak;
+                }
+            }
+            // If a candidate with positive gain was found, deactivate it and then make the state
+            // topological again with a sequence of merges.
+            if (candidate_dep != DepIdx(-1)) Improve(candidate_dep);
+            // Stop processing for now, even if nothing was activated, as the loop above may have
+            // had a nontrivial cost.
+            return !m_suboptimal_chunks.empty();
+        }
+        // No improvable chunk was found, we are done.
+        return false;
     }
 
-    /** Given a set of transactions with original indices, get their sorted indices. */
-    SetType OriginalToSorted(const SetType& arg) const noexcept
+    /** Construct a topologically-valid linearization from the current forest state. Must be
+     *  topological. */
+    std::vector<DepGraphIndex> GetLinearization() noexcept
     {
-        SetType ret;
-        for (auto pos : arg) ret.Set(m_original_to_sorted[pos]);
+        /** The output linearization. */
+        std::vector<DepGraphIndex> ret;
+        ret.reserve(m_transaction_idxs.Count());
+        /** A heap with all chunks (by representative) that can currently be included, sorted by
+         *  chunk feerate and a random tie-breaker. */
+        std::vector<std::pair<TxIdx, uint64_t>> ready_chunks;
+        /** Information about chunks:
+         *  - The first value is only used for chunk representatives, and counts the number of
+         *    unmet dependencies this chunk has on other chunks (not including dependencies within
+         *    the chunk itself).
+         *  - The second value is the number of unmet dependencies overall.
+         */
+        std::vector<std::pair<TxIdx, TxIdx>> chunk_deps(m_tx_data.size(), {0, 0});
+        /** The set of all chunk representatives. */
+        SetType chunk_reps;
+        /** A list with all transactions within the current chunk that can be included. */
+        std::vector<TxIdx> ready_tx;
+        // Populate chunk_deps[c] with the number of {out-of-chunk dependencies, dependencies} the
+        // child has.
+        for (TxIdx chl_idx : m_transaction_idxs) {
+            const auto& chl_data = m_tx_data[chl_idx];
+            chunk_deps[chl_idx].second = chl_data.parents.Count();
+            auto chl_chunk_rep = chl_data.chunk_rep;
+            chunk_reps.Set(chl_chunk_rep);
+            for (auto par_idx : chl_data.parents) {
+                auto par_chunk_rep = m_tx_data[par_idx].chunk_rep;
+                chunk_deps[chl_chunk_rep].first += (par_chunk_rep != chl_chunk_rep);
+            }
+        }
+        // Construct a heap with all chunks that have no out-of-chunk dependencies.
+        /** Comparison function for the heap. */
+        auto chunk_cmp_fn = [&](const std::pair<TxIdx, uint64_t>& a, const std::pair<TxIdx, uint64_t>& b) noexcept {
+            auto& chunk_a = m_tx_data[a.first];
+            auto& chunk_b = m_tx_data[b.first];
+            Assume(chunk_a.chunk_rep == a.first);
+            Assume(chunk_b.chunk_rep == b.first);
+            // First sort by chunk feerate.
+            if (chunk_a.chunk_setinfo.feerate != chunk_b.chunk_setinfo.feerate) {
+                return chunk_a.chunk_setinfo.feerate < chunk_b.chunk_setinfo.feerate;
+            }
+            // Tie-break randomly.
+            if (a.second != b.second) return a.second < b.second;
+            // Lastly, tie-break by chunk representative.
+            return a.first < b.first;
+        };
+        for (TxIdx chunk_rep : chunk_reps) {
+            if (chunk_deps[chunk_rep].first == 0) ready_chunks.emplace_back(chunk_rep, m_rng.rand64());
+        }
+        std::make_heap(ready_chunks.begin(), ready_chunks.end(), chunk_cmp_fn);
+        // Pop chunks off the heap, highest-feerate ones first.
+        while (!ready_chunks.empty()) {
+            auto [chunk_rep, _rnd] = ready_chunks.front();
+            std::pop_heap(ready_chunks.begin(), ready_chunks.end(), chunk_cmp_fn);
+            ready_chunks.pop_back();
+            Assume(m_tx_data[chunk_rep].chunk_rep == chunk_rep);
+            Assume(chunk_deps[chunk_rep].first == 0);
+            const auto& chunk_txn = m_tx_data[chunk_rep].chunk_setinfo.transactions;
+            // Build heap of all includable transactions in chunk.
+            for (TxIdx tx_idx : chunk_txn) {
+                if (chunk_deps[tx_idx].second == 0) {
+                    ready_tx.push_back(tx_idx);
+                }
+            }
+            Assume(!ready_tx.empty());
+            // Pick transactions from the ready queue, append them to linearization, and decrement
+            // dependency counts.
+            while (!ready_tx.empty()) {
+                // Move a random queue element to the back.
+                auto pos = m_rng.randrange(ready_tx.size());
+                if (pos != ready_tx.size() - 1) std::swap(ready_tx.back(), ready_tx[pos]);
+                // Pop from the back.
+                auto tx_idx = ready_tx.back();
+                Assume(chunk_txn[tx_idx]);
+                ready_tx.pop_back();
+                // Append to linearization.
+                ret.push_back(tx_idx);
+                // Decrement dependency counts.
+                auto& tx_data = m_tx_data[tx_idx];
+                for (TxIdx chl_idx : tx_data.children) {
+                    auto& chl_data = m_tx_data[chl_idx];
+                    // Decrement tx dependency count.
+                    Assume(chunk_deps[chl_idx].second > 0);
+                    if (--chunk_deps[chl_idx].second == 0 && chunk_txn[chl_idx]) {
+                        // Child tx has no dependencies left, and is in this chunk. Add it to the tx queue.
+                        ready_tx.push_back(chl_idx);
+                    }
+                    // Decrement chunk dependency count if this is out-of-chunk dependency.
+                    if (chl_data.chunk_rep != chunk_rep) {
+                        Assume(chunk_deps[chl_data.chunk_rep].first > 0);
+                        if (--chunk_deps[chl_data.chunk_rep].first == 0) {
+                            // Child chunk has no dependencies left. Add it to the chunk heap.
+                            ready_chunks.emplace_back(chl_data.chunk_rep, m_rng.rand64());
+                            std::push_heap(ready_chunks.begin(), ready_chunks.end(), chunk_cmp_fn);
+                        }
+                    }
+                }
+            }
+        }
+        Assume(ret.size() == m_transaction_idxs.Count());
         return ret;
     }
 
-public:
-    /** Construct a candidate finder for a graph.
+    /** Get the diagram for the current state, which must be topological. Test-only.
      *
-     * @param[in] depgraph   Dependency graph for the to-be-linearized cluster.
-     * @param[in] rng_seed   A random seed to control the search order.
+     * The linearization produced by GetLinearization() is always at least as good (in the
+     * CompareChunks() sense) as this diagram, but may be better.
      *
-     * Complexity: O(N^2) where N=depgraph.Count().
+     * After an OptimizeStep(), the diagram will always be at least as good as before. Once
+     * OptimizeStep() returns false, the diagram will be equivalent to that produced by
+     * GetLinearization(), and optimal.
      */
-    SearchCandidateFinder(const DepGraph<SetType>& depgraph, uint64_t rng_seed) noexcept :
-        m_rng(rng_seed),
-        m_sorted_to_original(depgraph.TxCount()),
-        m_original_to_sorted(depgraph.PositionRange())
+    std::vector<FeeFrac> GetDiagram() const noexcept
     {
-        // Determine reordering mapping, by sorting by decreasing feerate. Unused positions are
-        // not included, as they will never be looked up anyway.
-        DepGraphIndex sorted_pos{0};
-        for (auto i : depgraph.Positions()) {
-            m_sorted_to_original[sorted_pos++] = i;
-        }
-        std::sort(m_sorted_to_original.begin(), m_sorted_to_original.end(), [&](auto a, auto b) {
-            auto feerate_cmp = depgraph.FeeRate(a) <=> depgraph.FeeRate(b);
-            if (feerate_cmp == 0) return a < b;
-            return feerate_cmp > 0;
-        });
-        // Compute reverse mapping.
-        for (DepGraphIndex i = 0; i < m_sorted_to_original.size(); ++i) {
-            m_original_to_sorted[m_sorted_to_original[i]] = i;
+        std::vector<FeeFrac> ret;
+        for (auto tx : m_transaction_idxs) {
+            if (m_tx_data[tx].chunk_rep == tx) {
+                ret.push_back(m_tx_data[tx].chunk_setinfo.feerate);
+            }
         }
-        // Compute reordered dependency graph.
-        m_sorted_depgraph = DepGraph(depgraph, m_original_to_sorted, m_sorted_to_original.size());
-        m_todo = m_sorted_depgraph.Positions();
+        std::sort(ret.begin(), ret.end(), std::greater{});
+        return ret;
     }
 
-    /** Check whether any unlinearized transactions remain. */
-    bool AllDone() const noexcept
-    {
-        return m_todo.None();
-    }
+    /** Determine how much work was performed so far. */
+    uint64_t GetCost() const noexcept { return m_cost; }
 
-    /** Find a high-feerate topologically-valid subset of what remains of the cluster.
-     *  Requires !AllDone().
-     *
-     * @param[in] max_iterations  The maximum number of optimization steps that will be performed.
-     * @param[in] best            A set/feerate pair with an already-known good candidate. This may
-     *                            be empty.
-     * @return                    A pair of:
-     *                            - The best (highest feerate, smallest size as tiebreaker)
-     *                              topologically valid subset (and its feerate) that was
-     *                              encountered during search. It will be at least as good as the
-     *                              best passed in (if not empty).
-     *                            - The number of optimization steps that were performed. This will
-     *                              be <= max_iterations. If strictly < max_iterations, the
-     *                              returned subset is optimal.
-     *
-     * Complexity: possibly O(N * min(max_iterations, sqrt(2^N))) where N=depgraph.TxCount().
-     */
-    std::pair<SetInfo<SetType>, uint64_t> FindCandidateSet(uint64_t max_iterations, SetInfo<SetType> best) noexcept
+    /** Verify internal consistency of the data structure. */
+    void SanityCheck(const DepGraph<SetType>& depgraph) const
     {
-        Assume(!AllDone());
-
-        // Convert the provided best to internal sorted indices.
-        best.transactions = OriginalToSorted(best.transactions);
-
-        /** Type for work queue items. */
-        struct WorkItem
-        {
-            /** Set of transactions definitely included (and its feerate). This must be a subset
-             *  of m_todo, and be topologically valid (includes all in-m_todo ancestors of
-             *  itself). */
-            SetInfo<SetType> inc;
-            /** Set of undecided transactions. This must be a subset of m_todo, and have no overlap
-             *  with inc. The set (inc | und) must be topologically valid. */
-            SetType und;
-            /** (Only when inc is not empty) The best feerate of any superset of inc that is also a
-             *  subset of (inc | und), without requiring it to be topologically valid. It forms a
-             *  conservative upper bound on how good a set this work item can give rise to.
-             *  Transactions whose feerate is below best's are ignored when determining this value,
-             *  which means it may technically be an underestimate, but if so, this work item
-             *  cannot result in something that beats best anyway. */
-            FeeFrac pot_feerate;
-
-            /** Construct a new work item. */
-            WorkItem(SetInfo<SetType>&& i, SetType&& u, FeeFrac&& p_f) noexcept :
-                inc(std::move(i)), und(std::move(u)), pot_feerate(std::move(p_f))
-            {
-                Assume(pot_feerate.IsEmpty() == inc.feerate.IsEmpty());
+        //
+        // Verify dependency parent/child information, and build list of (active) dependencies.
+        //
+        std::vector<std::pair<TxIdx, TxIdx>> expected_dependencies;
+        std::vector<std::tuple<TxIdx, TxIdx, DepIdx>> all_dependencies;
+        std::vector<std::tuple<TxIdx, TxIdx, DepIdx>> active_dependencies;
+        for (auto parent_idx : depgraph.Positions()) {
+            for (auto child_idx : depgraph.GetReducedChildren(parent_idx)) {
+                expected_dependencies.emplace_back(parent_idx, child_idx);
             }
-
-            /** Swap two WorkItems. */
-            void Swap(WorkItem& other) noexcept
-            {
-                swap(inc, other.inc);
-                swap(und, other.und);
-                swap(pot_feerate, other.pot_feerate);
+        }
+        for (DepIdx dep_idx = 0; dep_idx < m_dep_data.size(); ++dep_idx) {
+            const auto& dep_data = m_dep_data[dep_idx];
+            all_dependencies.emplace_back(dep_data.parent, dep_data.child, dep_idx);
+            // Also add to active_dependencies if it is active.
+            if (m_dep_data[dep_idx].active) {
+                active_dependencies.emplace_back(dep_data.parent, dep_data.child, dep_idx);
             }
-        };
-
-        /** The queue of work items. */
-        VecDeque<WorkItem> queue;
-        queue.reserve(std::max<size_t>(256, 2 * m_todo.Count()));
-
-        // Create initial entries per connected component of m_todo. While clusters themselves are
-        // generally connected, this is not necessarily true after some parts have already been
-        // removed from m_todo. Without this, effort can be wasted on searching "inc" sets that
-        // span multiple components.
-        auto to_cover = m_todo;
-        do {
-            auto component = m_sorted_depgraph.FindConnectedComponent(to_cover);
-            to_cover -= component;
-            // If best is not provided, set it to the first component, so that during the work
-            // processing loop below, and during the add_fn/split_fn calls, we do not need to deal
-            // with the best=empty case.
-            if (best.feerate.IsEmpty()) best = SetInfo(m_sorted_depgraph, component);
-            queue.emplace_back(/*inc=*/SetInfo<SetType>{},
-                               /*und=*/std::move(component),
-                               /*pot_feerate=*/FeeFrac{});
-        } while (to_cover.Any());
-
-        /** Local copy of the iteration limit. */
-        uint64_t iterations_left = max_iterations;
-
-        /** The set of transactions in m_todo which have feerate > best's. */
-        SetType imp = m_todo;
-        while (imp.Any()) {
-            DepGraphIndex check = imp.Last();
-            if (m_sorted_depgraph.FeeRate(check) >> best.feerate) break;
-            imp.Reset(check);
+        }
+        std::sort(expected_dependencies.begin(), expected_dependencies.end());
+        std::sort(all_dependencies.begin(), all_dependencies.end());
+        assert(expected_dependencies.size() == all_dependencies.size());
+        for (size_t i = 0; i < expected_dependencies.size(); ++i) {
+            assert(expected_dependencies[i] ==
+                   std::make_pair(std::get<0>(all_dependencies[i]),
+                                  std::get<1>(all_dependencies[i])));
         }
 
-        /** Internal function to add an item to the queue of elements to explore if there are any
-         *  transactions left to split on, possibly improving it before doing so, and to update
-         *  best/imp.
-         *
-         * - inc: the "inc" value for the new work item (must be topological).
-         * - und: the "und" value for the new work item ((inc | und) must be topological).
-         */
-        auto add_fn = [&](SetInfo<SetType> inc, SetType und) noexcept {
-            /** SetInfo object with the set whose feerate will become the new work item's
-             *  pot_feerate. It starts off equal to inc. */
-            auto pot = inc;
-            if (!inc.feerate.IsEmpty()) {
-                // Add entries to pot. We iterate over all undecided transactions whose feerate is
-                // higher than best. While undecided transactions of lower feerate may improve pot,
-                // the resulting pot feerate cannot possibly exceed best's (and this item will be
-                // skipped in split_fn anyway).
-                for (auto pos : imp & und) {
-                    // Determine if adding transaction pos to pot (ignoring topology) would improve
-                    // it. If not, we're done updating pot. This relies on the fact that
-                    // m_sorted_depgraph, and thus the transactions iterated over, are in decreasing
-                    // individual feerate order.
-                    if (!(m_sorted_depgraph.FeeRate(pos) >> pot.feerate)) break;
-                    pot.Set(m_sorted_depgraph, pos);
-                }
-
-                // The "jump ahead" optimization: whenever pot has a topologically-valid subset,
-                // that subset can be added to inc. Any subset of (pot - inc) has the property that
-                // its feerate exceeds that of any set compatible with this work item (superset of
-                // inc, subset of (inc | und)). Thus, if T is a topological subset of pot, and B is
-                // the best topologically-valid set compatible with this work item, and (T - B) is
-                // non-empty, then (T | B) is better than B and also topological. This is in
-                // contradiction with the assumption that B is best. Thus, (T - B) must be empty,
-                // or T must be a subset of B.
-                //
-                // See https://delvingbitcoin.org/t/how-to-linearize-your-cluster/303 section 2.4.
-                const auto init_inc = inc.transactions;
-                for (auto pos : pot.transactions - inc.transactions) {
-                    // If the transaction's ancestors are a subset of pot, we can add it together
-                    // with its ancestors to inc. Just update the transactions here; the feerate
-                    // update happens below.
-                    auto anc_todo = m_sorted_depgraph.Ancestors(pos) & m_todo;
-                    if (anc_todo.IsSubsetOf(pot.transactions)) inc.transactions |= anc_todo;
+        //
+        // Verify the chunks against the list of active dependencies
+        //
+        for (auto tx_idx: depgraph.Positions()) {
+            // Only process chunks for now.
+            if (m_tx_data[tx_idx].chunk_rep == tx_idx) {
+                const auto& chunk_data = m_tx_data[tx_idx];
+                // Verify that transactions in the chunk point back to it. This guarantees
+                // that chunks are non-overlapping.
+                for (auto chunk_tx : chunk_data.chunk_setinfo.transactions) {
+                    assert(m_tx_data[chunk_tx].chunk_rep == tx_idx);
                 }
-                // Finally update und and inc's feerate to account for the added transactions.
-                und -= inc.transactions;
-                inc.feerate += m_sorted_depgraph.FeeRate(inc.transactions - init_inc);
-
-                // If inc's feerate is better than best's, remember it as our new best.
-                if (inc.feerate > best.feerate) {
-                    best = inc;
-                    // See if we can remove any entries from imp now.
-                    while (imp.Any()) {
-                        DepGraphIndex check = imp.Last();
-                        if (m_sorted_depgraph.FeeRate(check) >> best.feerate) break;
-                        imp.Reset(check);
+                // Verify the chunk's transaction set: it must contain the representative, and for
+                // every active dependency, if it contains the parent or child, it must contain
+                // both. It must have exactly N-1 active dependencies in it, guaranteeing it is
+                // acyclic.
+                SetType expected_chunk = SetType::Singleton(tx_idx);
+                while (true) {
+                    auto old = expected_chunk;
+                    size_t active_dep_count{0};
+                    for (const auto& [par, chl, _dep] : active_dependencies) {
+                        if (expected_chunk[par] || expected_chunk[chl]) {
+                            expected_chunk.Set(par);
+                            expected_chunk.Set(chl);
+                            ++active_dep_count;
+                        }
+                    }
+                    if (old == expected_chunk) {
+                        assert(expected_chunk.Count() == active_dep_count + 1);
+                        break;
                     }
                 }
-
-                // If no potential transactions exist beyond the already included ones, no
-                // improvement is possible anymore.
-                if (pot.feerate.size == inc.feerate.size) return;
-                // At this point und must be non-empty. If it were empty then pot would equal inc.
-                Assume(und.Any());
-            } else {
-                Assume(inc.transactions.None());
-                // If inc is empty, we just make sure there are undecided transactions left to
-                // split on.
-                if (und.None()) return;
-            }
-
-            // Actually construct a new work item on the queue. Due to the switch to DFS when queue
-            // space runs out (see below), we know that no reallocation of the queue should ever
-            // occur.
-            Assume(queue.size() < queue.capacity());
-            queue.emplace_back(/*inc=*/std::move(inc),
-                               /*und=*/std::move(und),
-                               /*pot_feerate=*/std::move(pot.feerate));
-        };
-
-        /** Internal process function. It takes an existing work item, and splits it in two: one
-         *  with a particular transaction (and its ancestors) included, and one with that
-         *  transaction (and its descendants) excluded. */
-        auto split_fn = [&](WorkItem&& elem) noexcept {
-            // Any queue element must have undecided transactions left, otherwise there is nothing
-            // to explore anymore.
-            Assume(elem.und.Any());
-            // The included and undecided set are all subsets of m_todo.
-            Assume(elem.inc.transactions.IsSubsetOf(m_todo) && elem.und.IsSubsetOf(m_todo));
-            // Included transactions cannot be undecided.
-            Assume(!elem.inc.transactions.Overlaps(elem.und));
-            // If pot is empty, then so is inc.
-            Assume(elem.inc.feerate.IsEmpty() == elem.pot_feerate.IsEmpty());
-
-            const DepGraphIndex first = elem.und.First();
-            if (!elem.inc.feerate.IsEmpty()) {
-                // If no undecided transactions remain with feerate higher than best, this entry
-                // cannot be improved beyond best.
-                if (!elem.und.Overlaps(imp)) return;
-                // We can ignore any queue item whose potential feerate isn't better than the best
-                // seen so far.
-                if (elem.pot_feerate <= best.feerate) return;
-            } else {
-                // In case inc is empty use a simpler alternative check.
-                if (m_sorted_depgraph.FeeRate(first) <= best.feerate) return;
+                assert(chunk_data.chunk_setinfo.transactions == expected_chunk);
+                // Verify the chunk's feerate.
+                assert(chunk_data.chunk_setinfo.feerate ==
+                       depgraph.FeeRate(chunk_data.chunk_setinfo.transactions));
             }
+        }
 
-            // Decide which transaction to split on. Splitting is how new work items are added, and
-            // how progress is made. One split transaction is chosen among the queue item's
-            // undecided ones, and:
-            // - A work item is (potentially) added with that transaction plus its remaining
-            //   descendants excluded (removed from the und set).
-            // - A work item is (potentially) added with that transaction plus its remaining
-            //   ancestors included (added to the inc set).
-            //
-            // To decide what to split on, consider the undecided ancestors of the highest
-            // individual feerate undecided transaction. Pick the one which reduces the search space
-            // most. Let I(t) be the size of the undecided set after including t, and E(t) the size
-            // of the undecided set after excluding t. Then choose the split transaction t such
-            // that 2^I(t) + 2^E(t) is minimal, tie-breaking by highest individual feerate for t.
-            DepGraphIndex split = 0;
-            const auto select = elem.und & m_sorted_depgraph.Ancestors(first);
-            Assume(select.Any());
-            std::optional<std::pair<DepGraphIndex, DepGraphIndex>> split_counts;
-            for (auto t : select) {
-                // Call max = max(I(t), E(t)) and min = min(I(t), E(t)). Let counts = {max,min}.
-                // Sorting by the tuple counts is equivalent to sorting by 2^I(t) + 2^E(t). This
-                // expression is equal to 2^max + 2^min = 2^max * (1 + 1/2^(max - min)). The second
-                // factor (1 + 1/2^(max - min)) there is in (1,2]. Thus increasing max will always
-                // increase it, even when min decreases. Because of this, we can first sort by max.
-                std::pair<DepGraphIndex, DepGraphIndex> counts{
-                    (elem.und - m_sorted_depgraph.Ancestors(t)).Count(),
-                    (elem.und - m_sorted_depgraph.Descendants(t)).Count()};
-                if (counts.first < counts.second) std::swap(counts.first, counts.second);
-                // Remember the t with the lowest counts.
-                if (!split_counts.has_value() || counts < *split_counts) {
-                    split = t;
-                    split_counts = counts;
+        //
+        // Verify other transaction data.
+        //
+        assert(m_transaction_idxs == depgraph.Positions());
+        for (auto tx_idx : m_transaction_idxs) {
+            const auto& tx_data = m_tx_data[tx_idx];
+            // Verify it has a valid chunk representative, and that chunk includes this
+            // transaction.
+            assert(m_tx_data[tx_data.chunk_rep].chunk_rep == tx_data.chunk_rep);
+            assert(m_tx_data[tx_data.chunk_rep].chunk_setinfo.transactions[tx_idx]);
+            // Verify parents/children.
+            assert(tx_data.parents == depgraph.GetReducedParents(tx_idx));
+            assert(tx_data.children == depgraph.GetReducedChildren(tx_idx));
+            // Verify list of child dependencies.
+            std::vector<DepIdx> expected_child_deps;
+            for (const auto& [par_idx, chl_idx, dep_idx] : all_dependencies) {
+                if (tx_idx == par_idx) {
+                    assert(tx_data.children[chl_idx]);
+                    expected_child_deps.push_back(dep_idx);
                 }
             }
-            // Since there was at least one transaction in select, we must always find one.
-            Assume(split_counts.has_value());
-
-            // Add a work item corresponding to exclusion of the split transaction.
-            const auto& desc = m_sorted_depgraph.Descendants(split);
-            add_fn(/*inc=*/elem.inc,
-                   /*und=*/elem.und - desc);
-
-            // Add a work item corresponding to inclusion of the split transaction.
-            const auto anc = m_sorted_depgraph.Ancestors(split) & m_todo;
-            add_fn(/*inc=*/elem.inc.Add(m_sorted_depgraph, anc),
-                   /*und=*/elem.und - anc);
-
-            // Account for the performed split.
-            --iterations_left;
-        };
+            std::sort(expected_child_deps.begin(), expected_child_deps.end());
+            auto child_deps_copy = tx_data.child_deps;
+            std::sort(child_deps_copy.begin(), child_deps_copy.end());
+            assert(expected_child_deps == child_deps_copy);
+        }
 
-        // Work processing loop.
-        //
-        // New work items are always added at the back of the queue, but items to process use a
-        // hybrid approach where they can be taken from the front or the back.
         //
-        // Depth-first search (DFS) corresponds to always taking from the back of the queue. This
-        // is very memory-efficient (linear in the number of transactions). Breadth-first search
-        // (BFS) corresponds to always taking from the front, which potentially uses more memory
-        // (up to exponential in the transaction count), but seems to work better in practice.
+        // Verify active dependencies' top_setinfo.
         //
-        // The approach here combines the two: use BFS (plus random swapping) until the queue grows
-        // too large, at which point we temporarily switch to DFS until the size shrinks again.
-        while (!queue.empty()) {
-            // Randomly swap the first two items to randomize the search order.
-            if (queue.size() > 1 && m_rng.randbool()) {
-                queue[0].Swap(queue[1]);
-            }
-
-            // Processing the first queue item, and then using DFS for everything it gives rise to,
-            // may increase the queue size by the number of undecided elements in there, minus 1
-            // for the first queue item being removed. Thus, only when that pushes the queue over
-            // its capacity can we not process from the front (BFS), and should we use DFS.
-            while (queue.size() - 1 + queue.front().und.Count() > queue.capacity()) {
-                if (!iterations_left) break;
-                auto elem = queue.back();
-                queue.pop_back();
-                split_fn(std::move(elem));
+        for (const auto& [par_idx, chl_idx, dep_idx] : active_dependencies) {
+            const auto& dep_data = m_dep_data[dep_idx];
+            // Verify the top_info's transactions: it must contain the parent, and for every
+            // active dependency, except dep_idx itself, if it contains the parent or child, it
+            // must contain both.
+            SetType expected_top = SetType::Singleton(par_idx);
+            while (true) {
+                auto old = expected_top;
+                for (const auto& [par2_idx, chl2_idx, dep2_idx] : active_dependencies) {
+                    if (dep2_idx != dep_idx && (expected_top[par2_idx] || expected_top[chl2_idx])) {
+                        expected_top.Set(par2_idx);
+                        expected_top.Set(chl2_idx);
+                    }
+                }
+                if (old == expected_top) break;
             }
-
-            // Process one entry from the front of the queue (BFS exploration)
-            if (!iterations_left) break;
-            auto elem = queue.front();
-            queue.pop_front();
-            split_fn(std::move(elem));
+            assert(!expected_top[chl_idx]);
+            assert(dep_data.top_setinfo.transactions == expected_top);
+            // Verify the top_info's feerate.
+            assert(dep_data.top_setinfo.feerate ==
+                   depgraph.FeeRate(dep_data.top_setinfo.transactions));
         }
 
-        // Return the found best set (converted to the original transaction indices), and the
-        // number of iterations performed.
-        best.transactions = SortedToOriginal(best.transactions);
-        return {std::move(best), max_iterations - iterations_left};
-    }
-
-    /** Remove a subset of transactions from the cluster being linearized.
-     *
-     * Complexity: O(N) where N=done.Count().
-     */
-    void MarkDone(const SetType& done) noexcept
-    {
-        const auto done_sorted = OriginalToSorted(done);
-        Assume(done_sorted.Any());
-        Assume(done_sorted.IsSubsetOf(m_todo));
-        m_todo -= done_sorted;
+        //
+        // Verify m_suboptimal_chunks.
+        //
+        for (size_t i = 0; i < m_suboptimal_chunks.size(); ++i) {
+            auto tx_idx = m_suboptimal_chunks[i];
+            assert(m_transaction_idxs[tx_idx]);
+        }
     }
 };
 
 /** Find or improve a linearization for a cluster.
  *
  * @param[in] depgraph            Dependency graph of the cluster to be linearized.
- * @param[in] max_iterations      Upper bound on the number of optimization steps that will be done.
+ * @param[in] max_iterations      Upper bound on the amount of work that will be done.
  * @param[in] rng_seed            A random number seed to control search order. This prevents peers
  *                                from predicting exactly which clusters would be hard for us to
  *                                linearize.
@@ -1048,85 +1346,30 @@ class SearchCandidateFinder
  *                                - A boolean indicating whether the result is guaranteed to be
  *                                  optimal.
  *                                - How many optimization steps were actually performed.
- *
- * Complexity: possibly O(N * min(max_iterations + N, sqrt(2^N))) where N=depgraph.TxCount().
  */
 template<typename SetType>
 std::tuple<std::vector<DepGraphIndex>, bool, uint64_t> Linearize(const DepGraph<SetType>& depgraph, uint64_t max_iterations, uint64_t rng_seed, std::span<const DepGraphIndex> old_linearization = {}) noexcept
 {
-    Assume(old_linearization.empty() || old_linearization.size() == depgraph.TxCount());
-    if (depgraph.TxCount() == 0) return {{}, true, 0};
-
-    uint64_t iterations_left = max_iterations;
-    std::vector<DepGraphIndex> linearization;
-
-    AncestorCandidateFinder anc_finder(depgraph);
-    std::optional<SearchCandidateFinder<SetType>> src_finder;
-    linearization.reserve(depgraph.TxCount());
-    bool optimal = true;
-
-    // Treat the initialization of SearchCandidateFinder as taking N^2/64 (rounded up) iterations
-    // (largely due to the cost of constructing the internal sorted-by-feerate DepGraph inside
-    // SearchCandidateFinder), a rough approximation based on benchmark. If we don't have that
-    // many, don't start it.
-    uint64_t start_iterations = (uint64_t{depgraph.TxCount()} * depgraph.TxCount() + 63) / 64;
-    if (iterations_left > start_iterations) {
-        iterations_left -= start_iterations;
-        src_finder.emplace(depgraph, rng_seed);
+    /** Initialize a spanning forest data structure for this cluster. */
+    SpanningForestState forest(depgraph, rng_seed);
+    if (!old_linearization.empty()) {
+        forest.LoadLinearization(old_linearization);
+    } else {
+        forest.MakeTopological();
     }
-
-    /** Chunking of what remains of the old linearization. */
-    LinearizationChunking old_chunking(depgraph, old_linearization);
-
-    while (true) {
-        // Find the highest-feerate prefix of the remainder of old_linearization.
-        SetInfo<SetType> best_prefix;
-        if (old_chunking.NumChunksLeft()) best_prefix = old_chunking.GetChunk(0);
-
-        // Then initialize best to be either the best remaining ancestor set, or the first chunk.
-        auto best = anc_finder.FindCandidateSet();
-        if (!best_prefix.feerate.IsEmpty() && best_prefix.feerate >= best.feerate) best = best_prefix;
-
-        uint64_t iterations_done_now = 0;
-        uint64_t max_iterations_now = 0;
-        if (src_finder) {
-            // Treat the invocation of SearchCandidateFinder::FindCandidateSet() as costing N/4
-            // up-front (rounded up) iterations (largely due to the cost of connected-component
-            // splitting), a rough approximation based on benchmarks.
-            uint64_t base_iterations = (anc_finder.NumRemaining() + 3) / 4;
-            if (iterations_left > base_iterations) {
-                // Invoke bounded search to update best, with up to half of our remaining
-                // iterations as limit.
-                iterations_left -= base_iterations;
-                max_iterations_now = (iterations_left + 1) / 2;
-                std::tie(best, iterations_done_now) = src_finder->FindCandidateSet(max_iterations_now, best);
-                iterations_left -= iterations_done_now;
-            }
-        }
-
-        if (iterations_done_now == max_iterations_now) {
-            optimal = false;
-            // If the search result is not (guaranteed to be) optimal, run intersections to make
-            // sure we don't pick something that makes us unable to reach further diagram points
-            // of the old linearization.
-            if (old_chunking.NumChunksLeft() > 0) {
-                best = old_chunking.IntersectPrefixes(best);
+    // Make improvement steps to it until we hit the max_iterations limit, or an optimal result
+    // is found.
+    bool optimal = false;
+    if (forest.GetCost() < max_iterations) {
+        forest.StartOptimizing();
+        do {
+            if (!forest.OptimizeStep()) {
+                optimal = true;
+                break;
             }
-        }
-
-        // Add to output in topological order.
-        depgraph.AppendTopo(linearization, best.transactions);
-
-        // Update state to reflect best is no longer to be linearized.
-        anc_finder.MarkDone(best.transactions);
-        if (anc_finder.AllDone()) break;
-        if (src_finder) src_finder->MarkDone(best.transactions);
-        if (old_chunking.NumChunksLeft() > 0) {
-            old_chunking.MarkDone(best.transactions);
-        }
+        } while (forest.GetCost() < max_iterations);
     }
-
-    return {std::move(linearization), optimal, max_iterations - iterations_left};
+    return {forest.GetLinearization(), optimal, forest.GetCost()};
 }
 
 /** Improve a given linearization.
@@ -1330,48 +1573,6 @@ void PostLinearize(const DepGraph<SetType>& depgraph, std::span<DepGraphIndex> l
     }
 }
 
-/** Merge two linearizations for the same cluster into one that is as good as both.
- *
- * Complexity: O(N^2) where N=depgraph.TxCount(); O(N) if both inputs are identical.
- */
-template<typename SetType>
-std::vector<DepGraphIndex> MergeLinearizations(const DepGraph<SetType>& depgraph, std::span<const DepGraphIndex> lin1, std::span<const DepGraphIndex> lin2)
-{
-    Assume(lin1.size() == depgraph.TxCount());
-    Assume(lin2.size() == depgraph.TxCount());
-
-    /** Chunkings of what remains of both input linearizations. */
-    LinearizationChunking chunking1(depgraph, lin1), chunking2(depgraph, lin2);
-    /** Output linearization. */
-    std::vector<DepGraphIndex> ret;
-    if (depgraph.TxCount() == 0) return ret;
-    ret.reserve(depgraph.TxCount());
-
-    while (true) {
-        // As long as we are not done, both linearizations must have chunks left.
-        Assume(chunking1.NumChunksLeft() > 0);
-        Assume(chunking2.NumChunksLeft() > 0);
-        // Find the set to output by taking the best remaining chunk, and then intersecting it with
-        // prefixes of remaining chunks of the other linearization.
-        SetInfo<SetType> best;
-        const auto& lin1_firstchunk = chunking1.GetChunk(0);
-        const auto& lin2_firstchunk = chunking2.GetChunk(0);
-        if (lin2_firstchunk.feerate >> lin1_firstchunk.feerate) {
-            best = chunking1.IntersectPrefixes(lin2_firstchunk);
-        } else {
-            best = chunking2.IntersectPrefixes(lin1_firstchunk);
-        }
-        // Append the result to the output and mark it as done.
-        depgraph.AppendTopo(ret, best.transactions);
-        chunking1.MarkDone(best.transactions);
-        if (chunking1.NumChunksLeft() == 0) break;
-        chunking2.MarkDone(best.transactions);
-    }
-
-    Assume(ret.size() == depgraph.TxCount());
-    return ret;
-}
-
 /** Make linearization topological, retaining its ordering where possible. */
 template<typename SetType>
 void FixLinearization(const DepGraph<SetType>& depgraph, std::span<DepGraphIndex> linearization) noexcept
diff --git a/depend/bitcoin/src/coins.cpp b/depend/bitcoin/src/coins.cpp
index 1ca5fca3..14381ecb 100644
--- a/depend/bitcoin/src/coins.cpp
+++ b/depend/bitcoin/src/coins.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/common/args.cpp b/depend/bitcoin/src/common/args.cpp
index 88a28edc..3ffa4d3f 100644
--- a/depend/bitcoin/src/common/args.cpp
+++ b/depend/bitcoin/src/common/args.cpp
@@ -164,7 +164,7 @@ std::list<SectionInfo> ArgsManager::GetUnrecognizedSections() const
 
     LOCK(cs_args);
     std::list<SectionInfo> unrecognized = m_config_sections;
-    unrecognized.remove_if([](const SectionInfo& appeared){ return available_sections.find(appeared.m_name) != available_sections.end(); });
+    unrecognized.remove_if([](const SectionInfo& appeared){ return available_sections.contains(appeared.m_name); });
     return unrecognized;
 }
 
@@ -832,7 +832,7 @@ std::variant<ChainType, std::string> ArgsManager::GetChainArg() const
 
 bool ArgsManager::UseDefaultSection(const std::string& arg) const
 {
-    return m_network == ChainTypeToString(ChainType::MAIN) || m_network_only_args.count(arg) == 0;
+    return m_network == ChainTypeToString(ChainType::MAIN) || !m_network_only_args.contains(arg);
 }
 
 common::SettingsValue ArgsManager::GetSetting(const std::string& arg) const
diff --git a/depend/bitcoin/src/common/config.cpp b/depend/bitcoin/src/common/config.cpp
index 79c0424a..a2cf9381 100644
--- a/depend/bitcoin/src/common/config.cpp
+++ b/depend/bitcoin/src/common/config.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/common/init.cpp b/depend/bitcoin/src/common/init.cpp
index 5a704404..7a1d664c 100644
--- a/depend/bitcoin/src/common/init.cpp
+++ b/depend/bitcoin/src/common/init.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/common/init.h b/depend/bitcoin/src/common/init.h
index 380ac3ac..2d3eacd2 100644
--- a/depend/bitcoin/src/common/init.h
+++ b/depend/bitcoin/src/common/init.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/common/interfaces.cpp b/depend/bitcoin/src/common/interfaces.cpp
index c8bbe2b3..ffd85e61 100644
--- a/depend/bitcoin/src/common/interfaces.cpp
+++ b/depend/bitcoin/src/common/interfaces.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/common/messages.cpp b/depend/bitcoin/src/common/messages.cpp
index 983c9826..123db93c 100644
--- a/depend/bitcoin/src/common/messages.cpp
+++ b/depend/bitcoin/src/common/messages.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/common/messages.h b/depend/bitcoin/src/common/messages.h
index 5d33edac..4cabdc79 100644
--- a/depend/bitcoin/src/common/messages.h
+++ b/depend/bitcoin/src/common/messages.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/common/netif.cpp b/depend/bitcoin/src/common/netif.cpp
index ed891f12..cba4d4e7 100644
--- a/depend/bitcoin/src/common/netif.cpp
+++ b/depend/bitcoin/src/common/netif.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2024 The Bitcoin Core developers
+// Copyright (c) 2024-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/common/netif.h b/depend/bitcoin/src/common/netif.h
index 55bc023b..769bcbcc 100644
--- a/depend/bitcoin/src/common/netif.h
+++ b/depend/bitcoin/src/common/netif.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2024 The Bitcoin Core developers
+// Copyright (c) 2024-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/common/pcp.h b/depend/bitcoin/src/common/pcp.h
index b3e36d13..121349b0 100644
--- a/depend/bitcoin/src/common/pcp.h
+++ b/depend/bitcoin/src/common/pcp.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2024 The Bitcoin Core developers
+// Copyright (c) 2024-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/common/run_command.cpp b/depend/bitcoin/src/common/run_command.cpp
index 1f6d51b4..57683e03 100644
--- a/depend/bitcoin/src/common/run_command.cpp
+++ b/depend/bitcoin/src/common/run_command.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/common/run_command.h b/depend/bitcoin/src/common/run_command.h
index 2fbdc071..56c94f83 100644
--- a/depend/bitcoin/src/common/run_command.h
+++ b/depend/bitcoin/src/common/run_command.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/common/settings.cpp b/depend/bitcoin/src/common/settings.cpp
index fbe531c7..e9b92979 100644
--- a/depend/bitcoin/src/common/settings.cpp
+++ b/depend/bitcoin/src/common/settings.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/common/settings.h b/depend/bitcoin/src/common/settings.h
index 0e9d376e..bc7b89a9 100644
--- a/depend/bitcoin/src/common/settings.h
+++ b/depend/bitcoin/src/common/settings.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/common/signmessage.cpp b/depend/bitcoin/src/common/signmessage.cpp
index 1612751e..a86310e1 100644
--- a/depend/bitcoin/src/common/signmessage.cpp
+++ b/depend/bitcoin/src/common/signmessage.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/common/signmessage.h b/depend/bitcoin/src/common/signmessage.h
index 215b563b..4533875a 100644
--- a/depend/bitcoin/src/common/signmessage.h
+++ b/depend/bitcoin/src/common/signmessage.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/common/types.h b/depend/bitcoin/src/common/types.h
index fb9ee4bf..7b5da0fc 100644
--- a/depend/bitcoin/src/common/types.h
+++ b/depend/bitcoin/src/common/types.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2010-2021 The Bitcoin Core developers
+// Copyright (c) 2010-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.
 
diff --git a/depend/bitcoin/src/common/url.cpp b/depend/bitcoin/src/common/url.cpp
index ecf88d07..30ac26a1 100644
--- a/depend/bitcoin/src/common/url.cpp
+++ b/depend/bitcoin/src/common/url.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/common/url.h b/depend/bitcoin/src/common/url.h
index 203f41c7..718a607f 100644
--- a/depend/bitcoin/src/common/url.h
+++ b/depend/bitcoin/src/common/url.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/compat/assumptions.h b/depend/bitcoin/src/compat/assumptions.h
index 7b66ab1b..9910c95d 100644
--- a/depend/bitcoin/src/compat/assumptions.h
+++ b/depend/bitcoin/src/compat/assumptions.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/compat/byteswap.h b/depend/bitcoin/src/compat/byteswap.h
index 0d0b0792..ec961503 100644
--- a/depend/bitcoin/src/compat/byteswap.h
+++ b/depend/bitcoin/src/compat/byteswap.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2022 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/compat/compat.h b/depend/bitcoin/src/compat/compat.h
index acb57b26..b7fe6b98 100644
--- a/depend/bitcoin/src/compat/compat.h
+++ b/depend/bitcoin/src/compat/compat.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/compat/cpuid.h b/depend/bitcoin/src/compat/cpuid.h
index 4237c8eb..1dddc1ea 100644
--- a/depend/bitcoin/src/compat/cpuid.h
+++ b/depend/bitcoin/src/compat/cpuid.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/compat/endian.h b/depend/bitcoin/src/compat/endian.h
index 4f584281..1553056a 100644
--- a/depend/bitcoin/src/compat/endian.h
+++ b/depend/bitcoin/src/compat/endian.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2022 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/compat/stdin.cpp b/depend/bitcoin/src/compat/stdin.cpp
index c11763f6..20540f2a 100644
--- a/depend/bitcoin/src/compat/stdin.cpp
+++ b/depend/bitcoin/src/compat/stdin.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/compat/stdin.h b/depend/bitcoin/src/compat/stdin.h
index 468fe4d6..1b74c7f9 100644
--- a/depend/bitcoin/src/compat/stdin.h
+++ b/depend/bitcoin/src/compat/stdin.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/compressor.cpp b/depend/bitcoin/src/compressor.cpp
index 668e2558..ad5859c4 100644
--- a/depend/bitcoin/src/compressor.cpp
+++ b/depend/bitcoin/src/compressor.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/consensus/amount.h b/depend/bitcoin/src/consensus/amount.h
index f0eb4e07..2a65a831 100644
--- a/depend/bitcoin/src/consensus/amount.h
+++ b/depend/bitcoin/src/consensus/amount.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/consensus/merkle.cpp b/depend/bitcoin/src/consensus/merkle.cpp
index 703a824e..84ff352d 100644
--- a/depend/bitcoin/src/consensus/merkle.cpp
+++ b/depend/bitcoin/src/consensus/merkle.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2020 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/consensus/merkle.h b/depend/bitcoin/src/consensus/merkle.h
index 29282d21..03b5a1b5 100644
--- a/depend/bitcoin/src/consensus/merkle.h
+++ b/depend/bitcoin/src/consensus/merkle.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2019 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/consensus/params.h b/depend/bitcoin/src/consensus/params.h
index f33ff15f..93ee071f 100644
--- a/depend/bitcoin/src/consensus/params.h
+++ b/depend/bitcoin/src/consensus/params.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/consensus/tx_check.cpp b/depend/bitcoin/src/consensus/tx_check.cpp
index b3fee1e8..251417c8 100644
--- a/depend/bitcoin/src/consensus/tx_check.cpp
+++ b/depend/bitcoin/src/consensus/tx_check.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2021 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/consensus/tx_check.h b/depend/bitcoin/src/consensus/tx_check.h
index 21f84240..faaeca93 100644
--- a/depend/bitcoin/src/consensus/tx_check.h
+++ b/depend/bitcoin/src/consensus/tx_check.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2019 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/consensus/tx_verify.cpp b/depend/bitcoin/src/consensus/tx_verify.cpp
index c38b9643..00022a33 100644
--- a/depend/bitcoin/src/consensus/tx_verify.cpp
+++ b/depend/bitcoin/src/consensus/tx_verify.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2021 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/consensus/validation.h b/depend/bitcoin/src/consensus/validation.h
index 2b2dd4bb..37a40e76 100644
--- a/depend/bitcoin/src/consensus/validation.h
+++ b/depend/bitcoin/src/consensus/validation.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/core_io.h b/depend/bitcoin/src/core_io.h
index 1874c93a..f768590c 100644
--- a/depend/bitcoin/src/core_io.h
+++ b/depend/bitcoin/src/core_io.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/core_memusage.h b/depend/bitcoin/src/core_memusage.h
index 6f1ace99..e96cd734 100644
--- a/depend/bitcoin/src/core_memusage.h
+++ b/depend/bitcoin/src/core_memusage.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2018 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/core_read.cpp b/depend/bitcoin/src/core_read.cpp
index 27d0d9d7..935f4659 100644
--- a/depend/bitcoin/src/core_read.cpp
+++ b/depend/bitcoin/src/core_read.cpp
@@ -1,20 +1,30 @@
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <core_io.h>
 
-#include <primitives/block.h>
+#include <primitives/block.h> // IWYU pragma: keep
 #include <primitives/transaction.h>
+#include <script/interpreter.h>
 #include <script/script.h>
-#include <script/sign.h>
 #include <serialize.h>
 #include <streams.h>
 #include <util/result.h>
 #include <util/strencodings.h>
+#include <util/string.h>
+#include <util/translation.h>
 
 #include <algorithm>
-#include <string>
+#include <compare>
+#include <cstdint>
+#include <exception>
+#include <map>
+#include <optional>
+#include <span>
+#include <stdexcept>
+#include <utility>
+#include <vector>
 
 using util::SplitString;
 
diff --git a/depend/bitcoin/src/core_write.cpp b/depend/bitcoin/src/core_write.cpp
index d805cfda..e4f23458 100644
--- a/depend/bitcoin/src/core_write.cpp
+++ b/depend/bitcoin/src/core_write.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/crypto/aes.h b/depend/bitcoin/src/crypto/aes.h
index 3a0011be..4eae9a3b 100644
--- a/depend/bitcoin/src/crypto/aes.h
+++ b/depend/bitcoin/src/crypto/aes.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2019 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 //
diff --git a/depend/bitcoin/src/crypto/hex_base.cpp b/depend/bitcoin/src/crypto/hex_base.cpp
index 7098aba7..f8b1ca2f 100644
--- a/depend/bitcoin/src/crypto/hex_base.cpp
+++ b/depend/bitcoin/src/crypto/hex_base.cpp
@@ -8,7 +8,6 @@
 #include <cassert>
 #include <cstring>
 #include <string>
-#include <tuple>
 
 namespace {
 
diff --git a/depend/bitcoin/src/crypto/sha256.cpp b/depend/bitcoin/src/crypto/sha256.cpp
index 8ad9a85d..54bd9a59 100644
--- a/depend/bitcoin/src/crypto/sha256.cpp
+++ b/depend/bitcoin/src/crypto/sha256.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2022 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/crypto/sha256_arm_shani.cpp b/depend/bitcoin/src/crypto/sha256_arm_shani.cpp
index a778e871..2eaa6655 100644
--- a/depend/bitcoin/src/crypto/sha256_arm_shani.cpp
+++ b/depend/bitcoin/src/crypto/sha256_arm_shani.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 //
diff --git a/depend/bitcoin/src/dbwrapper.cpp b/depend/bitcoin/src/dbwrapper.cpp
index 608f61f0..b3f08cb2 100644
--- a/depend/bitcoin/src/dbwrapper.cpp
+++ b/depend/bitcoin/src/dbwrapper.cpp
@@ -214,7 +214,7 @@ struct LevelDBContext {
 };
 
 CDBWrapper::CDBWrapper(const DBParams& params)
-    : m_db_context{std::make_unique<LevelDBContext>()}, m_name{fs::PathToString(params.path.stem())}, m_path{params.path}, m_is_memory{params.memory_only}
+    : m_db_context{std::make_unique<LevelDBContext>()}, m_name{fs::PathToString(params.path.stem())}
 {
     DBContext().penv = nullptr;
     DBContext().readoptions.verify_checksums = true;
diff --git a/depend/bitcoin/src/dbwrapper.h b/depend/bitcoin/src/dbwrapper.h
index c770df8e..b2ce67c7 100644
--- a/depend/bitcoin/src/dbwrapper.h
+++ b/depend/bitcoin/src/dbwrapper.h
@@ -191,12 +191,6 @@ class CDBWrapper
     //! obfuscation key storage key, null-prefixed to avoid collisions
     inline static const std::string OBFUSCATION_KEY{"\000obfuscate_key", 14}; // explicit size to avoid truncation at leading \0
 
-    //! path to filesystem storage
-    const fs::path m_path;
-
-    //! whether or not the database resides in memory
-    bool m_is_memory;
-
     std::optional<std::string> ReadImpl(std::span<const std::byte> key) const;
     bool ExistsImpl(std::span<const std::byte> key) const;
     size_t EstimateSizeImpl(std::span<const std::byte> key1, std::span<const std::byte> key2) const;
@@ -237,14 +231,6 @@ class CDBWrapper
         WriteBatch(batch, fSync);
     }
 
-    //! @returns filesystem path to the on-disk data.
-    std::optional<fs::path> StoragePath() {
-        if (m_is_memory) {
-            return {};
-        }
-        return m_path;
-    }
-
     template <typename K>
     bool Exists(const K& key) const
     {
diff --git a/depend/bitcoin/src/deploymentinfo.cpp b/depend/bitcoin/src/deploymentinfo.cpp
index 5c479550..e1447d4d 100644
--- a/depend/bitcoin/src/deploymentinfo.cpp
+++ b/depend/bitcoin/src/deploymentinfo.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/deploymentinfo.h b/depend/bitcoin/src/deploymentinfo.h
index 3178ea74..875505c1 100644
--- a/depend/bitcoin/src/deploymentinfo.h
+++ b/depend/bitcoin/src/deploymentinfo.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/deploymentstatus.cpp b/depend/bitcoin/src/deploymentstatus.cpp
index 46fd70bc..b3976013 100644
--- a/depend/bitcoin/src/deploymentstatus.cpp
+++ b/depend/bitcoin/src/deploymentstatus.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/deploymentstatus.h b/depend/bitcoin/src/deploymentstatus.h
index 97ff8dee..921c7c18 100644
--- a/depend/bitcoin/src/deploymentstatus.h
+++ b/depend/bitcoin/src/deploymentstatus.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/dummywallet.cpp b/depend/bitcoin/src/dummywallet.cpp
index 7c1934fa..85fb1ed1 100644
--- a/depend/bitcoin/src/dummywallet.cpp
+++ b/depend/bitcoin/src/dummywallet.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/external_signer.cpp b/depend/bitcoin/src/external_signer.cpp
index 1810f45b..33129199 100644
--- a/depend/bitcoin/src/external_signer.cpp
+++ b/depend/bitcoin/src/external_signer.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/external_signer.h b/depend/bitcoin/src/external_signer.h
index 81a60181..318b3bc0 100644
--- a/depend/bitcoin/src/external_signer.h
+++ b/depend/bitcoin/src/external_signer.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/flatfile.cpp b/depend/bitcoin/src/flatfile.cpp
index 33d8baf4..140217b0 100644
--- a/depend/bitcoin/src/flatfile.cpp
+++ b/depend/bitcoin/src/flatfile.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/flatfile.h b/depend/bitcoin/src/flatfile.h
index e902fbc4..6cdf22ff 100644
--- a/depend/bitcoin/src/flatfile.h
+++ b/depend/bitcoin/src/flatfile.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/httprpc.cpp b/depend/bitcoin/src/httprpc.cpp
index 1766d1a1..56a24308 100644
--- a/depend/bitcoin/src/httprpc.cpp
+++ b/depend/bitcoin/src/httprpc.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
@@ -142,7 +142,7 @@ static bool HTTPReq_JSONRPC(const std::any& context, HTTPRequest* req)
         jreq.URI = req->GetURI();
 
         UniValue reply;
-        bool user_has_whitelist = g_rpc_whitelist.count(jreq.authUser);
+        bool user_has_whitelist = g_rpc_whitelist.contains(jreq.authUser);
         if (!user_has_whitelist && g_rpc_whitelist_default) {
             LogWarning("RPC User %s not allowed to call any methods", jreq.authUser);
             req->WriteReply(HTTP_FORBIDDEN);
@@ -151,7 +151,7 @@ static bool HTTPReq_JSONRPC(const std::any& context, HTTPRequest* req)
         // singleton request
         } else if (valRequest.isObject()) {
             jreq.parse(valRequest);
-            if (user_has_whitelist && !g_rpc_whitelist[jreq.authUser].count(jreq.strMethod)) {
+            if (user_has_whitelist && !g_rpc_whitelist[jreq.authUser].contains(jreq.strMethod)) {
                 LogWarning("RPC User %s not allowed to call method %s", jreq.authUser, jreq.strMethod);
                 req->WriteReply(HTTP_FORBIDDEN);
                 return false;
@@ -181,7 +181,7 @@ static bool HTTPReq_JSONRPC(const std::any& context, HTTPRequest* req)
                         const UniValue& request = valRequest[reqIdx].get_obj();
                         // Parse method
                         std::string strMethod = request.find_value("method").get_str();
-                        if (!g_rpc_whitelist[jreq.authUser].count(strMethod)) {
+                        if (!g_rpc_whitelist[jreq.authUser].contains(strMethod)) {
                             LogWarning("RPC User %s not allowed to call method %s", jreq.authUser, strMethod);
                             req->WriteReply(HTTP_FORBIDDEN);
                             return false;
@@ -307,7 +307,7 @@ static bool InitRPCAuthentication()
     for (const std::string& strRPCWhitelist : gArgs.GetArgs("-rpcwhitelist")) {
         auto pos = strRPCWhitelist.find(':');
         std::string strUser = strRPCWhitelist.substr(0, pos);
-        bool intersect = g_rpc_whitelist.count(strUser);
+        bool intersect = g_rpc_whitelist.contains(strUser);
         std::set<std::string>& whitelist = g_rpc_whitelist[strUser];
         if (pos != std::string::npos) {
             std::string strWhitelist = strRPCWhitelist.substr(pos + 1);
diff --git a/depend/bitcoin/src/httprpc.h b/depend/bitcoin/src/httprpc.h
index 404d1308..1c1a6241 100644
--- a/depend/bitcoin/src/httprpc.h
+++ b/depend/bitcoin/src/httprpc.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2021 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/httpserver.cpp b/depend/bitcoin/src/httpserver.cpp
index abfcb455..6cf47eba 100644
--- a/depend/bitcoin/src/httpserver.cpp
+++ b/depend/bitcoin/src/httpserver.cpp
@@ -422,22 +422,20 @@ static void HTTPWorkQueueRun(WorkQueue<HTTPClosure>* queue, int worker_num)
 /** libevent event log callback */
 static void libevent_log_cb(int severity, const char *msg)
 {
-    BCLog::Level level;
     switch (severity) {
     case EVENT_LOG_DEBUG:
-        level = BCLog::Level::Debug;
+        LogDebug(BCLog::LIBEVENT, "%s", msg);
         break;
     case EVENT_LOG_MSG:
-        level = BCLog::Level::Info;
+        LogInfo("libevent: %s", msg);
         break;
     case EVENT_LOG_WARN:
-        level = BCLog::Level::Warning;
+        LogWarning("libevent: %s", msg);
         break;
     default: // EVENT_LOG_ERR and others are mapped to error
-        level = BCLog::Level::Error;
+        LogError("libevent: %s", msg);
         break;
     }
-    LogPrintLevel(BCLog::LIBEVENT, level, "%s\n", msg);
 }
 
 bool InitHTTPServer(const util::SignalInterrupt& interrupt)
diff --git a/depend/bitcoin/src/httpserver.h b/depend/bitcoin/src/httpserver.h
index 6535dc60..1ef3aaeb 100644
--- a/depend/bitcoin/src/httpserver.h
+++ b/depend/bitcoin/src/httpserver.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/i2p.cpp b/depend/bitcoin/src/i2p.cpp
index b4357470..04093ea1 100644
--- a/depend/bitcoin/src/i2p.cpp
+++ b/depend/bitcoin/src/i2p.cpp
@@ -415,7 +415,7 @@ void Session::CreateIfNotCreatedAlready()
     const auto session_type = m_transient ? "transient" : "persistent";
     const auto session_id = GetRandHash().GetHex().substr(0, 10); // full is overkill, too verbose in the logs
 
-    LogDebug(BCLog::I2P, "Creating %s SAM session %s with %s\n", session_type, session_id, m_control_host.ToString());
+    LogDebug(BCLog::I2P, "Creating %s I2P SAM session %s with %s\n", session_type, session_id, m_control_host.ToString());
 
     auto sock = Hello();
 
@@ -452,7 +452,7 @@ void Session::CreateIfNotCreatedAlready()
     m_session_id = session_id;
     m_control_sock = std::move(sock);
 
-    LogPrintLevel(BCLog::I2P, BCLog::Level::Info, "%s SAM session %s created, my address=%s\n",
+    LogInfo("%s I2P SAM session %s created, my address=%s",
         Capitalize(session_type),
         m_session_id,
         m_my_addr.ToStringAddrPort());
@@ -483,9 +483,9 @@ void Session::Disconnect()
 {
     if (m_control_sock) {
         if (m_session_id.empty()) {
-            LogPrintLevel(BCLog::I2P, BCLog::Level::Info, "Destroying incomplete SAM session\n");
+            LogInfo("Destroying incomplete I2P SAM session");
         } else {
-            LogPrintLevel(BCLog::I2P, BCLog::Level::Info, "Destroying SAM session %s\n", m_session_id);
+            LogInfo("Destroying I2P SAM session %s", m_session_id);
         }
         m_control_sock.reset();
     }
diff --git a/depend/bitcoin/src/i2p.h b/depend/bitcoin/src/i2p.h
index a41406f3..0eb005dd 100644
--- a/depend/bitcoin/src/i2p.h
+++ b/depend/bitcoin/src/i2p.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/index/base.cpp b/depend/bitcoin/src/index/base.cpp
index 6d424804..7f77d13a 100644
--- a/depend/bitcoin/src/index/base.cpp
+++ b/depend/bitcoin/src/index/base.cpp
@@ -9,7 +9,7 @@
 #include <dbwrapper.h>
 #include <interfaces/chain.h>
 #include <interfaces/types.h>
-#include <kernel/chain.h>
+#include <kernel/types.h>
 #include <logging.h>
 #include <node/abort.h>
 #include <node/blockstorage.h>
@@ -42,6 +42,8 @@
 #include <utility>
 #include <vector>
 
+using kernel::ChainstateRole;
+
 constexpr uint8_t DB_BEST_BLOCK{'B'};
 
 constexpr auto SYNC_LOG_INTERVAL{30s};
@@ -109,7 +111,7 @@ bool BaseIndex::Init()
     // m_chainstate member gives indexing code access to node internals. It is
     // removed in followup https://github.com/bitcoin/bitcoin/pull/24230
     m_chainstate = WITH_LOCK(::cs_main,
-        return &m_chain->context()->chainman->GetChainstateForIndexing());
+                             return &m_chain->context()->chainman->ValidatedChainstate());
     // Register to validation interface before setting the 'm_synced' flag, so that
     // callbacks are not missed once m_synced is true.
     m_chain->context()->validation_signals->RegisterValidationInterface(this);
@@ -323,15 +325,13 @@ bool BaseIndex::Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_ti
     return true;
 }
 
-void BaseIndex::BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex)
+void BaseIndex::BlockConnected(const ChainstateRole& role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex)
 {
-    // Ignore events from the assumed-valid chain; we will process its blocks
-    // (sequentially) after it is fully verified by the background chainstate. This
-    // is to avoid any out-of-order indexing.
+    // Ignore events from not fully validated chains to avoid out-of-order indexing.
     //
     // TODO at some point we could parameterize whether a particular index can be
     // built out of order, but for now just do the conservative simple thing.
-    if (role == ChainstateRole::ASSUMEDVALID) {
+    if (!role.validated) {
         return;
     }
 
@@ -377,11 +377,10 @@ void BaseIndex::BlockConnected(ChainstateRole role, const std::shared_ptr<const
     }
 }
 
-void BaseIndex::ChainStateFlushed(ChainstateRole role, const CBlockLocator& locator)
+void BaseIndex::ChainStateFlushed(const ChainstateRole& role, const CBlockLocator& locator)
 {
-    // Ignore events from the assumed-valid chain; we will process its blocks
-    // (sequentially) after it is fully verified by the background chainstate.
-    if (role == ChainstateRole::ASSUMEDVALID) {
+    // Ignore events from not fully validated chains to avoid out-of-order indexing.
+    if (!role.validated) {
         return;
     }
 
diff --git a/depend/bitcoin/src/index/base.h b/depend/bitcoin/src/index/base.h
index cbd0211a..8cb8ad8e 100644
--- a/depend/bitcoin/src/index/base.h
+++ b/depend/bitcoin/src/index/base.h
@@ -118,9 +118,9 @@ class BaseIndex : public CValidationInterface
     Chainstate* m_chainstate{nullptr};
     const std::string m_name;
 
-    void BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override;
+    void BlockConnected(const kernel::ChainstateRole& role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override;
 
-    void ChainStateFlushed(ChainstateRole role, const CBlockLocator& locator) override;
+    void ChainStateFlushed(const kernel::ChainstateRole& role, const CBlockLocator& locator) override;
 
     /// Return custom notification options for index.
     [[nodiscard]] virtual interfaces::Chain::NotifyOptions CustomOptions() { return {}; }
diff --git a/depend/bitcoin/src/index/blockfilterindex.cpp b/depend/bitcoin/src/index/blockfilterindex.cpp
index 4bf2f5e6..caf6d592 100644
--- a/depend/bitcoin/src/index/blockfilterindex.cpp
+++ b/depend/bitcoin/src/index/blockfilterindex.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
@@ -11,6 +11,7 @@
 #include <flatfile.h>
 #include <hash.h>
 #include <index/base.h>
+#include <index/db_key.h>
 #include <interfaces/chain.h>
 #include <interfaces/types.h>
 #include <logging.h>
@@ -25,7 +26,6 @@
 
 #include <cerrno>
 #include <exception>
-#include <ios>
 #include <map>
 #include <optional>
 #include <span>
@@ -46,12 +46,8 @@
  * disk location of the next block filter to be written (represented as a FlatFilePos) is stored
  * under the DB_FILTER_POS key.
  *
- * Keys for the height index have the type [DB_BLOCK_HEIGHT, uint32 (BE)]. The height is represented
- * as big-endian so that sequential reads of filters by height are fast.
- * Keys for the hash index have the type [DB_BLOCK_HASH, uint256].
+ * The logic for keys is shared with other indexes, see index/db_key.h.
  */
-constexpr uint8_t DB_BLOCK_HASH{'s'};
-constexpr uint8_t DB_BLOCK_HEIGHT{'t'};
 constexpr uint8_t DB_FILTER_POS{'P'};
 
 constexpr unsigned int MAX_FLTR_FILE_SIZE = 0x1000000; // 16 MiB
@@ -74,45 +70,6 @@ struct DBVal {
     SERIALIZE_METHODS(DBVal, obj) { READWRITE(obj.hash, obj.header, obj.pos); }
 };
 
-struct DBHeightKey {
-    int height;
-
-    explicit DBHeightKey(int height_in) : height(height_in) {}
-
-    template<typename Stream>
-    void Serialize(Stream& s) const
-    {
-        ser_writedata8(s, DB_BLOCK_HEIGHT);
-        ser_writedata32be(s, height);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s)
-    {
-        const uint8_t prefix{ser_readdata8(s)};
-        if (prefix != DB_BLOCK_HEIGHT) {
-            throw std::ios_base::failure("Invalid format for block filter index DB height key");
-        }
-        height = ser_readdata32be(s);
-    }
-};
-
-struct DBHashKey {
-    uint256 hash;
-
-    explicit DBHashKey(const uint256& hash_in) : hash(hash_in) {}
-
-    SERIALIZE_METHODS(DBHashKey, obj) {
-        uint8_t prefix{DB_BLOCK_HASH};
-        READWRITE(prefix);
-        if (prefix != DB_BLOCK_HASH) {
-            throw std::ios_base::failure("Invalid format for block filter index DB hash key");
-        }
-
-        READWRITE(obj.hash);
-    }
-};
-
 }; // namespace
 
 static std::map<BlockFilterType, BlockFilterIndex> g_filter_indexes;
@@ -278,7 +235,7 @@ size_t BlockFilterIndex::WriteFilterToDisk(FlatFilePos& pos, const BlockFilter&
 std::optional<uint256> BlockFilterIndex::ReadFilterHeader(int height, const uint256& expected_block_hash)
 {
     std::pair<uint256, DBVal> read_out;
-    if (!m_db->Read(DBHeightKey(height), read_out)) {
+    if (!m_db->Read(index_util::DBHeightKey(height), read_out)) {
         return std::nullopt;
     }
 
@@ -311,35 +268,12 @@ bool BlockFilterIndex::Write(const BlockFilter& filter, uint32_t block_height, c
     value.second.header = filter_header;
     value.second.pos = m_next_filter_pos;
 
-    m_db->Write(DBHeightKey(block_height), value);
+    m_db->Write(index_util::DBHeightKey(block_height), value);
 
     m_next_filter_pos.nPos += bytes_written;
     return true;
 }
 
-[[nodiscard]] static bool CopyHeightIndexToHashIndex(CDBIterator& db_it, CDBBatch& batch,
-                                                     const std::string& index_name, int height)
-{
-    DBHeightKey key(height);
-    db_it.Seek(key);
-
-    if (!db_it.GetKey(key) || key.height != height) {
-        LogError("unexpected key in %s: expected (%c, %d)",
-                  index_name, DB_BLOCK_HEIGHT, height);
-        return false;
-    }
-
-    std::pair<uint256, DBVal> value;
-    if (!db_it.GetValue(value)) {
-        LogError("unable to read value in %s at key (%c, %d)",
-                 index_name, DB_BLOCK_HEIGHT, height);
-        return false;
-    }
-
-    batch.Write(DBHashKey(value.first), std::move(value.second));
-    return true;
-}
-
 bool BlockFilterIndex::CustomRemove(const interfaces::BlockInfo& block)
 {
     CDBBatch batch(*m_db);
@@ -348,7 +282,7 @@ bool BlockFilterIndex::CustomRemove(const interfaces::BlockInfo& block)
     // During a reorg, we need to copy block filter that is getting disconnected from the
     // height index to the hash index so we can still find it when the height index entry
     // is overwritten.
-    if (!CopyHeightIndexToHashIndex(*db_it, batch, m_name, block.height)) {
+    if (!index_util::CopyHeightIndexToHashIndex<DBVal>(*db_it, batch, m_name, block.height)) {
         return false;
     }
 
@@ -363,24 +297,6 @@ bool BlockFilterIndex::CustomRemove(const interfaces::BlockInfo& block)
     return true;
 }
 
-static bool LookupOne(const CDBWrapper& db, const CBlockIndex* block_index, DBVal& result)
-{
-    // First check if the result is stored under the height index and the value there matches the
-    // block hash. This should be the case if the block is on the active chain.
-    std::pair<uint256, DBVal> read_out;
-    if (!db.Read(DBHeightKey(block_index->nHeight), read_out)) {
-        return false;
-    }
-    if (read_out.first == block_index->GetBlockHash()) {
-        result = std::move(read_out.second);
-        return true;
-    }
-
-    // If value at the height index corresponds to an different block, the result will be stored in
-    // the hash index.
-    return db.Read(DBHashKey(block_index->GetBlockHash()), result);
-}
-
 static bool LookupRange(CDBWrapper& db, const std::string& index_name, int start_height,
                         const CBlockIndex* stop_index, std::vector<DBVal>& results)
 {
@@ -397,9 +313,9 @@ static bool LookupRange(CDBWrapper& db, const std::string& index_name, int start
     size_t results_size = static_cast<size_t>(stop_index->nHeight - start_height + 1);
     std::vector<std::pair<uint256, DBVal>> values(results_size);
 
-    DBHeightKey key(start_height);
+    index_util::DBHeightKey key(start_height);
     std::unique_ptr<CDBIterator> db_it(db.NewIterator());
-    db_it->Seek(DBHeightKey(start_height));
+    db_it->Seek(index_util::DBHeightKey(start_height));
     for (int height = start_height; height <= stop_index->nHeight; ++height) {
         if (!db_it->Valid() || !db_it->GetKey(key) || key.height != height) {
             return false;
@@ -408,7 +324,7 @@ static bool LookupRange(CDBWrapper& db, const std::string& index_name, int start
         size_t i = static_cast<size_t>(height - start_height);
         if (!db_it->GetValue(values[i])) {
             LogError("unable to read value in %s at key (%c, %d)",
-                     index_name, DB_BLOCK_HEIGHT, height);
+                     index_name, index_util::DB_BLOCK_HEIGHT, height);
             return false;
         }
 
@@ -430,9 +346,9 @@ static bool LookupRange(CDBWrapper& db, const std::string& index_name, int start
             continue;
         }
 
-        if (!db.Read(DBHashKey(block_hash), results[i])) {
+        if (!db.Read(index_util::DBHashKey(block_hash), results[i])) {
             LogError("unable to read value in %s at key (%c, %s)",
-                     index_name, DB_BLOCK_HASH, block_hash.ToString());
+                     index_name, index_util::DB_BLOCK_HASH, block_hash.ToString());
             return false;
         }
     }
@@ -443,7 +359,7 @@ static bool LookupRange(CDBWrapper& db, const std::string& index_name, int start
 bool BlockFilterIndex::LookupFilter(const CBlockIndex* block_index, BlockFilter& filter_out) const
 {
     DBVal entry;
-    if (!LookupOne(*m_db, block_index, entry)) {
+    if (!index_util::LookUpOne(*m_db, {block_index->GetBlockHash(), block_index->nHeight}, entry)) {
         return false;
     }
 
@@ -466,7 +382,7 @@ bool BlockFilterIndex::LookupFilterHeader(const CBlockIndex* block_index, uint25
     }
 
     DBVal entry;
-    if (!LookupOne(*m_db, block_index, entry)) {
+    if (!index_util::LookUpOne(*m_db, {block_index->GetBlockHash(), block_index->nHeight}, entry)) {
         return false;
     }
 
diff --git a/depend/bitcoin/src/index/blockfilterindex.h b/depend/bitcoin/src/index/blockfilterindex.h
index b1ebd55f..85cc8f18 100644
--- a/depend/bitcoin/src/index/blockfilterindex.h
+++ b/depend/bitcoin/src/index/blockfilterindex.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/index/coinstatsindex.cpp b/depend/bitcoin/src/index/coinstatsindex.cpp
index 72bc09ce..6be3db9a 100644
--- a/depend/bitcoin/src/index/coinstatsindex.cpp
+++ b/depend/bitcoin/src/index/coinstatsindex.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
@@ -13,6 +13,7 @@
 #include <crypto/muhash.h>
 #include <dbwrapper.h>
 #include <index/base.h>
+#include <index/db_key.h>
 #include <interfaces/chain.h>
 #include <interfaces/types.h>
 #include <kernel/coinstats.h>
@@ -28,7 +29,6 @@
 #include <validation.h>
 
 #include <compare>
-#include <ios>
 #include <limits>
 #include <span>
 #include <string>
@@ -40,8 +40,6 @@ using kernel::CCoinsStats;
 using kernel::GetBogoSize;
 using kernel::RemoveCoinHash;
 
-static constexpr uint8_t DB_BLOCK_HASH{'s'};
-static constexpr uint8_t DB_BLOCK_HEIGHT{'t'};
 static constexpr uint8_t DB_MUHASH{'M'};
 
 namespace {
@@ -85,47 +83,6 @@ struct DBVal {
         SER_READ(obj, obj.total_coinbase_amount = UintToArith256(coinbase));
     }
 };
-
-struct DBHeightKey {
-    int height;
-
-    explicit DBHeightKey(int height_in) : height(height_in) {}
-
-    template <typename Stream>
-    void Serialize(Stream& s) const
-    {
-        ser_writedata8(s, DB_BLOCK_HEIGHT);
-        ser_writedata32be(s, height);
-    }
-
-    template <typename Stream>
-    void Unserialize(Stream& s)
-    {
-        const uint8_t prefix{ser_readdata8(s)};
-        if (prefix != DB_BLOCK_HEIGHT) {
-            throw std::ios_base::failure("Invalid format for coinstatsindex DB height key");
-        }
-        height = ser_readdata32be(s);
-    }
-};
-
-struct DBHashKey {
-    uint256 block_hash;
-
-    explicit DBHashKey(const uint256& hash_in) : block_hash(hash_in) {}
-
-    SERIALIZE_METHODS(DBHashKey, obj)
-    {
-        uint8_t prefix{DB_BLOCK_HASH};
-        READWRITE(prefix);
-        if (prefix != DB_BLOCK_HASH) {
-            throw std::ios_base::failure("Invalid format for coinstatsindex DB hash key");
-        }
-
-        READWRITE(obj.block_hash);
-    }
-};
-
 }; // namespace
 
 std::unique_ptr<CoinStatsIndex> g_coin_stats_index;
@@ -253,30 +210,7 @@ bool CoinStatsIndex::CustomAppend(const interfaces::BlockInfo& block)
 
     // Intentionally do not update DB_MUHASH here so it stays in sync with
     // DB_BEST_BLOCK, and the index is not corrupted if there is an unclean shutdown.
-    m_db->Write(DBHeightKey(block.height), value);
-    return true;
-}
-
-[[nodiscard]] static bool CopyHeightIndexToHashIndex(CDBIterator& db_it, CDBBatch& batch,
-                                                     const std::string& index_name, int height)
-{
-    DBHeightKey key{height};
-    db_it.Seek(key);
-
-    if (!db_it.GetKey(key) || key.height != height) {
-        LogError("unexpected key in %s: expected (%c, %d)",
-                 index_name, DB_BLOCK_HEIGHT, height);
-        return false;
-    }
-
-    std::pair<uint256, DBVal> value;
-    if (!db_it.GetValue(value)) {
-        LogError("unable to read value in %s at key (%c, %d)",
-                 index_name, DB_BLOCK_HEIGHT, height);
-        return false;
-    }
-
-    batch.Write(DBHashKey(value.first), value.second);
+    m_db->Write(index_util::DBHeightKey(block.height), value);
     return true;
 }
 
@@ -287,7 +221,7 @@ bool CoinStatsIndex::CustomRemove(const interfaces::BlockInfo& block)
 
     // During a reorg, copy the block's hash digest from the height index to the hash index,
     // ensuring it's still accessible after the height index entry is overwritten.
-    if (!CopyHeightIndexToHashIndex(*db_it, batch, m_name, block.height)) {
+    if (!index_util::CopyHeightIndexToHashIndex<DBVal>(*db_it, batch, m_name, block.height)) {
         return false;
     }
 
@@ -300,32 +234,13 @@ bool CoinStatsIndex::CustomRemove(const interfaces::BlockInfo& block)
     return true;
 }
 
-static bool LookUpOne(const CDBWrapper& db, const interfaces::BlockRef& block, DBVal& result)
-{
-    // First check if the result is stored under the height index and the value
-    // there matches the block hash. This should be the case if the block is on
-    // the active chain.
-    std::pair<uint256, DBVal> read_out;
-    if (!db.Read(DBHeightKey(block.height), read_out)) {
-        return false;
-    }
-    if (read_out.first == block.hash) {
-        result = std::move(read_out.second);
-        return true;
-    }
-
-    // If value at the height index corresponds to an different block, the
-    // result will be stored in the hash index.
-    return db.Read(DBHashKey(block.hash), result);
-}
-
 std::optional<CCoinsStats> CoinStatsIndex::LookUpStats(const CBlockIndex& block_index) const
 {
     CCoinsStats stats{block_index.nHeight, block_index.GetBlockHash()};
     stats.index_used = true;
 
     DBVal entry;
-    if (!LookUpOne(*m_db, {block_index.GetBlockHash(), block_index.nHeight}, entry)) {
+    if (!index_util::LookUpOne(*m_db, {block_index.GetBlockHash(), block_index.nHeight}, entry)) {
         return std::nullopt;
     }
 
@@ -360,7 +275,7 @@ bool CoinStatsIndex::CustomInit(const std::optional<interfaces::BlockRef>& block
 
     if (block) {
         DBVal entry;
-        if (!LookUpOne(*m_db, *block, entry)) {
+        if (!index_util::LookUpOne(*m_db, *block, entry)) {
             LogError("Cannot read current %s state; index may be corrupted",
                       GetName());
             return false;
@@ -415,7 +330,7 @@ bool CoinStatsIndex::RevertBlock(const interfaces::BlockInfo& block)
 
     // Ignore genesis block
     if (block.height > 0) {
-        if (!m_db->Read(DBHeightKey(block.height - 1), read_out)) {
+        if (!m_db->Read(index_util::DBHeightKey(block.height - 1), read_out)) {
             return false;
         }
 
@@ -424,7 +339,7 @@ bool CoinStatsIndex::RevertBlock(const interfaces::BlockInfo& block)
             LogWarning("previous block header belongs to unexpected block %s; expected %s",
                       read_out.first.ToString(), expected_block_hash.ToString());
 
-            if (!m_db->Read(DBHashKey(expected_block_hash), read_out)) {
+            if (!m_db->Read(index_util::DBHashKey(expected_block_hash), read_out)) {
                 LogError("previous block header not found; expected %s",
                           expected_block_hash.ToString());
                 return false;
diff --git a/depend/bitcoin/src/index/coinstatsindex.h b/depend/bitcoin/src/index/coinstatsindex.h
index ce953146..041c0b89 100644
--- a/depend/bitcoin/src/index/coinstatsindex.h
+++ b/depend/bitcoin/src/index/coinstatsindex.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/index/db_key.h b/depend/bitcoin/src/index/db_key.h
new file mode 100644
index 00000000..b7334c81
--- /dev/null
+++ b/depend/bitcoin/src/index/db_key.h
@@ -0,0 +1,116 @@
+// Copyright (c) 2025-present The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_INDEX_DB_KEY_H
+#define BITCOIN_INDEX_DB_KEY_H
+
+#include <dbwrapper.h>
+#include <interfaces/types.h>
+#include <logging.h>
+#include <serialize.h>
+#include <uint256.h>
+
+#include <cstdint>
+#include <ios>
+#include <string>
+#include <utility>
+
+namespace index_util {
+/*
+ * This file includes the logic for the db keys used by blockfilterindex and coinstatsindex.
+ * Index data is usually indexed by height, but in case of a reorg, entries of blocks no
+ * longer in the main chain will be copied to a hash index by which they can still be queried.
+ * Keys for the height index have the type [DB_BLOCK_HEIGHT, uint32 (BE)]. The height is represented
+ * as big-endian so that sequential reads of filters by height are fast.
+ * Keys for the hash index have the type [DB_BLOCK_HASH, uint256].
+ */
+
+static constexpr uint8_t DB_BLOCK_HASH{'s'};
+static constexpr uint8_t DB_BLOCK_HEIGHT{'t'};
+
+struct DBHeightKey {
+    int height;
+
+    explicit DBHeightKey(int height_in) : height(height_in) {}
+
+    template<typename Stream>
+    void Serialize(Stream& s) const
+    {
+        ser_writedata8(s, DB_BLOCK_HEIGHT);
+        ser_writedata32be(s, height);
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s)
+    {
+        const uint8_t prefix{ser_readdata8(s)};
+        if (prefix != DB_BLOCK_HEIGHT) {
+            throw std::ios_base::failure("Invalid format for index DB height key");
+        }
+        height = ser_readdata32be(s);
+    }
+};
+
+struct DBHashKey {
+    uint256 hash;
+
+    explicit DBHashKey(const uint256& hash_in) : hash(hash_in) {}
+
+    SERIALIZE_METHODS(DBHashKey, obj) {
+        uint8_t prefix{DB_BLOCK_HASH};
+        READWRITE(prefix);
+        if (prefix != DB_BLOCK_HASH) {
+            throw std::ios_base::failure("Invalid format for index DB hash key");
+        }
+
+        READWRITE(obj.hash);
+    }
+};
+
+template <typename DBVal>
+[[nodiscard]] static bool CopyHeightIndexToHashIndex(CDBIterator& db_it, CDBBatch& batch,
+                                                     const std::string& index_name, int height)
+{
+    DBHeightKey key(height);
+    db_it.Seek(key);
+
+    if (!db_it.GetKey(key) || key.height != height) {
+        LogError("unexpected key in %s: expected (%c, %d)",
+                  index_name, DB_BLOCK_HEIGHT, height);
+        return false;
+    }
+
+    std::pair<uint256, DBVal> value;
+    if (!db_it.GetValue(value)) {
+        LogError("unable to read value in %s at key (%c, %d)",
+                 index_name, DB_BLOCK_HEIGHT, height);
+        return false;
+    }
+
+    batch.Write(DBHashKey(value.first), value.second);
+    return true;
+}
+
+template <typename DBVal>
+static bool LookUpOne(const CDBWrapper& db, const interfaces::BlockRef& block, DBVal& result)
+{
+    // First check if the result is stored under the height index and the value
+    // there matches the block hash. This should be the case if the block is on
+    // the active chain.
+    std::pair<uint256, DBVal> read_out;
+    if (!db.Read(DBHeightKey(block.height), read_out)) {
+        return false;
+    }
+    if (read_out.first == block.hash) {
+        result = std::move(read_out.second);
+        return true;
+    }
+
+    // If value at the height index corresponds to an different block, the
+    // result will be stored in the hash index.
+    return db.Read(DBHashKey(block.hash), result);
+}
+} // namespace index_util
+
+#endif // BITCOIN_INDEX_DB_KEY_H
diff --git a/depend/bitcoin/src/index/disktxpos.h b/depend/bitcoin/src/index/disktxpos.h
index 5e4352db..ce5cc77b 100644
--- a/depend/bitcoin/src/index/disktxpos.h
+++ b/depend/bitcoin/src/index/disktxpos.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2020 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/index/txindex.cpp b/depend/bitcoin/src/index/txindex.cpp
index ab0f13b4..7d845021 100644
--- a/depend/bitcoin/src/index/txindex.cpp
+++ b/depend/bitcoin/src/index/txindex.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/index/txindex.h b/depend/bitcoin/src/index/txindex.h
index 889b6612..0358e0ae 100644
--- a/depend/bitcoin/src/index/txindex.h
+++ b/depend/bitcoin/src/index/txindex.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/indirectmap.h b/depend/bitcoin/src/indirectmap.h
index a9f4b0b9..05c840ae 100644
--- a/depend/bitcoin/src/indirectmap.h
+++ b/depend/bitcoin/src/indirectmap.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/init.cpp b/depend/bitcoin/src/init.cpp
index e283e89e..f2af858e 100644
--- a/depend/bitcoin/src/init.cpp
+++ b/depend/bitcoin/src/init.cpp
@@ -345,7 +345,7 @@ void Shutdown(NodeContext& node)
     // FlushStateToDisk generates a ChainStateFlushed callback, which we should avoid missing
     if (node.chainman) {
         LOCK(cs_main);
-        for (Chainstate* chainstate : node.chainman->GetAll()) {
+        for (const auto& chainstate : node.chainman->m_chainstates) {
             if (chainstate->CanFlushToDisk()) {
                 chainstate->ForceFlushStateToDisk();
             }
@@ -371,7 +371,7 @@ void Shutdown(NodeContext& node)
 
     if (node.chainman) {
         LOCK(cs_main);
-        for (Chainstate* chainstate : node.chainman->GetAll()) {
+        for (const auto& chainstate : node.chainman->m_chainstates) {
             if (chainstate->CanFlushToDisk()) {
                 chainstate->ForceFlushStateToDisk();
                 chainstate->ResetCoinsViews();
@@ -968,7 +968,7 @@ bool AppInitParameterInteraction(const ArgsManager& args)
 
     // Signal NODE_COMPACT_FILTERS if peerblockfilters and basic filters index are both enabled.
     if (args.GetBoolArg("-peerblockfilters", DEFAULT_PEERBLOCKFILTERS)) {
-        if (g_enabled_filter_types.count(BlockFilterType::BASIC) != 1) {
+        if (!g_enabled_filter_types.contains(BlockFilterType::BASIC)) {
             return InitError(_("Cannot set -peerblockfilters without -blockfilterindex."));
         }
 
@@ -1877,14 +1877,14 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     if (chainman.m_blockman.IsPruneMode()) {
         if (chainman.m_blockman.m_blockfiles_indexed) {
             LOCK(cs_main);
-            for (Chainstate* chainstate : chainman.GetAll()) {
+            for (const auto& chainstate : chainman.m_chainstates) {
                 uiInterface.InitMessage(_("Pruning blockstore…"));
                 chainstate->PruneAndFlush();
             }
         }
     } else {
         // Prior to setting NODE_NETWORK, check if we can provide historical blocks.
-        if (!WITH_LOCK(chainman.GetMutex(), return chainman.BackgroundSyncInProgress())) {
+        if (!WITH_LOCK(chainman.GetMutex(), return chainman.HistoricalChainstate())) {
             LogInfo("Setting NODE_NETWORK in non-prune mode");
             g_local_services = ServiceFlags(g_local_services | NODE_NETWORK);
         } else {
@@ -2233,7 +2233,7 @@ bool StartIndexBackgroundSync(NodeContext& node)
     std::optional<const CBlockIndex*> indexes_start_block;
     std::string older_index_name;
     ChainstateManager& chainman = *Assert(node.chainman);
-    const Chainstate& chainstate = WITH_LOCK(::cs_main, return chainman.GetChainstateForIndexing());
+    const Chainstate& chainstate = WITH_LOCK(::cs_main, return chainman.ValidatedChainstate());
     const CChain& index_chain = chainstate.m_chain;
 
     for (auto index : node.indexes) {
diff --git a/depend/bitcoin/src/init.h b/depend/bitcoin/src/init.h
index 6b60a4e1..f3a55da3 100644
--- a/depend/bitcoin/src/init.h
+++ b/depend/bitcoin/src/init.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/init/bitcoin-gui.cpp b/depend/bitcoin/src/init/bitcoin-gui.cpp
index aca3fbe1..ca3077b9 100644
--- a/depend/bitcoin/src/init/bitcoin-gui.cpp
+++ b/depend/bitcoin/src/init/bitcoin-gui.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/init/bitcoin-node.cpp b/depend/bitcoin/src/init/bitcoin-node.cpp
index e5f1411f..e4252193 100644
--- a/depend/bitcoin/src/init/bitcoin-node.cpp
+++ b/depend/bitcoin/src/init/bitcoin-node.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/init/bitcoin-qt.cpp b/depend/bitcoin/src/init/bitcoin-qt.cpp
index 05f3bc32..f46025cf 100644
--- a/depend/bitcoin/src/init/bitcoin-qt.cpp
+++ b/depend/bitcoin/src/init/bitcoin-qt.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/init/bitcoin-wallet.cpp b/depend/bitcoin/src/init/bitcoin-wallet.cpp
index f3a9ea26..f10f4629 100644
--- a/depend/bitcoin/src/init/bitcoin-wallet.cpp
+++ b/depend/bitcoin/src/init/bitcoin-wallet.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/init/bitcoind.cpp b/depend/bitcoin/src/init/bitcoind.cpp
index 0b0ab3f8..efe9352e 100644
--- a/depend/bitcoin/src/init/bitcoind.cpp
+++ b/depend/bitcoin/src/init/bitcoind.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/init/common.cpp b/depend/bitcoin/src/init/common.cpp
index 53f4215c..d1926d04 100644
--- a/depend/bitcoin/src/init/common.cpp
+++ b/depend/bitcoin/src/init/common.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/init/common.h b/depend/bitcoin/src/init/common.h
index b61a77c6..e3dae8f9 100644
--- a/depend/bitcoin/src/init/common.h
+++ b/depend/bitcoin/src/init/common.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/interfaces/chain.h b/depend/bitcoin/src/interfaces/chain.h
index 40291d20..e6847b9b 100644
--- a/depend/bitcoin/src/interfaces/chain.h
+++ b/depend/bitcoin/src/interfaces/chain.h
@@ -7,6 +7,7 @@
 
 #include <blockfilter.h>
 #include <common/settings.h>
+#include <kernel/chain.h> // IWYU pragma: export
 #include <node/types.h>
 #include <primitives/transaction.h>
 #include <util/result.h>
@@ -30,10 +31,12 @@ class Coin;
 class uint256;
 enum class MemPoolRemovalReason;
 enum class RBFTransactionState;
-enum class ChainstateRole;
 struct bilingual_str;
 struct CBlockLocator;
 struct FeeCalculation;
+namespace kernel {
+struct ChainstateRole;
+} // namespace kernel
 namespace node {
 struct NodeContext;
 } // namespace node
@@ -76,22 +79,6 @@ class FoundBlock
     mutable bool found = false;
 };
 
-//! Block data sent with blockConnected, blockDisconnected notifications.
-struct BlockInfo {
-    const uint256& hash;
-    const uint256* prev_hash = nullptr;
-    int height = -1;
-    int file_number = -1;
-    unsigned data_pos = 0;
-    const CBlock* data = nullptr;
-    const CBlockUndo* undo_data = nullptr;
-    // The maximum time in the chain up to and including this block.
-    // A timestamp that can only move forward.
-    unsigned int chain_time_max{0};
-
-    BlockInfo(const uint256& hash LIFETIMEBOUND) : hash(hash) {}
-};
-
 //! The action to be taken after updating a settings value.
 //! WRITE indicates that the updated value must be written to disk,
 //! while SKIP_WRITE indicates that the change will be kept in memory-only
@@ -321,10 +308,10 @@ class Chain
         virtual ~Notifications() = default;
         virtual void transactionAddedToMempool(const CTransactionRef& tx) {}
         virtual void transactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason) {}
-        virtual void blockConnected(ChainstateRole role, const BlockInfo& block) {}
+        virtual void blockConnected(const kernel::ChainstateRole& role, const BlockInfo& block) {}
         virtual void blockDisconnected(const BlockInfo& block) {}
         virtual void updatedBlockTip() {}
-        virtual void chainStateFlushed(ChainstateRole role, const CBlockLocator& locator) {}
+        virtual void chainStateFlushed(const kernel::ChainstateRole& role, const CBlockLocator& locator) {}
     };
 
     //! Options specifying which chain notifications are required.
@@ -389,7 +376,9 @@ class Chain
     //! removed transactions and already added new transactions.
     virtual void requestMempoolTransactions(Notifications& notifications) = 0;
 
-    //! Return true if an assumed-valid chain is in use.
+    //! Return true if an assumed-valid snapshot is in use. Note that this
+    //! returns true even after the snapshot is validated, until the next node
+    //! restart.
     virtual bool hasAssumedValidChain() = 0;
 
     //! Get internal node context. Useful for testing, but not
diff --git a/depend/bitcoin/src/interfaces/echo.h b/depend/bitcoin/src/interfaces/echo.h
index 964dbb02..0793342c 100644
--- a/depend/bitcoin/src/interfaces/echo.h
+++ b/depend/bitcoin/src/interfaces/echo.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/interfaces/handler.h b/depend/bitcoin/src/interfaces/handler.h
index 6fc14ed0..b3aebf7e 100644
--- a/depend/bitcoin/src/interfaces/handler.h
+++ b/depend/bitcoin/src/interfaces/handler.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/interfaces/init.h b/depend/bitcoin/src/interfaces/init.h
index 030ce306..b909c9e6 100644
--- a/depend/bitcoin/src/interfaces/init.h
+++ b/depend/bitcoin/src/interfaces/init.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/interfaces/ipc.h b/depend/bitcoin/src/interfaces/ipc.h
index 8f441118..f94ffa3c 100644
--- a/depend/bitcoin/src/interfaces/ipc.h
+++ b/depend/bitcoin/src/interfaces/ipc.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/interfaces/types.h b/depend/bitcoin/src/interfaces/types.h
index e5edd301..e2ef05b9 100644
--- a/depend/bitcoin/src/interfaces/types.h
+++ b/depend/bitcoin/src/interfaces/types.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2024 The Bitcoin Core developers
+// Copyright (c) 2024-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/interfaces/wallet.h b/depend/bitcoin/src/interfaces/wallet.h
index 2ccd514d..3ca0738c 100644
--- a/depend/bitcoin/src/interfaces/wallet.h
+++ b/depend/bitcoin/src/interfaces/wallet.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
@@ -325,7 +325,7 @@ class WalletLoader : public ChainClient
     virtual std::string getWalletDir() = 0;
 
     //! Restore backup wallet
-    virtual util::Result<std::unique_ptr<Wallet>> restoreWallet(const fs::path& backup_file, const std::string& wallet_name, std::vector<bilingual_str>& warnings) = 0;
+    virtual util::Result<std::unique_ptr<Wallet>> restoreWallet(const fs::path& backup_file, const std::string& wallet_name, std::vector<bilingual_str>& warnings, bool load_after_restore) = 0;
 
     //! Migrate a wallet
     virtual util::Result<WalletMigrationResult> migrateWallet(const std::string& name, const SecureString& passphrase) = 0;
diff --git a/depend/bitcoin/src/ipc/capnp/common-types.h b/depend/bitcoin/src/ipc/capnp/common-types.h
index 934dae5f..309799b8 100644
--- a/depend/bitcoin/src/ipc/capnp/common-types.h
+++ b/depend/bitcoin/src/ipc/capnp/common-types.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/capnp/common.capnp b/depend/bitcoin/src/ipc/capnp/common.capnp
index b3359f3f..cae6603d 100644
--- a/depend/bitcoin/src/ipc/capnp/common.capnp
+++ b/depend/bitcoin/src/ipc/capnp/common.capnp
@@ -1,4 +1,4 @@
-# Copyright (c) 2024 The Bitcoin Core developers
+# Copyright (c) 2024-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/capnp/context.h b/depend/bitcoin/src/ipc/capnp/context.h
index 06e16144..2bc18000 100644
--- a/depend/bitcoin/src/ipc/capnp/context.h
+++ b/depend/bitcoin/src/ipc/capnp/context.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/capnp/echo-types.h b/depend/bitcoin/src/ipc/capnp/echo-types.h
index 14970c1a..47eadce1 100644
--- a/depend/bitcoin/src/ipc/capnp/echo-types.h
+++ b/depend/bitcoin/src/ipc/capnp/echo-types.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2025 The Bitcoin Core developers
+// Copyright (c) 2025-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/capnp/echo.capnp b/depend/bitcoin/src/ipc/capnp/echo.capnp
index 03c40f90..ce7ea3f6 100644
--- a/depend/bitcoin/src/ipc/capnp/echo.capnp
+++ b/depend/bitcoin/src/ipc/capnp/echo.capnp
@@ -1,4 +1,4 @@
-# Copyright (c) 2021 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/capnp/init-types.h b/depend/bitcoin/src/ipc/capnp/init-types.h
index c3ddca27..2abd7b21 100644
--- a/depend/bitcoin/src/ipc/capnp/init-types.h
+++ b/depend/bitcoin/src/ipc/capnp/init-types.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/capnp/init.capnp b/depend/bitcoin/src/ipc/capnp/init.capnp
index 1001ee53..64a7bf9b 100644
--- a/depend/bitcoin/src/ipc/capnp/init.capnp
+++ b/depend/bitcoin/src/ipc/capnp/init.capnp
@@ -1,4 +1,4 @@
-# Copyright (c) 2021 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/capnp/mining-types.h b/depend/bitcoin/src/ipc/capnp/mining-types.h
index 62789759..40b7487a 100644
--- a/depend/bitcoin/src/ipc/capnp/mining-types.h
+++ b/depend/bitcoin/src/ipc/capnp/mining-types.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2024 The Bitcoin Core developers
+// Copyright (c) 2024-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/capnp/mining.capnp b/depend/bitcoin/src/ipc/capnp/mining.capnp
index ed01e44a..c001ee25 100644
--- a/depend/bitcoin/src/ipc/capnp/mining.capnp
+++ b/depend/bitcoin/src/ipc/capnp/mining.capnp
@@ -1,4 +1,4 @@
-# Copyright (c) 2024 The Bitcoin Core developers
+# Copyright (c) 2024-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/capnp/mining.cpp b/depend/bitcoin/src/ipc/capnp/mining.cpp
index f598f1b2..706fd154 100644
--- a/depend/bitcoin/src/ipc/capnp/mining.cpp
+++ b/depend/bitcoin/src/ipc/capnp/mining.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2024 The Bitcoin Core developers
+// Copyright (c) 2024-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/capnp/protocol.cpp b/depend/bitcoin/src/ipc/capnp/protocol.cpp
index 27ef73e8..2645e46f 100644
--- a/depend/bitcoin/src/ipc/capnp/protocol.cpp
+++ b/depend/bitcoin/src/ipc/capnp/protocol.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -31,22 +31,6 @@ namespace ipc {
 namespace capnp {
 namespace {
 
-BCLog::Level ConvertIPCLogLevel(mp::Log level)
-{
-    switch (level) {
-        case mp::Log::Trace: return BCLog::Level::Trace;
-        case mp::Log::Debug: return BCLog::Level::Debug;
-        case mp::Log::Info: return BCLog::Level::Info;
-        case mp::Log::Warning: return BCLog::Level::Warning;
-        case mp::Log::Error: return BCLog::Level::Error;
-        case mp::Log::Raise: return BCLog::Level::Error;
-    } // no default case, so the compiler can warn about missing cases
-
-    // Be conservative and assume that if MP ever adds a new log level, it
-    // should only be shown at our most verbose level.
-    return BCLog::Level::Trace;
-}
-
 mp::Log GetRequestedIPCLogLevel()
 {
     if (LogAcceptCategory(BCLog::IPC, BCLog::Level::Trace)) return mp::Log::Trace;
@@ -58,8 +42,30 @@ mp::Log GetRequestedIPCLogLevel()
 
 void IpcLogFn(mp::LogMessage message)
 {
-    LogPrintLevel(BCLog::IPC, ConvertIPCLogLevel(message.level), "%s\n", message.message);
-    if (message.level == mp::Log::Raise) throw Exception(message.message);
+    switch (message.level) {
+    case mp::Log::Trace:
+        LogTrace(BCLog::IPC, "%s", message.message);
+        return;
+    case mp::Log::Debug:
+        LogDebug(BCLog::IPC, "%s", message.message);
+        return;
+    case mp::Log::Info:
+        LogInfo("ipc: %s", message.message);
+        return;
+    case mp::Log::Warning:
+        LogWarning("ipc: %s", message.message);
+        return;
+    case mp::Log::Error:
+        LogError("ipc: %s", message.message);
+        return;
+    case mp::Log::Raise:
+        LogError("ipc: %s", message.message);
+        throw Exception(message.message);
+    } // no default case, so the compiler can warn about missing cases
+
+    // Be conservative and assume that if MP ever adds a new log level, it
+    // should only be shown at our most verbose level.
+    LogTrace(BCLog::IPC, "%s", message.message);
 }
 
 class CapnpProtocol : public Protocol
diff --git a/depend/bitcoin/src/ipc/capnp/protocol.h b/depend/bitcoin/src/ipc/capnp/protocol.h
index eb057949..54a8ae6e 100644
--- a/depend/bitcoin/src/ipc/capnp/protocol.h
+++ b/depend/bitcoin/src/ipc/capnp/protocol.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/context.h b/depend/bitcoin/src/ipc/context.h
index 924d7d74..6abf4196 100644
--- a/depend/bitcoin/src/ipc/context.h
+++ b/depend/bitcoin/src/ipc/context.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/exception.h b/depend/bitcoin/src/ipc/exception.h
index 53dee812..064f0075 100644
--- a/depend/bitcoin/src/ipc/exception.h
+++ b/depend/bitcoin/src/ipc/exception.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/interfaces.cpp b/depend/bitcoin/src/ipc/interfaces.cpp
index d6b078e6..f40913d1 100644
--- a/depend/bitcoin/src/ipc/interfaces.cpp
+++ b/depend/bitcoin/src/ipc/interfaces.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/process.cpp b/depend/bitcoin/src/ipc/process.cpp
index 2e28f949..e89414be 100644
--- a/depend/bitcoin/src/ipc/process.cpp
+++ b/depend/bitcoin/src/ipc/process.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/process.h b/depend/bitcoin/src/ipc/process.h
index 2ed8b73f..67c69593 100644
--- a/depend/bitcoin/src/ipc/process.h
+++ b/depend/bitcoin/src/ipc/process.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/protocol.h b/depend/bitcoin/src/ipc/protocol.h
index 335ffddc..e7d66887 100644
--- a/depend/bitcoin/src/ipc/protocol.h
+++ b/depend/bitcoin/src/ipc/protocol.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/test/ipc_test.capnp b/depend/bitcoin/src/ipc/test/ipc_test.capnp
index 5e8dfd5d..adb92825 100644
--- a/depend/bitcoin/src/ipc/test/ipc_test.capnp
+++ b/depend/bitcoin/src/ipc/test/ipc_test.capnp
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 The Bitcoin Core developers
+# Copyright (c) 2023-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/test/ipc_test.cpp b/depend/bitcoin/src/ipc/test/ipc_test.cpp
index 506facde..a8c28fdc 100644
--- a/depend/bitcoin/src/ipc/test/ipc_test.cpp
+++ b/depend/bitcoin/src/ipc/test/ipc_test.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/test/ipc_test.h b/depend/bitcoin/src/ipc/test/ipc_test.h
index 1d5254fe..8ef3bc90 100644
--- a/depend/bitcoin/src/ipc/test/ipc_test.h
+++ b/depend/bitcoin/src/ipc/test/ipc_test.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/test/ipc_test_types.h b/depend/bitcoin/src/ipc/test/ipc_test_types.h
index 235cd8a7..e7cdfa3f 100644
--- a/depend/bitcoin/src/ipc/test/ipc_test_types.h
+++ b/depend/bitcoin/src/ipc/test/ipc_test_types.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2024 The Bitcoin Core developers
+// Copyright (c) 2024-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/ipc/test/ipc_tests.cpp b/depend/bitcoin/src/ipc/test/ipc_tests.cpp
index cacd317e..cc03904e 100644
--- a/depend/bitcoin/src/ipc/test/ipc_tests.cpp
+++ b/depend/bitcoin/src/ipc/test/ipc_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/kernel/bitcoinkernel.cpp b/depend/bitcoin/src/kernel/bitcoinkernel.cpp
index be7c22de..bbcfd66b 100644
--- a/depend/bitcoin/src/kernel/bitcoinkernel.cpp
+++ b/depend/bitcoin/src/kernel/bitcoinkernel.cpp
@@ -51,6 +51,7 @@
 #include <utility>
 #include <vector>
 
+using kernel::ChainstateRole;
 using util::ImmediateTaskRunner;
 
 // Define G_TRANSLATION_FUN symbol in libbitcoinkernel library so users of the
@@ -359,7 +360,7 @@ class KernelValidationInterface final : public CValidationInterface
         }
     }
 
-    void BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override
+    void BlockConnected(const ChainstateRole& role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override
     {
         if (m_cbs.block_connected) {
             m_cbs.block_connected(m_cbs.user_data,
@@ -494,6 +495,7 @@ struct btck_BlockHash : Handle<btck_BlockHash, uint256> {};
 struct btck_TransactionInput : Handle<btck_TransactionInput, CTxIn> {};
 struct btck_TransactionOutPoint: Handle<btck_TransactionOutPoint, COutPoint> {};
 struct btck_Txid: Handle<btck_Txid, Txid> {};
+struct btck_PrecomputedTransactionData : Handle<btck_PrecomputedTransactionData, PrecomputedTransactionData> {};
 
 btck_Transaction* btck_transaction_create(const void* raw_transaction, size_t raw_transaction_len)
 {
@@ -607,10 +609,46 @@ void btck_transaction_output_destroy(btck_TransactionOutput* output)
     delete output;
 }
 
+btck_PrecomputedTransactionData* btck_precomputed_transaction_data_create(
+    const btck_Transaction* tx_to,
+    const btck_TransactionOutput** spent_outputs_, size_t spent_outputs_len)
+{
+    try {
+        const CTransaction& tx{*btck_Transaction::get(tx_to)};
+        auto txdata{btck_PrecomputedTransactionData::create()};
+        if (spent_outputs_ != nullptr && spent_outputs_len > 0) {
+            assert(spent_outputs_len == tx.vin.size());
+            std::vector<CTxOut> spent_outputs;
+            spent_outputs.reserve(spent_outputs_len);
+            for (size_t i = 0; i < spent_outputs_len; i++) {
+                const CTxOut& tx_out{btck_TransactionOutput::get(spent_outputs_[i])};
+                spent_outputs.push_back(tx_out);
+            }
+            btck_PrecomputedTransactionData::get(txdata).Init(tx, std::move(spent_outputs));
+        } else {
+            btck_PrecomputedTransactionData::get(txdata).Init(tx, {});
+        }
+
+        return txdata;
+    } catch (...) {
+        return nullptr;
+    }
+}
+
+btck_PrecomputedTransactionData* btck_precomputed_transaction_data_copy(const btck_PrecomputedTransactionData* precomputed_txdata)
+{
+    return btck_PrecomputedTransactionData::copy(precomputed_txdata);
+}
+
+void btck_precomputed_transaction_data_destroy(btck_PrecomputedTransactionData* precomputed_txdata)
+{
+    delete precomputed_txdata;
+}
+
 int btck_script_pubkey_verify(const btck_ScriptPubkey* script_pubkey,
                               const int64_t amount,
                               const btck_Transaction* tx_to,
-                              const btck_TransactionOutput** spent_outputs_, size_t spent_outputs_len,
+                              const btck_PrecomputedTransactionData* precomputed_txdata,
                               const unsigned int input_index,
                               const btck_ScriptVerificationFlags flags,
                               btck_ScriptVerifyStatus* status)
@@ -623,31 +661,18 @@ int btck_script_pubkey_verify(const btck_ScriptPubkey* script_pubkey,
         return 0;
     }
 
-    if (flags & btck_ScriptVerificationFlags_TAPROOT && spent_outputs_ == nullptr) {
+    const CTransaction& tx{*btck_Transaction::get(tx_to)};
+    assert(input_index < tx.vin.size());
+
+    const PrecomputedTransactionData& txdata{precomputed_txdata ? btck_PrecomputedTransactionData::get(precomputed_txdata) : PrecomputedTransactionData(tx)};
+
+    if (flags & btck_ScriptVerificationFlags_TAPROOT && txdata.m_spent_outputs.empty()) {
         if (status) *status = btck_ScriptVerifyStatus_ERROR_SPENT_OUTPUTS_REQUIRED;
         return 0;
     }
 
     if (status) *status = btck_ScriptVerifyStatus_OK;
 
-    const CTransaction& tx{*btck_Transaction::get(tx_to)};
-    std::vector<CTxOut> spent_outputs;
-    if (spent_outputs_ != nullptr) {
-        assert(spent_outputs_len == tx.vin.size());
-        spent_outputs.reserve(spent_outputs_len);
-        for (size_t i = 0; i < spent_outputs_len; i++) {
-            const CTxOut& tx_out{btck_TransactionOutput::get(spent_outputs_[i])};
-            spent_outputs.push_back(tx_out);
-        }
-    }
-
-    assert(input_index < tx.vin.size());
-    PrecomputedTransactionData txdata{tx};
-
-    if (spent_outputs_ != nullptr && flags & btck_ScriptVerificationFlags_TAPROOT) {
-        txdata.Init(tx, std::move(spent_outputs));
-    }
-
     bool result = VerifyScript(tx.vin[input_index].scriptSig,
                                btck_ScriptPubkey::get(script_pubkey),
                                &tx.vin[input_index].scriptWitness,
@@ -981,13 +1006,9 @@ btck_ChainstateManager* btck_chainstate_manager_create(
             LogError("Failed to verify loaded chain state from your datadir: %s", chainstate_err.original);
             return nullptr;
         }
-
-        for (Chainstate* chainstate : WITH_LOCK(chainman->GetMutex(), return chainman->GetAll())) {
-            BlockValidationState state;
-            if (!chainstate->ActivateBestChain(state, nullptr)) {
-                LogError("Failed to connect best block: %s", state.ToString());
-                return nullptr;
-            }
+        if (auto result = chainman->ActivateBestChains(); !result) {
+            LogError("%s", util::ErrorString(result).original);
+            return nullptr;
         }
     } catch (const std::exception& e) {
         LogError("Failed to load chainstate: %s", e.what());
@@ -1012,7 +1033,7 @@ void btck_chainstate_manager_destroy(btck_ChainstateManager* chainman)
 {
     {
         LOCK(btck_ChainstateManager::get(chainman).m_chainman->GetMutex());
-        for (Chainstate* chainstate : btck_ChainstateManager::get(chainman).m_chainman->GetAll()) {
+        for (const auto& chainstate : btck_ChainstateManager::get(chainman).m_chainman->m_chainstates) {
             if (chainstate->CanFlushToDisk()) {
                 chainstate->ForceFlushStateToDisk();
                 chainstate->ResetCoinsViews();
diff --git a/depend/bitcoin/src/kernel/bitcoinkernel.h b/depend/bitcoin/src/kernel/bitcoinkernel.h
index 887a1dcd..0ee41adc 100644
--- a/depend/bitcoin/src/kernel/bitcoinkernel.h
+++ b/depend/bitcoin/src/kernel/bitcoinkernel.h
@@ -282,6 +282,16 @@ typedef struct btck_TransactionInput btck_TransactionInput;
  */
 typedef struct btck_TransactionOutPoint btck_TransactionOutPoint;
 
+/**
+ * Opaque data structure for holding precomputed transaction data.
+ *
+ * Reusable when verifying multiple inputs of the same transaction.
+ * This avoids recomputing transaction hashes for each input.
+ *
+ * Required when verifying a taproot input.
+ */
+typedef struct btck_PrecomputedTransactionData btck_PrecomputedTransactionData;
+
 typedef struct btck_Txid btck_Txid;
 
 /** Current sync state passed to tip changed callbacks. */
@@ -571,6 +581,40 @@ BITCOINKERNEL_API void btck_transaction_destroy(btck_Transaction* transaction);
 
 ///@}
 
+/** @name PrecomputedTransactionData
+ * Functions for working with precomputed transaction data.
+ */
+///@{
+
+/**
+ * @brief Create precomputed transaction data for script verification.
+ *
+ * @param[in] tx_to             Non-null.
+ * @param[in] spent_outputs     Nullable for non-taproot verification. Points to an array of
+ *                              outputs spent by the transaction.
+ * @param[in] spent_outputs_len Length of the spent_outputs array.
+ * @return                      The precomputed data, or null on error.
+ */
+BITCOINKERNEL_API btck_PrecomputedTransactionData* BITCOINKERNEL_WARN_UNUSED_RESULT btck_precomputed_transaction_data_create(
+    const btck_Transaction* tx_to,
+    const btck_TransactionOutput** spent_outputs, size_t spent_outputs_len) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Copy precomputed transaction data.
+ *
+ * @param[in] precomputed_txdata Non-null.
+ * @return                       The copied precomputed transaction data.
+ */
+BITCOINKERNEL_API btck_PrecomputedTransactionData* BITCOINKERNEL_WARN_UNUSED_RESULT btck_precomputed_transaction_data_copy(
+    const btck_PrecomputedTransactionData* precomputed_txdata) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Destroy the precomputed transaction data.
+ */
+BITCOINKERNEL_API void btck_precomputed_transaction_data_destroy(btck_PrecomputedTransactionData* precomputed_txdata);
+
+///@}
+
 /** @name ScriptPubkey
  * Functions for working with script pubkeys.
  */
@@ -598,26 +642,25 @@ BITCOINKERNEL_API btck_ScriptPubkey* BITCOINKERNEL_WARN_UNUSED_RESULT btck_scrip
  * @brief Verify if the input at input_index of tx_to spends the script pubkey
  * under the constraints specified by flags. If the
  * `btck_ScriptVerificationFlags_WITNESS` flag is set in the flags bitfield, the
- * amount parameter is used. If the taproot flag is set, the spent outputs
- * parameter is used to validate taproot transactions.
- *
- * @param[in] script_pubkey     Non-null, script pubkey to be spent.
- * @param[in] amount            Amount of the script pubkey's associated output. May be zero if
- *                              the witness flag is not set.
- * @param[in] tx_to             Non-null, transaction spending the script_pubkey.
- * @param[in] spent_outputs     Nullable if the taproot flag is not set. Points to an array of
- *                              outputs spent by the transaction.
- * @param[in] spent_outputs_len Length of the spent_outputs array.
- * @param[in] input_index       Index of the input in tx_to spending the script_pubkey.
- * @param[in] flags             Bitfield of btck_ScriptVerificationFlags controlling validation constraints.
- * @param[out] status           Nullable, will be set to an error code if the operation fails, or OK otherwise.
- * @return                      1 if the script is valid, 0 otherwise.
+ * amount parameter is used. If the taproot flag is set, the precomputed data
+ * must contain the spent outputs.
+ *
+ * @param[in] script_pubkey      Non-null, script pubkey to be spent.
+ * @param[in] amount             Amount of the script pubkey's associated output. May be zero if
+ *                               the witness flag is not set.
+ * @param[in] tx_to              Non-null, transaction spending the script_pubkey.
+ * @param[in] precomputed_txdata Nullable if the taproot flag is not set. Otherwise, precomputed data
+ *                               for tx_to with the spent outputs must be provided.
+ * @param[in] input_index        Index of the input in tx_to spending the script_pubkey.
+ * @param[in] flags              Bitfield of btck_ScriptVerificationFlags controlling validation constraints.
+ * @param[out] status            Nullable, will be set to an error code if the operation fails, or OK otherwise.
+ * @return                       1 if the script is valid, 0 otherwise.
  */
 BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_script_pubkey_verify(
     const btck_ScriptPubkey* script_pubkey,
     int64_t amount,
     const btck_Transaction* tx_to,
-    const btck_TransactionOutput** spent_outputs, size_t spent_outputs_len,
+    const btck_PrecomputedTransactionData* precomputed_txdata,
     unsigned int input_index,
     btck_ScriptVerificationFlags flags,
     btck_ScriptVerifyStatus* status) BITCOINKERNEL_ARG_NONNULL(1, 3);
diff --git a/depend/bitcoin/src/kernel/bitcoinkernel_wrapper.h b/depend/bitcoin/src/kernel/bitcoinkernel_wrapper.h
index 3fb90da7..5c1b8d07 100644
--- a/depend/bitcoin/src/kernel/bitcoinkernel_wrapper.h
+++ b/depend/bitcoin/src/kernel/bitcoinkernel_wrapper.h
@@ -367,6 +367,7 @@ class UniqueHandle
     const CType* get() const { return m_ptr.get(); }
 };
 
+class PrecomputedTransactionData;
 class Transaction;
 class TransactionOutput;
 
@@ -385,7 +386,7 @@ class ScriptPubkeyApi
 public:
     bool Verify(int64_t amount,
                 const Transaction& tx_to,
-                std::span<const TransactionOutput> spent_outputs,
+                const PrecomputedTransactionData* precomputed_txdata,
                 unsigned int input_index,
                 ScriptVerificationFlags flags,
                 ScriptVerifyStatus& status) const;
@@ -626,29 +627,30 @@ class Transaction : public Handle<btck_Transaction, btck_transaction_copy, btck_
         : Handle{view} {}
 };
 
+class PrecomputedTransactionData : public Handle<btck_PrecomputedTransactionData, btck_precomputed_transaction_data_copy, btck_precomputed_transaction_data_destroy>
+{
+public:
+    explicit PrecomputedTransactionData(const Transaction& tx_to, std::span<const TransactionOutput> spent_outputs)
+        : Handle{btck_precomputed_transaction_data_create(
+            tx_to.get(),
+            reinterpret_cast<const btck_TransactionOutput**>(
+                const_cast<TransactionOutput*>(spent_outputs.data())),
+            spent_outputs.size())} {}
+};
+
 template <typename Derived>
 bool ScriptPubkeyApi<Derived>::Verify(int64_t amount,
                                       const Transaction& tx_to,
-                                      const std::span<const TransactionOutput> spent_outputs,
+                                      const PrecomputedTransactionData* precomputed_txdata,
                                       unsigned int input_index,
                                       ScriptVerificationFlags flags,
                                       ScriptVerifyStatus& status) const
 {
-    const btck_TransactionOutput** spent_outputs_ptr = nullptr;
-    std::vector<const btck_TransactionOutput*> raw_spent_outputs;
-    if (spent_outputs.size() > 0) {
-        raw_spent_outputs.reserve(spent_outputs.size());
-
-        for (const auto& output : spent_outputs) {
-            raw_spent_outputs.push_back(output.get());
-        }
-        spent_outputs_ptr = raw_spent_outputs.data();
-    }
     auto result = btck_script_pubkey_verify(
         impl(),
         amount,
         tx_to.get(),
-        spent_outputs_ptr, spent_outputs.size(),
+        precomputed_txdata ? precomputed_txdata->get() : nullptr,
         input_index,
         static_cast<btck_ScriptVerificationFlags>(flags),
         reinterpret_cast<btck_ScriptVerifyStatus*>(&status));
diff --git a/depend/bitcoin/src/kernel/blockmanager_opts.h b/depend/bitcoin/src/kernel/blockmanager_opts.h
index 5c7b24d7..3d8af68b 100644
--- a/depend/bitcoin/src/kernel/blockmanager_opts.h
+++ b/depend/bitcoin/src/kernel/blockmanager_opts.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/kernel/chain.cpp b/depend/bitcoin/src/kernel/chain.cpp
index 318c956b..0a33e9a1 100644
--- a/depend/bitcoin/src/kernel/chain.cpp
+++ b/depend/bitcoin/src/kernel/chain.cpp
@@ -1,15 +1,19 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <chain.h>
-#include <interfaces/chain.h>
 #include <kernel/chain.h>
+
+#include <chain.h>
+#include <kernel/cs_main.h>
+#include <kernel/types.h>
 #include <sync.h>
 #include <uint256.h>
 
 class CBlock;
 
+using kernel::ChainstateRole;
+
 namespace kernel {
 interfaces::BlockInfo MakeBlockInfo(const CBlockIndex* index, const CBlock* data)
 {
@@ -25,14 +29,15 @@ interfaces::BlockInfo MakeBlockInfo(const CBlockIndex* index, const CBlock* data
     info.data = data;
     return info;
 }
-} // namespace kernel
 
 std::ostream& operator<<(std::ostream& os, const ChainstateRole& role) {
-    switch(role) {
-        case ChainstateRole::NORMAL: os << "normal"; break;
-        case ChainstateRole::ASSUMEDVALID: os << "assumedvalid"; break;
-        case ChainstateRole::BACKGROUND: os << "background"; break;
-        default: os.setstate(std::ios_base::failbit);
+    if (!role.validated) {
+        os << "assumedvalid";
+    } else if (role.historical) {
+        os << "background";
+    } else {
+        os << "normal";
     }
     return os;
 }
+} // namespace kernel
diff --git a/depend/bitcoin/src/kernel/chain.h b/depend/bitcoin/src/kernel/chain.h
index feba24a5..5afa51f4 100644
--- a/depend/bitcoin/src/kernel/chain.h
+++ b/depend/bitcoin/src/kernel/chain.h
@@ -1,39 +1,42 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_KERNEL_CHAIN_H
 #define BITCOIN_KERNEL_CHAIN_H
 
-#include<iostream>
+#include <attributes.h>
+
+#include <iostream>
 
 class CBlock;
 class CBlockIndex;
+class CBlockUndo;
+class uint256;
+
 namespace interfaces {
-struct BlockInfo;
+//! Block data sent with blockConnected, blockDisconnected notifications.
+struct BlockInfo {
+    const uint256& hash;
+    const uint256* prev_hash = nullptr;
+    int height = -1;
+    int file_number = -1;
+    unsigned data_pos = 0;
+    const CBlock* data = nullptr;
+    const CBlockUndo* undo_data = nullptr;
+    // The maximum time in the chain up to and including this block.
+    // A timestamp that can only move forward.
+    unsigned int chain_time_max{0};
+
+    BlockInfo(const uint256& hash LIFETIMEBOUND) : hash(hash) {}
+};
 } // namespace interfaces
 
 namespace kernel {
+struct ChainstateRole;
 //! Return data from block index.
 interfaces::BlockInfo MakeBlockInfo(const CBlockIndex* block_index, const CBlock* data = nullptr);
-
-} // namespace kernel
-
-//! This enum describes the various roles a specific Chainstate instance can take.
-//! Other parts of the system sometimes need to vary in behavior depending on the
-//! existence of a background validation chainstate, e.g. when building indexes.
-enum class ChainstateRole {
-    // Single chainstate in use, "normal" IBD mode.
-    NORMAL,
-
-    // Doing IBD-style validation in the background. Implies use of an assumed-valid
-    // chainstate.
-    BACKGROUND,
-
-    // Active assumed-valid chainstate. Implies use of a background IBD chainstate.
-    ASSUMEDVALID,
-};
-
 std::ostream& operator<<(std::ostream& os, const ChainstateRole& role);
+} // namespace kernel
 
 #endif // BITCOIN_KERNEL_CHAIN_H
diff --git a/depend/bitcoin/src/kernel/chainparams.h b/depend/bitcoin/src/kernel/chainparams.h
index 0a1a5bdf..99437ee7 100644
--- a/depend/bitcoin/src/kernel/chainparams.h
+++ b/depend/bitcoin/src/kernel/chainparams.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/kernel/chainstatemanager_opts.h b/depend/bitcoin/src/kernel/chainstatemanager_opts.h
index 37a87931..134b9319 100644
--- a/depend/bitcoin/src/kernel/chainstatemanager_opts.h
+++ b/depend/bitcoin/src/kernel/chainstatemanager_opts.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/kernel/checks.cpp b/depend/bitcoin/src/kernel/checks.cpp
index e4a13ee4..fd010cc5 100644
--- a/depend/bitcoin/src/kernel/checks.cpp
+++ b/depend/bitcoin/src/kernel/checks.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/kernel/checks.h b/depend/bitcoin/src/kernel/checks.h
index fd8c1670..a288476e 100644
--- a/depend/bitcoin/src/kernel/checks.h
+++ b/depend/bitcoin/src/kernel/checks.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/kernel/coinstats.cpp b/depend/bitcoin/src/kernel/coinstats.cpp
index 6270f365..18a2de51 100644
--- a/depend/bitcoin/src/kernel/coinstats.cpp
+++ b/depend/bitcoin/src/kernel/coinstats.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/kernel/coinstats.h b/depend/bitcoin/src/kernel/coinstats.h
index 8a782ed5..35315f65 100644
--- a/depend/bitcoin/src/kernel/coinstats.h
+++ b/depend/bitcoin/src/kernel/coinstats.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/kernel/context.cpp b/depend/bitcoin/src/kernel/context.cpp
index 2420d18d..e74f29cb 100644
--- a/depend/bitcoin/src/kernel/context.cpp
+++ b/depend/bitcoin/src/kernel/context.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/kernel/context.h b/depend/bitcoin/src/kernel/context.h
index 159af126..8edd18c2 100644
--- a/depend/bitcoin/src/kernel/context.h
+++ b/depend/bitcoin/src/kernel/context.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/kernel/cs_main.cpp b/depend/bitcoin/src/kernel/cs_main.cpp
index d27cb7ca..2ef01da9 100644
--- a/depend/bitcoin/src/kernel/cs_main.cpp
+++ b/depend/bitcoin/src/kernel/cs_main.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/kernel/cs_main.h b/depend/bitcoin/src/kernel/cs_main.h
index 8d03903b..a9bd3e8d 100644
--- a/depend/bitcoin/src/kernel/cs_main.h
+++ b/depend/bitcoin/src/kernel/cs_main.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/kernel/disconnected_transactions.h b/depend/bitcoin/src/kernel/disconnected_transactions.h
index bc098f71..f34b7dea 100644
--- a/depend/bitcoin/src/kernel/disconnected_transactions.h
+++ b/depend/bitcoin/src/kernel/disconnected_transactions.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/kernel/mempool_limits.h b/depend/bitcoin/src/kernel/mempool_limits.h
index 7ca5d2bc..548e45c7 100644
--- a/depend/bitcoin/src/kernel/mempool_limits.h
+++ b/depend/bitcoin/src/kernel/mempool_limits.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #ifndef BITCOIN_KERNEL_MEMPOOL_LIMITS_H
diff --git a/depend/bitcoin/src/kernel/mempool_options.h b/depend/bitcoin/src/kernel/mempool_options.h
index d57dbb39..a18d565c 100644
--- a/depend/bitcoin/src/kernel/mempool_options.h
+++ b/depend/bitcoin/src/kernel/mempool_options.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #ifndef BITCOIN_KERNEL_MEMPOOL_OPTIONS_H
diff --git a/depend/bitcoin/src/kernel/messagestartchars.h b/depend/bitcoin/src/kernel/messagestartchars.h
index 829616dc..a3053417 100644
--- a/depend/bitcoin/src/kernel/messagestartchars.h
+++ b/depend/bitcoin/src/kernel/messagestartchars.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/kernel/notifications_interface.h b/depend/bitcoin/src/kernel/notifications_interface.h
index 816f0630..35a65cec 100644
--- a/depend/bitcoin/src/kernel/notifications_interface.h
+++ b/depend/bitcoin/src/kernel/notifications_interface.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/kernel/types.h b/depend/bitcoin/src/kernel/types.h
new file mode 100644
index 00000000..164d4cfd
--- /dev/null
+++ b/depend/bitcoin/src/kernel/types.h
@@ -0,0 +1,30 @@
+// Copyright (c) The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+//! @file kernel/types.h is a home for simple enum and struct type definitions
+//! that can be used internally by functions in the libbitcoin_kernel library,
+//! but also used externally by node, wallet, and GUI code.
+//!
+//! This file is intended to define only simple types that do not have external
+//! dependencies. More complicated types should be defined in dedicated header
+//! files.
+
+#ifndef BITCOIN_KERNEL_TYPES_H
+#define BITCOIN_KERNEL_TYPES_H
+
+namespace kernel {
+//! Information about chainstate that notifications are sent from.
+struct ChainstateRole {
+    //! Whether this is a notification from a chainstate that's been fully
+    //! validated starting from the genesis block. False if it is from an
+    //! assumeutxo snapshot chainstate that has not been validated yet.
+    bool validated{true};
+
+    //! Whether this is a historical chainstate downloading old blocks to
+    //! validate an assumeutxo snapshot, not syncing to the network tip.
+    bool historical{false};
+};
+} // namespace kernel
+
+#endif // BITCOIN_KERNEL_TYPES_H
diff --git a/depend/bitcoin/src/key_io.h b/depend/bitcoin/src/key_io.h
index e387273e..adc80137 100644
--- a/depend/bitcoin/src/key_io.h
+++ b/depend/bitcoin/src/key_io.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/logging.cpp b/depend/bitcoin/src/logging.cpp
index 5fb42bba..113fc346 100644
--- a/depend/bitcoin/src/logging.cpp
+++ b/depend/bitcoin/src/logging.cpp
@@ -75,7 +75,7 @@ bool BCLog::Logger::StartLogging()
     // dump buffered messages from before we opened the log
     m_buffering = false;
     if (m_buffer_lines_discarded > 0) {
-        LogPrintStr_(strprintf("Early logging buffer overflowed, %d log lines discarded.\n", m_buffer_lines_discarded), std::source_location::current(), BCLog::ALL, Level::Info, /*should_ratelimit=*/false);
+        LogPrintStr_(strprintf("Early logging buffer overflowed, %d log lines discarded.\n", m_buffer_lines_discarded), SourceLocation{__func__}, BCLog::ALL, Level::Info, /*should_ratelimit=*/false);
     }
     while (!m_msgs_before_open.empty()) {
         const auto& buflog = m_msgs_before_open.front();
@@ -388,7 +388,7 @@ std::shared_ptr<BCLog::LogRateLimiter> BCLog::LogRateLimiter::Create(
 }
 
 BCLog::LogRateLimiter::Status BCLog::LogRateLimiter::Consume(
-    const std::source_location& source_loc,
+    const SourceLocation& source_loc,
     const std::string& str)
 {
     StdLockGuard scoped_lock(m_mutex);
@@ -403,14 +403,14 @@ BCLog::LogRateLimiter::Status BCLog::LogRateLimiter::Consume(
     return status;
 }
 
-void BCLog::Logger::FormatLogStrInPlace(std::string& str, BCLog::LogFlags category, BCLog::Level level, const std::source_location& source_loc, std::string_view threadname, SystemClock::time_point now, std::chrono::seconds mocktime) const
+void BCLog::Logger::FormatLogStrInPlace(std::string& str, BCLog::LogFlags category, BCLog::Level level, const SourceLocation& source_loc, std::string_view threadname, SystemClock::time_point now, std::chrono::seconds mocktime) const
 {
     if (!str.ends_with('\n')) str.push_back('\n');
 
     str.insert(0, GetLogPrefix(category, level));
 
     if (m_log_sourcelocations) {
-        str.insert(0, strprintf("[%s:%d] [%s] ", RemovePrefixView(source_loc.file_name(), "./"), source_loc.line(), source_loc.function_name()));
+        str.insert(0, strprintf("[%s:%d] [%s] ", RemovePrefixView(source_loc.file_name(), "./"), source_loc.line(), source_loc.function_name_short()));
     }
 
     if (m_log_threadnames) {
@@ -420,14 +420,14 @@ void BCLog::Logger::FormatLogStrInPlace(std::string& str, BCLog::LogFlags catego
     str.insert(0, LogTimestampStr(now, mocktime));
 }
 
-void BCLog::Logger::LogPrintStr(std::string_view str, std::source_location&& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
+void BCLog::Logger::LogPrintStr(std::string_view str, SourceLocation&& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
 {
     StdLockGuard scoped_lock(m_cs);
     return LogPrintStr_(str, std::move(source_loc), category, level, should_ratelimit);
 }
 
 // NOLINTNEXTLINE(misc-no-recursion)
-void BCLog::Logger::LogPrintStr_(std::string_view str, std::source_location&& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
+void BCLog::Logger::LogPrintStr_(std::string_view str, SourceLocation&& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
 {
     std::string str_prefixed = LogEscapeMessage(str);
 
@@ -470,10 +470,10 @@ void BCLog::Logger::LogPrintStr_(std::string_view str, std::source_location&& so
                              "the last time window of %is. Suppressing logging to disk from this "
                              "source location until time window resets. Console logging "
                              "unaffected. Last log entry.",
-                             source_loc.file_name(), source_loc.line(), source_loc.function_name(),
+                             source_loc.file_name(), source_loc.line(), source_loc.function_name_short(),
                              m_limiter->m_max_bytes,
                              Ticks<std::chrono::seconds>(m_limiter->m_reset_window)),
-                         std::source_location::current(), LogFlags::ALL, Level::Warning, /*should_ratelimit=*/false); // with should_ratelimit=false, this cannot lead to infinite recursion
+                         SourceLocation{__func__}, LogFlags::ALL, Level::Warning, /*should_ratelimit=*/false); // with should_ratelimit=false, this cannot lead to infinite recursion
         } else if (status == LogRateLimiter::Status::STILL_SUPPRESSED) {
             ratelimit = true;
         }
@@ -564,7 +564,7 @@ void BCLog::LogRateLimiter::Reset()
         LogPrintLevel_(
             LogFlags::ALL, Level::Warning, /*should_ratelimit=*/false,
             "Restarting logging from %s:%d (%s): %d bytes were dropped during the last %ss.",
-            source_loc.file_name(), source_loc.line(), source_loc.function_name(),
+            source_loc.file_name(), source_loc.line(), source_loc.function_name_short(),
             stats.m_dropped_bytes, Ticks<std::chrono::seconds>(m_reset_window));
     }
 }
diff --git a/depend/bitcoin/src/logging.h b/depend/bitcoin/src/logging.h
index 4a6f1d16..2105039f 100644
--- a/depend/bitcoin/src/logging.h
+++ b/depend/bitcoin/src/logging.h
@@ -9,6 +9,7 @@
 #include <crypto/siphash.h>
 #include <threadsafety.h>
 #include <tinyformat.h>
+#include <util/check.h>
 #include <util/fs.h>
 #include <util/string.h>
 #include <util/time.h>
@@ -36,15 +37,35 @@ extern const char * const DEFAULT_DEBUGLOGFILE;
 
 extern bool fLogIPs;
 
+/// Like std::source_location, but allowing to override the function name.
+class SourceLocation
+{
+public:
+    /// The func argument must be constructed from the C++11 __func__ macro.
+    /// Ref: https://en.cppreference.com/w/cpp/language/function.html#func
+    /// Non-static string literals are not supported.
+    SourceLocation(const char* func,
+                   std::source_location loc = std::source_location::current())
+        : m_func{func}, m_loc{loc} {}
+
+    std::string_view file_name() const { return m_loc.file_name(); }
+    std::uint_least32_t line() const { return m_loc.line(); }
+    std::string_view function_name_short() const { return m_func; }
+
+private:
+    std::string_view m_func;
+    std::source_location m_loc;
+};
+
 struct SourceLocationEqual {
-    bool operator()(const std::source_location& lhs, const std::source_location& rhs) const noexcept
+    bool operator()(const SourceLocation& lhs, const SourceLocation& rhs) const noexcept
     {
         return lhs.line() == rhs.line() && std::string_view(lhs.file_name()) == std::string_view(rhs.file_name());
     }
 };
 
 struct SourceLocationHasher {
-    size_t operator()(const std::source_location& s) const noexcept
+    size_t operator()(const SourceLocation& s) const noexcept
     {
         // Use CSipHasher(0, 0) as a simple way to get uniform distribution.
         return size_t(CSipHasher(0, 0)
@@ -130,7 +151,7 @@ namespace BCLog {
         mutable StdMutex m_mutex;
 
         //! Stats for each source location that has attempted to log something.
-        std::unordered_map<std::source_location, Stats, SourceLocationHasher, SourceLocationEqual> m_source_locations GUARDED_BY(m_mutex);
+        std::unordered_map<SourceLocation, Stats, SourceLocationHasher, SourceLocationEqual> m_source_locations GUARDED_BY(m_mutex);
         //! Whether any log locations are suppressed. Cached view on m_source_locations for performance reasons.
         std::atomic<bool> m_suppression_active{false};
         LogRateLimiter(uint64_t max_bytes, std::chrono::seconds reset_window);
@@ -162,7 +183,7 @@ namespace BCLog {
         //! Consumes `source_loc`'s available bytes corresponding to the size of the (formatted)
         //! `str` and returns its status.
         [[nodiscard]] Status Consume(
-            const std::source_location& source_loc,
+            const SourceLocation& source_loc,
             const std::string& str) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
         //! Resets all usage to zero. Called periodically by the scheduler.
         void Reset() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
@@ -177,7 +198,7 @@ namespace BCLog {
             SystemClock::time_point now;
             std::chrono::seconds mocktime;
             std::string str, threadname;
-            std::source_location source_loc;
+            SourceLocation source_loc;
             LogFlags category;
             Level level;
         };
@@ -205,7 +226,7 @@ namespace BCLog {
         /** Log categories bitfield. */
         std::atomic<CategoryMask> m_categories{BCLog::NONE};
 
-        void FormatLogStrInPlace(std::string& str, LogFlags category, Level level, const std::source_location& source_loc, std::string_view threadname, SystemClock::time_point now, std::chrono::seconds mocktime) const;
+        void FormatLogStrInPlace(std::string& str, LogFlags category, Level level, const SourceLocation& source_loc, std::string_view threadname, SystemClock::time_point now, std::chrono::seconds mocktime) const;
 
         std::string LogTimestampStr(SystemClock::time_point now, std::chrono::seconds mocktime) const;
 
@@ -213,7 +234,7 @@ namespace BCLog {
         std::list<std::function<void(const std::string&)>> m_print_callbacks GUARDED_BY(m_cs) {};
 
         /** Send a string to the log output (internal) */
-        void LogPrintStr_(std::string_view str, std::source_location&& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
+        void LogPrintStr_(std::string_view str, SourceLocation&& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
             EXCLUSIVE_LOCKS_REQUIRED(m_cs);
 
         std::string GetLogPrefix(LogFlags category, Level level) const;
@@ -232,7 +253,7 @@ namespace BCLog {
         std::atomic<bool> m_reopen_file{false};
 
         /** Send a string to the log output */
-        void LogPrintStr(std::string_view str, std::source_location&& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
+        void LogPrintStr(std::string_view str, SourceLocation&& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
             EXCLUSIVE_LOCKS_REQUIRED(!m_cs);
 
         /** Returns whether logs will be written to any output */
@@ -346,7 +367,7 @@ static inline bool LogAcceptCategory(BCLog::LogFlags category, BCLog::Level leve
 bool GetLogCategory(BCLog::LogFlags& flag, std::string_view str);
 
 template <typename... Args>
-inline void LogPrintFormatInternal(std::source_location&& source_loc, BCLog::LogFlags flag, BCLog::Level level, bool should_ratelimit, util::ConstevalFormatString<sizeof...(Args)> fmt, const Args&... args)
+inline void LogPrintFormatInternal(SourceLocation&& source_loc, BCLog::LogFlags flag, BCLog::Level level, bool should_ratelimit, util::ConstevalFormatString<sizeof...(Args)> fmt, const Args&... args)
 {
     if (LogInstance().Enabled()) {
         std::string log_msg;
@@ -359,7 +380,9 @@ inline void LogPrintFormatInternal(std::source_location&& source_loc, BCLog::Log
     }
 }
 
-#define LogPrintLevel_(category, level, should_ratelimit, ...) LogPrintFormatInternal(std::source_location::current(), category, level, should_ratelimit, __VA_ARGS__)
+// Allow __func__ to be used in any context without warnings:
+// NOLINTNEXTLINE(bugprone-lambda-function-name)
+#define LogPrintLevel_(category, level, should_ratelimit, ...) LogPrintFormatInternal(SourceLocation{__func__}, category, level, should_ratelimit, __VA_ARGS__)
 
 // Log unconditionally. Uses basic rate limiting to mitigate disk filling attacks.
 // Be conservative when using functions that unconditionally log to debug.log!
@@ -372,22 +395,20 @@ inline void LogPrintFormatInternal(std::source_location&& source_loc, BCLog::Log
 // Use a macro instead of a function for conditional logging to prevent
 // evaluating arguments when logging for the category is not enabled.
 
-// Log by prefixing the output with the passed category name and severity level. This can either
-// log conditionally if the category is allowed or unconditionally if level >= BCLog::Level::Info
-// is passed. If this function logs unconditionally, logging to disk is rate-limited. This is
-// important so that callers don't need to worry about accidentally introducing a disk-fill
-// vulnerability if level >= Info is used. Additionally, users specifying -debug are assumed to be
+// Log by prefixing the output with the passed category name and severity level. This logs conditionally if
+// the category is allowed. No rate limiting is applied, because users specifying -debug are assumed to be
 // developers or power users who are aware that -debug may cause excessive disk usage due to logging.
-#define LogPrintLevel(category, level, ...)                           \
+#define detail_LogIfCategoryAndLevelEnabled(category, level, ...)     \
     do {                                                              \
         if (LogAcceptCategory((category), (level))) {                 \
             bool rate_limit{level >= BCLog::Level::Info};             \
+            Assume(!rate_limit);/*Only called with the levels below*/ \
             LogPrintLevel_(category, level, rate_limit, __VA_ARGS__); \
         }                                                             \
     } while (0)
 
 // Log conditionally, prefixing the output with the passed category name.
-#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
-#define LogTrace(category, ...) LogPrintLevel(category, BCLog::Level::Trace, __VA_ARGS__)
+#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, BCLog::Level::Debug, __VA_ARGS__)
+#define LogTrace(category, ...) detail_LogIfCategoryAndLevelEnabled(category, BCLog::Level::Trace, __VA_ARGS__)
 
 #endif // BITCOIN_LOGGING_H
diff --git a/depend/bitcoin/src/logging/timer.h b/depend/bitcoin/src/logging/timer.h
index 5a969243..52a86e71 100644
--- a/depend/bitcoin/src/logging/timer.h
+++ b/depend/bitcoin/src/logging/timer.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/mapport.cpp b/depend/bitcoin/src/mapport.cpp
index e71bb1af..43918ebf 100644
--- a/depend/bitcoin/src/mapport.cpp
+++ b/depend/bitcoin/src/mapport.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
@@ -47,7 +47,7 @@ static void ProcessPCP()
     // Local functor to handle result from PCP/NATPMP mapping.
     auto handle_mapping = [&](std::variant<MappingResult, MappingError> &res) -> void {
         if (MappingResult* mapping = std::get_if<MappingResult>(&res)) {
-            LogPrintLevel(BCLog::NET, BCLog::Level::Info, "portmap: Added mapping %s\n", mapping->ToString());
+            LogInfo("portmap: Added mapping %s", mapping->ToString());
             AddLocal(mapping->external, LOCAL_MAPPED);
             ret = true;
             actual_lifetime = std::min(actual_lifetime, mapping->lifetime);
diff --git a/depend/bitcoin/src/mapport.h b/depend/bitcoin/src/mapport.h
index ea16aef7..2133907b 100644
--- a/depend/bitcoin/src/mapport.h
+++ b/depend/bitcoin/src/mapport.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/memusage.h b/depend/bitcoin/src/memusage.h
index 9d9e549e..02691bb4 100644
--- a/depend/bitcoin/src/memusage.h
+++ b/depend/bitcoin/src/memusage.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/merkleblock.cpp b/depend/bitcoin/src/merkleblock.cpp
index 34ff06e5..0bd8af5b 100644
--- a/depend/bitcoin/src/merkleblock.cpp
+++ b/depend/bitcoin/src/merkleblock.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
@@ -40,7 +40,7 @@ CMerkleBlock::CMerkleBlock(const CBlock& block, CBloomFilter* filter, const std:
     for (unsigned int i = 0; i < block.vtx.size(); i++)
     {
         const Txid& hash{block.vtx[i]->GetHash()};
-        if (txids && txids->count(hash)) {
+        if (txids && txids->contains(hash)) {
             vMatch.push_back(true);
         } else if (filter && filter->IsRelevantAndUpdate(*block.vtx[i])) {
             vMatch.push_back(true);
diff --git a/depend/bitcoin/src/merkleblock.h b/depend/bitcoin/src/merkleblock.h
index a7b37d3b..79611af0 100644
--- a/depend/bitcoin/src/merkleblock.h
+++ b/depend/bitcoin/src/merkleblock.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/musig.cpp b/depend/bitcoin/src/musig.cpp
index 686ec5e8..706874be 100644
--- a/depend/bitcoin/src/musig.cpp
+++ b/depend/bitcoin/src/musig.cpp
@@ -7,6 +7,13 @@
 
 #include <secp256k1_musig.h>
 
+//! 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}; }(),
+};
+
 static bool GetMuSig2KeyAggCache(const std::vector<CPubKey>& pubkeys, secp256k1_musig_keyagg_cache& keyagg_cache)
 {
     // Parse the pubkeys
diff --git a/depend/bitcoin/src/musig.h b/depend/bitcoin/src/musig.h
index 10234568..f518ae81 100644
--- a/depend/bitcoin/src/musig.h
+++ b/depend/bitcoin/src/musig.h
@@ -14,15 +14,6 @@ struct secp256k1_musig_keyagg_cache;
 class MuSig2SecNonceImpl;
 struct secp256k1_musig_secnonce;
 
-//! 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}; }(),
-};
-
-
-
 constexpr size_t MUSIG2_PUBNONCE_SIZE{66};
 
 //! Compute the full aggregate pubkey from the given participant pubkeys in their current order.
diff --git a/depend/bitcoin/src/net.cpp b/depend/bitcoin/src/net.cpp
index 4abcf20d..bd3d0bb1 100644
--- a/depend/bitcoin/src/net.cpp
+++ b/depend/bitcoin/src/net.cpp
@@ -329,7 +329,7 @@ bool SeenLocal(const CService& addr)
 bool IsLocal(const CService& addr)
 {
     LOCK(g_maplocalhost_mutex);
-    return mapLocalHost.count(addr) > 0;
+    return mapLocalHost.contains(addr);
 }
 
 bool CConnman::AlreadyConnectedToHost(std::string_view host) const
@@ -2629,7 +2629,7 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect, std
                 // (e.g. in case of -onlynet changes by the user), fixed seeds will
                 // be loaded only for networks for which we have no addresses.
                 seed_addrs.erase(std::remove_if(seed_addrs.begin(), seed_addrs.end(),
-                                                [&fixed_seed_networks](const CAddress& addr) { return fixed_seed_networks.count(addr.GetNetwork()) == 0; }),
+                                                [&fixed_seed_networks](const CAddress& addr) { return !fixed_seed_networks.contains(addr.GetNetwork()); }),
                                  seed_addrs.end());
                 CNetAddr local;
                 local.SetInternal("fixedseeds");
@@ -2776,7 +2776,7 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect, std
                 m_anchors.pop_back();
                 if (!addr.IsValid() || IsLocal(addr) || !g_reachable_nets.Contains(addr) ||
                     !m_msgproc->HasAllDesirableServiceFlags(addr.nServices) ||
-                    outbound_ipv46_peer_netgroups.count(m_netgroupman.GetGroup(addr))) continue;
+                    outbound_ipv46_peer_netgroups.contains(m_netgroupman.GetGroup(addr))) continue;
                 addrConnect = addr;
                 LogDebug(BCLog::NET, "Trying to make an anchor connection to %s\n", addrConnect.ToStringAddrPort());
                 break;
@@ -2822,7 +2822,7 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect, std
             }
 
             // Require outbound IPv4/IPv6 connections, other than feelers, to be to distinct network groups
-            if (!fFeeler && outbound_ipv46_peer_netgroups.count(m_netgroupman.GetGroup(addr))) {
+            if (!fFeeler && outbound_ipv46_peer_netgroups.contains(m_netgroupman.GetGroup(addr))) {
                 continue;
             }
 
diff --git a/depend/bitcoin/src/net_permissions.cpp b/depend/bitcoin/src/net_permissions.cpp
index 8f0042c1..122099c9 100644
--- a/depend/bitcoin/src/net_permissions.cpp
+++ b/depend/bitcoin/src/net_permissions.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/net_permissions.h b/depend/bitcoin/src/net_permissions.h
index c93e18e1..fbaa8f1d 100644
--- a/depend/bitcoin/src/net_permissions.h
+++ b/depend/bitcoin/src/net_permissions.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/net_processing.cpp b/depend/bitcoin/src/net_processing.cpp
index 00acebd1..6ec55256 100644
--- a/depend/bitcoin/src/net_processing.cpp
+++ b/depend/bitcoin/src/net_processing.cpp
@@ -22,7 +22,7 @@
 #include <flatfile.h>
 #include <headerssync.h>
 #include <index/blockfilterindex.h>
-#include <kernel/chain.h>
+#include <kernel/types.h>
 #include <logging.h>
 #include <merkleblock.h>
 #include <net.h>
@@ -85,6 +85,7 @@
 #include <typeinfo>
 #include <utility>
 
+using kernel::ChainstateRole;
 using namespace util::hex_literals;
 
 TRACEPOINT_SEMAPHORE(net, inbound_message);
@@ -507,7 +508,7 @@ class PeerManagerImpl final : public PeerManager
     /** Overridden from CValidationInterface. */
     void ActiveTipChange(const CBlockIndex& new_tip, bool) override
         EXCLUSIVE_LOCKS_REQUIRED(!m_tx_download_mutex);
-    void BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected) override
+    void BlockConnected(const ChainstateRole& role, const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected) override
         EXCLUSIVE_LOCKS_REQUIRED(!m_tx_download_mutex);
     void BlockDisconnected(const std::shared_ptr<const CBlock> &block, const CBlockIndex* pindex) override
         EXCLUSIVE_LOCKS_REQUIRED(!m_tx_download_mutex);
@@ -1158,7 +1159,7 @@ std::chrono::microseconds PeerManagerImpl::NextInvToInbounds(std::chrono::micros
 
 bool PeerManagerImpl::IsBlockRequested(const uint256& hash)
 {
-    return mapBlocksInFlight.count(hash);
+    return mapBlocksInFlight.contains(hash);
 }
 
 bool PeerManagerImpl::IsBlockRequestedFromOutbound(const uint256& hash)
@@ -1387,7 +1388,7 @@ void PeerManagerImpl::FindNextBlocksToDownload(const Peer& peer, unsigned int co
     // When we sync with AssumeUtxo and discover the snapshot is not in the peer's best chain, abort:
     // We can't reorg to this chain due to missing undo data until the background sync has finished,
     // so downloading blocks from it would be futile.
-    const CBlockIndex* snap_base{m_chainman.GetSnapshotBaseBlock()};
+    const CBlockIndex* snap_base{m_chainman.CurrentChainstate().SnapshotBase()};
     if (snap_base && state->pindexBestKnownBlock->GetAncestor(snap_base->nHeight) != snap_base) {
         LogDebug(BCLog::NET, "Not downloading blocks from peer=%d, which doesn't have the snapshot block in its best chain.\n", peer.m_id);
         return;
@@ -1946,7 +1947,7 @@ void PeerManagerImpl::ActiveTipChange(const CBlockIndex& new_tip, bool is_ibd)
  * possibly reduce dynamic block stalling timeout.
  */
 void PeerManagerImpl::BlockConnected(
-    ChainstateRole role,
+    const ChainstateRole& role,
     const std::shared_ptr<const CBlock>& pblock,
     const CBlockIndex* pindex)
 {
@@ -1965,8 +1966,8 @@ void PeerManagerImpl::BlockConnected(
     }
 
     // The following task can be skipped since we don't maintain a mempool for
-    // the ibd/background chainstate.
-    if (role == ChainstateRole::BACKGROUND) {
+    // the historical chainstate.
+    if (role.historical) {
         return;
     }
     LOCK(m_tx_download_mutex);
@@ -5921,18 +5922,19 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                 return std::max(0, MAX_BLOCKS_IN_TRANSIT_PER_PEER - static_cast<int>(state.vBlocksInFlight.size()));
             };
 
-            // If a snapshot chainstate is in use, we want to find its next blocks
-            // before the background chainstate to prioritize getting to network tip.
+            // If there are multiple chainstates, download blocks for the
+            // current chainstate first, to prioritize getting to network tip
+            // before downloading historical blocks.
             FindNextBlocksToDownload(*peer, get_inflight_budget(), vToDownload, staller);
-            if (m_chainman.BackgroundSyncInProgress() && !IsLimitedPeer(*peer)) {
-                // If the background tip is not an ancestor of the snapshot block,
+            auto historical_blocks{m_chainman.GetHistoricalBlockRange()};
+            if (historical_blocks && !IsLimitedPeer(*peer)) {
+                // If the first needed historical block is not an ancestor of the last,
                 // we need to start requesting blocks from their last common ancestor.
-                const CBlockIndex *from_tip = LastCommonAncestor(m_chainman.GetBackgroundSyncTip(), m_chainman.GetSnapshotBaseBlock());
+                const CBlockIndex* from_tip = LastCommonAncestor(historical_blocks->first, historical_blocks->second);
                 TryDownloadingHistoricalBlocks(
                     *peer,
                     get_inflight_budget(),
-                    vToDownload, from_tip,
-                    Assert(m_chainman.GetSnapshotBaseBlock()));
+                    vToDownload, from_tip, historical_blocks->second);
             }
             for (const CBlockIndex *pindex : vToDownload) {
                 uint32_t nFetchFlags = GetFetchFlags(*peer);
diff --git a/depend/bitcoin/src/net_types.cpp b/depend/bitcoin/src/net_types.cpp
index 978c5fa6..15a122a7 100644
--- a/depend/bitcoin/src/net_types.cpp
+++ b/depend/bitcoin/src/net_types.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/net_types.h b/depend/bitcoin/src/net_types.h
index 21ef835b..097a2a24 100644
--- a/depend/bitcoin/src/net_types.h
+++ b/depend/bitcoin/src/net_types.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/netbase.h b/depend/bitcoin/src/netbase.h
index 41b3ca8f..d3c263f9 100644
--- a/depend/bitcoin/src/netbase.h
+++ b/depend/bitcoin/src/netbase.h
@@ -132,7 +132,7 @@ class ReachableNets {
     {
         AssertLockNotHeld(m_mutex);
         LOCK(m_mutex);
-        return m_reachable.count(net) > 0;
+        return m_reachable.contains(net);
     }
 
     [[nodiscard]] bool Contains(const CNetAddr& addr) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
diff --git a/depend/bitcoin/src/netgroup.cpp b/depend/bitcoin/src/netgroup.cpp
index 5b682409..474d8a9c 100644
--- a/depend/bitcoin/src/netgroup.cpp
+++ b/depend/bitcoin/src/netgroup.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/netgroup.h b/depend/bitcoin/src/netgroup.h
index 5aa6ef77..74dc7503 100644
--- a/depend/bitcoin/src/netgroup.h
+++ b/depend/bitcoin/src/netgroup.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/netmessagemaker.h b/depend/bitcoin/src/netmessagemaker.h
index d04867e4..7d8c3eb0 100644
--- a/depend/bitcoin/src/netmessagemaker.h
+++ b/depend/bitcoin/src/netmessagemaker.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/node/abort.cpp b/depend/bitcoin/src/node/abort.cpp
index c15bf047..a7c81536 100644
--- a/depend/bitcoin/src/node/abort.cpp
+++ b/depend/bitcoin/src/node/abort.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/node/abort.h b/depend/bitcoin/src/node/abort.h
index c8514628..53d25452 100644
--- a/depend/bitcoin/src/node/abort.h
+++ b/depend/bitcoin/src/node/abort.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/node/blockmanager_args.cpp b/depend/bitcoin/src/node/blockmanager_args.cpp
index 5186b655..1f84819b 100644
--- a/depend/bitcoin/src/node/blockmanager_args.cpp
+++ b/depend/bitcoin/src/node/blockmanager_args.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/node/blockmanager_args.h b/depend/bitcoin/src/node/blockmanager_args.h
index de9fe83a..dda3e4b6 100644
--- a/depend/bitcoin/src/node/blockmanager_args.h
+++ b/depend/bitcoin/src/node/blockmanager_args.h
@@ -1,5 +1,5 @@
 
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/node/blockstorage.cpp b/depend/bitcoin/src/node/blockstorage.cpp
index 22c8f619..84b7cfec 100644
--- a/depend/bitcoin/src/node/blockstorage.cpp
+++ b/depend/bitcoin/src/node/blockstorage.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
@@ -7,7 +7,6 @@
 #include <arith_uint256.h>
 #include <chain.h>
 #include <consensus/params.h>
-#include <consensus/validation.h>
 #include <dbwrapper.h>
 #include <flatfile.h>
 #include <hash.h>
@@ -15,6 +14,7 @@
 #include <kernel/chainparams.h>
 #include <kernel/messagestartchars.h>
 #include <kernel/notifications_interface.h>
+#include <kernel/types.h>
 #include <logging.h>
 #include <pow.h>
 #include <primitives/block.h>
@@ -22,16 +22,17 @@
 #include <random.h>
 #include <serialize.h>
 #include <signet.h>
-#include <span.h>
 #include <streams.h>
 #include <sync.h>
 #include <tinyformat.h>
 #include <uint256.h>
 #include <undo.h>
-#include <util/batchpriority.h>
 #include <util/check.h>
+#include <util/expected.h>
 #include <util/fs.h>
 #include <util/obfuscation.h>
+#include <util/overflow.h>
+#include <util/result.h>
 #include <util/signalinterrupt.h>
 #include <util/strencodings.h>
 #include <util/syserror.h>
@@ -39,9 +40,17 @@
 #include <util/translation.h>
 #include <validation.h>
 
+#include <cerrno>
+#include <compare>
 #include <cstddef>
+#include <cstdio>
+#include <exception>
 #include <map>
 #include <optional>
+#include <ostream>
+#include <span>
+#include <stdexcept>
+#include <system_error>
 #include <unordered_map>
 
 namespace kernel {
@@ -282,8 +291,7 @@ void BlockManager::PruneOneBlockFile(const int fileNumber)
 void BlockManager::FindFilesToPruneManual(
     std::set<int>& setFilesToPrune,
     int nManualPruneHeight,
-    const Chainstate& chain,
-    ChainstateManager& chainman)
+    const Chainstate& chain)
 {
     assert(IsPruneMode() && nManualPruneHeight > 0);
 
@@ -292,7 +300,7 @@ void BlockManager::FindFilesToPruneManual(
         return;
     }
 
-    const auto [min_block_to_prune, last_block_can_prune] = chainman.GetPruneRange(chain, nManualPruneHeight);
+    const auto [min_block_to_prune, last_block_can_prune] = chain.GetPruneRange(nManualPruneHeight);
 
     int count = 0;
     for (int fileNumber = 0; fileNumber < this->MaxBlockfileNum(); fileNumber++) {
@@ -316,9 +324,16 @@ void BlockManager::FindFilesToPrune(
     ChainstateManager& chainman)
 {
     LOCK2(cs_main, cs_LastBlockFile);
-    // Distribute our -prune budget over all chainstates.
+    // 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
+    // user. If there is a historical chainstate being used to populate indexes
+    // and validate the snapshot, the target is divided by two so half of the
+    // block storage will be reserved for the historical chainstate, and the
+    // other half will be reserved for the most-work chainstate.
+    const int num_chainstates{chainman.HistoricalChainstate() ? 2 : 1};
     const auto target = std::max(
-        MIN_DISK_SPACE_FOR_BLOCK_FILES, GetPruneTarget() / chainman.GetAll().size());
+        MIN_DISK_SPACE_FOR_BLOCK_FILES, GetPruneTarget() / num_chainstates);
     const uint64_t target_sync_height = chainman.m_best_header->nHeight;
 
     if (chain.m_chain.Height() < 0 || target == 0) {
@@ -328,7 +343,7 @@ void BlockManager::FindFilesToPrune(
         return;
     }
 
-    const auto [min_block_to_prune, last_block_can_prune] = chainman.GetPruneRange(chain, last_prune);
+    const auto [min_block_to_prune, last_block_can_prune] = chain.GetPruneRange(last_prune);
 
     uint64_t nCurrentUsage = CalculateCurrentUsage();
     // We don't check to prune until after we've allocated new space for files
@@ -1083,7 +1098,7 @@ BlockManager::ReadRawBlockResult BlockManager::ReadRawBlock(const FlatFilePos& p
 
         if (block_part) {
             const auto [offset, size]{*block_part};
-            if (size == 0 || offset >= blk_size || size > blk_size - offset) {
+            if (size == 0 || SaturatingAdd(offset, size) > blk_size) {
                 return util::Unexpected{ReadRawError::BadPartRange}; // Avoid logging - offset/size come from untrusted REST input
             }
             filein.seek(offset, SEEK_CUR);
@@ -1232,26 +1247,27 @@ void ImportBlocks(ChainstateManager& chainman, std::span<const fs::path> import_
 
     // -reindex
     if (!chainman.m_blockman.m_blockfiles_indexed) {
-        int nFile = 0;
+        int total_files{0};
+        while (fs::exists(chainman.m_blockman.GetBlockPosFilename(FlatFilePos(total_files, 0)))) {
+            total_files++;
+        }
+
         // Map of disk positions for blocks with unknown parent (only used for reindex);
         // parent hash -> child disk position, multiple children can have the same parent.
         std::multimap<uint256, FlatFilePos> blocks_with_unknown_parent;
-        while (true) {
+
+        for (int nFile{0}; nFile < total_files; ++nFile) {
             FlatFilePos pos(nFile, 0);
-            if (!fs::exists(chainman.m_blockman.GetBlockPosFilename(pos))) {
-                break; // No block files left to reindex
-            }
             AutoFile file{chainman.m_blockman.OpenBlockFile(pos, /*fReadOnly=*/true)};
             if (file.IsNull()) {
                 break; // This error is logged in OpenBlockFile
             }
-            LogInfo("Reindexing block file blk%05u.dat...", (unsigned int)nFile);
+            LogInfo("Reindexing block file blk%05u.dat (%d%% complete)...", (unsigned int)nFile, nFile * 100 / total_files);
             chainman.LoadExternalBlockFile(file, &pos, &blocks_with_unknown_parent);
             if (chainman.m_interrupt) {
                 LogInfo("Interrupt requested. Exit reindexing.");
                 return;
             }
-            nFile++;
         }
         WITH_LOCK(::cs_main, chainman.m_blockman.m_block_tree_db->WriteReindexing(false));
         chainman.m_blockman.m_blockfiles_indexed = true;
@@ -1276,16 +1292,8 @@ void ImportBlocks(ChainstateManager& chainman, std::span<const fs::path> import_
     }
 
     // scan for better chains in the block chain database, that are not yet connected in the active best chain
-
-    // We can't hold cs_main during ActivateBestChain even though we're accessing
-    // the chainman unique_ptrs since ABC requires us not to be holding cs_main, so retrieve
-    // the relevant pointers before the ABC call.
-    for (Chainstate* chainstate : WITH_LOCK(::cs_main, return chainman.GetAll())) {
-        BlockValidationState state;
-        if (!chainstate->ActivateBestChain(state, nullptr)) {
-            chainman.GetNotifications().fatalError(strprintf(_("Failed to connect best block (%s)."), state.ToString()));
-            return;
-        }
+    if (auto result = chainman.ActivateBestChains(); !result) {
+        chainman.GetNotifications().fatalError(util::ErrorString(result));
     }
     // End scope of ImportingNow
 }
diff --git a/depend/bitcoin/src/node/blockstorage.h b/depend/bitcoin/src/node/blockstorage.h
index e3f9c445..3fb6cc3e 100644
--- a/depend/bitcoin/src/node/blockstorage.h
+++ b/depend/bitcoin/src/node/blockstorage.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
@@ -14,17 +14,22 @@
 #include <kernel/cs_main.h>
 #include <kernel/messagestartchars.h>
 #include <primitives/block.h>
+#include <serialize.h>
 #include <streams.h>
 #include <sync.h>
 #include <uint256.h>
 #include <util/expected.h>
 #include <util/fs.h>
 #include <util/hasher.h>
+#include <util/obfuscation.h>
 
+#include <algorithm>
 #include <array>
 #include <atomic>
+#include <cstddef>
 #include <cstdint>
 #include <functional>
+#include <iosfwd>
 #include <limits>
 #include <map>
 #include <memory>
@@ -223,8 +228,7 @@ class BlockManager
     void FindFilesToPruneManual(
         std::set<int>& setFilesToPrune,
         int nManualPruneHeight,
-        const Chainstate& chain,
-        ChainstateManager& chainman);
+        const Chainstate& chain);
 
     /**
      * Prune block and undo files (blk???.dat and rev???.dat) so that the disk space used is less than a user-defined target.
@@ -249,7 +253,6 @@ class BlockManager
         ChainstateManager& chainman);
 
     RecursiveMutex cs_LastBlockFile;
-    std::vector<CBlockFileInfo> m_blockfile_info;
 
     //! 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
@@ -284,12 +287,6 @@ class BlockManager
 
     const Obfuscation m_obfuscation;
 
-    /** Dirty block index entries. */
-    std::set<CBlockIndex*> m_dirty_blockindex;
-
-    /** Dirty block file entries. */
-    std::set<int> m_dirty_fileinfo;
-
     /**
      * Map from external index name to oldest block that must not be pruned.
      *
@@ -305,6 +302,15 @@ class BlockManager
     const FlatFileSeq m_block_file_seq;
     const FlatFileSeq m_undo_file_seq;
 
+protected:
+    std::vector<CBlockFileInfo> m_blockfile_info;
+
+    /** Dirty block index entries. */
+    std::set<CBlockIndex*> m_dirty_blockindex;
+
+    /** Dirty block file entries. */
+    std::set<int> m_dirty_fileinfo;
+
 public:
     using Options = kernel::BlockManagerOpts;
     using ReadRawBlockResult = util::Expected<std::vector<std::byte>, ReadRawError>;
diff --git a/depend/bitcoin/src/node/caches.cpp b/depend/bitcoin/src/node/caches.cpp
index e4a5e6d1..ecff3c62 100644
--- a/depend/bitcoin/src/node/caches.cpp
+++ b/depend/bitcoin/src/node/caches.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/node/caches.h b/depend/bitcoin/src/node/caches.h
index c0ef41ec..2cf526b2 100644
--- a/depend/bitcoin/src/node/caches.h
+++ b/depend/bitcoin/src/node/caches.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/node/chainstate.cpp b/depend/bitcoin/src/node/chainstate.cpp
index 1f0cf805..930d8431 100644
--- a/depend/bitcoin/src/node/chainstate.cpp
+++ b/depend/bitcoin/src/node/chainstate.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -66,8 +66,8 @@ static ChainstateLoadResult CompleteChainstateInitialization(
         return {ChainstateLoadStatus::FAILURE, _("Error initializing block database")};
     }
 
-    auto is_coinsview_empty = [&](Chainstate* chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
-        return options.wipe_chainstate_db || chainstate->CoinsTip().GetBestBlock().IsNull();
+    auto is_coinsview_empty = [&](Chainstate& chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
+        return options.wipe_chainstate_db || chainstate.CoinsTip().GetBestBlock().IsNull();
     };
 
     assert(chainman.m_total_coinstip_cache > 0);
@@ -78,12 +78,12 @@ static ChainstateLoadResult CompleteChainstateInitialization(
     // recalculated by `chainman.MaybeRebalanceCaches()`. The discount factor
     // is conservatively chosen such that the sum of the caches does not exceed
     // the allowable amount during this temporary initialization state.
-    double init_cache_fraction = chainman.GetAll().size() > 1 ? 0.2 : 1.0;
+    double init_cache_fraction = chainman.HistoricalChainstate() ? 0.2 : 1.0;
 
     // At this point we're either in reindex or we've loaded a useful
     // block tree into BlockIndex()!
 
-    for (Chainstate* chainstate : chainman.GetAll()) {
+    for (const auto& chainstate : chainman.m_chainstates) {
         LogInfo("Initializing chainstate %s", chainstate->ToString());
 
         try {
@@ -117,7 +117,7 @@ static ChainstateLoadResult CompleteChainstateInitialization(
         chainstate->InitCoinsCache(chainman.m_total_coinstip_cache * init_cache_fraction);
         assert(chainstate->CanFlushToDisk());
 
-        if (!is_coinsview_empty(chainstate)) {
+        if (!is_coinsview_empty(*chainstate)) {
             // LoadChainTip initializes the chain based on CoinsTip()'s best block
             if (!chainstate->LoadChainTip()) {
                 return {ChainstateLoadStatus::FAILURE, _("Error initializing block database")};
@@ -126,9 +126,9 @@ static ChainstateLoadResult CompleteChainstateInitialization(
         }
     }
 
-    auto chainstates{chainman.GetAll()};
+    const auto& chainstates{chainman.m_chainstates};
     if (std::any_of(chainstates.begin(), chainstates.end(),
-                    [](const Chainstate* cs) EXCLUSIVE_LOCKS_REQUIRED(cs_main) { return cs->NeedsRedownload(); })) {
+                    [](const auto& cs) EXCLUSIVE_LOCKS_REQUIRED(cs_main) { return cs->NeedsRedownload(); })) {
         return {ChainstateLoadStatus::FAILURE, strprintf(_("Witness data for blocks after height %d requires validation. Please restart with -reindex."),
                                                          chainman.GetConsensus().SegwitHeight)};
     };
@@ -166,16 +166,19 @@ ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSize
     chainman.m_total_coinsdb_cache = cache_sizes.coins_db;
 
     // Load the fully validated chainstate.
-    chainman.InitializeChainstate(options.mempool);
+    Chainstate& validated_cs{chainman.InitializeChainstate(options.mempool)};
 
     // Load a chain created from a UTXO snapshot, if any exist.
-    bool has_snapshot = chainman.DetectSnapshotChainstate();
+    Chainstate* assumeutxo_cs{chainman.LoadAssumeutxoChainstate()};
 
-    if (has_snapshot && options.wipe_chainstate_db) {
+    if (assumeutxo_cs && options.wipe_chainstate_db) {
+        // Reset chainstate target to network tip instead of snapshot block.
+        validated_cs.SetTargetBlock(nullptr);
         LogInfo("[snapshot] deleting snapshot chainstate due to reindexing");
-        if (!chainman.DeleteSnapshotChainstate()) {
+        if (!chainman.DeleteChainstate(*assumeutxo_cs)) {
             return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated("Couldn't remove snapshot chainstate.")};
         }
+        assumeutxo_cs = nullptr;
     }
 
     auto [init_status, init_error] = CompleteChainstateInitialization(chainman, options);
@@ -191,22 +194,22 @@ ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSize
     // snapshot is actually validated? Because this entails unusual
     // filesystem operations to move leveldb data directories around, and that seems
     // too risky to do in the middle of normal runtime.
-    auto snapshot_completion = chainman.MaybeCompleteSnapshotValidation();
+    auto snapshot_completion{assumeutxo_cs
+                             ? chainman.MaybeValidateSnapshot(validated_cs, *assumeutxo_cs)
+                             : SnapshotCompletionResult::SKIPPED};
 
     if (snapshot_completion == SnapshotCompletionResult::SKIPPED) {
         // do nothing; expected case
     } else if (snapshot_completion == SnapshotCompletionResult::SUCCESS) {
         LogInfo("[snapshot] cleaning up unneeded background chainstate, then reinitializing");
-        if (!chainman.ValidatedSnapshotCleanup()) {
+        if (!chainman.ValidatedSnapshotCleanup(validated_cs, *assumeutxo_cs)) {
             return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated("Background chainstate cleanup failed unexpectedly.")};
         }
 
         // Because ValidatedSnapshotCleanup() has torn down chainstates with
         // ChainstateManager::ResetChainstates(), reinitialize them here without
         // duplicating the blockindex work above.
-        assert(chainman.GetAll().empty());
-        assert(!chainman.IsSnapshotActive());
-        assert(!chainman.IsSnapshotValidated());
+        assert(chainman.m_chainstates.empty());
 
         chainman.InitializeChainstate(options.mempool);
 
@@ -229,14 +232,14 @@ ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSize
 
 ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager& chainman, const ChainstateLoadOptions& options)
 {
-    auto is_coinsview_empty = [&](Chainstate* chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
-        return options.wipe_chainstate_db || chainstate->CoinsTip().GetBestBlock().IsNull();
+    auto is_coinsview_empty = [&](Chainstate& chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
+        return options.wipe_chainstate_db || chainstate.CoinsTip().GetBestBlock().IsNull();
     };
 
     LOCK(cs_main);
 
-    for (Chainstate* chainstate : chainman.GetAll()) {
-        if (!is_coinsview_empty(chainstate)) {
+    for (auto& chainstate : chainman.m_chainstates) {
+        if (!is_coinsview_empty(*chainstate)) {
             const CBlockIndex* tip = chainstate->m_chain.Tip();
             if (tip && tip->nTime > GetTime() + MAX_FUTURE_BLOCK_TIME) {
                 return {ChainstateLoadStatus::FAILURE, _("The block database contains a block which appears to be from the future. "
diff --git a/depend/bitcoin/src/node/chainstate.h b/depend/bitcoin/src/node/chainstate.h
index 843e8e09..11484d50 100644
--- a/depend/bitcoin/src/node/chainstate.h
+++ b/depend/bitcoin/src/node/chainstate.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/node/chainstatemanager_args.cpp b/depend/bitcoin/src/node/chainstatemanager_args.cpp
index d5970b01..640fe128 100644
--- a/depend/bitcoin/src/node/chainstatemanager_args.cpp
+++ b/depend/bitcoin/src/node/chainstatemanager_args.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/chainstatemanager_args.h b/depend/bitcoin/src/node/chainstatemanager_args.h
index af13aa8d..cbcbb6b4 100644
--- a/depend/bitcoin/src/node/chainstatemanager_args.h
+++ b/depend/bitcoin/src/node/chainstatemanager_args.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/coin.cpp b/depend/bitcoin/src/node/coin.cpp
index eba67f4c..a4ff9aed 100644
--- a/depend/bitcoin/src/node/coin.cpp
+++ b/depend/bitcoin/src/node/coin.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/node/coin.h b/depend/bitcoin/src/node/coin.h
index b32e410e..9c8a74b4 100644
--- a/depend/bitcoin/src/node/coin.h
+++ b/depend/bitcoin/src/node/coin.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/node/coins_view_args.cpp b/depend/bitcoin/src/node/coins_view_args.cpp
index 5d55143e..b781ea6b 100644
--- a/depend/bitcoin/src/node/coins_view_args.cpp
+++ b/depend/bitcoin/src/node/coins_view_args.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/coins_view_args.h b/depend/bitcoin/src/node/coins_view_args.h
index 71a7a671..337fba35 100644
--- a/depend/bitcoin/src/node/coins_view_args.h
+++ b/depend/bitcoin/src/node/coins_view_args.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/connection_types.cpp b/depend/bitcoin/src/node/connection_types.cpp
index 5e4dc5bf..6ce2f269 100644
--- a/depend/bitcoin/src/node/connection_types.cpp
+++ b/depend/bitcoin/src/node/connection_types.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/context.cpp b/depend/bitcoin/src/node/context.cpp
index bfec54bc..d7d01b49 100644
--- a/depend/bitcoin/src/node/context.cpp
+++ b/depend/bitcoin/src/node/context.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/node/context.h b/depend/bitcoin/src/node/context.h
index debc1221..3a7488fd 100644
--- a/depend/bitcoin/src/node/context.h
+++ b/depend/bitcoin/src/node/context.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/node/database_args.cpp b/depend/bitcoin/src/node/database_args.cpp
index aba3c38f..f62995df 100644
--- a/depend/bitcoin/src/node/database_args.cpp
+++ b/depend/bitcoin/src/node/database_args.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/database_args.h b/depend/bitcoin/src/node/database_args.h
index 001976f2..15412cb0 100644
--- a/depend/bitcoin/src/node/database_args.h
+++ b/depend/bitcoin/src/node/database_args.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/eviction.cpp b/depend/bitcoin/src/node/eviction.cpp
index 33406931..a2267813 100644
--- a/depend/bitcoin/src/node/eviction.cpp
+++ b/depend/bitcoin/src/node/eviction.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/eviction.h b/depend/bitcoin/src/node/eviction.h
index 1bb32e53..6ab72644 100644
--- a/depend/bitcoin/src/node/eviction.h
+++ b/depend/bitcoin/src/node/eviction.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/interface_ui.cpp b/depend/bitcoin/src/node/interface_ui.cpp
index 273e5197..89e69f8d 100644
--- a/depend/bitcoin/src/node/interface_ui.cpp
+++ b/depend/bitcoin/src/node/interface_ui.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2010-2022 The Bitcoin Core developers
+// Copyright (c) 2010-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.
 
diff --git a/depend/bitcoin/src/node/interface_ui.h b/depend/bitcoin/src/node/interface_ui.h
index 7732cf47..2165402f 100644
--- a/depend/bitcoin/src/node/interface_ui.h
+++ b/depend/bitcoin/src/node/interface_ui.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/node/interfaces.cpp b/depend/bitcoin/src/node/interfaces.cpp
index ac817e01..663304b4 100644
--- a/depend/bitcoin/src/node/interfaces.cpp
+++ b/depend/bitcoin/src/node/interfaces.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
@@ -81,6 +81,7 @@ using interfaces::MakeSignalHandler;
 using interfaces::Mining;
 using interfaces::Node;
 using interfaces::WalletLoader;
+using kernel::ChainstateRole;
 using node::BlockAssembler;
 using node::BlockWaitOptions;
 using util::Join;
@@ -461,7 +462,7 @@ class NotificationsProxy : public CValidationInterface
     {
         m_notifications->transactionRemovedFromMempool(tx, reason);
     }
-    void BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* index) override
+    void BlockConnected(const ChainstateRole& role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* index) override
     {
         m_notifications->blockConnected(role, kernel::MakeBlockInfo(index, block.get()));
     }
@@ -473,7 +474,8 @@ class NotificationsProxy : public CValidationInterface
     {
         m_notifications->updatedBlockTip();
     }
-    void ChainStateFlushed(ChainstateRole role, const CBlockLocator& locator) override {
+    void ChainStateFlushed(const ChainstateRole& role, const CBlockLocator& locator) override
+    {
         m_notifications->chainStateFlushed(role, locator);
     }
     std::shared_ptr<Chain::Notifications> m_notifications;
@@ -843,7 +845,8 @@ class ChainImpl : public Chain
     }
     bool hasAssumedValidChain() override
     {
-        return chainman().IsSnapshotActive();
+        LOCK(::cs_main);
+        return bool{chainman().CurrentChainstate().m_from_snapshot_blockhash};
     }
 
     NodeContext* context() override { return &m_node; }
diff --git a/depend/bitcoin/src/node/kernel_notifications.cpp b/depend/bitcoin/src/node/kernel_notifications.cpp
index 56c7188a..f207b49a 100644
--- a/depend/bitcoin/src/node/kernel_notifications.cpp
+++ b/depend/bitcoin/src/node/kernel_notifications.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/node/kernel_notifications.h b/depend/bitcoin/src/node/kernel_notifications.h
index 21d2ea43..e9f1e8f1 100644
--- a/depend/bitcoin/src/node/kernel_notifications.h
+++ b/depend/bitcoin/src/node/kernel_notifications.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/node/mempool_args.cpp b/depend/bitcoin/src/node/mempool_args.cpp
index 14ee8405..d5ff50be 100644
--- a/depend/bitcoin/src/node/mempool_args.cpp
+++ b/depend/bitcoin/src/node/mempool_args.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/mempool_args.h b/depend/bitcoin/src/node/mempool_args.h
index 630fee64..a6a52c8b 100644
--- a/depend/bitcoin/src/node/mempool_args.h
+++ b/depend/bitcoin/src/node/mempool_args.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/mempool_persist.cpp b/depend/bitcoin/src/node/mempool_persist.cpp
index 19819a3a..dcb05267 100644
--- a/depend/bitcoin/src/node/mempool_persist.cpp
+++ b/depend/bitcoin/src/node/mempool_persist.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/mempool_persist.h b/depend/bitcoin/src/node/mempool_persist.h
index 7c5754a9..be7ad897 100644
--- a/depend/bitcoin/src/node/mempool_persist.h
+++ b/depend/bitcoin/src/node/mempool_persist.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/mempool_persist_args.cpp b/depend/bitcoin/src/node/mempool_persist_args.cpp
index 97ecdd65..adba5676 100644
--- a/depend/bitcoin/src/node/mempool_persist_args.cpp
+++ b/depend/bitcoin/src/node/mempool_persist_args.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/mempool_persist_args.h b/depend/bitcoin/src/node/mempool_persist_args.h
index 3b101f09..7973ec58 100644
--- a/depend/bitcoin/src/node/mempool_persist_args.h
+++ b/depend/bitcoin/src/node/mempool_persist_args.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/miner.cpp b/depend/bitcoin/src/node/miner.cpp
index a137f5d4..1d84b635 100644
--- a/depend/bitcoin/src/node/miner.cpp
+++ b/depend/bitcoin/src/node/miner.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/node/mini_miner.cpp b/depend/bitcoin/src/node/mini_miner.cpp
index b70c7503..b847c500 100644
--- a/depend/bitcoin/src/node/mini_miner.cpp
+++ b/depend/bitcoin/src/node/mini_miner.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -73,7 +73,7 @@ MiniMiner::MiniMiner(const CTxMemPool& mempool, const std::vector<COutPoint>& ou
 
     // Add every entry to m_entries_by_txid and m_entries, except the ones that will be replaced.
     for (const auto& txiter : cluster) {
-        if (!m_to_be_replaced.count(txiter->GetTx().GetHash())) {
+        if (!m_to_be_replaced.contains(txiter->GetTx().GetHash())) {
             auto [ancestor_count, ancestor_size, ancestor_fee] = mempool.CalculateAncestorData(*txiter);
             auto [mapiter, success] = m_entries_by_txid.emplace(txiter->GetTx().GetHash(),
                 MiniMinerMempoolEntry{/*tx_in=*/txiter->GetSharedTx(),
@@ -101,13 +101,13 @@ MiniMiner::MiniMiner(const CTxMemPool& mempool, const std::vector<COutPoint>& ou
         // Cache descendants for future use. Unlike the real mempool, a descendant MiniMinerMempoolEntry
         // will not exist without its ancestor MiniMinerMempoolEntry, so these sets won't be invalidated.
         std::vector<MockEntryMap::iterator> cached_descendants;
-        const bool remove{m_to_be_replaced.count(txid) > 0};
+        const bool remove{m_to_be_replaced.contains(txid)};
         CTxMemPool::setEntries descendants;
         mempool.CalculateDescendants(txiter, descendants);
-        Assume(descendants.count(txiter) > 0);
+        Assume(descendants.contains(txiter));
         for (const auto& desc_txiter : descendants) {
             const auto txid_desc = desc_txiter->GetTx().GetHash();
-            const bool remove_desc{m_to_be_replaced.count(txid_desc) > 0};
+            const bool remove_desc{m_to_be_replaced.contains(txid_desc)};
             auto desc_it{m_entries_by_txid.find(txid_desc)};
             Assume((desc_it == m_entries_by_txid.end()) == remove_desc);
             if (remove) Assume(remove_desc);
@@ -136,7 +136,7 @@ MiniMiner::MiniMiner(const std::vector<MiniMinerMempoolEntry>& manual_entries,
     for (const auto& entry : manual_entries) {
         const auto& txid = entry.GetTx().GetHash();
         // We need to know the descendant set of every transaction.
-        if (!Assume(descendant_caches.count(txid) > 0)) {
+        if (!Assume(descendant_caches.contains(txid))) {
             m_ready_to_calculate = false;
             return;
         }
@@ -201,7 +201,7 @@ void MiniMiner::DeleteAncestorPackage(const std::set<MockEntryMap::iterator, Ite
     Assume(ancestors.size() >= 1);
     // "Mine" all transactions in this ancestor set.
     for (auto& anc : ancestors) {
-        Assume(m_in_block.count(anc->first) == 0);
+        Assume(!m_in_block.contains(anc->first));
         m_in_block.insert(anc->first);
         m_total_fees += anc->second.GetModifiedFee();
         m_total_vsize += anc->second.GetTxSize();
@@ -240,7 +240,7 @@ void MiniMiner::SanityCheck() const
                entry->second.GetModFeesWithAncestors() >= entry->second.GetModifiedFee();}));
     // None of the entries should be to-be-replaced transactions
     Assume(std::all_of(m_to_be_replaced.begin(), m_to_be_replaced.end(),
-        [&](const auto& txid){return m_entries_by_txid.find(txid) == m_entries_by_txid.end();}));
+        [&](const auto& txid){ return !m_entries_by_txid.contains(txid); }));
 }
 
 void MiniMiner::BuildMockTemplate(std::optional<CFeeRate> target_feerate)
@@ -274,7 +274,7 @@ void MiniMiner::BuildMockTemplate(std::optional<CFeeRate> target_feerate)
                 ancestors.insert(*iter);
                 for (const auto& input : (*iter)->second.GetTx().vin) {
                     if (auto parent_it{m_entries_by_txid.find(input.prevout.hash)}; parent_it != m_entries_by_txid.end()) {
-                        if (ancestors.count(parent_it) == 0) {
+                        if (!ancestors.contains(parent_it)) {
                             to_process.insert(parent_it);
                         }
                     }
@@ -400,7 +400,7 @@ std::optional<CAmount> MiniMiner::CalculateTotalBumpFees(const CFeeRate& target_
     for (const auto& [txid, outpoints] : m_requested_outpoints_by_txid) {
         // Skip any ancestors that already have a miner score higher than the target feerate
         // (already "made it" into the block)
-        if (m_in_block.count(txid)) continue;
+        if (m_in_block.contains(txid)) continue;
         auto iter = m_entries_by_txid.find(txid);
         if (iter == m_entries_by_txid.end()) continue;
         to_process.insert(iter);
@@ -413,7 +413,7 @@ std::optional<CAmount> MiniMiner::CalculateTotalBumpFees(const CFeeRate& target_
         const CTransaction& tx = (*iter)->second.GetTx();
         for (const auto& input : tx.vin) {
             if (auto parent_it{m_entries_by_txid.find(input.prevout.hash)}; parent_it != m_entries_by_txid.end()) {
-                if (!has_been_processed.count(input.prevout.hash)) {
+                if (!has_been_processed.contains(input.prevout.hash)) {
                     to_process.insert(parent_it);
                 }
                 ancestors.insert(parent_it);
diff --git a/depend/bitcoin/src/node/minisketchwrapper.cpp b/depend/bitcoin/src/node/minisketchwrapper.cpp
index 36d03749..37089d56 100644
--- a/depend/bitcoin/src/node/minisketchwrapper.cpp
+++ b/depend/bitcoin/src/node/minisketchwrapper.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/node/minisketchwrapper.h b/depend/bitcoin/src/node/minisketchwrapper.h
index a92912d9..a0d3fa85 100644
--- a/depend/bitcoin/src/node/minisketchwrapper.h
+++ b/depend/bitcoin/src/node/minisketchwrapper.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/node/psbt.cpp b/depend/bitcoin/src/node/psbt.cpp
index 3933202e..faedf0b6 100644
--- a/depend/bitcoin/src/node/psbt.cpp
+++ b/depend/bitcoin/src/node/psbt.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/node/psbt.h b/depend/bitcoin/src/node/psbt.h
index cbb3bd82..b5968404 100644
--- a/depend/bitcoin/src/node/psbt.h
+++ b/depend/bitcoin/src/node/psbt.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/node/transaction.cpp b/depend/bitcoin/src/node/transaction.cpp
index f5bd0efe..0b68fab9 100644
--- a/depend/bitcoin/src/node/transaction.cpp
+++ b/depend/bitcoin/src/node/transaction.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/node/transaction.h b/depend/bitcoin/src/node/transaction.h
index a8689b3f..e2f237ec 100644
--- a/depend/bitcoin/src/node/transaction.h
+++ b/depend/bitcoin/src/node/transaction.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/node/txdownloadman.h b/depend/bitcoin/src/node/txdownloadman.h
index 90dc0e34..2cc1ec2c 100644
--- a/depend/bitcoin/src/node/txdownloadman.h
+++ b/depend/bitcoin/src/node/txdownloadman.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2024 The Bitcoin Core developers
+// Copyright (c) 2024-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/node/txorphanage.cpp b/depend/bitcoin/src/node/txorphanage.cpp
index 164fecdc..ca7eb204 100644
--- a/depend/bitcoin/src/node/txorphanage.cpp
+++ b/depend/bitcoin/src/node/txorphanage.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/node/txorphanage.h b/depend/bitcoin/src/node/txorphanage.h
index 5cbf3451..81c57da3 100644
--- a/depend/bitcoin/src/node/txorphanage.h
+++ b/depend/bitcoin/src/node/txorphanage.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/node/txreconciliation.cpp b/depend/bitcoin/src/node/txreconciliation.cpp
index 73f76693..2333181c 100644
--- a/depend/bitcoin/src/node/txreconciliation.cpp
+++ b/depend/bitcoin/src/node/txreconciliation.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/txreconciliation.h b/depend/bitcoin/src/node/txreconciliation.h
index 3bbb0773..68deeaba 100644
--- a/depend/bitcoin/src/node/txreconciliation.h
+++ b/depend/bitcoin/src/node/txreconciliation.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/node/types.h b/depend/bitcoin/src/node/types.h
index 6c268762..8b9f24f2 100644
--- a/depend/bitcoin/src/node/types.h
+++ b/depend/bitcoin/src/node/types.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2010-2021 The Bitcoin Core developers
+// Copyright (c) 2010-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.
 
diff --git a/depend/bitcoin/src/node/utxo_snapshot.cpp b/depend/bitcoin/src/node/utxo_snapshot.cpp
index d6e878ae..f11e979a 100644
--- a/depend/bitcoin/src/node/utxo_snapshot.cpp
+++ b/depend/bitcoin/src/node/utxo_snapshot.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
@@ -8,7 +8,6 @@
 #include <streams.h>
 #include <sync.h>
 #include <tinyformat.h>
-#include <txdb.h>
 #include <uint256.h>
 #include <util/fs.h>
 #include <validation.h>
@@ -16,6 +15,7 @@
 #include <cassert>
 #include <cstdio>
 #include <optional>
+#include <span>
 #include <string>
 
 namespace node {
@@ -25,7 +25,7 @@ bool WriteSnapshotBaseBlockhash(Chainstate& snapshot_chainstate)
     AssertLockHeld(::cs_main);
     assert(snapshot_chainstate.m_from_snapshot_blockhash);
 
-    const std::optional<fs::path> chaindir = snapshot_chainstate.CoinsDB().StoragePath();
+    const std::optional<fs::path> chaindir = snapshot_chainstate.StoragePath();
     assert(chaindir); // Sanity check that chainstate isn't in-memory.
     const fs::path write_to = *chaindir / node::SNAPSHOT_BLOCKHASH_FILENAME;
 
@@ -81,7 +81,7 @@ std::optional<uint256> ReadSnapshotBaseBlockhash(fs::path chaindir)
     return base_blockhash;
 }
 
-std::optional<fs::path> FindSnapshotChainstateDir(const fs::path& data_dir)
+std::optional<fs::path> FindAssumeutxoChainstateDir(const fs::path& data_dir)
 {
     fs::path possible_dir =
         data_dir / fs::u8path(strprintf("chainstate%s", SNAPSHOT_CHAINSTATE_SUFFIX));
diff --git a/depend/bitcoin/src/node/utxo_snapshot.h b/depend/bitcoin/src/node/utxo_snapshot.h
index e4eb6d60..d8b3ca61 100644
--- a/depend/bitcoin/src/node/utxo_snapshot.h
+++ b/depend/bitcoin/src/node/utxo_snapshot.h
@@ -1,23 +1,27 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_NODE_UTXO_SNAPSHOT_H
 #define BITCOIN_NODE_UTXO_SNAPSHOT_H
 
-#include <chainparams.h>
 #include <kernel/chainparams.h>
 #include <kernel/cs_main.h>
-#include <serialize.h>
+#include <kernel/messagestartchars.h>
 #include <sync.h>
+#include <tinyformat.h>
 #include <uint256.h>
 #include <util/chaintype.h>
-#include <util/check.h>
 #include <util/fs.h>
 
+#include <algorithm>
+#include <array>
 #include <cstdint>
+#include <ios>
 #include <optional>
+#include <set>
+#include <string>
 #include <string_view>
 
 // UTXO set snapshot magic bytes
@@ -77,7 +81,7 @@ class SnapshotMetadata
         // Read the version
         uint16_t version;
         s >> version;
-        if (m_supported_versions.find(version) == m_supported_versions.end()) {
+        if (!m_supported_versions.contains(version)) {
             throw std::ios_base::failure(strprintf("Version of snapshot %s does not match any of the supported versions.", version));
         }
 
@@ -125,7 +129,7 @@ constexpr std::string_view SNAPSHOT_CHAINSTATE_SUFFIX = "_snapshot";
 
 
 //! Return a path to the snapshot-based chainstate dir, if one exists.
-std::optional<fs::path> FindSnapshotChainstateDir(const fs::path& data_dir);
+std::optional<fs::path> FindAssumeutxoChainstateDir(const fs::path& data_dir);
 
 } // namespace node
 
diff --git a/depend/bitcoin/src/node/warnings.cpp b/depend/bitcoin/src/node/warnings.cpp
index 255d8dba..839846fe 100644
--- a/depend/bitcoin/src/node/warnings.cpp
+++ b/depend/bitcoin/src/node/warnings.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/node/warnings.h b/depend/bitcoin/src/node/warnings.h
index 24aeb8a9..2f7e1e4a 100644
--- a/depend/bitcoin/src/node/warnings.h
+++ b/depend/bitcoin/src/node/warnings.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/noui.cpp b/depend/bitcoin/src/noui.cpp
index 9f57a3da..75d5f19f 100644
--- a/depend/bitcoin/src/noui.cpp
+++ b/depend/bitcoin/src/noui.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/noui.h b/depend/bitcoin/src/noui.h
index ff752a28..bd07137e 100644
--- a/depend/bitcoin/src/noui.h
+++ b/depend/bitcoin/src/noui.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2013-2020 The Bitcoin Core developers
+// Copyright (c) 2013-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.
 
diff --git a/depend/bitcoin/src/policy/fees/block_policy_estimator.cpp b/depend/bitcoin/src/policy/fees/block_policy_estimator.cpp
index 723cb88f..23aecefe 100644
--- a/depend/bitcoin/src/policy/fees/block_policy_estimator.cpp
+++ b/depend/bitcoin/src/policy/fees/block_policy_estimator.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
@@ -598,7 +598,7 @@ void CBlockPolicyEstimator::processTransaction(const NewMempoolTransactionInfo&
     LOCK(m_cs_fee_estimator);
     const unsigned int txHeight = tx.info.txHeight;
     const auto& hash = tx.info.m_tx->GetHash();
-    if (mapMemPoolTxs.count(hash)) {
+    if (mapMemPoolTxs.contains(hash)) {
         LogDebug(BCLog::ESTIMATEFEE, "Blockpolicy error mempool tx %s already being tracked\n",
                  hash.ToString());
         return;
diff --git a/depend/bitcoin/src/policy/fees/block_policy_estimator.h b/depend/bitcoin/src/policy/fees/block_policy_estimator.h
index ed561d9a..ec432dcb 100644
--- a/depend/bitcoin/src/policy/fees/block_policy_estimator.h
+++ b/depend/bitcoin/src/policy/fees/block_policy_estimator.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #ifndef BITCOIN_POLICY_FEES_BLOCK_POLICY_ESTIMATOR_H
diff --git a/depend/bitcoin/src/policy/fees/block_policy_estimator_args.cpp b/depend/bitcoin/src/policy/fees/block_policy_estimator_args.cpp
index c66b09bf..6622a658 100644
--- a/depend/bitcoin/src/policy/fees/block_policy_estimator_args.cpp
+++ b/depend/bitcoin/src/policy/fees/block_policy_estimator_args.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/policy/fees/block_policy_estimator_args.h b/depend/bitcoin/src/policy/fees/block_policy_estimator_args.h
index f206c667..a8f5d56a 100644
--- a/depend/bitcoin/src/policy/fees/block_policy_estimator_args.h
+++ b/depend/bitcoin/src/policy/fees/block_policy_estimator_args.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/policy/packages.cpp b/depend/bitcoin/src/policy/packages.cpp
index 187bd467..0af70733 100644
--- a/depend/bitcoin/src/policy/packages.cpp
+++ b/depend/bitcoin/src/policy/packages.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -26,7 +26,7 @@ bool IsTopoSortedPackage(const Package& txns, std::unordered_set<Txid, SaltedTxi
     // than its child.
     for (const auto& tx : txns) {
         for (const auto& input : tx->vin) {
-            if (later_txids.find(input.prevout.hash) != later_txids.end()) {
+            if (later_txids.contains(input.prevout.hash)) {
                 // The parent is a subsequent transaction in the package.
                 return false;
             }
@@ -62,7 +62,7 @@ bool IsConsistentPackage(const Package& txns)
             return false;
         }
         for (const auto& input : tx->vin) {
-            if (inputs_seen.find(input.prevout) != inputs_seen.end()) {
+            if (inputs_seen.contains(input.prevout)) {
                 // This input is also present in another tx in the package.
                 return false;
             }
@@ -130,7 +130,7 @@ bool IsChildWithParents(const Package& package)
 
     // Every transaction must be a parent of the last transaction in the package.
     return std::all_of(package.cbegin(), package.cend() - 1,
-                       [&input_txids](const auto& ptx) { return input_txids.count(ptx->GetHash()) > 0; });
+                       [&input_txids](const auto& ptx) { return input_txids.contains(ptx->GetHash()); });
 }
 
 bool IsChildWithParentsTree(const Package& package)
@@ -142,7 +142,7 @@ bool IsChildWithParentsTree(const Package& package)
     // Each parent must not have an input who is one of the other parents.
     return std::all_of(package.cbegin(), package.cend() - 1, [&](const auto& ptx) {
         for (const auto& input : ptx->vin) {
-            if (parent_txids.count(input.prevout.hash) > 0) return false;
+            if (parent_txids.contains(input.prevout.hash)) return false;
         }
         return true;
     });
diff --git a/depend/bitcoin/src/policy/packages.h b/depend/bitcoin/src/policy/packages.h
index 85081977..fa1b4d40 100644
--- a/depend/bitcoin/src/policy/packages.h
+++ b/depend/bitcoin/src/policy/packages.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/policy/policy.h b/depend/bitcoin/src/policy/policy.h
index f3f5ffb7..35189d71 100644
--- a/depend/bitcoin/src/policy/policy.h
+++ b/depend/bitcoin/src/policy/policy.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/policy/rbf.cpp b/depend/bitcoin/src/policy/rbf.cpp
index c78fed8e..d0203127 100644
--- a/depend/bitcoin/src/policy/rbf.cpp
+++ b/depend/bitcoin/src/policy/rbf.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
@@ -88,7 +88,7 @@ std::optional<std::string> EntriesAndTxidsDisjoint(const CTxMemPool::setEntries&
 {
     for (CTxMemPool::txiter ancestorIt : ancestors) {
         const Txid& hashAncestor = ancestorIt->GetTx().GetHash();
-        if (direct_conflicts.count(hashAncestor)) {
+        if (direct_conflicts.contains(hashAncestor)) {
             return strprintf("%s spends conflicting transaction %s",
                              txid.ToString(),
                              hashAncestor.ToString());
diff --git a/depend/bitcoin/src/policy/rbf.h b/depend/bitcoin/src/policy/rbf.h
index b135ecf2..ad8a2dbf 100644
--- a/depend/bitcoin/src/policy/rbf.h
+++ b/depend/bitcoin/src/policy/rbf.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/policy/settings.cpp b/depend/bitcoin/src/policy/settings.cpp
index 722b12ac..dbcf5f05 100644
--- a/depend/bitcoin/src/policy/settings.cpp
+++ b/depend/bitcoin/src/policy/settings.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/policy/settings.h b/depend/bitcoin/src/policy/settings.h
index 145454b0..c218c162 100644
--- a/depend/bitcoin/src/policy/settings.h
+++ b/depend/bitcoin/src/policy/settings.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/policy/truc_policy.cpp b/depend/bitcoin/src/policy/truc_policy.cpp
index bc5142c7..597d08f7 100644
--- a/depend/bitcoin/src/policy/truc_policy.cpp
+++ b/depend/bitcoin/src/policy/truc_policy.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
@@ -30,7 +30,7 @@ std::vector<size_t> FindInPackageParents(const Package& package, const CTransact
         // We assume the package is sorted, so that we don't need to continue
         // looking past the transaction itself.
         if (&(*tx) == &(*ptx)) break;
-        if (possible_parents.count(tx->GetHash())) {
+        if (possible_parents.contains(tx->GetHash())) {
             in_package_parents.push_back(i);
         }
     }
@@ -240,7 +240,7 @@ std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CT
         // TRUC transaction can only have 1 descendant.
         const bool child_will_be_replaced = !descendants.empty() &&
             std::any_of(descendants.cbegin(), descendants.cend(),
-                [&direct_conflicts](const CTxMemPool::txiter& child){return direct_conflicts.count(child->GetTx().GetHash()) > 0;});
+                [&direct_conflicts](const CTxMemPool::txiter& child){return direct_conflicts.contains(child->GetTx().GetHash());});
         if (pool.GetDescendantCount(parent_entry) + 1 > TRUC_DESCENDANT_LIMIT && !child_will_be_replaced) {
             // Allow sibling eviction for TRUC transaction: if another child already exists, even if
             // we don't conflict inputs with it, consider evicting it under RBF rules. We rely on TRUC rules
diff --git a/depend/bitcoin/src/policy/truc_policy.h b/depend/bitcoin/src/policy/truc_policy.h
index 9eec8d2f..b6fe6e12 100644
--- a/depend/bitcoin/src/policy/truc_policy.h
+++ b/depend/bitcoin/src/policy/truc_policy.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/pow.cpp b/depend/bitcoin/src/pow.cpp
index 907d3787..9a9f4e58 100644
--- a/depend/bitcoin/src/pow.cpp
+++ b/depend/bitcoin/src/pow.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/primitives/block.cpp b/depend/bitcoin/src/primitives/block.cpp
index 27da161e..c390de38 100644
--- a/depend/bitcoin/src/primitives/block.cpp
+++ b/depend/bitcoin/src/primitives/block.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2019 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/primitives/block.h b/depend/bitcoin/src/primitives/block.h
index 207d2b29..f0ee1525 100644
--- a/depend/bitcoin/src/primitives/block.h
+++ b/depend/bitcoin/src/primitives/block.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/primitives/transaction.cpp b/depend/bitcoin/src/primitives/transaction.cpp
index e80ab60f..c8bbd9f8 100644
--- a/depend/bitcoin/src/primitives/transaction.cpp
+++ b/depend/bitcoin/src/primitives/transaction.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/primitives/transaction.h b/depend/bitcoin/src/primitives/transaction.h
index da3db602..2ccdb4e4 100644
--- a/depend/bitcoin/src/primitives/transaction.h
+++ b/depend/bitcoin/src/primitives/transaction.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/primitives/transaction_identifier.h b/depend/bitcoin/src/primitives/transaction_identifier.h
index 79af2dde..921f82c6 100644
--- a/depend/bitcoin/src/primitives/transaction_identifier.h
+++ b/depend/bitcoin/src/primitives/transaction_identifier.h
@@ -34,6 +34,7 @@ class transaction_identifier
 
 public:
     transaction_identifier() : m_wrapped{} {}
+    consteval explicit transaction_identifier(std::string_view hex_str) : m_wrapped{uint256{hex_str}} {}
 
     template <typename Other>
     bool operator==(const Other& other) const { return Compare(other) == 0; }
diff --git a/depend/bitcoin/src/protocol.cpp b/depend/bitcoin/src/protocol.cpp
index 5217c45d..5f0b76e3 100644
--- a/depend/bitcoin/src/protocol.cpp
+++ b/depend/bitcoin/src/protocol.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/protocol.h b/depend/bitcoin/src/protocol.h
index 804597b8..8ed90dd3 100644
--- a/depend/bitcoin/src/protocol.h
+++ b/depend/bitcoin/src/protocol.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/psbt.cpp b/depend/bitcoin/src/psbt.cpp
index 92ddcba6..9e99ca5e 100644
--- a/depend/bitcoin/src/psbt.cpp
+++ b/depend/bitcoin/src/psbt.cpp
@@ -38,7 +38,7 @@ bool PartiallySignedTransaction::Merge(const PartiallySignedTransaction& psbt)
         outputs[i].Merge(psbt.outputs[i]);
     }
     for (auto& xpub_pair : psbt.m_xpubs) {
-        if (m_xpubs.count(xpub_pair.first) == 0) {
+        if (!m_xpubs.contains(xpub_pair.first)) {
             m_xpubs[xpub_pair.first] = xpub_pair.second;
         } else {
             m_xpubs[xpub_pair.first].insert(xpub_pair.second.begin(), xpub_pair.second.end());
diff --git a/depend/bitcoin/src/psbt.h b/depend/bitcoin/src/psbt.h
index 2e7fe964..d8a4a52d 100644
--- a/depend/bitcoin/src/psbt.h
+++ b/depend/bitcoin/src/psbt.h
@@ -158,7 +158,7 @@ void DeserializeHDKeypaths(Stream& s, const std::vector<unsigned char>& key, std
     if (!pubkey.IsFullyValid()) {
        throw std::ios_base::failure("Invalid pubkey");
     }
-    if (hd_keypaths.count(pubkey) > 0) {
+    if (hd_keypaths.contains(pubkey)) {
         throw std::ios_base::failure("Duplicate Key, pubkey derivation path already provided");
     }
 
@@ -518,7 +518,7 @@ struct PSBTInput
                     if (!pubkey.IsFullyValid()) {
                        throw std::ios_base::failure("Invalid pubkey");
                     }
-                    if (partial_sigs.count(pubkey.GetID()) > 0) {
+                    if (partial_sigs.contains(pubkey.GetID())) {
                         throw std::ios_base::failure("Duplicate Key, input partial signature for pubkey already provided");
                     }
 
@@ -599,7 +599,7 @@ struct PSBTInput
                     // Read in the hash from key
                     std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
                     uint160 hash(hash_vec);
-                    if (ripemd160_preimages.count(hash) > 0) {
+                    if (ripemd160_preimages.contains(hash)) {
                         throw std::ios_base::failure("Duplicate Key, input ripemd160 preimage already provided");
                     }
 
@@ -620,7 +620,7 @@ struct PSBTInput
                     // Read in the hash from key
                     std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
                     uint256 hash(hash_vec);
-                    if (sha256_preimages.count(hash) > 0) {
+                    if (sha256_preimages.contains(hash)) {
                         throw std::ios_base::failure("Duplicate Key, input sha256 preimage already provided");
                     }
 
@@ -641,7 +641,7 @@ struct PSBTInput
                     // Read in the hash from key
                     std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
                     uint160 hash(hash_vec);
-                    if (hash160_preimages.count(hash) > 0) {
+                    if (hash160_preimages.contains(hash)) {
                         throw std::ios_base::failure("Duplicate Key, input hash160 preimage already provided");
                     }
 
@@ -662,7 +662,7 @@ struct PSBTInput
                     // Read in the hash from key
                     std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
                     uint256 hash(hash_vec);
-                    if (hash256_preimages.count(hash) > 0) {
+                    if (hash256_preimages.contains(hash)) {
                         throw std::ios_base::failure("Duplicate Key, input hash256 preimage already provided");
                     }
 
@@ -828,7 +828,7 @@ struct PSBTInput
                     this_prop.subtype = ReadCompactSize(skey);
                     this_prop.key = key;
 
-                    if (m_proprietary.count(this_prop) > 0) {
+                    if (m_proprietary.contains(this_prop)) {
                         throw std::ios_base::failure("Duplicate Key, proprietary key already found");
                     }
                     s >> this_prop.value;
@@ -837,7 +837,7 @@ struct PSBTInput
                 }
                 // Unknown stuff
                 default:
-                    if (unknown.count(key) > 0) {
+                    if (unknown.contains(key)) {
                         throw std::ios_base::failure("Duplicate Key, key for unknown value already provided");
                     }
                     // Read in the value
@@ -1088,7 +1088,7 @@ struct PSBTOutput
                     this_prop.subtype = ReadCompactSize(skey);
                     this_prop.key = key;
 
-                    if (m_proprietary.count(this_prop) > 0) {
+                    if (m_proprietary.contains(this_prop)) {
                         throw std::ios_base::failure("Duplicate Key, proprietary key already found");
                     }
                     s >> this_prop.value;
@@ -1097,7 +1097,7 @@ struct PSBTOutput
                 }
                 // Unknown stuff
                 default: {
-                    if (unknown.count(key) > 0) {
+                    if (unknown.contains(key)) {
                         throw std::ios_base::failure("Duplicate Key, key for unknown value already provided");
                     }
                     // Read in the value
@@ -1276,7 +1276,7 @@ struct PartiallySignedTransaction
                     if (!xpub.pubkey.IsFullyValid()) {
                        throw std::ios_base::failure("Invalid pubkey");
                     }
-                    if (global_xpubs.count(xpub) > 0) {
+                    if (global_xpubs.contains(xpub)) {
                        throw std::ios_base::failure("Duplicate key, global xpub already provided");
                     }
                     global_xpubs.insert(xpub);
@@ -1286,7 +1286,7 @@ struct PartiallySignedTransaction
 
                     // Note that we store these swapped to make searches faster.
                     // Serialization uses xpub -> keypath to enqure key uniqueness
-                    if (m_xpubs.count(keypath) == 0) {
+                    if (!m_xpubs.contains(keypath)) {
                         // Make a new set to put the xpub in
                         m_xpubs[keypath] = {xpub};
                     } else {
@@ -1317,7 +1317,7 @@ struct PartiallySignedTransaction
                     this_prop.subtype = ReadCompactSize(skey);
                     this_prop.key = key;
 
-                    if (m_proprietary.count(this_prop) > 0) {
+                    if (m_proprietary.contains(this_prop)) {
                         throw std::ios_base::failure("Duplicate Key, proprietary key already found");
                     }
                     s >> this_prop.value;
@@ -1326,7 +1326,7 @@ struct PartiallySignedTransaction
                 }
                 // Unknown stuff
                 default: {
-                    if (unknown.count(key) > 0) {
+                    if (unknown.contains(key)) {
                         throw std::ios_base::failure("Duplicate Key, key for unknown value already provided");
                     }
                     // Read in the value
diff --git a/depend/bitcoin/src/qt/addressbookpage.cpp b/depend/bitcoin/src/qt/addressbookpage.cpp
index 26e93bf2..aeeb5700 100644
--- a/depend/bitcoin/src/qt/addressbookpage.cpp
+++ b/depend/bitcoin/src/qt/addressbookpage.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/addressbookpage.h b/depend/bitcoin/src/qt/addressbookpage.h
index b649da4a..63cbb134 100644
--- a/depend/bitcoin/src/qt/addressbookpage.h
+++ b/depend/bitcoin/src/qt/addressbookpage.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/addresstablemodel.cpp b/depend/bitcoin/src/qt/addresstablemodel.cpp
index 190fd5ae..526e093f 100644
--- a/depend/bitcoin/src/qt/addresstablemodel.cpp
+++ b/depend/bitcoin/src/qt/addresstablemodel.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/addresstablemodel.h b/depend/bitcoin/src/qt/addresstablemodel.h
index 44808364..4bfacc56 100644
--- a/depend/bitcoin/src/qt/addresstablemodel.h
+++ b/depend/bitcoin/src/qt/addresstablemodel.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/askpassphrasedialog.cpp b/depend/bitcoin/src/qt/askpassphrasedialog.cpp
index b0bc1f48..5c9f9f13 100644
--- a/depend/bitcoin/src/qt/askpassphrasedialog.cpp
+++ b/depend/bitcoin/src/qt/askpassphrasedialog.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/askpassphrasedialog.h b/depend/bitcoin/src/qt/askpassphrasedialog.h
index c567c294..c884d691 100644
--- a/depend/bitcoin/src/qt/askpassphrasedialog.h
+++ b/depend/bitcoin/src/qt/askpassphrasedialog.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/bantablemodel.h b/depend/bitcoin/src/qt/bantablemodel.h
index adb97ad1..8e77220f 100644
--- a/depend/bitcoin/src/qt/bantablemodel.h
+++ b/depend/bitcoin/src/qt/bantablemodel.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/bitcoin.cpp b/depend/bitcoin/src/qt/bitcoin.cpp
index 59e74f92..54e1747c 100644
--- a/depend/bitcoin/src/qt/bitcoin.cpp
+++ b/depend/bitcoin/src/qt/bitcoin.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/bitcoinaddressvalidator.cpp b/depend/bitcoin/src/qt/bitcoinaddressvalidator.cpp
index a2adca6e..fa9ba7b5 100644
--- a/depend/bitcoin/src/qt/bitcoinaddressvalidator.cpp
+++ b/depend/bitcoin/src/qt/bitcoinaddressvalidator.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2018 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/bitcoinaddressvalidator.h b/depend/bitcoin/src/qt/bitcoinaddressvalidator.h
index ae698c72..36130dc3 100644
--- a/depend/bitcoin/src/qt/bitcoinaddressvalidator.h
+++ b/depend/bitcoin/src/qt/bitcoinaddressvalidator.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/bitcoinamountfield.cpp b/depend/bitcoin/src/qt/bitcoinamountfield.cpp
index a7e2d224..78ed34c1 100644
--- a/depend/bitcoin/src/qt/bitcoinamountfield.cpp
+++ b/depend/bitcoin/src/qt/bitcoinamountfield.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/bitcoinamountfield.h b/depend/bitcoin/src/qt/bitcoinamountfield.h
index f710915a..68b0a92e 100644
--- a/depend/bitcoin/src/qt/bitcoinamountfield.h
+++ b/depend/bitcoin/src/qt/bitcoinamountfield.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/bitcoingui.cpp b/depend/bitcoin/src/qt/bitcoingui.cpp
index 9413356b..dc4a8271 100644
--- a/depend/bitcoin/src/qt/bitcoingui.cpp
+++ b/depend/bitcoin/src/qt/bitcoingui.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
@@ -72,6 +72,14 @@
 #include <QWindow>
 
 
+/**
+ * Maximum gap between node time and block time used
+ * for the "Catching up..." mode in GUI.
+ *
+ * Ref: https://github.com/bitcoin/bitcoin/pull/1026
+ */
+static constexpr int64_t MAX_BLOCK_TIME_GAP = 90 * 60;
+
 const std::string BitcoinGUI::DEFAULT_UIPLATFORM =
 #if defined(Q_OS_MACOS)
         "macosx"
@@ -485,6 +493,32 @@ void BitcoinGUI::createActions()
                 QAction* action = m_migrate_wallet_menu->addAction(tr("No wallets available"));
                 action->setEnabled(false);
             }
+            m_migrate_wallet_menu->addSeparator();
+            QAction* restore_migrate_file_action = m_migrate_wallet_menu->addAction(tr("Restore and Migrate Wallet File..."));
+            restore_migrate_file_action->setEnabled(true);
+
+            connect(restore_migrate_file_action, &QAction::triggered, [this] {
+                QString name_data_file = tr("Wallet Data");
+                QString title_windows = tr("Restore and Migrate Wallet Backup");
+
+                QString backup_file = GUIUtil::getOpenFileName(this, title_windows, QString(), name_data_file + QLatin1String(" (*.dat)"), nullptr);
+                if (backup_file.isEmpty()) return;
+
+                bool wallet_name_ok;
+                /*: Title of pop-up window shown when the user is attempting to
+                    restore a wallet. */
+                QString title = tr("Restore and Migrate Wallet");
+                //: Label of the input field where the name of the wallet is entered.
+                QString label = tr("Wallet Name");
+                QString wallet_name = QInputDialog::getText(this, title, label, QLineEdit::Normal, "", &wallet_name_ok);
+                if (!wallet_name_ok || wallet_name.isEmpty()) return;
+
+                auto activity = new MigrateWalletActivity(m_wallet_controller, this);
+                connect(activity, &MigrateWalletActivity::migrated, this, &BitcoinGUI::setCurrentWallet);
+                connect(activity, &MigrateWalletActivity::migrated, rpcConsole, &RPCConsole::setCurrentWallet);
+                auto backup_file_path = fs::PathFromString(backup_file.toStdString());
+                activity->restore_and_migrate(backup_file_path, wallet_name.toStdString());
+            });
         });
         connect(m_mask_values_action, &QAction::toggled, this, &BitcoinGUI::setPrivacy);
         connect(m_mask_values_action, &QAction::toggled, this, &BitcoinGUI::enableHistoryAction);
diff --git a/depend/bitcoin/src/qt/bitcoingui.h b/depend/bitcoin/src/qt/bitcoingui.h
index 32fb7488..2322860a 100644
--- a/depend/bitcoin/src/qt/bitcoingui.h
+++ b/depend/bitcoin/src/qt/bitcoingui.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/bitcoinunits.cpp b/depend/bitcoin/src/qt/bitcoinunits.cpp
index f73d83e4..767c618f 100644
--- a/depend/bitcoin/src/qt/bitcoinunits.cpp
+++ b/depend/bitcoin/src/qt/bitcoinunits.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/bitcoinunits.h b/depend/bitcoin/src/qt/bitcoinunits.h
index b3b5a8fc..31f5d13d 100644
--- a/depend/bitcoin/src/qt/bitcoinunits.h
+++ b/depend/bitcoin/src/qt/bitcoinunits.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/clientmodel.h b/depend/bitcoin/src/qt/clientmodel.h
index 7d0e35e7..b4c9481b 100644
--- a/depend/bitcoin/src/qt/clientmodel.h
+++ b/depend/bitcoin/src/qt/clientmodel.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/coincontroldialog.cpp b/depend/bitcoin/src/qt/coincontroldialog.cpp
index febf1ee8..9535b0c6 100644
--- a/depend/bitcoin/src/qt/coincontroldialog.cpp
+++ b/depend/bitcoin/src/qt/coincontroldialog.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/coincontroldialog.h b/depend/bitcoin/src/qt/coincontroldialog.h
index 5fc2cdca..7b4c7e6f 100644
--- a/depend/bitcoin/src/qt/coincontroldialog.h
+++ b/depend/bitcoin/src/qt/coincontroldialog.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/coincontroltreewidget.cpp b/depend/bitcoin/src/qt/coincontroltreewidget.cpp
index 4ffbd832..70f2e955 100644
--- a/depend/bitcoin/src/qt/coincontroltreewidget.cpp
+++ b/depend/bitcoin/src/qt/coincontroltreewidget.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2018 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/coincontroltreewidget.h b/depend/bitcoin/src/qt/coincontroltreewidget.h
index ac03a409..8f5ee41f 100644
--- a/depend/bitcoin/src/qt/coincontroltreewidget.h
+++ b/depend/bitcoin/src/qt/coincontroltreewidget.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/createwalletdialog.cpp b/depend/bitcoin/src/qt/createwalletdialog.cpp
index 2908043d..59c6f51a 100644
--- a/depend/bitcoin/src/qt/createwalletdialog.cpp
+++ b/depend/bitcoin/src/qt/createwalletdialog.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/qt/createwalletdialog.h b/depend/bitcoin/src/qt/createwalletdialog.h
index 24ee9738..90aff428 100644
--- a/depend/bitcoin/src/qt/createwalletdialog.h
+++ b/depend/bitcoin/src/qt/createwalletdialog.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/qt/csvmodelwriter.cpp b/depend/bitcoin/src/qt/csvmodelwriter.cpp
index 445ea414..e9496799 100644
--- a/depend/bitcoin/src/qt/csvmodelwriter.cpp
+++ b/depend/bitcoin/src/qt/csvmodelwriter.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2018 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/csvmodelwriter.h b/depend/bitcoin/src/qt/csvmodelwriter.h
index a1e77826..105dc41d 100644
--- a/depend/bitcoin/src/qt/csvmodelwriter.h
+++ b/depend/bitcoin/src/qt/csvmodelwriter.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/editaddressdialog.cpp b/depend/bitcoin/src/qt/editaddressdialog.cpp
index 092a89fa..dad7d6d7 100644
--- a/depend/bitcoin/src/qt/editaddressdialog.cpp
+++ b/depend/bitcoin/src/qt/editaddressdialog.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/editaddressdialog.h b/depend/bitcoin/src/qt/editaddressdialog.h
index 7bfadcfb..fe015840 100644
--- a/depend/bitcoin/src/qt/editaddressdialog.h
+++ b/depend/bitcoin/src/qt/editaddressdialog.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/guiconstants.h b/depend/bitcoin/src/qt/guiconstants.h
index 30ffa302..a3b8cb9d 100644
--- a/depend/bitcoin/src/qt/guiconstants.h
+++ b/depend/bitcoin/src/qt/guiconstants.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/guiutil.h b/depend/bitcoin/src/qt/guiutil.h
index 1b493430..bcde397d 100644
--- a/depend/bitcoin/src/qt/guiutil.h
+++ b/depend/bitcoin/src/qt/guiutil.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/initexecutor.cpp b/depend/bitcoin/src/qt/initexecutor.cpp
index bb3f970b..15578402 100644
--- a/depend/bitcoin/src/qt/initexecutor.cpp
+++ b/depend/bitcoin/src/qt/initexecutor.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2022 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/qt/initexecutor.h b/depend/bitcoin/src/qt/initexecutor.h
index 410c44fa..a1631d1e 100644
--- a/depend/bitcoin/src/qt/initexecutor.h
+++ b/depend/bitcoin/src/qt/initexecutor.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2021 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/qt/macdockiconhandler.h b/depend/bitcoin/src/qt/macdockiconhandler.h
index ff867e21..f610f82e 100644
--- a/depend/bitcoin/src/qt/macdockiconhandler.h
+++ b/depend/bitcoin/src/qt/macdockiconhandler.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2018 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/macdockiconhandler.mm b/depend/bitcoin/src/qt/macdockiconhandler.mm
index 5eb23c76..b7b1b98e 100644
--- a/depend/bitcoin/src/qt/macdockiconhandler.mm
+++ b/depend/bitcoin/src/qt/macdockiconhandler.mm
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2019 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/macnotificationhandler.h b/depend/bitcoin/src/qt/macnotificationhandler.h
index 03c744c1..1ebd6fee 100644
--- a/depend/bitcoin/src/qt/macnotificationhandler.h
+++ b/depend/bitcoin/src/qt/macnotificationhandler.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2018 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/macnotificationhandler.mm b/depend/bitcoin/src/qt/macnotificationhandler.mm
index 2d26a838..0a066c9f 100644
--- a/depend/bitcoin/src/qt/macnotificationhandler.mm
+++ b/depend/bitcoin/src/qt/macnotificationhandler.mm
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/macos_appnap.h b/depend/bitcoin/src/qt/macos_appnap.h
index 8c2cd840..6f5b5e3f 100644
--- a/depend/bitcoin/src/qt/macos_appnap.h
+++ b/depend/bitcoin/src/qt/macos_appnap.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2018 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/macos_appnap.mm b/depend/bitcoin/src/qt/macos_appnap.mm
index 22a88782..bcf60920 100644
--- a/depend/bitcoin/src/qt/macos_appnap.mm
+++ b/depend/bitcoin/src/qt/macos_appnap.mm
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2018 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/main.cpp b/depend/bitcoin/src/qt/main.cpp
index 649fead9..422cf7f2 100644
--- a/depend/bitcoin/src/qt/main.cpp
+++ b/depend/bitcoin/src/qt/main.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/qt/modaloverlay.cpp b/depend/bitcoin/src/qt/modaloverlay.cpp
index e752628d..d3d389ed 100644
--- a/depend/bitcoin/src/qt/modaloverlay.cpp
+++ b/depend/bitcoin/src/qt/modaloverlay.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/qt/modaloverlay.h b/depend/bitcoin/src/qt/modaloverlay.h
index 40e487b2..7c4b7a4b 100644
--- a/depend/bitcoin/src/qt/modaloverlay.h
+++ b/depend/bitcoin/src/qt/modaloverlay.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/qt/networkstyle.cpp b/depend/bitcoin/src/qt/networkstyle.cpp
index d3f7c02d..09d2df69 100644
--- a/depend/bitcoin/src/qt/networkstyle.cpp
+++ b/depend/bitcoin/src/qt/networkstyle.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2021 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/qt/networkstyle.h b/depend/bitcoin/src/qt/networkstyle.h
index dd2aee3e..ac103ee7 100644
--- a/depend/bitcoin/src/qt/networkstyle.h
+++ b/depend/bitcoin/src/qt/networkstyle.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2019 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/qt/notificator.h b/depend/bitcoin/src/qt/notificator.h
index 932cfc46..37a65510 100644
--- a/depend/bitcoin/src/qt/notificator.h
+++ b/depend/bitcoin/src/qt/notificator.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/openuridialog.cpp b/depend/bitcoin/src/qt/openuridialog.cpp
index fd22f21f..29392abf 100644
--- a/depend/bitcoin/src/qt/openuridialog.cpp
+++ b/depend/bitcoin/src/qt/openuridialog.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/openuridialog.h b/depend/bitcoin/src/qt/openuridialog.h
index 2c8f7f8b..85f6b61f 100644
--- a/depend/bitcoin/src/qt/openuridialog.h
+++ b/depend/bitcoin/src/qt/openuridialog.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/optionsdialog.cpp b/depend/bitcoin/src/qt/optionsdialog.cpp
index 0a0e44f6..12446206 100644
--- a/depend/bitcoin/src/qt/optionsdialog.cpp
+++ b/depend/bitcoin/src/qt/optionsdialog.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/optionsdialog.h b/depend/bitcoin/src/qt/optionsdialog.h
index 031e4d31..10e245b2 100644
--- a/depend/bitcoin/src/qt/optionsdialog.h
+++ b/depend/bitcoin/src/qt/optionsdialog.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/overviewpage.cpp b/depend/bitcoin/src/qt/overviewpage.cpp
index 36b7c417..f2efbe92 100644
--- a/depend/bitcoin/src/qt/overviewpage.cpp
+++ b/depend/bitcoin/src/qt/overviewpage.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/overviewpage.h b/depend/bitcoin/src/qt/overviewpage.h
index 1d47370f..61b3e8d1 100644
--- a/depend/bitcoin/src/qt/overviewpage.h
+++ b/depend/bitcoin/src/qt/overviewpage.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/paymentserver.cpp b/depend/bitcoin/src/qt/paymentserver.cpp
index d4c325b7..281587a5 100644
--- a/depend/bitcoin/src/qt/paymentserver.cpp
+++ b/depend/bitcoin/src/qt/paymentserver.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/paymentserver.h b/depend/bitcoin/src/qt/paymentserver.h
index b9ea97d5..f79b0c8a 100644
--- a/depend/bitcoin/src/qt/paymentserver.h
+++ b/depend/bitcoin/src/qt/paymentserver.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/peertablemodel.cpp b/depend/bitcoin/src/qt/peertablemodel.cpp
index 9f47213e..3c0dedfc 100644
--- a/depend/bitcoin/src/qt/peertablemodel.cpp
+++ b/depend/bitcoin/src/qt/peertablemodel.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/peertablesortproxy.cpp b/depend/bitcoin/src/qt/peertablesortproxy.cpp
index a70b5d4e..5829fdca 100644
--- a/depend/bitcoin/src/qt/peertablesortproxy.cpp
+++ b/depend/bitcoin/src/qt/peertablesortproxy.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/qt/peertablesortproxy.h b/depend/bitcoin/src/qt/peertablesortproxy.h
index 29e53200..98b94fb3 100644
--- a/depend/bitcoin/src/qt/peertablesortproxy.h
+++ b/depend/bitcoin/src/qt/peertablesortproxy.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/qt/platformstyle.cpp b/depend/bitcoin/src/qt/platformstyle.cpp
index a4306500..f128de61 100644
--- a/depend/bitcoin/src/qt/platformstyle.cpp
+++ b/depend/bitcoin/src/qt/platformstyle.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2021 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/qt/platformstyle.h b/depend/bitcoin/src/qt/platformstyle.h
index 98797d6a..50ca7e8a 100644
--- a/depend/bitcoin/src/qt/platformstyle.h
+++ b/depend/bitcoin/src/qt/platformstyle.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2021 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/qt/psbtoperationsdialog.cpp b/depend/bitcoin/src/qt/psbtoperationsdialog.cpp
index afe6a899..7661e59f 100644
--- a/depend/bitcoin/src/qt/psbtoperationsdialog.cpp
+++ b/depend/bitcoin/src/qt/psbtoperationsdialog.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/psbtoperationsdialog.h b/depend/bitcoin/src/qt/psbtoperationsdialog.h
index 23f7dbf2..55c6ec50 100644
--- a/depend/bitcoin/src/qt/psbtoperationsdialog.h
+++ b/depend/bitcoin/src/qt/psbtoperationsdialog.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/qrimagewidget.cpp b/depend/bitcoin/src/qt/qrimagewidget.cpp
index 79b5cde9..1e982e89 100644
--- a/depend/bitcoin/src/qt/qrimagewidget.cpp
+++ b/depend/bitcoin/src/qt/qrimagewidget.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/qrimagewidget.h b/depend/bitcoin/src/qt/qrimagewidget.h
index d9ca2b89..844a6e03 100644
--- a/depend/bitcoin/src/qt/qrimagewidget.h
+++ b/depend/bitcoin/src/qt/qrimagewidget.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/qvalidatedlineedit.cpp b/depend/bitcoin/src/qt/qvalidatedlineedit.cpp
index b6463320..026ff8d0 100644
--- a/depend/bitcoin/src/qt/qvalidatedlineedit.cpp
+++ b/depend/bitcoin/src/qt/qvalidatedlineedit.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/qvalidatedlineedit.h b/depend/bitcoin/src/qt/qvalidatedlineedit.h
index b1ae0139..877aaae8 100644
--- a/depend/bitcoin/src/qt/qvalidatedlineedit.h
+++ b/depend/bitcoin/src/qt/qvalidatedlineedit.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/qvaluecombobox.cpp b/depend/bitcoin/src/qt/qvaluecombobox.cpp
index c163ba56..ffac6e31 100644
--- a/depend/bitcoin/src/qt/qvaluecombobox.cpp
+++ b/depend/bitcoin/src/qt/qvaluecombobox.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/qvaluecombobox.h b/depend/bitcoin/src/qt/qvaluecombobox.h
index 14379dd6..01279dc3 100644
--- a/depend/bitcoin/src/qt/qvaluecombobox.h
+++ b/depend/bitcoin/src/qt/qvaluecombobox.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/receivecoinsdialog.cpp b/depend/bitcoin/src/qt/receivecoinsdialog.cpp
index be7741e8..19a0adb2 100644
--- a/depend/bitcoin/src/qt/receivecoinsdialog.cpp
+++ b/depend/bitcoin/src/qt/receivecoinsdialog.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/receivecoinsdialog.h b/depend/bitcoin/src/qt/receivecoinsdialog.h
index 0bb02ebc..c28e27d8 100644
--- a/depend/bitcoin/src/qt/receivecoinsdialog.h
+++ b/depend/bitcoin/src/qt/receivecoinsdialog.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/receiverequestdialog.cpp b/depend/bitcoin/src/qt/receiverequestdialog.cpp
index a5ee6583..91956b98 100644
--- a/depend/bitcoin/src/qt/receiverequestdialog.cpp
+++ b/depend/bitcoin/src/qt/receiverequestdialog.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/receiverequestdialog.h b/depend/bitcoin/src/qt/receiverequestdialog.h
index d64fee36..4f0936cb 100644
--- a/depend/bitcoin/src/qt/receiverequestdialog.h
+++ b/depend/bitcoin/src/qt/receiverequestdialog.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/recentrequeststablemodel.cpp b/depend/bitcoin/src/qt/recentrequeststablemodel.cpp
index a8d54cdc..d8ef0695 100644
--- a/depend/bitcoin/src/qt/recentrequeststablemodel.cpp
+++ b/depend/bitcoin/src/qt/recentrequeststablemodel.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/recentrequeststablemodel.h b/depend/bitcoin/src/qt/recentrequeststablemodel.h
index 7a5b71c9..31602b81 100644
--- a/depend/bitcoin/src/qt/recentrequeststablemodel.h
+++ b/depend/bitcoin/src/qt/recentrequeststablemodel.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/res/animation/makespinner.sh b/depend/bitcoin/src/qt/res/animation/makespinner.sh
index 92e34a84..ff7b191b 100755
--- a/depend/bitcoin/src/qt/res/animation/makespinner.sh
+++ b/depend/bitcoin/src/qt/res/animation/makespinner.sh
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 #
-# Copyright (c) 2014-2021 The Bitcoin Core developers
+# Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/qt/rpcconsole.cpp b/depend/bitcoin/src/qt/rpcconsole.cpp
index d6d2be7b..f9b850dc 100644
--- a/depend/bitcoin/src/qt/rpcconsole.cpp
+++ b/depend/bitcoin/src/qt/rpcconsole.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/rpcconsole.h b/depend/bitcoin/src/qt/rpcconsole.h
index fe2955cc..53dccd7d 100644
--- a/depend/bitcoin/src/qt/rpcconsole.h
+++ b/depend/bitcoin/src/qt/rpcconsole.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/sendcoinsdialog.cpp b/depend/bitcoin/src/qt/sendcoinsdialog.cpp
index 3962dd08..c475c6b7 100644
--- a/depend/bitcoin/src/qt/sendcoinsdialog.cpp
+++ b/depend/bitcoin/src/qt/sendcoinsdialog.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/sendcoinsdialog.h b/depend/bitcoin/src/qt/sendcoinsdialog.h
index 4d5adc4f..e1b4a156 100644
--- a/depend/bitcoin/src/qt/sendcoinsdialog.h
+++ b/depend/bitcoin/src/qt/sendcoinsdialog.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/sendcoinsentry.cpp b/depend/bitcoin/src/qt/sendcoinsentry.cpp
index d8102c1d..67945726 100644
--- a/depend/bitcoin/src/qt/sendcoinsentry.cpp
+++ b/depend/bitcoin/src/qt/sendcoinsentry.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/sendcoinsentry.h b/depend/bitcoin/src/qt/sendcoinsentry.h
index 0edc0d12..429fd0a1 100644
--- a/depend/bitcoin/src/qt/sendcoinsentry.h
+++ b/depend/bitcoin/src/qt/sendcoinsentry.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/sendcoinsrecipient.h b/depend/bitcoin/src/qt/sendcoinsrecipient.h
index aa2ea049..496bf689 100644
--- a/depend/bitcoin/src/qt/sendcoinsrecipient.h
+++ b/depend/bitcoin/src/qt/sendcoinsrecipient.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/signverifymessagedialog.h b/depend/bitcoin/src/qt/signverifymessagedialog.h
index 4072707b..6c9eb28a 100644
--- a/depend/bitcoin/src/qt/signverifymessagedialog.h
+++ b/depend/bitcoin/src/qt/signverifymessagedialog.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/splashscreen.cpp b/depend/bitcoin/src/qt/splashscreen.cpp
index ccaa2018..237df5f6 100644
--- a/depend/bitcoin/src/qt/splashscreen.cpp
+++ b/depend/bitcoin/src/qt/splashscreen.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/splashscreen.h b/depend/bitcoin/src/qt/splashscreen.h
index 2356bbac..46821296 100644
--- a/depend/bitcoin/src/qt/splashscreen.h
+++ b/depend/bitcoin/src/qt/splashscreen.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/test/addressbooktests.h b/depend/bitcoin/src/qt/test/addressbooktests.h
index ab522064..c64e8f84 100644
--- a/depend/bitcoin/src/qt/test/addressbooktests.h
+++ b/depend/bitcoin/src/qt/test/addressbooktests.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2020 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/qt/test/apptests.cpp b/depend/bitcoin/src/qt/test/apptests.cpp
index 73e04b55..752c8773 100644
--- a/depend/bitcoin/src/qt/test/apptests.cpp
+++ b/depend/bitcoin/src/qt/test/apptests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/qt/test/apptests.h b/depend/bitcoin/src/qt/test/apptests.h
index f0a55500..bcc787fb 100644
--- a/depend/bitcoin/src/qt/test/apptests.h
+++ b/depend/bitcoin/src/qt/test/apptests.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2020 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/qt/test/optiontests.cpp b/depend/bitcoin/src/qt/test/optiontests.cpp
index 0d522e98..3edf37de 100644
--- a/depend/bitcoin/src/qt/test/optiontests.cpp
+++ b/depend/bitcoin/src/qt/test/optiontests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/qt/test/optiontests.h b/depend/bitcoin/src/qt/test/optiontests.h
index 2d7b9493..f8791882 100644
--- a/depend/bitcoin/src/qt/test/optiontests.h
+++ b/depend/bitcoin/src/qt/test/optiontests.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/qt/test/rpcnestedtests.h b/depend/bitcoin/src/qt/test/rpcnestedtests.h
index 28dc7140..19207265 100644
--- a/depend/bitcoin/src/qt/test/rpcnestedtests.h
+++ b/depend/bitcoin/src/qt/test/rpcnestedtests.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/qt/test/test_main.cpp b/depend/bitcoin/src/qt/test/test_main.cpp
index f3430c78..a8015fb5 100644
--- a/depend/bitcoin/src/qt/test/test_main.cpp
+++ b/depend/bitcoin/src/qt/test/test_main.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/qt/test/uritests.cpp b/depend/bitcoin/src/qt/test/uritests.cpp
index 935f078e..183de4cd 100644
--- a/depend/bitcoin/src/qt/test/uritests.cpp
+++ b/depend/bitcoin/src/qt/test/uritests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2018 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/qt/test/uritests.h b/depend/bitcoin/src/qt/test/uritests.h
index 49948427..7fbca5f6 100644
--- a/depend/bitcoin/src/qt/test/uritests.h
+++ b/depend/bitcoin/src/qt/test/uritests.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2015 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/qt/test/util.cpp b/depend/bitcoin/src/qt/test/util.cpp
index d91b90fb..30f7839f 100644
--- a/depend/bitcoin/src/qt/test/util.cpp
+++ b/depend/bitcoin/src/qt/test/util.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/qt/test/util.h b/depend/bitcoin/src/qt/test/util.h
index a1788ca7..b89b1f75 100644
--- a/depend/bitcoin/src/qt/test/util.h
+++ b/depend/bitcoin/src/qt/test/util.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/qt/test/wallettests.cpp b/depend/bitcoin/src/qt/test/wallettests.cpp
index 5e65dcca..b62b2a3b 100644
--- a/depend/bitcoin/src/qt/test/wallettests.cpp
+++ b/depend/bitcoin/src/qt/test/wallettests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/qt/test/wallettests.h b/depend/bitcoin/src/qt/test/wallettests.h
index 6044bedb..6a230bf7 100644
--- a/depend/bitcoin/src/qt/test/wallettests.h
+++ b/depend/bitcoin/src/qt/test/wallettests.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2020 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/qt/trafficgraphwidget.cpp b/depend/bitcoin/src/qt/trafficgraphwidget.cpp
index fb6f2cb4..266c003b 100644
--- a/depend/bitcoin/src/qt/trafficgraphwidget.cpp
+++ b/depend/bitcoin/src/qt/trafficgraphwidget.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/trafficgraphwidget.h b/depend/bitcoin/src/qt/trafficgraphwidget.h
index 5e5557ec..47f559fc 100644
--- a/depend/bitcoin/src/qt/trafficgraphwidget.h
+++ b/depend/bitcoin/src/qt/trafficgraphwidget.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/transactiondesc.cpp b/depend/bitcoin/src/qt/transactiondesc.cpp
index 93d31ee6..918d0af9 100644
--- a/depend/bitcoin/src/qt/transactiondesc.cpp
+++ b/depend/bitcoin/src/qt/transactiondesc.cpp
@@ -124,7 +124,7 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
     {
         strHTML += "<b>" + tr("Source") + ":</b> " + tr("Generated") + "<br>";
     }
-    else if (wtx.value_map.count("from") && !wtx.value_map["from"].empty())
+    else if (wtx.value_map.contains("from") && !wtx.value_map["from"].empty())
     {
         // Online transaction
         strHTML += "<b>" + tr("From") + ":</b> " + GUIUtil::HtmlEscape(wtx.value_map["from"]) + "<br>";
@@ -157,7 +157,7 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
     //
     // To
     //
-    if (wtx.value_map.count("to") && !wtx.value_map["to"].empty())
+    if (wtx.value_map.contains("to") && !wtx.value_map["to"].empty())
     {
         // Online transaction
         std::string strAddress = wtx.value_map["to"];
@@ -212,7 +212,7 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
                 if (toSelf && all_from_me)
                     continue;
 
-                if (!wtx.value_map.count("to") || wtx.value_map["to"].empty())
+                if (!wtx.value_map.contains("to") || wtx.value_map["to"].empty())
                 {
                     // Offline transaction
                     CTxDestination address;
@@ -273,9 +273,9 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
     //
     // Message
     //
-    if (wtx.value_map.count("message") && !wtx.value_map["message"].empty())
+    if (wtx.value_map.contains("message") && !wtx.value_map["message"].empty())
         strHTML += "<br><b>" + tr("Message") + ":</b><br>" + GUIUtil::HtmlEscape(wtx.value_map["message"], true) + "<br>";
-    if (wtx.value_map.count("comment") && !wtx.value_map["comment"].empty())
+    if (wtx.value_map.contains("comment") && !wtx.value_map["comment"].empty())
         strHTML += "<br><b>" + tr("Comment") + ":</b><br>" + GUIUtil::HtmlEscape(wtx.value_map["comment"], true) + "<br>";
 
     strHTML += "<b>" + tr("Transaction ID") + ":</b> " + rec->getTxHash() + "<br>";
diff --git a/depend/bitcoin/src/qt/transactiondesc.h b/depend/bitcoin/src/qt/transactiondesc.h
index b92df67f..477f3b79 100644
--- a/depend/bitcoin/src/qt/transactiondesc.h
+++ b/depend/bitcoin/src/qt/transactiondesc.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/transactiondescdialog.cpp b/depend/bitcoin/src/qt/transactiondescdialog.cpp
index 893752b2..08f8817f 100644
--- a/depend/bitcoin/src/qt/transactiondescdialog.cpp
+++ b/depend/bitcoin/src/qt/transactiondescdialog.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/transactiondescdialog.h b/depend/bitcoin/src/qt/transactiondescdialog.h
index 3204b226..fd93f78d 100644
--- a/depend/bitcoin/src/qt/transactiondescdialog.h
+++ b/depend/bitcoin/src/qt/transactiondescdialog.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/transactionfilterproxy.cpp b/depend/bitcoin/src/qt/transactionfilterproxy.cpp
index 459dba45..975128c6 100644
--- a/depend/bitcoin/src/qt/transactionfilterproxy.cpp
+++ b/depend/bitcoin/src/qt/transactionfilterproxy.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/transactionfilterproxy.h b/depend/bitcoin/src/qt/transactionfilterproxy.h
index a8570c5b..f8724a9c 100644
--- a/depend/bitcoin/src/qt/transactionfilterproxy.h
+++ b/depend/bitcoin/src/qt/transactionfilterproxy.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/transactionoverviewwidget.cpp b/depend/bitcoin/src/qt/transactionoverviewwidget.cpp
index 24b96c86..a96283b5 100644
--- a/depend/bitcoin/src/qt/transactionoverviewwidget.cpp
+++ b/depend/bitcoin/src/qt/transactionoverviewwidget.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/qt/transactionoverviewwidget.h b/depend/bitcoin/src/qt/transactionoverviewwidget.h
index eb9d6619..4d07e1f5 100644
--- a/depend/bitcoin/src/qt/transactionoverviewwidget.h
+++ b/depend/bitcoin/src/qt/transactionoverviewwidget.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/qt/transactionrecord.h b/depend/bitcoin/src/qt/transactionrecord.h
index 2c5d834b..7b72ff9b 100644
--- a/depend/bitcoin/src/qt/transactionrecord.h
+++ b/depend/bitcoin/src/qt/transactionrecord.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/transactiontablemodel.cpp b/depend/bitcoin/src/qt/transactiontablemodel.cpp
index 76351fa5..28734e3e 100644
--- a/depend/bitcoin/src/qt/transactiontablemodel.cpp
+++ b/depend/bitcoin/src/qt/transactiontablemodel.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/transactiontablemodel.h b/depend/bitcoin/src/qt/transactiontablemodel.h
index 1edae189..f92de787 100644
--- a/depend/bitcoin/src/qt/transactiontablemodel.h
+++ b/depend/bitcoin/src/qt/transactiontablemodel.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/transactionview.cpp b/depend/bitcoin/src/qt/transactionview.cpp
index e34ec334..0cb9b43b 100644
--- a/depend/bitcoin/src/qt/transactionview.cpp
+++ b/depend/bitcoin/src/qt/transactionview.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/transactionview.h b/depend/bitcoin/src/qt/transactionview.h
index d661d9b6..944ef88f 100644
--- a/depend/bitcoin/src/qt/transactionview.h
+++ b/depend/bitcoin/src/qt/transactionview.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/utilitydialog.cpp b/depend/bitcoin/src/qt/utilitydialog.cpp
index 86c37704..99a3a837 100644
--- a/depend/bitcoin/src/qt/utilitydialog.cpp
+++ b/depend/bitcoin/src/qt/utilitydialog.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/utilitydialog.h b/depend/bitcoin/src/qt/utilitydialog.h
index d2a5d5f6..61cd96cc 100644
--- a/depend/bitcoin/src/qt/utilitydialog.h
+++ b/depend/bitcoin/src/qt/utilitydialog.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2020 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/walletcontroller.cpp b/depend/bitcoin/src/qt/walletcontroller.cpp
index 869f9614..1d6153d4 100644
--- a/depend/bitcoin/src/qt/walletcontroller.cpp
+++ b/depend/bitcoin/src/qt/walletcontroller.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
@@ -409,7 +409,7 @@ void RestoreWalletActivity::restore(const fs::path& backup_file, const std::stri
         tr("Restoring Wallet <b>%1</b>…").arg(name.toHtmlEscaped()));
 
     QTimer::singleShot(0, worker(), [this, backup_file, wallet_name] {
-        auto wallet{node().walletLoader().restoreWallet(backup_file, wallet_name, m_warning_message)};
+        auto wallet{node().walletLoader().restoreWallet(backup_file, wallet_name, m_warning_message, /*load_after_restore=*/true)};
 
         if (wallet) {
             m_wallet_model = m_wallet_controller->getOrCreateWallet(std::move(*wallet));
@@ -439,22 +439,8 @@ void RestoreWalletActivity::finish()
     Q_EMIT finished();
 }
 
-void MigrateWalletActivity::migrate(const std::string& name)
+void MigrateWalletActivity::do_migrate(const std::string& name)
 {
-    // Warn the user about migration
-    QMessageBox box(m_parent_widget);
-    box.setWindowTitle(tr("Migrate wallet"));
-    box.setText(tr("Are you sure you wish to migrate the wallet <i>%1</i>?").arg(GUIUtil::HtmlEscape(GUIUtil::WalletDisplayName(name))));
-    box.setInformativeText(tr("Migrating the wallet will convert this wallet to one or more descriptor wallets. A new wallet backup will need to be made.\n"
-                "If this wallet contains any watchonly scripts, a new wallet will be created which contains those watchonly scripts.\n"
-                "If this wallet contains any solvable but not watched scripts, a different and new wallet will be created which contains those scripts.\n\n"
-                "The migration process will create a backup of the wallet before migrating. This backup file will be named "
-                "<wallet name>-<timestamp>.legacy.bak and can be found in the directory for this wallet. In the event of "
-                "an incorrect migration, the backup can be restored with the \"Restore Wallet\" functionality."));
-    box.setStandardButtons(QMessageBox::Yes|QMessageBox::Cancel);
-    box.setDefaultButton(QMessageBox::Yes);
-    if (box.exec() != QMessageBox::Yes) return;
-
     SecureString passphrase;
     if (node().walletLoader().isEncrypted(name)) {
         // Get the passphrase for the wallet
@@ -484,6 +470,64 @@ void MigrateWalletActivity::migrate(const std::string& name)
     });
 }
 
+void MigrateWalletActivity::migrate(const std::string& name)
+{
+    // Warn the user about migration
+    QMessageBox box(m_parent_widget);
+    box.setWindowTitle(tr("Migrate wallet"));
+    box.setText(tr("Are you sure you wish to migrate the wallet <i>%1</i>?").arg(GUIUtil::HtmlEscape(GUIUtil::WalletDisplayName(name))));
+    box.setInformativeText(tr("Migrating the wallet will convert this wallet to one or more descriptor wallets. A new wallet backup will need to be made.\n"
+                "If this wallet contains any watchonly scripts, a new wallet will be created which contains those watchonly scripts.\n"
+                "If this wallet contains any solvable but not watched scripts, a different and new wallet will be created which contains those scripts.\n\n"
+                "The migration process will create a backup of the wallet before migrating. This backup file will be named "
+                "<wallet name>-<timestamp>.legacy.bak and can be found in the directory for this wallet. In the event of "
+                "an incorrect migration, the backup can be restored with the \"Restore Wallet\" functionality."));
+    box.setStandardButtons(QMessageBox::Yes|QMessageBox::Cancel);
+    box.setDefaultButton(QMessageBox::Yes);
+    if (box.exec() != QMessageBox::Yes) return;
+
+    do_migrate(name);
+}
+
+void MigrateWalletActivity::restore_and_migrate(const fs::path& path, const std::string& wallet_name)
+{
+    // Warn the user about migration
+    QMessageBox box(m_parent_widget);
+    box.setWindowTitle(tr("Restore and Migrate wallet"));
+    box.setText(tr("Are you sure you wish to restore the wallet file <i>%1</i> to <i>%2</i> and migrate it?").arg(GUIUtil::HtmlEscape(fs::PathToString(path)), GUIUtil::HtmlEscape(GUIUtil::WalletDisplayName(wallet_name))));
+    box.setInformativeText(tr("Restoring the wallet will copy the backup file to the wallets directory and place it in the standard "
+                "wallet directory layout. The original file will not be modified.\n\n"
+                "Migrating the wallet will convert the restored wallet to one or more descriptor wallets. A new wallet backup will need to be made.\n"
+                "If this wallet contains any watchonly scripts, a new wallet will be created which contains those watchonly scripts.\n"
+                "If this wallet contains any solvable but not watched scripts, a different and new wallet will be created which contains those scripts.\n\n"
+                "The migration process will create a backup of the wallet before migrating. This backup file will be named "
+                "<wallet name>-<timestamp>.legacy.bak and can be found in the directory for this wallet. In the event of "
+                "an incorrect migration, the backup can be restored with the \"Restore Wallet\" functionality."));
+    box.setStandardButtons(QMessageBox::Yes|QMessageBox::Cancel);
+    box.setDefaultButton(QMessageBox::Yes);
+    if (box.exec() != QMessageBox::Yes) return;
+
+    showProgressDialog(
+        //: Title of progress window which is displayed when wallets are being restored.
+        tr("Restore Wallet"),
+        /*: Descriptive text of the restore wallets progress window which indicates to
+            the user that wallets are currently being restored.*/
+        tr("Restoring Wallet <b>%1</b>…").arg(GUIUtil::HtmlEscape(GUIUtil::WalletDisplayName(wallet_name))));
+
+    QTimer::singleShot(0, worker(), [this, path, wallet_name] {
+        auto res{node().walletLoader().restoreWallet(path, wallet_name, m_warning_message, /*load_after_restore=*/false)};
+
+        if (!res) {
+            m_error_message = util::ErrorString(res);
+            QTimer::singleShot(0, this, &MigrateWalletActivity::finish);
+            return;
+        }
+        QTimer::singleShot(0, this, [this, wallet_name] {
+            do_migrate(wallet_name);
+        });
+    });
+}
+
 void MigrateWalletActivity::finish()
 {
     if (!m_error_message.empty()) {
diff --git a/depend/bitcoin/src/qt/walletcontroller.h b/depend/bitcoin/src/qt/walletcontroller.h
index 4d2ba435..2fb9ccf1 100644
--- a/depend/bitcoin/src/qt/walletcontroller.h
+++ b/depend/bitcoin/src/qt/walletcontroller.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
@@ -187,6 +187,7 @@ class MigrateWalletActivity : public WalletControllerActivity
 public:
     MigrateWalletActivity(WalletController* wallet_controller, QWidget* parent) : WalletControllerActivity(wallet_controller, parent) {}
 
+    void restore_and_migrate(const fs::path& path, const std::string& wallet_name);
     void migrate(const std::string& path);
 
 Q_SIGNALS:
@@ -195,6 +196,7 @@ class MigrateWalletActivity : public WalletControllerActivity
 private:
     QString m_success_message;
 
+    void do_migrate(const std::string& name);
     void finish();
 };
 
diff --git a/depend/bitcoin/src/qt/walletframe.cpp b/depend/bitcoin/src/qt/walletframe.cpp
index 7a8a0539..579c033d 100644
--- a/depend/bitcoin/src/qt/walletframe.cpp
+++ b/depend/bitcoin/src/qt/walletframe.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
@@ -70,7 +70,7 @@ bool WalletFrame::addView(WalletView* walletView)
 {
     if (!clientModel) return false;
 
-    if (mapWalletViews.count(walletView->getWalletModel()) > 0) return false;
+    if (mapWalletViews.contains(walletView->getWalletModel())) return false;
 
     walletView->setClientModel(clientModel);
     walletView->showOutOfSyncWarning(bOutOfSync);
@@ -90,7 +90,7 @@ bool WalletFrame::addView(WalletView* walletView)
 
 void WalletFrame::setCurrentWallet(WalletModel* wallet_model)
 {
-    if (mapWalletViews.count(wallet_model) == 0) return;
+    if (!mapWalletViews.contains(wallet_model)) return;
 
     // Stop the effect of hidden widgets on the size hint of the shown one in QStackedWidget.
     WalletView* view_about_to_hide = currentWalletView();
@@ -116,7 +116,7 @@ void WalletFrame::setCurrentWallet(WalletModel* wallet_model)
 
 void WalletFrame::removeWallet(WalletModel* wallet_model)
 {
-    if (mapWalletViews.count(wallet_model) == 0) return;
+    if (!mapWalletViews.contains(wallet_model)) return;
 
     WalletView *walletView = mapWalletViews.take(wallet_model);
     walletStack->removeWidget(walletView);
diff --git a/depend/bitcoin/src/qt/walletframe.h b/depend/bitcoin/src/qt/walletframe.h
index 60c97ff7..0c8276e2 100644
--- a/depend/bitcoin/src/qt/walletframe.h
+++ b/depend/bitcoin/src/qt/walletframe.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/walletmodel.h b/depend/bitcoin/src/qt/walletmodel.h
index ece797bf..edecd476 100644
--- a/depend/bitcoin/src/qt/walletmodel.h
+++ b/depend/bitcoin/src/qt/walletmodel.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/walletmodeltransaction.cpp b/depend/bitcoin/src/qt/walletmodeltransaction.cpp
index 8222672b..8da0bd25 100644
--- a/depend/bitcoin/src/qt/walletmodeltransaction.cpp
+++ b/depend/bitcoin/src/qt/walletmodeltransaction.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/walletmodeltransaction.h b/depend/bitcoin/src/qt/walletmodeltransaction.h
index 0e6ed8be..fa3c738d 100644
--- a/depend/bitcoin/src/qt/walletmodeltransaction.h
+++ b/depend/bitcoin/src/qt/walletmodeltransaction.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/walletview.cpp b/depend/bitcoin/src/qt/walletview.cpp
index 39e9dcad..9f6084c6 100644
--- a/depend/bitcoin/src/qt/walletview.cpp
+++ b/depend/bitcoin/src/qt/walletview.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/walletview.h b/depend/bitcoin/src/qt/walletview.h
index 47508504..53e94194 100644
--- a/depend/bitcoin/src/qt/walletview.h
+++ b/depend/bitcoin/src/qt/walletview.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/qt/winshutdownmonitor.cpp b/depend/bitcoin/src/qt/winshutdownmonitor.cpp
index 3f835a7a..44d3f97b 100644
--- a/depend/bitcoin/src/qt/winshutdownmonitor.cpp
+++ b/depend/bitcoin/src/qt/winshutdownmonitor.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2019 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/qt/winshutdownmonitor.h b/depend/bitcoin/src/qt/winshutdownmonitor.h
index 42c8da75..fa7dc6fa 100644
--- a/depend/bitcoin/src/qt/winshutdownmonitor.h
+++ b/depend/bitcoin/src/qt/winshutdownmonitor.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2021 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/randomenv.cpp b/depend/bitcoin/src/randomenv.cpp
index 829a610f..662625b5 100644
--- a/depend/bitcoin/src/randomenv.cpp
+++ b/depend/bitcoin/src/randomenv.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/randomenv.h b/depend/bitcoin/src/randomenv.h
index b192ff40..e53f3bf1 100644
--- a/depend/bitcoin/src/randomenv.h
+++ b/depend/bitcoin/src/randomenv.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/rest.cpp b/depend/bitcoin/src/rest.cpp
index 06da3906..b91b229a 100644
--- a/depend/bitcoin/src/rest.cpp
+++ b/depend/bitcoin/src/rest.cpp
@@ -1142,20 +1142,20 @@ static const struct {
     const char* prefix;
     bool (*handler)(const std::any& context, HTTPRequest* req, const std::string& strReq);
 } uri_prefixes[] = {
-      {"/rest/tx/", rest_tx},
-      {"/rest/block/notxdetails/", rest_block_notxdetails},
-      {"/rest/block/", rest_block_extended},
-      {"/rest/blockpart/", rest_block_part},
-      {"/rest/blockfilter/", rest_block_filter},
-      {"/rest/blockfilterheaders/", rest_filter_header},
-      {"/rest/chaininfo", rest_chaininfo},
-      {"/rest/mempool/", rest_mempool},
-      {"/rest/headers/", rest_headers},
-      {"/rest/getutxos", rest_getutxos},
-      {"/rest/deploymentinfo/", rest_deploymentinfo},
-      {"/rest/deploymentinfo", rest_deploymentinfo},
-      {"/rest/blockhashbyheight/", rest_blockhash_by_height},
-      {"/rest/spenttxouts/", rest_spent_txouts},
+    {"/rest/tx/", rest_tx},
+    {"/rest/block/notxdetails/", rest_block_notxdetails},
+    {"/rest/block/", rest_block_extended},
+    {"/rest/blockpart/", rest_block_part},
+    {"/rest/blockfilter/", rest_block_filter},
+    {"/rest/blockfilterheaders/", rest_filter_header},
+    {"/rest/chaininfo", rest_chaininfo},
+    {"/rest/mempool/", rest_mempool},
+    {"/rest/headers/", rest_headers},
+    {"/rest/getutxos", rest_getutxos},
+    {"/rest/deploymentinfo/", rest_deploymentinfo},
+    {"/rest/deploymentinfo", rest_deploymentinfo},
+    {"/rest/blockhashbyheight/", rest_blockhash_by_height},
+    {"/rest/spenttxouts/", rest_spent_txouts},
 };
 
 void StartREST(const std::any& context)
diff --git a/depend/bitcoin/src/rest.h b/depend/bitcoin/src/rest.h
index 49b1c333..0e27f4be 100644
--- a/depend/bitcoin/src/rest.h
+++ b/depend/bitcoin/src/rest.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/rpc/blockchain.cpp b/depend/bitcoin/src/rpc/blockchain.cpp
index c68bfb8c..6918a66e 100644
--- a/depend/bitcoin/src/rpc/blockchain.cpp
+++ b/depend/bitcoin/src/rpc/blockchain.cpp
@@ -1896,7 +1896,7 @@ static inline bool SetHasKeys(const std::set<T>& set) {return false;}
 template<typename T, typename Tk, typename... Args>
 static inline bool SetHasKeys(const std::set<T>& set, const Tk& key, const Args&... args)
 {
-    return (set.count(key) != 0) || SetHasKeys(set, args...);
+    return (set.contains(key)) || SetHasKeys(set, args...);
 }
 
 // outpoint (needed for the utxo index) + nHeight + fCoinBase
@@ -1987,12 +1987,12 @@ static RPCHelpMan getblockstats()
     const CBlockUndo& blockUndo = GetUndoChecked(chainman.m_blockman, pindex);
 
     const bool do_all = stats.size() == 0; // Calculate everything if nothing selected (default)
-    const bool do_mediantxsize = do_all || stats.count("mediantxsize") != 0;
-    const bool do_medianfee = do_all || stats.count("medianfee") != 0;
-    const bool do_feerate_percentiles = do_all || stats.count("feerate_percentiles") != 0;
+    const bool do_mediantxsize = do_all || stats.contains("mediantxsize");
+    const bool do_medianfee = do_all || stats.contains("medianfee");
+    const bool do_feerate_percentiles = do_all || stats.contains("feerate_percentiles");
     const bool loop_inputs = do_all || do_medianfee || do_feerate_percentiles ||
         SetHasKeys(stats, "utxo_increase", "utxo_increase_actual", "utxo_size_inc", "utxo_size_inc_actual", "totalfee", "avgfee", "avgfeerate", "minfee", "maxfee", "minfeerate", "maxfeerate");
-    const bool loop_outputs = do_all || loop_inputs || stats.count("total_out");
+    const bool loop_outputs = do_all || loop_inputs || stats.contains("total_out");
     const bool do_calculate_size = do_mediantxsize ||
         SetHasKeys(stats, "total_size", "avgtxsize", "mintxsize", "maxtxsize", "swtotal_size");
     const bool do_calculate_weight = do_all || SetHasKeys(stats, "total_weight", "avgfeerate", "swtotal_weight", "avgfeerate", "feerate_percentiles", "minfeerate", "maxfeerate");
@@ -2185,7 +2185,7 @@ bool FindScriptPubKey(std::atomic<int>& scan_progress, const std::atomic<bool>&
             uint32_t high = 0x100 * *UCharCast(key.hash.begin()) + *(UCharCast(key.hash.begin()) + 1);
             scan_progress = (int)(high * 100.0 / 65536.0 + 0.5);
         }
-        if (needles.count(coin.out.scriptPubKey)) {
+        if (needles.contains(coin.out.scriptPubKey)) {
             out_results.emplace(key, coin);
         }
         cursor->Next();
@@ -2460,7 +2460,7 @@ static bool CheckBlockFilterMatches(BlockManager& blockman, const CBlockIndex& b
     // Check if any of the outputs match the scriptPubKey
     for (const auto& tx : block.vtx) {
         if (std::any_of(tx->vout.cbegin(), tx->vout.cend(), [&](const auto& txout) {
-                return needles.count(std::vector<unsigned char>(txout.scriptPubKey.begin(), txout.scriptPubKey.end())) != 0;
+                return needles.contains(std::vector<unsigned char>(txout.scriptPubKey.begin(), txout.scriptPubKey.end()));
             })) {
             return true;
         }
@@ -2468,7 +2468,7 @@ static bool CheckBlockFilterMatches(BlockManager& blockman, const CBlockIndex& b
     // Check if any of the inputs match the scriptPubKey
     for (const auto& txundo : block_undo.vtxundo) {
         if (std::any_of(txundo.vprevout.cbegin(), txundo.vprevout.cend(), [&](const auto& coin) {
-                return needles.count(std::vector<unsigned char>(coin.out.scriptPubKey.begin(), coin.out.scriptPubKey.end())) != 0;
+                return needles.contains(std::vector<unsigned char>(coin.out.scriptPubKey.begin(), coin.out.scriptPubKey.end()));
             })) {
             return true;
         }
@@ -3428,7 +3428,7 @@ return RPCHelpMan{
 
     ChainstateManager& chainman = EnsureAnyChainman(request.context);
 
-    auto make_chain_data = [&](const Chainstate& cs, bool validated) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
+    auto make_chain_data = [&](const Chainstate& cs) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
         AssertLockHeld(::cs_main);
         UniValue data(UniValue::VOBJ);
         if (!cs.m_chain.Tip()) {
@@ -3448,17 +3448,16 @@ return RPCHelpMan{
         if (cs.m_from_snapshot_blockhash) {
             data.pushKV("snapshot_blockhash", cs.m_from_snapshot_blockhash->ToString());
         }
-        data.pushKV("validated", validated);
+        data.pushKV("validated", cs.m_assumeutxo == Assumeutxo::VALIDATED);
         return data;
     };
 
     obj.pushKV("headers", chainman.m_best_header ? chainman.m_best_header->nHeight : -1);
-
-    const auto& chainstates = chainman.GetAll();
     UniValue obj_chainstates{UniValue::VARR};
-    for (Chainstate* cs : chainstates) {
-      obj_chainstates.push_back(make_chain_data(*cs, !cs->m_from_snapshot_blockhash || chainstates.size() == 1));
+    if (const Chainstate * cs{chainman.HistoricalChainstate()}) {
+        obj_chainstates.push_back(make_chain_data(*cs));
     }
+    obj_chainstates.push_back(make_chain_data(chainman.CurrentChainstate()));
     obj.pushKV("chainstates", std::move(obj_chainstates));
     return obj;
 }
diff --git a/depend/bitcoin/src/rpc/client.h b/depend/bitcoin/src/rpc/client.h
index b67cd27f..b9f0315f 100644
--- a/depend/bitcoin/src/rpc/client.h
+++ b/depend/bitcoin/src/rpc/client.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2009-2018 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/rpc/external_signer.cpp b/depend/bitcoin/src/rpc/external_signer.cpp
index 44de5443..d0fad123 100644
--- a/depend/bitcoin/src/rpc/external_signer.cpp
+++ b/depend/bitcoin/src/rpc/external_signer.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/rpc/fees.cpp b/depend/bitcoin/src/rpc/fees.cpp
index 54f506f6..991e19b3 100644
--- a/depend/bitcoin/src/rpc/fees.cpp
+++ b/depend/bitcoin/src/rpc/fees.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/rpc/mempool.cpp b/depend/bitcoin/src/rpc/mempool.cpp
index a9a67834..2df02e34 100644
--- a/depend/bitcoin/src/rpc/mempool.cpp
+++ b/depend/bitcoin/src/rpc/mempool.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/rpc/mempool.h b/depend/bitcoin/src/rpc/mempool.h
index 229d7d52..926a64bf 100644
--- a/depend/bitcoin/src/rpc/mempool.h
+++ b/depend/bitcoin/src/rpc/mempool.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/rpc/mining.cpp b/depend/bitcoin/src/rpc/mining.cpp
index 2639b916..e6c03639 100644
--- a/depend/bitcoin/src/rpc/mining.cpp
+++ b/depend/bitcoin/src/rpc/mining.cpp
@@ -846,12 +846,12 @@ static RPCHelpMan getblocktemplate()
     const Consensus::Params& consensusParams = chainman.GetParams().GetConsensus();
 
     // GBT must be called with 'signet' set in the rules for signet chains
-    if (consensusParams.signet_blocks && setClientRules.count("signet") != 1) {
+    if (consensusParams.signet_blocks && !setClientRules.contains("signet")) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "getblocktemplate must be called with the signet rule set (call with {\"rules\": [\"segwit\", \"signet\"]})");
     }
 
     // GBT must be called with 'segwit' set in the rules
-    if (setClientRules.count("segwit") != 1) {
+    if (!setClientRules.contains("segwit")) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "getblocktemplate must be called with the segwit rule set (call with {\"rules\": [\"segwit\"]})");
     }
 
@@ -913,7 +913,7 @@ static RPCHelpMan getblocktemplate()
         UniValue deps(UniValue::VARR);
         for (const CTxIn &in : tx.vin)
         {
-            if (setTxIndex.count(in.prevout.hash))
+            if (setTxIndex.contains(in.prevout.hash))
                 deps.push_back(setTxIndex[in.prevout.hash]);
         }
         entry.pushKV("depends", std::move(deps));
@@ -957,7 +957,7 @@ static RPCHelpMan getblocktemplate()
 
     for (const auto& [name, info] : gbtstatus.signalling) {
         vbavailable.pushKV(gbt_rule_value(name, info.gbt_optional_rule), info.bit);
-        if (!info.gbt_optional_rule && !setClientRules.count(name)) {
+        if (!info.gbt_optional_rule && !setClientRules.contains(name)) {
             // If the client doesn't support this, don't indicate it in the [default] version
             block.nVersion &= ~info.mask;
         }
@@ -966,7 +966,7 @@ static RPCHelpMan getblocktemplate()
     for (const auto& [name, info] : gbtstatus.locked_in) {
         block.nVersion |= info.mask;
         vbavailable.pushKV(gbt_rule_value(name, info.gbt_optional_rule), info.bit);
-        if (!info.gbt_optional_rule && !setClientRules.count(name)) {
+        if (!info.gbt_optional_rule && !setClientRules.contains(name)) {
             // If the client doesn't support this, don't indicate it in the [default] version
             block.nVersion &= ~info.mask;
         }
@@ -974,7 +974,7 @@ static RPCHelpMan getblocktemplate()
 
     for (const auto& [name, info] : gbtstatus.active) {
         aRules.push_back(gbt_rule_value(name, info.gbt_optional_rule));
-        if (!info.gbt_optional_rule && !setClientRules.count(name)) {
+        if (!info.gbt_optional_rule && !setClientRules.contains(name)) {
             // Not supported by the client; make sure it's safe to proceed
             throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Support for '%s' rule requires explicit client support", name));
         }
diff --git a/depend/bitcoin/src/rpc/mining.h b/depend/bitcoin/src/rpc/mining.h
index acc74e1d..13627227 100644
--- a/depend/bitcoin/src/rpc/mining.h
+++ b/depend/bitcoin/src/rpc/mining.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2020 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/rpc/output_script.cpp b/depend/bitcoin/src/rpc/output_script.cpp
index 5c1151f0..2d65b98a 100644
--- a/depend/bitcoin/src/rpc/output_script.cpp
+++ b/depend/bitcoin/src/rpc/output_script.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/rpc/protocol.h b/depend/bitcoin/src/rpc/protocol.h
index 0574335c..3f18365c 100644
--- a/depend/bitcoin/src/rpc/protocol.h
+++ b/depend/bitcoin/src/rpc/protocol.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/rpc/rawtransaction.cpp b/depend/bitcoin/src/rpc/rawtransaction.cpp
index 2baeb679..a01782e0 100644
--- a/depend/bitcoin/src/rpc/rawtransaction.cpp
+++ b/depend/bitcoin/src/rpc/rawtransaction.cpp
@@ -1841,7 +1841,7 @@ static RPCHelpMan joinpsbts()
             merged_psbt.AddOutput(psbt.tx->vout[i], psbt.outputs[i]);
         }
         for (auto& xpub_pair : psbt.m_xpubs) {
-            if (merged_psbt.m_xpubs.count(xpub_pair.first) == 0) {
+            if (!merged_psbt.m_xpubs.contains(xpub_pair.first)) {
                 merged_psbt.m_xpubs[xpub_pair.first] = xpub_pair.second;
             } else {
                 merged_psbt.m_xpubs[xpub_pair.first].insert(xpub_pair.second.begin(), xpub_pair.second.end());
diff --git a/depend/bitcoin/src/rpc/rawtransaction_util.cpp b/depend/bitcoin/src/rpc/rawtransaction_util.cpp
index e6910c93..c74ae8d1 100644
--- a/depend/bitcoin/src/rpc/rawtransaction_util.cpp
+++ b/depend/bitcoin/src/rpc/rawtransaction_util.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/rpc/rawtransaction_util.h b/depend/bitcoin/src/rpc/rawtransaction_util.h
index 36d65fac..65e65c37 100644
--- a/depend/bitcoin/src/rpc/rawtransaction_util.h
+++ b/depend/bitcoin/src/rpc/rawtransaction_util.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/rpc/register.h b/depend/bitcoin/src/rpc/register.h
index 17ed6c14..8d3089ae 100644
--- a/depend/bitcoin/src/rpc/register.h
+++ b/depend/bitcoin/src/rpc/register.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/rpc/request.cpp b/depend/bitcoin/src/rpc/request.cpp
index df28e4ea..1798cdef 100644
--- a/depend/bitcoin/src/rpc/request.cpp
+++ b/depend/bitcoin/src/rpc/request.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/rpc/request.h b/depend/bitcoin/src/rpc/request.h
index 2fb234c1..4588db51 100644
--- a/depend/bitcoin/src/rpc/request.h
+++ b/depend/bitcoin/src/rpc/request.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/rpc/server_util.cpp b/depend/bitcoin/src/rpc/server_util.cpp
index a0b19925..69fc2429 100644
--- a/depend/bitcoin/src/rpc/server_util.cpp
+++ b/depend/bitcoin/src/rpc/server_util.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/rpc/server_util.h b/depend/bitcoin/src/rpc/server_util.h
index 6fb5e1c9..14bb1c8f 100644
--- a/depend/bitcoin/src/rpc/server_util.h
+++ b/depend/bitcoin/src/rpc/server_util.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/rpc/signmessage.cpp b/depend/bitcoin/src/rpc/signmessage.cpp
index a3fb0bbf..dcdc0260 100644
--- a/depend/bitcoin/src/rpc/signmessage.cpp
+++ b/depend/bitcoin/src/rpc/signmessage.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/rpc/txoutproof.cpp b/depend/bitcoin/src/rpc/txoutproof.cpp
index 24cb8599..7e8e3bdb 100644
--- a/depend/bitcoin/src/rpc/txoutproof.cpp
+++ b/depend/bitcoin/src/rpc/txoutproof.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
@@ -109,7 +109,7 @@ static RPCHelpMan gettxoutproof()
 
             unsigned int ntxFound = 0;
             for (const auto& tx : block.vtx) {
-                if (setTxids.count(tx->GetHash())) {
+                if (setTxids.contains(tx->GetHash())) {
                     ntxFound++;
                 }
             }
diff --git a/depend/bitcoin/src/rpc/util.cpp b/depend/bitcoin/src/rpc/util.cpp
index 642b8c09..49569c7b 100644
--- a/depend/bitcoin/src/rpc/util.cpp
+++ b/depend/bitcoin/src/rpc/util.cpp
@@ -71,7 +71,7 @@ void RPCTypeCheckObj(const UniValue& o,
     {
         for (const std::string& k : o.getKeys())
         {
-            if (typesExpected.count(k) == 0)
+            if (!typesExpected.contains(k))
             {
                 std::string err = strprintf("Unexpected key %s", k);
                 throw JSONRPCError(RPC_TYPE_ERROR, err);
@@ -1172,7 +1172,7 @@ UniValue RPCResult::MatchesType(const UniValue& result) const
         std::map<std::string, UniValue> result_obj;
         result.getObjMap(result_obj);
         for (const auto& result_entry : result_obj) {
-            if (doc_keys.find(result_entry.first) == doc_keys.end()) {
+            if (!doc_keys.contains(result_entry.first)) {
                 errors.pushKV(result_entry.first, "key returned that was not in doc");
             }
         }
diff --git a/depend/bitcoin/src/scheduler.cpp b/depend/bitcoin/src/scheduler.cpp
index eb174a75..a1ce06f3 100644
--- a/depend/bitcoin/src/scheduler.cpp
+++ b/depend/bitcoin/src/scheduler.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/scheduler.h b/depend/bitcoin/src/scheduler.h
index 454c083b..79b8afd2 100644
--- a/depend/bitcoin/src/scheduler.h
+++ b/depend/bitcoin/src/scheduler.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/script/descriptor.h b/depend/bitcoin/src/script/descriptor.h
index a6744b92..b86e788d 100644
--- a/depend/bitcoin/src/script/descriptor.h
+++ b/depend/bitcoin/src/script/descriptor.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/script/keyorigin.h b/depend/bitcoin/src/script/keyorigin.h
index c779872b..e54133cd 100644
--- a/depend/bitcoin/src/script/keyorigin.h
+++ b/depend/bitcoin/src/script/keyorigin.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2020 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/script/script_error.cpp b/depend/bitcoin/src/script/script_error.cpp
index 24e2f5f0..a6707638 100644
--- a/depend/bitcoin/src/script/script_error.cpp
+++ b/depend/bitcoin/src/script/script_error.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/script/script_error.h b/depend/bitcoin/src/script/script_error.h
index fbcc1bd1..198d037c 100644
--- a/depend/bitcoin/src/script/script_error.h
+++ b/depend/bitcoin/src/script/script_error.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/script/sign.cpp b/depend/bitcoin/src/script/sign.cpp
index 8103e318..9ea2157f 100644
--- a/depend/bitcoin/src/script/sign.cpp
+++ b/depend/bitcoin/src/script/sign.cpp
@@ -87,8 +87,6 @@ std::optional<uint256> MutableTransactionSignatureCreator::ComputeSchnorrSignatu
 
 bool MutableTransactionSignatureCreator::CreateSchnorrSig(const SigningProvider& provider, std::vector<unsigned char>& sig, const XOnlyPubKey& pubkey, const uint256* leaf_hash, const uint256* merkle_root, SigVersion sigversion) const
 {
-    assert(sigversion == SigVersion::TAPROOT || sigversion == SigVersion::TAPSCRIPT);
-
     CKey key;
     if (!provider.GetKeyByXOnly(pubkey, key)) return false;
 
@@ -342,7 +340,7 @@ static bool SignMuSig2(const BaseSignatureCreator& creator, SignatureData& sigda
                 sigdata.musig2_partial_sigs[pub_key_leaf_hash].emplace(part_pk, partial_sig);
             }
         }
-        // If there are any partial signatures, exit early
+        // If there are any partial signatures, continue with next aggregate pubkey
         auto partial_sigs_it = sigdata.musig2_partial_sigs.find(pub_key_leaf_hash);
         if (partial_sigs_it != sigdata.musig2_partial_sigs.end() && !partial_sigs_it->second.empty()) {
             continue;
@@ -890,7 +888,7 @@ SignatureData DataFromTransaction(const CMutableTransaction& tx, unsigned int nI
             for (unsigned int i = last_success_key; i < num_pubkeys; ++i) {
                 const valtype& pubkey = solutions[i+1];
                 // We either have a signature for this pubkey, or we have found a signature and it is valid
-                if (data.signatures.count(CPubKey(pubkey).GetID()) || extractor_checker.CheckECDSASignature(sig, pubkey, next_script, sigversion)) {
+                if (data.signatures.contains(CPubKey(pubkey).GetID()) || extractor_checker.CheckECDSASignature(sig, pubkey, next_script, sigversion)) {
                     last_success_key = i + 1;
                     break;
                 }
diff --git a/depend/bitcoin/src/script/sign.h b/depend/bitcoin/src/script/sign.h
index dd86a806..8d502755 100644
--- a/depend/bitcoin/src/script/sign.h
+++ b/depend/bitcoin/src/script/sign.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/script/signingprovider.cpp b/depend/bitcoin/src/script/signingprovider.cpp
index 8557eb77..19596544 100644
--- a/depend/bitcoin/src/script/signingprovider.cpp
+++ b/depend/bitcoin/src/script/signingprovider.cpp
@@ -122,7 +122,9 @@ std::map<CPubKey, std::vector<CPubKey>> FlatSigningProvider::GetAllMuSig2Partici
 void FlatSigningProvider::SetMuSig2SecNonce(const uint256& session_id, MuSig2SecNonce&& nonce) const
 {
     if (!Assume(musig2_secnonces)) return;
-    musig2_secnonces->emplace(session_id, std::move(nonce));
+    auto [it, inserted] = musig2_secnonces->try_emplace(session_id, std::move(nonce));
+    // No secnonce should exist for this session yet.
+    Assert(inserted);
 }
 
 std::optional<std::reference_wrapper<MuSig2SecNonce>> FlatSigningProvider::GetMuSig2SecNonce(const uint256& session_id) const
@@ -196,7 +198,7 @@ bool FillableSigningProvider::AddKeyPubKey(const CKey& key, const CPubKey &pubke
 bool FillableSigningProvider::HaveKey(const CKeyID &address) const
 {
     LOCK(cs_KeyStore);
-    return mapKeys.count(address) > 0;
+    return mapKeys.contains(address);
 }
 
 std::set<CKeyID> FillableSigningProvider::GetKeys() const
@@ -235,7 +237,7 @@ bool FillableSigningProvider::AddCScript(const CScript& redeemScript)
 bool FillableSigningProvider::HaveCScript(const CScriptID& hash) const
 {
     LOCK(cs_KeyStore);
-    return mapScripts.count(hash) > 0;
+    return mapScripts.contains(hash);
 }
 
 std::set<CScriptID> FillableSigningProvider::GetCScripts() const
diff --git a/depend/bitcoin/src/signet.cpp b/depend/bitcoin/src/signet.cpp
index 6524ebff..787f5ae4 100644
--- a/depend/bitcoin/src/signet.cpp
+++ b/depend/bitcoin/src/signet.cpp
@@ -4,24 +4,25 @@
 
 #include <signet.h>
 
-#include <common/system.h>
 #include <consensus/merkle.h>
 #include <consensus/params.h>
 #include <consensus/validation.h>
-#include <core_io.h>
-#include <hash.h>
 #include <logging.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
-#include <span.h>
+#include <script/script.h>
 #include <streams.h>
 #include <uint256.h>
-#include <util/strencodings.h>
+#include <util/check.h>
 
 #include <algorithm>
-#include <array>
+#include <cstddef>
 #include <cstdint>
+#include <exception>
+#include <memory>
+#include <span>
+#include <utility>
 #include <vector>
 
 static constexpr uint8_t SIGNET_HEADER[4] = {0xec, 0xc7, 0xda, 0xa2};
diff --git a/depend/bitcoin/src/signet.h b/depend/bitcoin/src/signet.h
index 6912fc7f..9ebae840 100644
--- a/depend/bitcoin/src/signet.h
+++ b/depend/bitcoin/src/signet.h
@@ -1,16 +1,20 @@
-// Copyright (c) 2019-2021 The Bitcoin Core developers
+// Copyright (c) 2019-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_SIGNET_H
 #define BITCOIN_SIGNET_H
 
-#include <consensus/params.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 
 #include <optional>
 
+class CScript;
+namespace Consensus {
+struct Params;
+} // namespace Consensus
+
 /**
  * Extract signature and check whether a block has a valid solution
  */
diff --git a/depend/bitcoin/src/support/allocators/pool.h b/depend/bitcoin/src/support/allocators/pool.h
index 108f0938..abca09ad 100644
--- a/depend/bitcoin/src/support/allocators/pool.h
+++ b/depend/bitcoin/src/support/allocators/pool.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/support/allocators/zeroafterfree.h b/depend/bitcoin/src/support/allocators/zeroafterfree.h
index 9a942a41..54d30de4 100644
--- a/depend/bitcoin/src/support/allocators/zeroafterfree.h
+++ b/depend/bitcoin/src/support/allocators/zeroafterfree.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/support/cleanse.cpp b/depend/bitcoin/src/support/cleanse.cpp
index 4e370f15..e1985ed4 100644
--- a/depend/bitcoin/src/support/cleanse.cpp
+++ b/depend/bitcoin/src/support/cleanse.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2019 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/support/cleanse.h b/depend/bitcoin/src/support/cleanse.h
index 161f3cc3..6a4110b9 100644
--- a/depend/bitcoin/src/support/cleanse.h
+++ b/depend/bitcoin/src/support/cleanse.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/support/events.h b/depend/bitcoin/src/support/events.h
index 0a74d023..f89daf6d 100644
--- a/depend/bitcoin/src/support/events.h
+++ b/depend/bitcoin/src/support/events.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2018 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/support/lockedpool.h b/depend/bitcoin/src/support/lockedpool.h
index 2363b1e4..7be20823 100644
--- a/depend/bitcoin/src/support/lockedpool.h
+++ b/depend/bitcoin/src/support/lockedpool.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/sync.cpp b/depend/bitcoin/src/sync.cpp
index d33a01dc..b661aad9 100644
--- a/depend/bitcoin/src/sync.cpp
+++ b/depend/bitcoin/src/sync.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
@@ -173,11 +173,11 @@ static void push_lock(MutexType* c, const CLockLocation& locklocation)
         }
 
         const LockPair p1 = std::make_pair(i.first, c);
-        if (lockdata.lockorders.count(p1))
+        if (lockdata.lockorders.contains(p1))
             continue;
 
         const LockPair p2 = std::make_pair(c, i.first);
-        if (lockdata.lockorders.count(p2)) {
+        if (lockdata.lockorders.contains(p2)) {
             auto lock_stack_copy = lock_stack;
             lock_stack.pop_back();
             potential_deadlock_detected(p1, lockdata.lockorders[p2], lock_stack_copy);
diff --git a/depend/bitcoin/src/sync.h b/depend/bitcoin/src/sync.h
index f863e5f5..e73a9022 100644
--- a/depend/bitcoin/src/sync.h
+++ b/depend/bitcoin/src/sync.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/test/addrman_tests.cpp b/depend/bitcoin/src/test/addrman_tests.cpp
index 310dc709..4debdc16 100644
--- a/depend/bitcoin/src/test/addrman_tests.cpp
+++ b/depend/bitcoin/src/test/addrman_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/allocator_tests.cpp b/depend/bitcoin/src/test/allocator_tests.cpp
index 8c0af6f2..65a0629d 100644
--- a/depend/bitcoin/src/test/allocator_tests.cpp
+++ b/depend/bitcoin/src/test/allocator_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2021 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/argsman_tests.cpp b/depend/bitcoin/src/test/argsman_tests.cpp
index e5953cd5..5236d5db 100644
--- a/depend/bitcoin/src/test/argsman_tests.cpp
+++ b/depend/bitcoin/src/test/argsman_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
@@ -232,8 +232,8 @@ BOOST_AUTO_TEST_CASE(util_ParseParameters)
     BOOST_CHECK(testArgs.m_settings.command_line_options.size() == 3 && testArgs.m_settings.ro_config.empty());
     BOOST_CHECK(testArgs.IsArgSet("-a") && testArgs.IsArgSet("-b") && testArgs.IsArgSet("-ccc")
                 && !testArgs.IsArgSet("f") && !testArgs.IsArgSet("-d"));
-    BOOST_CHECK(testArgs.m_settings.command_line_options.count("a") && testArgs.m_settings.command_line_options.count("b") && testArgs.m_settings.command_line_options.count("ccc")
-                && !testArgs.m_settings.command_line_options.count("f") && !testArgs.m_settings.command_line_options.count("d"));
+    BOOST_CHECK(testArgs.m_settings.command_line_options.contains("a") && testArgs.m_settings.command_line_options.contains("b") && testArgs.m_settings.command_line_options.contains("ccc")
+                && !testArgs.m_settings.command_line_options.contains("f") && !testArgs.m_settings.command_line_options.contains("d"));
 
     BOOST_CHECK(testArgs.m_settings.command_line_options["a"].size() == 1);
     BOOST_CHECK(testArgs.m_settings.command_line_options["a"].front().get_str() == "");
@@ -460,18 +460,18 @@ BOOST_AUTO_TEST_CASE(util_ReadConfigStream)
     BOOST_CHECK(test_args.m_settings.ro_config["sec1"].size() == 3);
     BOOST_CHECK(test_args.m_settings.ro_config["sec2"].size() == 2);
 
-    BOOST_CHECK(test_args.m_settings.ro_config[""].count("a"));
-    BOOST_CHECK(test_args.m_settings.ro_config[""].count("b"));
-    BOOST_CHECK(test_args.m_settings.ro_config[""].count("ccc"));
-    BOOST_CHECK(test_args.m_settings.ro_config[""].count("d"));
-    BOOST_CHECK(test_args.m_settings.ro_config[""].count("fff"));
-    BOOST_CHECK(test_args.m_settings.ro_config[""].count("ggg"));
-    BOOST_CHECK(test_args.m_settings.ro_config[""].count("h"));
-    BOOST_CHECK(test_args.m_settings.ro_config[""].count("i"));
-    BOOST_CHECK(test_args.m_settings.ro_config["sec1"].count("ccc"));
-    BOOST_CHECK(test_args.m_settings.ro_config["sec1"].count("h"));
-    BOOST_CHECK(test_args.m_settings.ro_config["sec2"].count("ccc"));
-    BOOST_CHECK(test_args.m_settings.ro_config["sec2"].count("iii"));
+    BOOST_CHECK(test_args.m_settings.ro_config[""].contains("a"));
+    BOOST_CHECK(test_args.m_settings.ro_config[""].contains("b"));
+    BOOST_CHECK(test_args.m_settings.ro_config[""].contains("ccc"));
+    BOOST_CHECK(test_args.m_settings.ro_config[""].contains("d"));
+    BOOST_CHECK(test_args.m_settings.ro_config[""].contains("fff"));
+    BOOST_CHECK(test_args.m_settings.ro_config[""].contains("ggg"));
+    BOOST_CHECK(test_args.m_settings.ro_config[""].contains("h"));
+    BOOST_CHECK(test_args.m_settings.ro_config[""].contains("i"));
+    BOOST_CHECK(test_args.m_settings.ro_config["sec1"].contains("ccc"));
+    BOOST_CHECK(test_args.m_settings.ro_config["sec1"].contains("h"));
+    BOOST_CHECK(test_args.m_settings.ro_config["sec2"].contains("ccc"));
+    BOOST_CHECK(test_args.m_settings.ro_config["sec2"].contains("iii"));
 
     BOOST_CHECK(test_args.IsArgSet("-a"));
     BOOST_CHECK(test_args.IsArgSet("-b"));
diff --git a/depend/bitcoin/src/test/arith_uint256_tests.cpp b/depend/bitcoin/src/test/arith_uint256_tests.cpp
index b0d75cde..0a154580 100644
--- a/depend/bitcoin/src/test/arith_uint256_tests.cpp
+++ b/depend/bitcoin/src/test/arith_uint256_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/test/banman_tests.cpp b/depend/bitcoin/src/test/banman_tests.cpp
index cebe3629..2b0c6218 100644
--- a/depend/bitcoin/src/test/banman_tests.cpp
+++ b/depend/bitcoin/src/test/banman_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/base32_tests.cpp b/depend/bitcoin/src/test/base32_tests.cpp
index e4605bca..051a8fcd 100644
--- a/depend/bitcoin/src/test/base32_tests.cpp
+++ b/depend/bitcoin/src/test/base32_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/base58_tests.cpp b/depend/bitcoin/src/test/base58_tests.cpp
index 62db257a..35b8ea46 100644
--- a/depend/bitcoin/src/test/base58_tests.cpp
+++ b/depend/bitcoin/src/test/base58_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/test/base64_tests.cpp b/depend/bitcoin/src/test/base64_tests.cpp
index d505caab..dbb56da6 100644
--- a/depend/bitcoin/src/test/base64_tests.cpp
+++ b/depend/bitcoin/src/test/base64_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/test/bech32_tests.cpp b/depend/bitcoin/src/test/bech32_tests.cpp
index 51a1d119..c9eed385 100644
--- a/depend/bitcoin/src/test/bech32_tests.cpp
+++ b/depend/bitcoin/src/test/bech32_tests.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2017 Pieter Wuille
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/bip32_tests.cpp b/depend/bitcoin/src/test/bip32_tests.cpp
index cbbec94e..1df368ad 100644
--- a/depend/bitcoin/src/test/bip32_tests.cpp
+++ b/depend/bitcoin/src/test/bip32_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2013-2022 The Bitcoin Core developers
+// Copyright (c) 2013-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.
 
diff --git a/depend/bitcoin/src/test/blockchain_tests.cpp b/depend/bitcoin/src/test/blockchain_tests.cpp
index 23556884..c6b35e32 100644
--- a/depend/bitcoin/src/test/blockchain_tests.cpp
+++ b/depend/bitcoin/src/test/blockchain_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/test/blockencodings_tests.cpp b/depend/bitcoin/src/test/blockencodings_tests.cpp
index 096449b9..0fbe0f3c 100644
--- a/depend/bitcoin/src/test/blockencodings_tests.cpp
+++ b/depend/bitcoin/src/test/blockencodings_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/test/blockfilter_index_tests.cpp b/depend/bitcoin/src/test/blockfilter_index_tests.cpp
index 224acb8b..867bb220 100644
--- a/depend/bitcoin/src/test/blockfilter_index_tests.cpp
+++ b/depend/bitcoin/src/test/blockfilter_index_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/test/blockfilter_tests.cpp b/depend/bitcoin/src/test/blockfilter_tests.cpp
index 8e21d345..c8334dab 100644
--- a/depend/bitcoin/src/test/blockfilter_tests.cpp
+++ b/depend/bitcoin/src/test/blockfilter_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/test/blockmanager_tests.cpp b/depend/bitcoin/src/test/blockmanager_tests.cpp
index 4a326458..db59931b 100644
--- a/depend/bitcoin/src/test/blockmanager_tests.cpp
+++ b/depend/bitcoin/src/test/blockmanager_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/test/bloom_tests.cpp b/depend/bitcoin/src/test/bloom_tests.cpp
index 584c970e..938aa233 100644
--- a/depend/bitcoin/src/test/bloom_tests.cpp
+++ b/depend/bitcoin/src/test/bloom_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
@@ -140,11 +140,11 @@ BOOST_AUTO_TEST_CASE(bloom_match)
     BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match output address");
 
     filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
-    filter.insert(COutPoint(Txid::FromHex("90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b").value(), 0));
+    filter.insert(COutPoint{Txid{"90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"}, 0});
     BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match COutPoint");
 
     filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
-    COutPoint prevOutPoint(Txid::FromHex("90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b").value(), 0);
+    COutPoint prevOutPoint{Txid{"90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"}, 0};
     {
         std::vector<unsigned char> data(32 + sizeof(unsigned int));
         memcpy(data.data(), prevOutPoint.hash.begin(), 32);
@@ -162,11 +162,11 @@ BOOST_AUTO_TEST_CASE(bloom_match)
     BOOST_CHECK_MESSAGE(!filter.IsRelevantAndUpdate(tx), "Simple Bloom filter matched random address");
 
     filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
-    filter.insert(COutPoint(Txid::FromHex("90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b").value(), 1));
+    filter.insert(COutPoint{Txid{"90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"}, 1});
     BOOST_CHECK_MESSAGE(!filter.IsRelevantAndUpdate(tx), "Simple Bloom filter matched COutPoint for an output we didn't care about");
 
     filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
-    filter.insert(COutPoint(Txid::FromHex("000000d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b").value(), 0));
+    filter.insert(COutPoint{Txid{"000000d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"}, 0});
     BOOST_CHECK_MESSAGE(!filter.IsRelevantAndUpdate(tx), "Simple Bloom filter matched COutPoint for an output we didn't care about");
 }
 
@@ -426,9 +426,9 @@ BOOST_AUTO_TEST_CASE(merkle_block_4_test_p2pubkey_only)
     BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
 
     // We should match the generation outpoint
-    BOOST_CHECK(filter.contains(COutPoint(Txid::FromHex("147caa76786596590baa4e98f5d9f48b86c7765e489f7a6ff3360fe5c674360b").value(), 0)));
+    BOOST_CHECK(filter.contains(COutPoint{Txid{"147caa76786596590baa4e98f5d9f48b86c7765e489f7a6ff3360fe5c674360b"}, 0}));
     // ... but not the 4th transaction's output (its not pay-2-pubkey)
-    BOOST_CHECK(!filter.contains(COutPoint(Txid::FromHex("02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041").value(), 0)));
+    BOOST_CHECK(!filter.contains(COutPoint{Txid{"02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041"}, 0}));
 }
 
 BOOST_AUTO_TEST_CASE(merkle_block_4_test_update_none)
@@ -451,8 +451,8 @@ BOOST_AUTO_TEST_CASE(merkle_block_4_test_update_none)
     BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
 
     // We shouldn't match any outpoints (UPDATE_NONE)
-    BOOST_CHECK(!filter.contains(COutPoint(Txid::FromHex("147caa76786596590baa4e98f5d9f48b86c7765e489f7a6ff3360fe5c674360b").value(), 0)));
-    BOOST_CHECK(!filter.contains(COutPoint(Txid::FromHex("02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041").value(), 0)));
+    BOOST_CHECK(!filter.contains(COutPoint{Txid{"147caa76786596590baa4e98f5d9f48b86c7765e489f7a6ff3360fe5c674360b"}, 0}));
+    BOOST_CHECK(!filter.contains(COutPoint{Txid{"02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041"}, 0}));
 }
 
 std::vector<unsigned char> BloomTest::RandomData()
diff --git a/depend/bitcoin/src/test/bswap_tests.cpp b/depend/bitcoin/src/test/bswap_tests.cpp
index fe48e39c..a2df1ea8 100644
--- a/depend/bitcoin/src/test/bswap_tests.cpp
+++ b/depend/bitcoin/src/test/bswap_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/test/caches_tests.cpp b/depend/bitcoin/src/test/caches_tests.cpp
index 3086118f..f444f1be 100644
--- a/depend/bitcoin/src/test/caches_tests.cpp
+++ b/depend/bitcoin/src/test/caches_tests.cpp
@@ -1,3 +1,7 @@
+// Copyright (c) The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or https://opensource.org/license/mit.
+
 #include <node/caches.h>
 #include <util/byte_units.h>
 
diff --git a/depend/bitcoin/src/test/chainstate_write_tests.cpp b/depend/bitcoin/src/test/chainstate_write_tests.cpp
index e1b82ebc..5c459227 100644
--- a/depend/bitcoin/src/test/chainstate_write_tests.cpp
+++ b/depend/bitcoin/src/test/chainstate_write_tests.cpp
@@ -8,6 +8,8 @@
 
 #include <boost/test/unit_test.hpp>
 
+using kernel::ChainstateRole;
+
 // Taken from validation.cpp
 static constexpr auto DATABASE_WRITE_INTERVAL_MIN{50min};
 static constexpr auto DATABASE_WRITE_INTERVAL_MAX{70min};
@@ -18,7 +20,7 @@ BOOST_FIXTURE_TEST_CASE(chainstate_write_interval, TestingSetup)
 {
     struct TestSubscriber final : CValidationInterface {
         bool m_did_flush{false};
-        void ChainStateFlushed(ChainstateRole, const CBlockLocator&) override
+        void ChainStateFlushed(const ChainstateRole&, const CBlockLocator&) override
         {
             m_did_flush = true;
         }
@@ -55,7 +57,7 @@ BOOST_FIXTURE_TEST_CASE(write_during_multiblock_activation, TestChain100Setup)
     {
         const CBlockIndex* m_tip{nullptr};
         const CBlockIndex* m_flushed_at_block{nullptr};
-        void ChainStateFlushed(ChainstateRole, const CBlockLocator&) override
+        void ChainStateFlushed(const ChainstateRole&, const CBlockLocator&) override
         {
             m_flushed_at_block = m_tip;
         }
diff --git a/depend/bitcoin/src/test/checkqueue_tests.cpp b/depend/bitcoin/src/test/checkqueue_tests.cpp
index da9c3aa8..2d13a267 100644
--- a/depend/bitcoin/src/test/checkqueue_tests.cpp
+++ b/depend/bitcoin/src/test/checkqueue_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/cluster_linearize_tests.cpp b/depend/bitcoin/src/test/cluster_linearize_tests.cpp
index 3413af4a..ede17b97 100644
--- a/depend/bitcoin/src/test/cluster_linearize_tests.cpp
+++ b/depend/bitcoin/src/test/cluster_linearize_tests.cpp
@@ -15,6 +15,7 @@
 BOOST_FIXTURE_TEST_SUITE(cluster_linearize_tests, BasicTestingSetup)
 
 using namespace cluster_linearize;
+using namespace util::hex_literals;
 
 namespace {
 
@@ -36,6 +37,7 @@ void TestDepGraphSerialization(const std::vector<std::pair<FeeFrac, SetType>>& c
         depgraph.AddDependencies(cluster[i].second, i);
     }
     depgraph.RemoveTransactions(holes);
+    SanityCheck(depgraph);
 
     // There may be multiple serializations of the same graph, but DepGraphFormatter's serializer
     // only produces one of those. Verify that hexenc matches that canonical serialization.
@@ -52,6 +54,65 @@ void TestDepGraphSerialization(const std::vector<std::pair<FeeFrac, SetType>>& c
     BOOST_CHECK(depgraph == depgraph_read);
 }
 
+void TestOptimalLinearization(const std::vector<uint8_t>& enc, const std::vector<FeeFrac>& optimal_diagram)
+{
+    DepGraphIndex tx_count = 0;
+    FastRandomContext rng;
+
+    auto test_fn = [&]<typename SetType>() {
+        DepGraph<SetType> depgraph;
+        SpanReader reader(enc);
+        reader >> Using<DepGraphFormatter>(depgraph);
+        SanityCheck(depgraph);
+        std::vector<DepGraphIndex> lin;
+        for (int iter = 0; iter < 200; ++iter) {
+            bool opt;
+            uint64_t cost{0};
+            switch (rng.randrange(3)) {
+            case 0:
+                // Use empty input linearization.
+                lin.clear();
+                break;
+            case 1:
+                // Reuse previous optimal linearization as input.
+                break;
+            case 2:
+                // Construct random input linearization.
+                std::shuffle(lin.begin(), lin.end(), rng);
+                FixLinearization(depgraph, lin);
+                break;
+            }
+            std::tie(lin, opt, cost) = Linearize(depgraph, 1000000000000, rng.rand64(), lin);
+            BOOST_CHECK(opt);
+            BOOST_CHECK(cost <= MaxOptimalLinearizationIters(depgraph.TxCount()));
+            SanityCheck(depgraph, lin);
+            auto chunking = ChunkLinearization(depgraph, lin);
+            BOOST_CHECK(std::is_eq(CompareChunks(chunking, optimal_diagram)));
+            // TODO: temporarily disabled; SFL does not guarantee minimal chunks. This will be
+            // reinstated in a future commit.
+            // // Verify that the chunks are minimal.
+            // BOOST_CHECK(chunking.size() == optimal_diagram.size());
+        }
+        tx_count = depgraph.PositionRange();
+    };
+
+    // Always run with 64-bit set types
+    // - The native one that will be used on this platform.
+    test_fn.template operator()<BitSet<64>>();
+    // - The one used on 32-bit platforms.
+    test_fn.template operator()<bitset_detail::MultiIntBitSet<uint32_t, 2>>();
+    // - An 8-bit one, which is maximally different in terms of bitset behavior.
+    test_fn.template operator()<bitset_detail::MultiIntBitSet<uint8_t, 8>>();
+
+    // Also run with 32-bit set types if the cluster doesn't use indexes above 31.
+    if (tx_count <= 32) {
+        // - The native one that will be used on this platform.
+        test_fn.template operator()<BitSet<32>>();
+        // - An 8-bit one, which is maximally different in terms of bitset behavior.
+        test_fn.template operator()<bitset_detail::MultiIntBitSet<uint8_t, 4>>();
+    }
+}
+
 } // namespace
 
 BOOST_AUTO_TEST_CASE(depgraph_ser_tests)
@@ -174,4 +235,244 @@ BOOST_AUTO_TEST_CASE(depgraph_ser_tests)
     );
 }
 
+BOOST_AUTO_TEST_CASE(depgraph_optimal_tests)
+{
+    // Compare linearizations with known-optimal chunk feerate diagrams.
+
+    // Hard clusters (according to various metrics) that appeared in replayed 2023 mempool data, ranging from 2 to 64 transactions.
+    TestOptimalLinearization("9276fa3a009c3b80cd4001a21680d85c02927bfa5403934280845404a04c80cf0805c75b82c22206a46880f532079c7e80b85608965780916a09a04a80cf080a9823809b3e0bb27b81ec0c0c8540c60e0c0c993e80c86a0d0b8540c2020c0c9352809f780c09972f80f84a080c85449900080c875da164080c875081ae54070c8335af4c071f9c6781a72a13010f99108190160e000e85419f2c07168332903c05158540819e54041216ba5183907a140000001182428d080024a25c83c11201040400010609b6668487240004060000000000"_hex_v_u8, {{47188, 8550}, {42800, 7755}, {325314, 79021}, {2070, 833}, {900, 450}, {2226, 1117}, {1664, 836}, {1118, 562}});
+    TestOptimalLinearization("850d81fd4000850e81fd400000850d81fd400000850d81fd400000850e8285000000850d8285000000850e8288600000850e8288600000850e828860000000"_hex_v_u8, {{223440, 7034}});
+    TestOptimalLinearization("818f1c8a935a0083219530000083219530010083219530020083219530030083219530040083219530050083219530060083219530070083219530080000"_hex_v_u8, {{104325, 39749}});
+    TestOptimalLinearization("836880bf4000834c80b6600000836880bf400100834c80b6600001836880bf400101834c80b6600002836880bf400102834c80b6600003836880bf400103834c80b6600004836880bf400104834c80b6600005836880bf400105836880bf400006834c80b6600106834c80b6600106836880bf400206834c80b6600008836880bf400108836880bf40000900"_hex_v_u8, {{12320, 616}, {11760, 588}, {12320, 616}, {11760, 588}, {12320, 616}, {11760, 588}, {12320, 616}, {11760, 588}, {12320, 616}, {11760, 588}, {12320, 616}, {11760, 588}, {12320, 616}, {11760, 588}, {12320, 616}, {11760, 588}, {12320, 616}, {11760, 588}, {12320, 616}, {12320, 616}});
+    TestOptimalLinearization("84a22e8fce380083208c38000083208c38010083208c38020083208c38030083208c38040083208c38050083208c38060083208c38070083208c38080083208c38090000"_hex_v_u8, {{144756, 91886}});
+    TestOptimalLinearization("8361a8340084309730000000"_hex_v_u8, {{2650, 609}, {1560, 688}});
+    TestOptimalLinearization("829428f0fe20008319809604000183198096040100831980960402008319809604030083198096040400831980960405008319809604060083198096040700831980960408008319809604090083198096040a0083198096040b0083198096040c0083198096040d0083198096040e0083198096040f008319809604100083198096041100831980960412008319809604130083198096041400831980960415008319809604160083198096041700831980960418008319809604190083198096041a0000"_hex_v_u8, {{933840, 51880}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}});
+    TestOptimalLinearization("854ec47200854ec4720001854ec4720001854ec4720001854ec4720001854ec4720001854ec4720001854ec4720001854ec4720001854ec4720000854ec4720000854ec4720000854ec4720000854ec4720000854ec4720000854ec4720000854ec4720000854ec4720000854ec4720000854ec4720000854ec4720000854ec4720000854ec4720000854ec4720000854ec472000000"_hex_v_u8, {{4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}, {4473, 846}});
+    TestOptimalLinearization("d1378f927c00e81293cc4001f36095ef5202f20195c33203e93a93817404e76793d0700b80ba72a3e82806fd4697e52207da5d91894608c73d8d98401480990c9d954a0af73292e73a0b8090259bba640c808f689bac760de50692fc1e0eac40888c1a0fbf308bcf481080a3259f980c11c30282fd78128b6f83c2300612932d8ba65e0b09896a88837c010011886281d6380e0000040f953c8594580b000000129e0491c0381300000000148235f72802228653818c08021db40c9180620229833180991c011f854081a95c0020833180bd66002082418097740020953c8784000e00000000000201030d8d7c838d0c04011a874f84842a001600"_hex_v_u8, {{248978, 14346}, {1136423, 78068}, {270282, 20244}, {1423139, 109038}, {903617, 69567}, {106746, 10092}});
+    TestOptimalLinearization("836880ba5807845d80df200000836880ba580100845d80df200001836880bd0c0101845d80e2100002836880bf400102845d80e5000003836880bf400103845d80e5000004854e818800010300854e818800000300854e818800000200854e818800000100854e819178000000836880ed1c0000845f819b500017854e818b28001700"_hex_v_u8, {{252408, 12326}, {17172, 846}});
+    TestOptimalLinearization("854e829b580088318881580000a37a90ae600000a37a90ae600100a37a90ae600200a37a90ae600300835a819e680303835a819e680403835a819e680503835a819e680603835a819e680703835a819e680803835a819e680903835a819e680a03835a819e680b03835a819e680c03835a819e680d03835a819e680e03835a819e680f03835a819e681003835a819e681103835a819e681203835a819e681303835a819e681403835a819e681503835a819e681603835a819e681703835a819e681803835a819e681903835a819e681a03835a819e681902835a819e681b01835a819e681c01835a819e681c02835a819e681e01835a819e681f01835a819e682001835a819e682002835a819e682102835a819e682301835a819e682302835a819e682501835a819e682502835a819e682602835a819e682801835a819e682802835a819e682a01835a819e682a02835a819e682b02835a819e682d01835a819e682d02835a819e682f01835a819e682f02835a819e683002835a819e68320100"_hex_v_u8, {{100312, 2047}, {584400, 19178}, {381780, 12556}, {363360, 11954}, {142320, 4730}});
+    TestOptimalLinearization("83688095520089c17481b5cf780000842d809c700000842d809c700100842d809c700200842d809c700300842d809c700400842d809c700500842d809c700600842d809c700700842d809c700800842d809c700900842d809c700a00842d809c700b00842d809c700c00842d809c700d00842d809c700e00842d809c700f00842d809c701000842d809c701100842d809c701200842d809c701300842d809c701400842d809c701500842d809c701600842d809c701700842d809c701800842d809c701900842d809c701a00842d809c701b00842d809c701c00842d809c701d00842d809c701e00842d809c701f00842d809c702000842d809c702100842d809c702200842d809c702300842d809c702400842d809c702500842d809c702600842d809c702700842d809c702800842d809c702900842d809c702a00842d809c702b00842d809c702c00842d809c702d00842d809c702e00842d809c702f00842d809c703000842d809c703100842d809c703200842d809c70330000"_hex_v_u8, {{9641, 616}, {2544700, 172404}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}, {10104, 685}});
+    TestOptimalLinearization("99469a2e008e638f32018e638f32028e638718038e638718048e638718058e648c44068e659002078e639340088f74873c098e6488380a8d6586340b894784240c894784240d8b56852c0ea71993100f8b6d8538108b56852c118e628b76128e638b76138e638b76148e628b76158e648b7616a06c8f78178e638b76188e628838198e638b761a8e6388381b894784241c9412894c1d8e6690521e9c538e1c05199b10f15017000400189527955a1a0000000000001a9e5d8e70120000000000000117b372993c000300000000000000000000000000001800"_hex_v_u8, {{11835, 11678}, {1129, 2022}, {1751, 3398}, {866, 2020}, {827, 2018}, {827, 2018}, {827, 2019}, {827, 2019}, {827, 2019}, {827, 2019}, {827, 2020}, {3025, 8912}, {604, 2018}, {604, 2019}, {604, 2020}, {974, 3795}, {678, 2706}, {542, 2164}, {412, 1645}, {474, 1893}, {1288, 5145}, {406, 1622}, {406, 1622}, {1084, 4332}, {3724, 14884}});
+    TestOptimalLinearization("833583380083368338000083328334000083318334000083328334000083368338000083358338000083328334000000"_hex_v_u8, {{284, 565}, {848, 1689}, {850, 1693}, {282, 562}});
+    TestOptimalLinearization("80f96f88ab2a008235839b0600008a4880b31801008604ec3c02008235a97c0300833dab7204008752d502050000"_hex_v_u8, {{140794, 37044}});
+    TestOptimalLinearization("f9718def4800823ab01c01833980c238028544848f20038478e07c04887280ef2a05823680a54e068081149ea80a07808714ac995208823680a55c0980b85cbcdc020abb759acf180b8338fe680c82359eac280c0c824280a9620d0c857cf9400e0c823ae5520a0c823590c744090c823584ef14090c847c80a32a0a0c8451808b100b0c824280a9420a0c823580a52c0b0c823586bf2c0c0c857c8186200d0c847882c63a0d0c854081cf060e0c833880b66e0f0c8338808e40100b8368809552110b8241de74130a8242c34c1608894480bc48102a851e818356050e0fad56888c401d00000000198fe81c808fc7501a0000000410933d86e120031300000a00"_hex_v_u8, {{42000, 836}, {255465, 8557}, {21507, 832}, {10670, 438}, {10663, 438}, {588686, 25096}, {389673, 16616}, {418483, 17865}, {400487, 17097}, {12508, 569}, {11767, 568}, {16848, 892}, {24863, 1366}, {83604, 4861}, {9184, 568}, {9641, 616}, {10517, 764}, {6138, 449}, {21950, 1708}, {8968, 721}, {84012, 7176}, {4390, 450}, {1184296, 275612}});
+    TestOptimalLinearization("82369e200084459e200186569e200282369e200384459e200488649e200586559e200684459e200788649e200886549e200984449e200a82369e200b9961dc600ca34b81da7800000000000000000000000000008368af4c0000869520c6dd6800008368af3800008368af3801008368af3802008368af3803008368af3804008368af3805008368af3806008368af3807008368af3808008368af3809008368af380a008368af380b008368af380c008368af380d008368af380e008368af380f0000"_hex_v_u8, {{692678, 145712}});
+    TestOptimalLinearization("8335862e008335862e00008335862e00008335862e00008335862e00008335862e00008335862e00008335862e00008331862600008335862e00008335862e00008335862e00008335862e00008335862e00008335862e0000833d863a00008335862e00008335862e00008544896a000000"_hex_v_u8, {{471, 565}, {471, 565}, {471, 565}, {471, 565}, {471, 565}, {471, 565}, {471, 565}, {471, 565}, {3293, 3951}, {1419, 1703}, {693, 836}});
+    TestOptimalLinearization("836183f20200842b84b82e00008a1089f33e0100842a849a7c00018361838f420101842b83ca680002836282f8280102842983b00c000300"_hex_v_u8, {{40129, 609}, {44631, 683}, {89375, 1424}, {42750, 682}, {33825, 609}, {37620, 683}, {32340, 610}, {35910, 681}});
+    TestOptimalLinearization("80fc6c80fd300080e03c80f50e01823aaf3402823aac060380f42080f55e04833d84200580ea0580ea6006833e855a0780ce7c81b724088235898b1c08088474bd2c0908875180a10e0a08857cb0000b088239ad260c088336b8180d0889448e660e08823588db0e0e088242ac5a0c08823588df180d08854588660e088478d670120584498a440f08833dbb1e0f088474ea3810088470d83a1108823588ac7812088242844a13088546886614088545d67e1705823a84181b02875c8c0a1707854088601a058241ae3c1b05823587a67e180887548b7e19088241ae3c21018600d6401b08823a84141c088336854825008755f34a1e088335b6001c2d81d25ca2f16e27001e902d80ea6a250318894ce9202206068336d140034c9969829e282800001d82f57fb48c2e260000040e00"_hex_v_u8, {{3098, 442}, {2883, 442}, {1070885, 209051}, {148942, 39219}, {107942, 30418}, {3136, 892}, {738, 713}, {357, 450}, {332, 442}, {624, 832}, {831, 1108}, {837, 1116}, {1011, 1348}, {627, 837}, {627, 838}, {330, 442}, {420, 566}});
+    TestOptimalLinearization("80e67480e6740080d53480d56e0180d04881bd62028f108f1c038335cb7204847ce13e0404824184240504823594990c0604823580d07c07048235a6160804857cdd4009048474f2640904823592ce5c0a04833692700b048540ad300d038608b37c0c04823583e0720d048500a9000e048239841c0f048242b70011038540cc681203833e855a13038470bf7c13048545956a16008600be000d1a8f1880990a17000d8a448a4c1600048544f63c1603018f18f1180c0d0b8600ac40041f00"_hex_v_u8, {{4921, 565}, {221979, 33050}, {185495, 29087}, {4980, 832}, {2507, 437}, {9861, 2072}, {4032, 896}, {2968, 832}, {2912, 896}, {76978, 31757}, {1272, 566}, {1461, 837}, {334, 441}, {338, 449}, {429, 574}, {1038, 2064}, {742, 1476}});
+    TestOptimalLinearization("84418c6a0080fe1d86fc00000080b97084ea50000080de1c85fc00010080ed4986b930020080a17b848a70030080d07b85c670040080a86b84a630050080e405869320060080db1185ef50070080d11b85c770080080d00185c310090000"_hex_v_u8, {{593589, 297030}});
+    TestOptimalLinearization("856ea51800856da5180000856eab080002856eab080002856dab080002856dab08000000"_hex_v_u8, {{16168, 5265}});
+    TestOptimalLinearization("83318c2a00833d8c400183318c1c0283318c1c020283318c1c020283358c28020283318c1e020683318c1c020583318c1c0204833d8c40020a833d8c40020883318c1c020683318c1c020e83318c1c020b8331943e0208833d8c40021283318c1e020e83319a0c020a83358d58011183318c1e031083318d08011383318c1c0113833d8c40011583319a0c011483318c1c01169260809308021583358c280118a84380f9100a021383318c1c011983319430001983319938001983319a1c001883319a0c00188540a71609030683319a0c011983319a0c011283319a0c011283319a0c0113833d9a56011483319b52011483359a26011583359b6c011583319a0c011783319b52011683319a0c011983319b52011783319b52011b83319b520118833d9d6a001983309d18001900"_hex_v_u8, {{88836, 35145}});
+    TestOptimalLinearization("80886c99f50c00835df5600000835df5600100835df5600200835df5600300835df5600400835df5600500835df5600600835df5600700835df5600800835df5600900835df5600a00835df5600b00835df5600c00835df5600d00835df5600e00835df5600f00835df5601000835df5601100835df5601200835df5601300835df5601400835df5601500835df5601600835df5601700836880cd78180080895badcb740018835b80c9740018835b80c9740118835b80c9740218835b80c9740318835b80c9740418835b80c9740518835b80c9740618835b80c9740718835b80c9740818835b80c9740918835b80c9740a18835b80c9740b18835b80c9740c18835b80c9740d18835b80c9740e18835b80c9740f18835b80c9741018835b80c974111800"_hex_v_u8, {{849296, 46869}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}, {7600, 605}});
+    TestOptimalLinearization("8514d518008344be3800008514d51801008344be3800018514d51801018514d51800028344be3801028344be3801028514d51802028344be3800048514d51801048344be3800058514d51801058514d51800068344be3801068344be3801068514d51802068344be3800088514d51801088344be3800098514d51801098514d518000a00"_hex_v_u8, {{5516, 788}, {4060, 580}, {5516, 788}, {4060, 580}, {5516, 788}, {4060, 580}, {5516, 788}, {4060, 580}, {5516, 788}, {4060, 580}, {5516, 788}, {4060, 580}, {5516, 788}, {4060, 580}, {5516, 788}, {4060, 580}, {5516, 788}, {4060, 580}, {5516, 788}, {4060, 580}, {5516, 788}, {5516, 788}});
+    TestOptimalLinearization("8442922e009069bd3a0000872d9c1a010083618f5e010183618f5e020183618f5e030183618f5e040183618f5e050183618f5e060183618f5e070183618f5e080183618f5e09019743a36609018442922e0a01835f8610010b835f8610020b835f8610030b835f8610040b835f8610050b835f8610060b835f8610070b835f8610080b835f8610090b835f86100a0b835f86100b0b835f86100c0b8442d82a0c0b8441e332001700"_hex_v_u8, {{16489, 3892}, {13636, 7762}, {7827, 10423}});
+    TestOptimalLinearization("9420928e2c008368f11a0000c52488dd700000834acf100000834acf100100834acf100200834acf100300834acf100400834acf100500834acf100600834acf100700834acf100800834acf100900834acf100a00834acf100b00834acf100c00834acf100d00834acf100e00834acf100f00834acf101000834acf101100834acf101200834acf101300834acf10140000"_hex_v_u8, {{156630, 2720}, {7309, 616}, {79800, 8996}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}, {5128, 586}});
+    TestOptimalLinearization("9d2c83920200856cf66200008570f7280100856bf65202008567f60c03008563f54604008572f74c0500856ef7060600856af6400700856af64008008561f52209008566f57a0a008566f57a0b008575f8000c008571f73a0d008571f73a0e00856df6740f00856df67410008565f56811008561f522120000"_hex_v_u8, {{102774, 11745}, {7569, 865}, {7569, 865}, {7604, 869}, {7674, 877}, {7674, 877}, {7709, 881}, {7709, 881}, {7744, 885}, {7665, 876}, {7700, 880}});
+    TestOptimalLinearization("854e80806600854e80806600008368e25000008462f54200008368e50601008463f8340001854e80b25c010000854e80b606000183688089400001846280a3620001854e80c00401000083688095520001846280b21c000100"_hex_v_u8, {{120967, 9647}});
+    TestOptimalLinearization("836186101483618872001583608842001584508d74001583618812011500"_hex_v_u8, {{2652, 2546}, {585, 609}});
+    TestOptimalLinearization("8ee34aafe24c0083208c1a000083208c1a010083208c1a020083208c1a030083208c1a040083208c1a050083208c1a060083208c1a070083208c1a080083208c1a090083208c1a0a0083208c1a0b0083208c1a0c0083208c1a0d0083208c1a0e0083208c1a0f0083208c1a100083208c1a110083208c1a120083208c1a130083208c1a140083208c1a150083208c1a160083208c1a170083208c1a180083208c1a190083208c1a1a0083208c1a1b0083208c1a1c0083208c1a1d0083208c1a1e0083208c1a1f0083208c1a200083208c1a210083208c1a220083208c1a230083208c1a240083208c1a250083208c1a260083208c1a270083208c1a280083208c1a290083208c1a2a0083208c1a2b0083208c1a2c0083208c1a2d0083208c1a2e0083208c1a2f0083208c1a300083208c1a310083208c1a320083208c1a330083208c1a340083208c1a350083208c1a360083208c1a370083208c1a380083208c1a390083208c1a3a0083208c1a3b0000"_hex_v_u8, {{450290, 291274}});
+    TestOptimalLinearization("a34c88ff6400835c80a4140000835c80a4140100835c80a4140200835c80a4140300835c80a4140400835c80a4140500835c80a4140600835c80a4140700835c80a4140800835c80a4140900835c80a4140a00835c80a4140b00835c80a4140c00835c80a4140d00835c80a4140e00835c80a4140f00835c80a414100000"_hex_v_u8, {{81970, 4684}, {10570, 604}, {10570, 604}, {10570, 604}, {10570, 604}, {10570, 604}, {10570, 604}, {10570, 604}, {10570, 604}, {10570, 604}, {10570, 604}, {10570, 604}, {10570, 604}, {10570, 604}, {10570, 604}, {10570, 604}, {10570, 604}, {10570, 604}});
+    TestOptimalLinearization("83369734008331903c01a41680dd2e02b24989886c0380cb0a86fe4404a97680ff680582368c60068451a53407df7783c500088806b80c09a74a80f1660a841e9644080a823581c71e070a854cb37c09098236ee2e080a8452a534070a8753b2580b068235a104080a847ced5e090a831695740e06895080b7340b0a8312955e0c0a8478de000d088755d57e0e088908c0140f088235910210088500a6001603831199701208833da73013088545a6301b001b85419f541700178451a5340f1e8331b40e1218847cdc000e1b880682bf201800108a4880b84018010f85708088401611824183a3560b188541a52407358335b37c06278752b7220a1900228544a954002221896ac558001805001700"_hex_v_u8, {{82550, 6601}, {136779, 19257}, {12190, 1724}, {3399, 561}, {3390, 565}, {5567, 1109}, {2178, 437}, {2584, 573}, {27411, 6674}, {23563, 5932}, {2458, 721}, {4916, 1443}, {86513, 26559}, {1720, 529}, {2496, 768}, {4170, 1288}, {30286, 10050}, {3308, 1107}, {1466, 534}, {1455, 530}, {5420, 2104}, {1506, 670}});
+    TestOptimalLinearization("83689e4c0085599314000083689e4c0100864cc014010185599314010183689e4c0201864cc014010300"_hex_v_u8, {{2022, 616}, {2022, 616}, {2022, 616}, {5460, 1829}, {5460, 1829}});
+    TestOptimalLinearization("81c47cafb03400835bd8540000835bd8540100835bd8540200835bd8540300835bd8540400835bd8540500835bd8540600835bd8540700835bd8540800835bd8540900835bd8540a00835bd8540b00835bd8540c00835bd8540d00835bd8540e00835bd8540f00835bd8541000835bd8541100835bd8541200835bd8541300835bd8541400835bd8541500835bd8541600835bd8541700835bd8541800835bd8541900835bd8541a00835bd8541b00835bd8541c00835bd8541d00835bd8541e00835bd8541f00835bd8542000835bd8542100835bd8542200835bd8542300835bd8542400835bd8542500835bd8542600835bd8542700835bd8542800835bd8542900835bd8542a0000"_hex_v_u8, {{643112, 67653}});
+    TestOptimalLinearization("83359d2c0083359d2c000083359d2c000283359d2c000283359d2c000200"_hex_v_u8, {{1942, 565}, {1942, 565}, {1942, 565}, {1942, 565}, {1942, 565}});
+    TestOptimalLinearization("a335b4af0400832f85b3280000832f85b3280100832f85b3280200832f85b3280300832f85b3280400832f85b3280500832f85b3280600832f85b3280700832f85b3280800832f85b3280900832f85b3280a00832f85b3280b00832f85b3280c00832f85b3280d00832f85b3280e00832f85b3280f00832f85b3281000832f85b328110000"_hex_v_u8, {{1382250, 14723}});
+    TestOptimalLinearization("833284fd3a00833581fc3801823684d50e02833181fb500383358695480480d77881b6f12005857c89bf7c0681a21d82999c300780d81d81b3ec6808844581a474098332899a7e0909833185bb04090984398190380809823587ae06070982358ddc1e080982368688220909823585cb000a09823586b3120b09823687aa6e0a0982359bf34a0b09823592ed040b09860880af480f05833286e0460b1d833185ba620b1c833288e64a0b1a833188a270022a833186bb5e0228833e89976a0225833186eb0a012b8332898512012783358a9130012d823986ff5a012883358a8f00012fed4996937e04020b000000000000000100"_hex_v_u8, {{272375, 2247}, {438299, 3939}, {46471, 438}, {353620, 3397}, {58788, 565}, {2916860, 29954}, {86078, 892}, {3665780, 38152}, {2692854, 28242}, {18810, 709}, {189759, 14153}, {11300, 904}});
+    TestOptimalLinearization("883180ae7800a37a81cc480001a37a81cc480100a37a81cc480204835aaa160101835aaa160102835aaa160301835aaa160401835aaa160501835aaa160601835aaa160602835aaa160900835aaa160901835aaa160a01835aaa160b01835aaa160c01835aaa160c02835aaa160e01835aaa160f01835aaa160f02835aaa161101835aaa161201835aaa161301835aaa161401835aaa161600835aaa161700835aaa161800835aaa161702835aaa161802835aaa161902835aaa161c00835aaa161b02835aaa161e0000"_hex_v_u8, {{11260, 1201}, {62793, 13760}, {43452, 9546}, {37926, 8342}});
+    TestOptimalLinearization("a25c81b56200832fa5000000832fa5000100832fa5000200832fa5000300832fa5000400832fa5000500832fa5000600832fa5000700832fa5000800832fa5000900832fa5000a00832fa5000b00832fa5000c00832fa5000d00832fa5000e00832fa5000f00832fa5001000832fa5001100832fa5001200832fa5001300832fa500140000"_hex_v_u8, {{70961, 16311}});
+    TestOptimalLinearization("8368d63c00b273aaf80001842dec5e0101854e829f0201018f6681fb320103854e828b060300019e228ea20a0202835aea780206835aea780306835aea780406835aea780506835aea780606835aea780706835aea780806835aea780906835aea780a06842dec720a05836281a96a0a04836281a96a0b04836281a96a0c04836281a96a0d04836281a96a0e04836281a96a0f04836281a96a1004836281a96a1104836281a96a1204836281a96a1304836281a96a1404836281a96a1504836281a96a1604836281a96a1704836281a96a1804836281a96a1904836281a96a1a04836281a96a1b04836281a96a1c049d1e84a95e132200"_hex_v_u8, {{360000, 6643}, {26625, 846}, {488500, 15592}, {30945, 1462}, {93540, 8253}, {50728, 4555}});
+    TestOptimalLinearization("80de6ebba3280081a442d1976601990e86a22a02996686ba6a0381cb6bdcce060480e358beea3205823590802e0506847480cb6c06058241e47a0705845280a22e0805824180ab2c09058241e5120a05854580fd100b05833580b34e0b058235919c180c05833280b8080d05823593c3700b0586048189660c05906383fd600d0582358db5100d0582358087700e05823a8088400f058242e47a10058241eb4016008235ec001304874f81ec4a1701860881896608198a77829b761700000e900f83e20e160002000300"_hex_v_u8, {{644225, 29540}, {935163, 43040}, {822655, 38007}, {641121, 29709}, {23397, 1103}, {11844, 562}, {11559, 565}, {8760, 437}, {8800, 442}, {16264, 837}, {17075, 900}, {17075, 904}, {40880, 2275}, {39111, 2191}, {59605, 3342}, {61173, 3430}, {13110, 756}, {26427, 1527}, {6976, 437}, {6944, 449}, {6537, 449}, {6525, 449}, {6525, 450}, {10455, 722}});
+    TestOptimalLinearization("836280c06000836180c06001836280c06002834280b1600202836180c0600302834280b1600302836180c0600402834280b1600402836280c0600502877e81fc200509833a80b1600509836280c0600609877f81fc200608834180b1600608877e81fc200607836280c0600607834180b1600707836180c0600715834280b1600614836280c0600611836180c060050f834380b160050d834180b1600420834380b1600318834280b1600315836180c0600510836280c0600511877f81fc200428880281f96011030e836280c0600315836280c060022e834280b1600030836180c0600130880281fc20080710834280b1600132836280c060022e877f81fc200c0915833b80b1600131877e81fc2002022e877f81fc200a0610877e81fc20010230877f81fc2004110c877e81fc2000130d877f81fc2002110d877e81f96006021500"_hex_v_u8, {{96480, 4675}, {48240, 2338}, {48240, 2338}, {482080, 23373}, {12400, 609}, {12400, 610}, {12400, 610}});
+    TestOptimalLinearization("818e6ca18c5000834fc8700001834fc8700100834fc8700200834fc8700300834fc8700400834fc8700500834fc8700600834fc8700700834fc8700800834fc8700900834fc8700a00834fc8700b00834fc8700c00834fc8700d00834fc8700e00834fc8700f00834fc8701000834fc8701100834fc8701200834fc8701300834fc8701400834fc8701500834fc8701600834fc8701700834fc8701800834fc8701900834fc8701a00834fc8701b00834fc8701c00834fc8701d00834fc8701e00834fc8701f00834fc8702000834fc8702100834fc8702200834fc8702300834fc8702400834fc8702500834fc8702600834fc8702700834fc870280000"_hex_v_u8, {{279400, 34796}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}});
+    TestOptimalLinearization("8442872600c61981fd680000835a8c420000835a8c420100835a8c420200835a8c420300835a8c420400835a8c420500835a8c420600835a8c420700835a8c420800835a8c420900835a8c420a00835a8c420b00835a8c420c00835a8c420d00835a8c420e00835a8c420f00835a8c421000835a8c421100835a8c421200835a8c421300835a8c421400835a8c421500835a8c421600835a8c421700835a8c42180000"_hex_v_u8, {{25031, 9819}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}, {865, 602}});
+    TestOptimalLinearization("8540e74000833180831801875dd14e00000000"_hex_v_u8, {{8460, 561}, {6688, 832}, {5287, 1117}});
+    TestOptimalLinearization("808a5292d06800835ad3780000835ad3780100835ad3780200835ad3780300835ad3780400835ad3780500835ad3780600835ad3780700835ad3780800835ad3780900835ad3780a00835ad3780b00835ad3780c00835ad3780d00835ad3780e00835ad3780f00835ad3781000835ad3781100835ad3781200835ad3781300835ad3781400835ad3781500835ad3781600835ad3781700835ad3781800835ad3781900835ad3781a00835ad3781b00835ad3781c0000"_hex_v_u8, {{318528, 35332}});
+    TestOptimalLinearization("8a0d8a54008368843000008a0d8a5401008368843000018a0d8a54010000836884300001996cc3320100008a449d1e00018d20a37e01000000"_hex_v_u8, {{11949, 12847}});
+    TestOptimalLinearization("80ba1386a6640080c14d86cc1001809b10858b500280927684e2580380e9458893680480b6538695240580bb2086ac2006942981e1240000000000000000900e819b3a0100000000000000e2528bf6420200000000000000854dca54020200"_hex_v_u8, {{565214, 183924}});
+    TestOptimalLinearization("80cc3fb8e500008327809a2000018327809a2001008327809a2002008327809a2003008327809a2004008327809a2005008327809a2006008327809a2007008327809a2008008327809a2009008327809a200a008327809a200b008327809a200c008327809a200d008327809a200e008327809a200f008327809a2010008327809a2011008327809a2012008327809a2013008327809a2014008327809a2015008327809a2016008327809a2017008327809a2018008327809a2019008327809a201a008327809a201b008327809a201c008327809a201d008327809a201e008327809a201f008327809a2020008327809a2021008327809a2022008327809a2023008327809a2024008327809a2025008327809a2026008327809a2027008327809a2028008327809a2029008327809a202a008327809a202b008327809a202c0000"_hex_v_u8, {{920592, 51098}});
+    TestOptimalLinearization("83ea5fb6be1a0083c44cb2c86c0182ff47abfc140285940cc6dd7c038c3281d1740303841f80a25c0402870880f9740403833d809c400503896a81fb500603897680940608028a4c80b9560603836580941807038365819f0e0803833180874c0903851e80c0600d008331ad6e0c02833180874c0c0383358088480d03833180874c0e0383388089441101833880894412018338808944130183388089441500836180931c1501907d83ae781600158a4d81e82c150010912a84831c16000f8335808848091583388089440616851e80c0600815907583ad001a00000f91238aba401c000007833580884804208338808944041ca84c898e1c1e000000118235809e56042c83388089440220833180874c041e823580ee4c0331833180874c012200"_hex_v_u8, {{2460632, 356111}, {9539, 1398}, {2999, 561}});
+    TestOptimalLinearization("8368aa5e008368aa5e018368aa5e028368aa5e02028368aa5e02028368aa5e0202836897260500836897260501a35780b6380106a35780b6380106836797080108836797080208836797080308836797080408836797080508836797080608836797080708836797080808836797080908836797080a08836797080b08836797080c08836797080d08836797080e08836797080f08836797081008836797081108836797081208836797081308836797081408836797081407836797081507836797081607836797081707836797081807836797081907836797081a07836797081b07836797081c07836797081d07836797081e07836797081f078367970820078367970821078367970822078367970823078367970824078367970825078734cb0a2a00002a00"_hex_v_u8, {{2799, 616}, {2799, 616}, {2799, 616}, {2799, 616}, {2799, 616}, {2799, 616}, {4869, 1076}, {1555, 616}, {1555, 616}, {42540, 16995}, {39460, 15765}});
+    TestOptimalLinearization("854887862000854887862000008548878a0000008548878a0000008548878d6000008548879520000000"_hex_v_u8, {{397920, 5040}});
+    TestOptimalLinearization("8331f924008336fa1400008331f70e00008335f56200008331ee3000008336ef1600008335e17c00008335df62000000"_hex_v_u8, {{7826, 561}, {7882, 566}, {7687, 561}, {7601, 565}, {7128, 561}, {7179, 566}, {6334, 565}, {6193, 565}});
+    TestOptimalLinearization("808962829f2c0083628d2c000183628d2c010183628d2c020083628d2c030083628d2c040083628d2c050083628d2c060083628d2c070083628d2c080083628d2c090083628d2c0a0083628d2c0b0083628d2c0c0083628d2c0d0083628d2c0e0083628d2c0f0083628d2c100083628d2c110083628d2c120083628d2c130083628d2c140083628d2c150083628d2c160083628d2c170083628d2c180083628d2c190083628d2c1a0083628d2c1b0083628d2c1c0083628d2c1d0083628d2c1e0083628d2c1f0083628d2c200083628d2c210083628d2c220083628d2c230083628d2c240083628d2c250083628d2c260000"_hex_v_u8, {{62448, 41552}});
+    TestOptimalLinearization("b27883865800833e81de3601833ea76a029d1d8e1003af4f82e54804c06484911005ad2d82ce6006ae2c82d86007b10082f32808af3882e35809833eba080aa13681d7300bbc1283e2480ca41d81f3400d847088140d0d824180f0280e0d8331a67e0d0d865adf4a0d0d8241ab120c0d86088081540d0d833eaa600e0d854e88720f0d823580c4580e0d8541b9260f0d833ead6c100d8545c014110d8542885e120d823680cd00120d8446bc7c130d83319d42140d8544c658140d8546c658130d8474f034130c854dca56200083318199601b06833281a4021e04865982aa6c1e05854e81e8681c088239c9121d08847c81b4181d09844582987a1b0c854dca5622068608f1242504833e8a142505857ceb401f0c847caa4c23099254828a502c002a8335a7221e378574b95a1c338332ce7419328335ad1819328331d2241731854680f04628001b8235b706122c9260828a503200012c833db00a06548235d332044a833ea76a0931895080a07e023e80dd6690b7682d0000010000000000031100"_hex_v_u8, {{22491, 574}, {83836, 9123}, {72635, 9291}, {6944, 892}, {74024, 9613}, {77864, 10309}, {57207, 7689}, {51363, 6931}, {50808, 6964}, {41279, 5818}, {42972, 6497}, {8845, 1395}, {2825, 449}, {17265, 2817}, {4843, 845}, {4843, 845}, {3966, 710}, {4588, 836}, {4588, 838}, {5954, 1139}, {166740, 33283}, {4170, 837}, {2800, 574}, {7749, 1700}, {2613, 574}, {32469, 7383}, {2790, 764}, {1953, 561}, {714, 574}, {586, 752}, {633, 846}, {623, 834}});
+    TestOptimalLinearization("a25c82906c00835fb17e0000835fb17e0100835fb17e0200835fb17e0300835fb17e0400835fb17e0500835fb17e0600835fb17e0700835fb17e0800835fb17e0900835fb17e0a00835fb17e0b00835fb17e0c00835fb17e0d00835fb17e0e00835fb17e0f00835fb17e1000835fb17e1100835fb17e1200835fb17e1300835fb17e140000"_hex_v_u8, {{25718, 4572}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}, {3263, 607}});
+    TestOptimalLinearization("834180872600834a808726018361808b3c028362808b3c03877f81914c0303877e81914c0303834280804c0303834280804c030383618086500208836280841a04048342fc1001098342f97201088361808650020883628081640406877f819142030d8341fc10020b8362808906030b8342f754030a83618086500313877e8196160705088342fe2e030e83628086500218877e819142060906836280865003138346fc10050f8361809028031d83618086500317836180865003178341fc100612834bfc10051383418085080424836180925e05248362808650051d8361809028051c8342fc1006188343fc1008178342808726042d836180902804258347fc10051b8342808508012a877f81881008121c836280902800368342808508003600"_hex_v_u8, {{26297, 1728}, {26297, 1736}, {139807, 9456}, {8990, 610}, {68514, 4674}, {35240, 2406}, {26660, 1828}, {8835, 610}, {8294, 578}, {8151, 578}, {8008, 577}, {8008, 578}, {8008, 579}, {8008, 582}, {8008, 583}, {8370, 610}, {8008, 587}, {7722, 578}});
+    TestOptimalLinearization("a44d9db27a00824081e92c0000824081e92c0100824081e92c0200824081e92c0300824081e92c0400824081e92c0500824081e92c0600824081e92c070000"_hex_v_u8, {{434605, 8397}});
+    TestOptimalLinearization("880180cf2200829428c7e9180000831ce0040000831ce0040100831ce0040200831ce0040300831ce004040000"_hex_v_u8, {{13329, 1153}, {596620, 51880}, {6210, 540}, {6210, 540}, {6210, 540}, {6210, 540}, {6210, 540}});
+    TestOptimalLinearization("f90bc0b7520080840cc7e7780194268aae4602823581931c0202823681931c0302857882dc2e0402857c82de400502823581911c0602860482e26407028236819f1e0802823984a6160902823681a11e0a02860082e55a0b02847082c60a0c02847482c60a0d02847482c60a0e02826684a6160f02847082b8721002824180f0721102852282a8341202850082af001302823681bf201402823581bf201402823681bf201502823681b9701602847c83df681702823581b1201802857882e55a1902860882b0401a02823681c9221b02852982b0241c02847c82e6781d02850082b32a1f01823983b1521e028235819b1e20018235a5441e208242848b1a1c1f8242889a3819238a4485a45424000a823480e96408218a4c85a4542500028d07e0bb1a1100000500001900"_hex_v_u8, {{2320269, 40741}, {38964, 764}, {21137, 438}, {20152, 438}, {19600, 437}, {18447, 438}, {18191, 437}, {31228, 764}, {129164, 3167}, {17678, 437}, {17678, 438}, {28281, 752}, {27925, 768}, {27648, 768}, {31149, 888}, {51562, 1476}, {31149, 896}, {51562, 1484}, {15481, 449}, {30551, 888}, {30688, 892}, {30962, 900}, {42756, 1245}, {27226, 802}, {27744, 904}, {2466, 437}});
+    TestOptimalLinearization("8361a17a008430a138000000"_hex_v_u8, {{2237, 609}, {2204, 688}});
+    TestOptimalLinearization("fc7d88962000f93b87f516018a50809c6401018235a10402018235f65203018236cd1004018a4c80bb6405018235956e06018604de2c07018332fc480801847cdc0009018336fc700a018a50809e340b0182418c540c01831dcf020d01893c809f400d018470df300e018474dc640f01857cdd4010018802c83811018608dc00120183159a0a14008578dc0015008600dc001501823acf7c0e15857cf12412128336b6760a14926881943019000400"_hex_v_u8, {{171970, 27015}, {134824, 24317}, {2178, 437}, {4700, 1154}, {1463, 437}, {1733, 533}, {874, 449}});
+    TestOptimalLinearization("829428f0fe20008319809604000183198096040100831980960402008319809604030083198096040400831980960405008319809604060083198096040700831980960408008319809604090083198096040a0083198096040b0083198096040c0083198096040d0083198096040e0083198096040f008319809604100083198096041100831980960412008319809604130083198096041400831980960415008319809604160083198096041700831980960418008319809604190083198096041a0083198096041b0083198096041c0083198096041d0083198096041e0083198096041f008319809604200083198096042100831980960422008319809604230083198096042400831980960425008319809604260083198096042700831980960428008319809604290083198096042a0083198096042b0083198096042c0083198096042d0083198096042e0083198096042f0083198096043000831980960431008319809604320083198096043300831980960434008319809604350000"_hex_v_u8, {{933840, 51880}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}, {9666, 537}});
+    TestOptimalLinearization("870180db6e00841580832400008416808d5400008416eb7800008416808d54000000"_hex_v_u8, {{14135, 1025}, {17596, 1323}, {16102, 1324}});
+    TestOptimalLinearization("818f1c85840c0083208b08000083208b08010083208b08020083208b08030083208b08040083208b08050083208b08060083208b08070083208b08080083208b08090083208b080a0083208b080b0083208b080c0083208b080d0083208b080e0083208b080f0083208b08100083208b08110083208b08120083208b08130083208b08140083208b08150083208b08160000"_hex_v_u8, {{49478, 34844}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}, {772, 544}});
+    TestOptimalLinearization("81b8668092af300080da66e0f02801a36e8dc30a0280e87af0a9080380de2bdfea4a0480d709ef9f1405860081bd40068332ee300780cb48f1a11c08844682a01808088235d7dc300908826580f94c0a08824180e7600b088316818b4c0c088235c39c320c08833e81a31a0d08833280dd240e08854d81ce401007824280e4421008854b8df30e100893588984141108824180ad041208847483e97c12088235bdb51c1308824280b2261408824180b27e1508824180f66e19058448829a1a1a05823580fc1c1a068235c6f26c1808823581b2221908823981fa1a1a08860982d7681b088336819f0e1c08875d82ba3e1d088235b28b2a1d08823a8188381e08824180be341f08823680ba662008857881bc0a20088235a6d9061f08823a81a1182008824280e45c2108833680de6e2208823a80b2022308833281e41a2c00845182806e2c0024833581ac261d32831d81d04e2224854582ea7a2b010e823980c408062c896483ae002a0404866283d5781717158e10878014210f011fab528cf5380e1f050900"_hex_v_u8, {{1406632, 29465}, {1934192, 40603}, {1338143, 28094}, {1360813, 28571}, {1479376, 31139}, {1261329, 26621}, {19665, 437}, {241164, 5561}, {18572, 442}, {22861, 562}, {16988, 442}, {54538, 1431}, {31485, 837}, {26700, 710}, {26317, 712}, {38797, 1075}, {15863, 449}, {24695, 721}, {65610, 1936}, {30260, 905}, {14896, 449}, {16038, 485}, {14702, 450}, {14689, 450}, {18701, 574}, {18439, 566}, {82250, 2648}, {40755, 1410}, {12019, 438}, {12250, 449}, {26939, 1007}, {35776, 1380}, {11457, 442}, {11519, 449}, {11475, 450}, {28383, 1117}, {14226, 562}, {11138, 449}, {40677, 1784}, {121204, 6276}});
+    TestOptimalLinearization("80ba43afe456008b358582100180c16cb587240280d261c0c11a0380d924bbc75c04833180ad5805900e84e9260682359b9b5c060782398087040706823598f2560606823599eb60050684788199680606823594a33c0805823580a95e0905854081f70c0d02824183c8280e028eb06183c190480b00058a7183aa0c0a000400ad428fc3340d000000000800"_hex_v_u8, {{49352, 1589}, {692467, 25721}, {711083, 27542}, {655101, 25377}, {716126, 28377}, {10927, 437}, {18100, 760}, {135450, 5954}, {94469, 4272}, {8706, 441}, {4736100, 252129}});
+    TestOptimalLinearization("a25c86f87e008362808722000083628087220100836280872202008362808722030083628087220400836280872205008362808722060083628087220700836280872208008362808722090083628087220a0083628087220b0083628087220c0083628087220d0083628087220e0083628087220f008362808722100083628087221100836280872212008362808722130000"_hex_v_u8, {{239571, 16772}});
+    TestOptimalLinearization("864a828f7a008b6384a51401854181d76c02833180e754038431819c3a04892a87a42205894587ba5c06853981d44607861c81ca2c0107857881bb3a010785008193000306823582ee280505854e81ec5a0a000a853581e22c0014896183d36c0007000007833e80f734000e860481c37000098642829e5c0106078a588398500108854181e744010f9659899c24000707843a81ac70000e857881b50e010c860481fb26020788358393240210833180f7420012843e81b51a0011874082e014000807853581ea0a000f853681ea0a000f833e80fc66000e833580f924000e833580fe4c000d00"_hex_v_u8, {{99621, 1759}, {69358, 1349}, {594899, 21560}, {24339, 900}, {20792, 900}, {17664, 768}, {34408, 1496}, {21206, 924}, {20253, 888}, {19847, 888}});
+    TestOptimalLinearization("818e6ca18c5000834fc8700001834fc8700100834fc8700200834fc8700300834fc8700400834fc8700500834fc8700600834fc8700700834fc8700800834fc8700900834fc8700a00834fc8700b00834fc8700c00834fc8700d00834fc8700e00834fc8700f00834fc8701000834fc8701100834fc8701200834fc8701300834fc8701400834fc8701500834fc8701600834fc8701700834fc8701800834fc8701900834fc8701a00834fc8701b00834fc8701c00834fc8701d00834fc8701e00834fc8701f00834fc8702000834fc8702100834fc8702200834fc8702300834fc8702400834fc8702500834fc8702600834fc870270000"_hex_v_u8, {{279400, 34796}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}, {4728, 591}});
+    TestOptimalLinearization("c7128ac61a00837ae46e0000837ae46e0100837ae46e0200837ae46e0300837ae46e0400837ae46e0500837ae46e0600837ae46e0700837ae46e0800837ae46e0900837ae46e0a00837ae46e0b00837ae46e0c00837ae46e0d00837ae46e0e00837ae46e0f00837ae46e1000837ae46e1100837ae46e1200837ae46e1300837ae46e1400837ae46e1500837ae46e1600837ae46e1700837ae46e1800837ae46e1900837ae46e1a00837ae46e1b00837ae46e1c00837ae46e1d00837ae46e1e0000"_hex_v_u8, {{296758, 28888}});
+    TestOptimalLinearization("8440881a0084408c5e000000"_hex_v_u8, {{1468, 1408}});
+    TestOptimalLinearization("a22d80e478008e4be10000008e4be42e00029031f0120002903284fe200000d25c9b8d380000835b80c71c0002835b80c71c0102835b80c71c0202835b80c71c0300835b80c71c0400835b80c71c0500835b80c71c0600835b80c71c0700835b80c71c0800835b80c71c0900835b80c71c0a00835b80c71c0b00835b80c71c0c00835b80c71c0d00835b80c71c0e00835b80c71c0f00835b80c71c1000835b80c71c1100835b80c71c1200835b80c71c1300835b80c71c1400835b80c71c1500835b80c71c1600835b80c71c1700835b80c71c1800835b80c71c1900835b80c71c1a00835b80c71c1b00835b80c71c1c00835b80c71c1d00835b80c71c1e00835b80c71c1f00835b80c71c2000835b80c71c2100835b80c71c2200835b80c71c2300835b80c71c2400835b80c71c2500835b80c71c2600835b80c71c2700835b80c71c2800835b80c71c2900835b80c71c2a00835b80c71c2b00835b80c71c2c00835b80c71c2d00835b80c71c2e00835b80c71c2f00835b80c71c3000835b80c71c3100835b80c71c3200835b80c71c3300835b80c71c3400835b80c71c350000"_hex_v_u8, {{1006076, 56244}});
+    TestOptimalLinearization("8472e52e008473e52e018473e52e028473e52e038472e52e048472f85c058472e77405058472e52e05058473e52e05058473e52e05058473e52e05058472fe0005058472ef1e050f8473809e14050e8473e874050d8239ad42060d8473809e14060c8472e874060b8472fb58060a847280b024061a847280837406188473e674061684738083740514847280b91405128473fb580424847380cd24031e8472fb58031a8472f85c03178473fb58032b8473f85c03238472f85c031e847380ab14031a8472f85c03318472f85c03288473fe0003228473fb58031d8472f85c03378473f85c011d8473f85c031c8472808028023c8472f85c021e8473f85c021f8473f85c01208473f85c00218e0b81d3280a03010514901a8089000c000502020800"_hex_v_u8, {{50602, 4526}, {196414, 18533}, {7980, 755}, {23898, 2262}, {15918, 1509}, {23856, 2262}, {15580, 1509}, {7790, 755}, {7790, 755}, {7790, 755}, {7790, 755}, {2977, 441}, {8832, 2202}});
+    TestOptimalLinearization("8361c74a0084a108cec45c0000831cbe5e0000831cbe5e0100831cbe5e0200831cbe5e0300831cbe5e0400831cbe5e0500831cbe5e0600831cbe5e0700831cbe5e0800831cbe5e0900831cbe5e0a00831cbe5e0b00831cbe5e0c00831cbe5e0d00831cbe5e0e00831cbe5e0f00831cbe5e1000831cbe5e1100831cbe5e1200831cbe5e1300831cbe5e1400831cbe5e1500831cbe5e1600831cbe5e1700831cbe5e1800831cbe5e1900831cbe5e1a00831cbe5e1b00831cbe5e1c00831cbe5e1d00831cbe5e1e00831cbe5e1f00831cbe5e2000831cbe5e2100831cbe5e2200831cbe5e2300831cbe5e2400831cbe5e2500831cbe5e2600831cbe5e270000"_hex_v_u8, {{4645, 609}, {814790, 107880}});
+    TestOptimalLinearization("8431e564008369a158018369a15c028369a162038550ae20048369a17a058501a94a068501a946078430e72e088369a178098500a93a0a842fe5640b8502a9360c8501a8740d83699f5a0e8431e5640f8431e564108369a144118550ae2211118737ba280a118369a178081183699f5a051183699e4605118374b1601204891ec536060b0682199b70021582199b70041482199b7006138540ab7c031a853fab76001db6219ddc1007000000000100000000000000000000001e00"_hex_v_u8, {{327699, 22688}, {3248, 628}, {1848, 409}, {1848, 409}, {1848, 409}, {2210, 617}, {10260, 2973}});
+    TestOptimalLinearization("836881f0280088318cba380000a37a9986500000a37a9986500100a37a9986500200a37a9986500300835a82ae5c0303835a82ae5c0403835a82ae5c0503835a82ae5c0603835a82ae5c0703835a82ae5c0803835a82ae5c0903835a82ae5c0a03835a82ae5c0b03835a82ae5c0c03835a82ae5c0d03835a82ae5c0e03835a82ae5c0f03835a82ae5c1003835a82ae5c1103835a82ae5c1203835a82ae5c1303835a82ae5c1403835a82ae5c1503835a82ae5c1603835a82ae5c1703835a82ae5c1803835a82ae5c1903835a82ae5c1a03835a82ae5c1a02835a82ae5c1a02835a82ae5c1c01835a82ae5c1c02835a82ae5c1e01835a82ae5c1e02835a82ae5c2001835a82ae5c2002835a82ae5c2102835a82ae5c2301835a82ae5c2302835a82ae5c2402835a82ae5c2502835a82ae5c2701835a82ae5c2801835a82ae5c2901835a82ae5c2a01835a82ae5c2a02835a82ae5c2c01835a82ae5c2d01835a82ae5c2d02835a82ae5c2f01835a82ae5c3001835a82ae5c3101835a82ae5c3102835a82ae5c3301835a82ae5c330200"_hex_v_u8, {{133936, 1817}, {876600, 19178}, {627930, 13760}, {545040, 11954}, {213480, 4730}});
+    TestOptimalLinearization("836884c43c00a30da899200000847285dd280000856c86e6180100853586aa700200846085c6400300853586aa70040085168686300500853a86af38060085238694080700844f85b4200800853b86af380900850985f8580a00850185ef480b00853d86b4000c00853c86af380d00855d86d8400e00853e86b4000f00845985c1781000846485cb081100844c85af581200853e86b4001300845085b420140000"_hex_v_u8, {{45406, 616}, {1043316, 14258}, {52560, 719}, {58692, 803}, {60444, 827}, {52268, 716}, {52560, 720}, {53728, 736}, {54020, 740}, {60444, 828}, {63948, 876}});
+    TestOptimalLinearization("8369821a008369821a0185018272028369821a038369821a0485018272058431892e0685018272078369821a088431892e09850182720a850182720b855083280c855083280d8369821a0e8369821a0f8369821a108369821a1185028272128369821a138369821a148369821a1585508328168369821a17823d834a188369821a198369821a1a8369821a1b855083281c8430892e1d842f892e1e843086101f8369821a208369821a0e338369821a1b208b0586542218860b8a381a208550832811208e538870111d8550832809208737843609208369821a09208369821a1c0d8369821a09498369821a032b8369821a032a8369821a0b2283699e5a04298369821a032c9d7181ea04012d8369821a012f8359a46c012e8369821a0131833983380034bc5285e37a110000110000000000000000000000000020bf6983b65e09000200000400000000000000000000100900"_hex_v_u8, {{25744, 6035}, {2422, 601}, {61527, 21962}, {43202, 25453}, {899, 2420}, {205, 617}, {205, 617}, {205, 617}});
+    TestOptimalLinearization("8089328682520083329b52000083329b52010083329b52020083329b52030083329b52040083329b52050083329b52060083329b52070083329b52080083329b52090083329b520a0083329b520b0083329b520c0083329b520d0083329b520e0083329b520f0083329b52100083329b52110083329b52120083329b52130083329b52140083329b52150083329b52160083329b52170083329b52180083329b52190083329b521a0083329b521b0083329b521c0083329b521d0083329b521e0000"_hex_v_u8, {{114400, 35136}});
+    TestOptimalLinearization("872d8f58009928c064000089509a400000895d99700100860d90680200860a905e03008655921c0400872b936e0500857f904006008603904a07008608905408008602904a0900861f91100a00862591240b0000"_hex_v_u8, {{20428, 16489}});
+    TestOptimalLinearization("8472cf14008472cf14018472cf14028473cf1402028473cf1401028472cf1403018472cf1401098472cf1403068473cf1402048473cf1402058473cf1402068472cf1402068472cf1402078472cf1402088473cf1402088472cf1402098473cf14020a8472cf14020a8472cf14010d8473cf14030b8473cf14020cb42181bf200d00010e8473cf14020e8472cf14040d8472cf14030e8472cf1402108473cf1402118473cf1402118473cf1402128472cf1402138472cf140213886f80845e090b01148473cf1402158472cf1404148472cf1403158472cf1402188472cf1402178473cf1402188472cf14021b8473cf14001b00"_hex_v_u8, {{5130, 754}, {5130, 754}, {5130, 754}, {5130, 754}, {25650, 3772}, {61560, 9053}, {46170, 6790}, {30780, 4527}, {5130, 755}, {5130, 755}, {29055, 8080}});
+    TestOptimalLinearization("808967889a74008367a77400018367a77401008367a77402008367a77403008367a77404008367a77405008367a77406008367a77407008367a77408008367a77409008367a7740a008367a7740b008367a7740c008367a7740d008367a7740e008367a7740f008367a77410008367a77411008367a77412008367a77413008367a77414008367a77415008367a77416008367a77417008367a77418008367a77419008367a7741a008367a7741b008367a7741c008367a7741d0000"_hex_v_u8, {{154054, 36217}});
+    TestOptimalLinearization("8335b816008335c44c00008335c44c00008331c40c00008335c44c00008335c44c00008335c44c00008335c44c0000833dc54800008335c44c00008331c40c00008335c44c00008335c44c00008335c44c00008335c44c00008335c44c0000833dc54800008331c40c00008331c40c00008335c44c00008335c44c00008335c44c00008335c44c000000"_hex_v_u8, {{101643, 12995}});
+    TestOptimalLinearization("89c0788087d818008448c72800008448c72801008448c72802008448c72803008448c72804008448c72805008448c72806008448c72807008448c72808008448c72809008448c7280a008448c7280b008448c7280c008448c7280d008448c7280e008448c7280f008448c72810008448c72811008448c72812008448c72813008448c72814008448c72815008448c72816008448c72817008448c72818008448c72819008448c7281a008448c7281b008448c7281c008448c7281d008448c7281e008448c7281f008448c72820008448c72821008448c72822008448c728230000"_hex_v_u8, {{1119820, 172280}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}, {4628, 712}});
+    TestOptimalLinearization("81c62aebef0200823580816a01819771dba4680280d371c4eb600381ac0ee3960604854080ae0c05845081ce140505823580a59b260605857c82bb400705824180e86008058a4884bc36090582428188380a05833182d3140b058235808f93460a05860881fc300b05832480c92c0c058332818f7a0c05860082b74c0d05844482c1160e058235ed82480f058545828578100583368186741105854c829a121205823980f8361205823981906e13058235809892121405845181b2001505833180f3481605823a8188141705860482b12c1921857c81f5401d00847c82a7201b038b7e84bf581c03824180ef6a1c04875382d1161f02826581ce621e04875385b93a2300854d83c1702400833e81ce202203823681bf182402823581bf182403823581bf182503823681bf182702823681bf182a00823681c75a270484448394622c00823581c75a2d00823981eb302e008a4484cd682533860482e96c2831824181e6282534845182fa5430012797518b902c310028833281b9381930845181dc44300018ad5688bd082e1b857c82dc2e075f823982ac58045c9b698c944e3500021d00"_hex_v_u8, {{2075276, 38979}, {2283550, 42896}, {1937047, 36390}, {1473556, 27686}, {23320, 441}, {22996, 449}, {34161, 708}, {21037, 437}, {21037, 438}, {52893, 1107}, {20492, 437}, {20492, 437}, {20492, 438}, {20492, 438}, {20492, 438}, {32490, 721}, {21489, 485}, {37048, 845}, {28811, 708}, {17527, 441}, {16970, 442}, {16988, 450}, {21456, 574}, {15963, 441}, {27152, 764}, {15413, 449}, {135287, 4031}, {59862, 1792}, {14960, 449}, {35776, 1123}, {121446, 3848}, {28198, 896}, {26313, 844}, {17469, 562}, {27798, 900}, {25020, 837}, {16890, 566}, {21450, 720}, {107879, 3689}, {19648, 721}, {45100, 1662}, {24408, 904}, {29835, 1107}, {23968, 892}, {12950, 548}, {33576, 1553}, {77700, 5974}});
+    TestOptimalLinearization("8368aa5e008368aa5e018368aa5e028368aa5e038368aa5e0483689726058368aa5e05058368aa5e05058368aa5e05058368aa5e05058368aa5e05058368aa5e05058368972608038368aa5e010b854ea024080005a35780b638020ba35780b638010e83679708010d83679708020d83679708030d83679708040d83679708050d83679708060d83679708070d83679708080d83679708090d836797080a0d836797080b0d836797080c0d836797080d0d836797080e0d854eba7414001c836797080f1d83679708101d83679708111d83679708121d83679708131d83679708141d83679708151d83679708161d83679708171d83679708181d83679708191d836797081a1d836797081b1d836797081c1d836797081d1d836797081e1d836797081f1d83679708201d83679708211d8734cb0a2a0000308734cf280013112600"_hex_v_u8, {{2799, 616}, {2799, 616}, {2799, 616}, {2799, 616}, {2799, 616}, {2799, 616}, {2799, 616}, {2799, 616}, {2799, 616}, {2799, 616}, {3834, 846}, {4869, 1076}, {12293, 2924}, {1555, 616}, {2130, 846}, {41000, 16380}, {33300, 13305}});
+    TestOptimalLinearization("8361ee3400877f80d86401877e80d864028362ee3403877e80d86404877e80d86405877e80d864068362ee34078341e5640707877e80d86408078362ee3408078362ee340807877f80d86408078346e56409078361ee3409078361ee340907877f80f97608078342e56409078361ee340b068361ee340918877e80f51809178346e5640a178360f80c0a168342e5640b168362ee340b158361f80c0a148341e5640b148361fa420b138342e5640c138361fa420a118341e5640b118343e5640b2c8361fa420c2c8361fa420a288341ee5c0b288361fa420a268342e5640b268361fa420b238343ee5c0c23877e80f5180b218343f07a0c21877f80f5180b1c8343f07a0c1c8341f07a0a42877e80f5180b42877f80f5180b3b8341f07a0c3b877e80f5180b378342f07a0c37877f80f5180b338341f07a0c33877f819a421e0a2d877f819a420a1511877f819b2c031921877e819a42061121877e819a42090c3b877e819a420b0737877e819a4203141600"_hex_v_u8, {{263296, 19845}, {267965, 20479}, {7293, 577}, {7293, 577}, {7293, 577}, {7293, 578}, {7293, 579}, {7293, 579}, {7150, 577}, {7150, 579}, {6578, 577}, {6578, 578}, {6578, 582}});
+    TestOptimalLinearization("80de1a89c02e0080dd1c8aac460180d10789b70202b04282ee2803854da96204833da30005ae0e82d6200682429268078608ac7408833e973a09b4558397700a823589e10e0a0a8331b54c0b0a8335a0000c0a823588ec180c0a8544ac400d0a8242bd000d0a8235899b7e0e0a8546ac500f0a8544ac5011098242974e12098545d03a110a8331a42215058241974015068545d35c140883319d5017068578b37c130a8541d3261408f43185ba60120a82429b001607833282b6161a048235ac5a140a8336b87219068331b54c14288f1c81a34020001a8751bb1e2000178540ac341f001483359d6611228241cc781024833db67c101a8b708099280d1dbf3a85a62a2301021483319d4a0634833d9e1e0633dd3884c704230000108a58d654120f0a9e65829c580438880ff5100010208474e9700030894880bd1002013200"_hex_v_u8, {{59807, 6900}, {10201, 1286}, {5422, 837}, {173248, 27774}, {454202, 73978}, {39260, 7429}, {5967, 1134}, {13266, 2536}, {37285, 7306}, {61944, 14794}, {1792, 450}, {68941, 17522}, {5610, 1496}, {2112, 565}, {1575, 450}, {1960, 561}, {2920, 836}, {1568, 449}, {3855, 1105}, {1971, 565}, {1957, 561}, {2920, 838}, {2912, 836}, {7642, 2250}});
+    TestOptimalLinearization("81903fc9ee3800819170cfe6520180d334bef35002819540d0d4480380da6ebdd94a0482359094100405823580a7120504823589bd760504847c819d100504823585f11c060482358d8d6a0604823589c62e0604823580b5520704a51586dd5008000000000000"_hex_v_u8, {{784665, 36085}, {764717, 35881}, {611877, 29016}, {598334, 28389}, {747940, 35621}, {63400, 4885}});
+    TestOptimalLinearization("808963829f2c0083638d2c000183638d2c010083638d2c020083638d2c030083638d2c040083638d2c050083638d2c060083638d2c070083638d2c080083638d2c090083638d2c0a0083638d2c0b0083638d2c0c0083638d2c0d0083638d2c0e0083638d2c0f0083638d2c100083638d2c110083638d2c120083638d2c130083638d2c140083638d2c150083638d2c160083638d2c170083638d2c180083638d2c190083638d2c1a0083638d2c1b0083638d2c1c0083638d2c1d0083638d2c1e0083638d2c1f0083638d2c200083638d2c210083638d2c220000"_hex_v_u8, {{58776, 39148}});
+    TestOptimalLinearization("8d29889718008368809064018368809064028d1386db10020292618bd5080302846380ac380301846380ac38030283688090640307854e80c6580500038360b8540403824182812a0503844682b6300603846380ac38040e8368809064050e8368809064050b846380ac38060a842ebf400609846380ac38031683688090640415846380ac380410846380ac38011a854e80c65802030b846380ac3800108368809064010e846280ac38000f8368809064010d846280ac38000e8368809064010e846380ac38000f00"_hex_v_u8, {{203813, 4811}, {28120, 710}, {63240, 1811}, {9330, 616}, {9330, 616}, {9330, 616}, {9330, 616}, {9330, 616}, {62880, 4156}, {11100, 738}, {11100, 738}, {11100, 739}, {11100, 739}, {11100, 739}, {11100, 739}, {11100, 739}, {11100, 739}, {11100, 739}, {11100, 739}, {11100, 739}, {3690, 608}, {4128, 686}});
+    TestOptimalLinearization("81bd6f8dc370008544a9200180df1588f04e028541ac340380c97c88b0240480e74989ca6c0583359a38068608d7240606854ec40a070687128091760806941381c52009068608d7240a06854de8200b05a32081e9680c058445c4200d058335ad300e05823580b40e0f05875d80856810058450809a380f068578d60e10068545d03a11068546b63212068a54808b20130682419c7214068474b93e15068235a26216068608d7241706833ead6c1806823580840a19068242cd221a068754c4081b06847480971a19068235c5281a068a58809c641b068474d2101c068239c2041d06854cd11e1e06823aa16e1f06ab7282a6702006823580887621068608a22825028540af5224048500e23425048336c0502604823abf2627048235fa3a2804896a80984e2904823997162a048803bd7a2b04823a97082c0483329d4a2d048332b1343002857cd64028388d7c818d0033002d8500ca0022328452ec581d36845180804835011a8545b9541a368546c658242dac1f82811c3702178450af18360210a70de536270e10854dee6c2c0c0400"_hex_v_u8, {{248259, 59175}, {180475, 43031}, {27624, 6624}, {167256, 41844}, {116449, 30424}, {3113, 832}, {1547, 441}, {4029, 1155}, {1540, 442}, {1957, 562}, {1756, 565}, {2260, 904}, {6555, 5133}});
+    TestOptimalLinearization("c554baaa4600835c82fa220000835c82fa220100835c82fa220200835c82fa220300835c82fa220400835c82fa220500835c82fa220600835c82fa220700835c82fa220800835c82fa220900835c82fa220a0000"_hex_v_u8, {{486115, 9044}, {32465, 604}, {32465, 604}, {32465, 604}, {32465, 604}, {32465, 604}, {32465, 604}, {32465, 604}, {32465, 604}, {32465, 604}, {32465, 604}, {32465, 604}});
+    TestOptimalLinearization("8184258aa316008185018287740180f14981ea6c028183288285600381a93a82c0180481831082a64005818a4182b2460681884983ae0a0781911684fd2208857cc81608088950904409088a4480d3240a08823590e0460a0882358fba2e0a08823590d1380a08823593963a0a08823590ed140908823590ae680b07823584640b08823a9f540d078235846e100585159a640f078541886014038478b41015038a54f370120782368a7a1604823588be08190282358fde161308854188601408823ab9661a03823a85101a048544c0141906844487281c048332aa561b068239a6181b078944e9201b0882358ee5281b088540bf6c1c08850088001d088c5f934a1e088445be0e2601833587662206854ce25a26038236856c22088541c30c2a018332875e0d2a8444c554250408875dd152121716833d8776023080970e80e35a013a9c6d81aa082b0000000000002400"_hex_v_u8, {{188460, 36250}, {175929, 34601}, {161920, 31928}, {182991, 36239}, {179050, 35516}, {176697, 35119}, {179744, 35778}, {194089, 38639}, {169428, 33733}, {7480, 1492}, {19140, 3821}, {4170, 836}, {4150, 832}, {2795, 562}, {2090, 442}, {3400, 760}, {5913, 1950}, {1778, 789}, {765, 438}, {438, 438}, {563, 565}, {1130, 1135}, {392, 442}, {375, 437}, {370, 437}, {1122, 1360}, {14637, 19470}, {532, 708}, {576, 768}, {624, 833}, {1317, 1759}});
+    TestOptimalLinearization("836880ed0e00d724a0e46400008430818630000084308186300100842c81846c02008430818630030084308186300400842c81846c0500842c81846c060084308186300700842c81846c080084308186300900842c81846c0a0084308186300b0084308186300c0084308186300d00842c81846c0e00842c81846c0f0084308186301000842c81846c11008430818630120000"_hex_v_u8, {{15239, 616}, {276850, 11300}, {16758, 684}, {16758, 684}, {16758, 684}, {16758, 684}, {16758, 684}, {16758, 684}, {16758, 684}, {16758, 684}, {16856, 688}, {16856, 688}, {16856, 688}, {16856, 688}, {16856, 688}, {16856, 688}, {16856, 688}, {16856, 688}, {16856, 688}, {16856, 688}, {16856, 688}});
+    TestOptimalLinearization("d02a82c24800fe6b84ff6001de7983ff08028235930202028578e04803028336915204028a48809e3405028474829172060285409a3807028474e30c08028a48809e34090283128d3c0a0283118d3c0b028608e1700c028948fd600d02857ce4060e028a5880aa140e028542b5700f028a4480a70e100282359f0412018600e44012028600e8001302b62180aa301402854182ad48150282368f0216028a4cef3417028a50d65418028500ee761a018600e4401a028236a3041b0286538292241d018578eb021e01823684fe6c1e028235a9061e028478f1241f02857cee4020028474dd4021028236ad0623018235a50423028241f41824028235a104250282418f0225238a5480a83c2800188235900a1e20824181834e181e82359f3e270f8a5080b9002b01078241a9060d2700"_hex_v_u8, {{119706, 15443}, {6467, 892}, {178169, 24786}, {6244, 888}, {6328, 904}, {10202, 1480}, {10202, 1480}, {2947, 438}, {8112, 1352}, {2306, 438}, {90860, 18386}, {7194, 1484}, {3512, 834}, {5610, 1488}, {3272, 1003}, {1281, 437}, {1025, 438}, {1025, 449}, {1756, 832}, {2019, 966}, {926, 530}, {10968, 7073}});
+    TestOptimalLinearization("80896681da040083668b04000183668b04010083668b04020083668b04030083668b04040083668b04050083668b04060083668b04070083668b04080083668b04090083668b040a0083668b040b0083668b040c0083668b040d0083668b040e0083668b040f0083668b04100083668b04110083668b04120083668b04130083668b04140083668b04150083668b04160083668b04170083668b04180083668b04190083668b041a0083668b041b0083668b041c0083668b041d0083668b041e0083668b041f0083668b04200083668b04210083668b04220083668b04230083668b04240083668b04250083668b04260083668b04270083668b04280083668b04290083668b042a0083668b042b0000"_hex_v_u8, {{56090, 44782}});
+    TestOptimalLinearization("80ea55a1fc3c0080e47da4dc2c0180e159a1c3340280e411a4ca500380d35ba1f20c04823586f77404048a5080b00405048265994a0604823a994a07048242c90a08048500e91a0904823680830e0904850081884e0a0482358397480b048474d8080c0485208194460d048542bf6c0e04854dc40a0f048239c92010048335ad181203823585e33a1104853f80871812048474e80613048236e47a1304823582a2261404823582894414048241c86a1504854cc40a17038658d0301704854dc0641804865fc4601c00138546c3361c0109833eb00a041c8452ba141c0004875c80c2541e0002833ead6c032900"_hex_v_u8, {{386635, 31880}, {338487, 29454}, {351640, 30602}, {341304, 30204}, {311144, 27664}, {12522, 1116}, {4752, 441}, {4741, 450}, {4725, 449}, {8716, 831}, {6723, 756}, {6797, 768}, {11330, 1488}, {5700, 756}, {7562, 1418}, {5208, 984}, {3786, 722}, {4421, 845}, {2956, 565}, {4379, 838}, {2998, 574}, {4210, 845}, {4150, 834}, {4464, 991}, {1701, 442}, {1701, 485}});
+    TestOptimalLinearization("83698158008570832e0183698158028361831403875387440483698158058369815806b95d82d2480785018222088369815809836981580a836981580b836981580c8669831a0d836981580e836198220f8369815810860b843211836981581111843083221111bf69a814111183698158121184308336121183698158101188018362101183698158130a836981580e108430883c0b1183698158092b8339836c092a83698158082983698158082883698158082583698158061f83698158061c83698158091883698158073b83698158073983698158052983698158042383698158042183698158044687538744052d83698158042d83698158042883698158034d83698158012a836981580329836981580252823d880c022b83698158013d83698158003e83698158003d857c8968050a1f823d8400013eb623c2281104000004010500000000000019a63281c2600b0100010203050000000f00"_hex_v_u8, {{29924, 7517}, {1617, 609}, {25754, 20468}, {754, 1062}, {546, 1107}, {1036, 2126}, {7609, 17367}, {1180, 3530}, {2634, 8297}, {172, 617}, {172, 617}});
+    TestOptimalLinearization("836280c06000836180c06001836280c06002834280b1600202836180c0600302834280b1600302836180c0600402834280b1600402836280c0600502877e81fc200509833a80b1600509836280c0600609877f81fc200608834180b1600608877e81fc200607836280c0600607834180b1600707836180c0600715834280b1600614836280c0600611836180c060050f834380b160050d834180b1600420834380b1600318834280b1600315836180c0600510877f81fc200327880281f96010030d836280c060012b834280b160002c836180c060012c880281fc2006070e834280b160012e836280c060022a877f81fc200a0913833b80b160012d877e81fc2002022a877f81fc2009050e877e81fc2001022c877f81fc20040f0a877e81fc2000110b877f81fc20020f0b877e81f96006021100"_hex_v_u8, {{96480, 4675}, {48240, 2338}, {48240, 2338}, {482080, 23373}, {12400, 609}});
+    TestOptimalLinearization("836880bf4000834c80b6600000836880bf400100834c80b6600001836880bf400101834c80b6600002836880bf400102834c80b6600003836880bf400103834c80b6600004836880bf400104834c80b6600005836880bf400105834c80b6600006836880bf400106834c80b6600007836880bf400107834c80b6600008836881b768010800"_hex_v_u8, {{130900, 6160}, {11760, 588}, {11760, 588}, {11760, 588}, {11760, 588}, {11760, 588}, {11760, 588}, {11760, 588}, {11760, 588}, {11760, 588}});
+    TestOptimalLinearization("8369817400885084460183698174028369817403842482760485028244058501824406836981740783698174088550827609866883460a836981740b836981740c850282440d836981740e836981740f8550827610836983261183698326128550846613836983261483698326158501841c168501841c1783698326188550846619836981741a836983261b836983261c836983261d842486681e836983261f83698326208501841c2185508276228550827647850182442483698174258550827626836981742783698174288369817429836981742a866783462b836981742c836981742d836981742e836981742e2f956f9220152f873786240e2f8667855c142a8b0589240f23823d897c0453bc50d70c06000000000000000000000024bf66db78061e00000000000000000000000000000035c30085961a0200020b000000000000000000000000000000003500"_hex_v_u8, {{59283, 28013}, {7894, 15440}, {9513, 20143}, {466, 1079}, {430, 999}});
+    TestOptimalLinearization("cc1b8ae36800d6628bd74401912d81d342028368d406038e54819144048f7481a73405af7687b42806d35e8aa12c078416ab0c088f4781d31609a42e85905a0909b53087da7c07098459e30a0809cc4789cd7e0709912881db4405098422de500509a84b8693220e000d901e828d56050f823cce0e030f9017828c2201158608809b340807000d901e81d8420116925282b97c080600020a901c81d8420117901f81d8420012ca088ab75202010102020200"_hex_v_u8, {{68948, 6262}, {127805, 11981}, {21771, 2119}, {44226, 4410}, {22113, 2207}, {146849, 14665}, {162611, 16557}, {31803, 3253}, {151865, 16609}, {6120, 674}, {216238, 23904}, {6405, 729}});
+    TestOptimalLinearization("8530af0600853daf60018930cd0602893abe00038638b70204862db62805853da600068a39e134078531af060707853caf600707853ca60007078531af0607078530af0606078530a53808068332b77408078540e6600c04883cc62009078500dc3e0c058500dc3e0a078312bf5e0b07853caf600b198531af060b168a4cd6180a1682359d5e09148241a0200b11853caf6008138239be4c09138541bf6c0b0e853daf60072b8745bf1c06258530af06081d8751d50209148f4bfb581200188531af0604278530b53a03228500dc3e05208638ab68032d8332b774042c8531af0604298a4880a930032b853db940051f8c33e3640b10248931cd0605348235a44806348530b53a052a8570f4340423853ca600044387548091640430853db9400328937081fa741410002e8835c564033c8a4c80a9300b12168236b366012a8c3be4200a0e23894480997c021c138e4bf4180102308f1c80cc6e06020832853ca60001338654f55602298534a55001338824ce14003f853ca600003f00"_hex_v_u8, {{16424, 2763}, {9568, 1720}, {54506, 9812}, {11635, 2160}, {45440, 8447}, {20893, 4158}, {4150, 833}, {5505, 1105}, {7182, 1503}, {68976, 14854}, {1967, 437}, {11126, 2482}, {24695, 5526}, {13379, 3279}, {10034, 2836}, {2496, 828}});
+    TestOptimalLinearization("80884d94bf40008349db4000018349db4001008349db4002008349db4003008349db4004008349db4005008349db4006008349db4007008349db4008008349db4009008349db400a008349db400b008349db400c008349db400d008349db400e008349db400f008349db4010008349db4011008349db4012008349db4013008349db4014008349db4015008349db4016008349db4017008349db4018008349db4019008349db401a008349db401b008349db401c008349db401d008349db401e008349db401f008349db4020008349db4021008349db4022008349db4023008349db4024008349db4025008349db4026008349db4027008349db4028008349db4029008349db402a008349db402b008349db402c008349db402d008349db402e008349db402f0000"_hex_v_u8, {{460320, 45693}});
+    TestOptimalLinearization("80cc00829900008449c452018336c318028335b4200380c95c86c57004ce3488a30c0580b63281ed680683358c1a078477da46088336b37c0988728092340a8540955c0b9f0a82831c0c8474c2760c0c82359094240d0c8335b2160e0c8239af7e0f0c823aad50100c9738c840110c8478c3520e0c823581db200f0c82358ae40e100c847cbb000f0c8478cf74100c8331a006110c8311af5c120c82358dd418130c8239ab58140c8331b97c1708854d926018088478c32419088600cf401e048621b8701f048235b13a1c088336bc4a160c8242b01c1e048335b216142d8331b97c08268474d14c131b967e81f164040a0a000009bd6580a1061f00000000000000000f00"_hex_v_u8, {{5859, 759}, {4364, 566}, {76038, 10164}, {9434, 1266}, {187130, 27709}, {3774, 561}, {3774, 561}, {172985, 27560}, {4457, 713}, {209015, 34252}, {3408, 565}, {3118, 529}, {3275, 565}, {3275, 565}, {4393, 760}, {4347, 756}, {4370, 760}, {5152, 896}, {3840, 764}, {3704, 929}, {2115, 561}, {9990, 3884}, {1264, 845}, {845, 565}, {10371, 8037}});
+    TestOptimalLinearization("cf0884cf6c008324a54400008324a54401008324a54402008324a54403008324a54404008324a54405008324a54406008324a54407008324a54408008324a54409008324a5440a008324a5440b008324a5440c008324a5440d008324a5440e0000"_hex_v_u8, {{46134, 10248}, {2466, 548}, {2466, 548}, {2466, 548}, {2466, 548}, {2466, 548}, {2466, 548}, {2466, 548}, {2466, 548}, {2466, 548}, {2466, 548}, {2466, 548}, {2466, 548}, {2466, 548}, {2466, 548}, {2466, 548}});
+    TestOptimalLinearization("8474ad70008474ad70018470ad70028470ad70038470ad70048470ad70058470ad70068474ad70078474ad70088470ad70098474ad700a8474ad700b8474ad700c8470ad700d8474ad700e8474ad700fb83285d734000000000000000000000000000000000f00"_hex_v_u8, {{102810, 19414}});
+    TestOptimalLinearization("a408f07c00832c8c320000832c8c320100832c8c320200832c8c320300832c8c320400832c8c320500832c8c320600832c8c320700832c8c320800832c8c32090083308c3e0a0083308c3e0b0083308c3e0c0083308c3e0d00832f8c3a0e00832f8c3a0f00832f8c3a1000832f8c3a1100832f8c3a1200832d8c341300832d8c341400832d8c341500832d8c34160000"_hex_v_u8, {{27053, 17567}});
+    TestOptimalLinearization("8362861c00da64e1740000832a83460000832a83460100832e834a02008331834e0300832a83460400832a83460500832a83460600832a83460700832a83460800832a83460900832a83460a00832a83460b00832a83460c00832a83460d0000"_hex_v_u8, {{462, 610}, {6330, 11748}, {295, 561}, {291, 554}, {291, 554}, {291, 554}, {291, 554}, {291, 554}, {291, 554}, {291, 554}, {291, 554}, {291, 554}, {291, 554}, {291, 554}, {291, 554}, {293, 558}});
+    TestOptimalLinearization("80df4cacb754009e3d87e13a0180f36aac8350028541808e5803833180867004833180ce0a05971285db6206ab6d8bbe0407854180f21608841280c278099a2e86ce3c0a83328086700ba81f8abc700c857c80ef360d860080fb000e8331809e140f857881922210ad498bfa16118331808e1a1281c806d98a341380d468ad813a148235a4fa741415824180a40015148239d05c1614823ad22017148236d1101714847480bc561714823980804018148235ace32819148331e7681a138236e35c1d11833580d5681e11854480c66a19148236f9301614833280a23e1c0d8331808612181285788187681514857c81a01a1414846681882e1414823a809620151482359ec46414148335f12e151482359392721514854480a5161614847c80f9502b008241e252191382358082122b02833df27e1130857c818b260b338578818b260b31854d80aa041d1105857c819222013d857881aa5403358a7581d40e3100000029857c81aa540133c92091aa5e2a0000000000000000011e823580a6480035a10988bb460103010b0e000000000d00"_hex_v_u8, {{13253, 561}, {707608, 30199}, {996428, 42555}, {743996, 31775}, {16040, 764}, {36126, 1780}, {88603, 4456}, {34788, 1780}, {542102, 27805}, {8393, 437}, {12540, 658}, {8288, 441}, {15563, 833}, {10463, 562}, {132850, 7145}, {10186, 561}, {70262, 3940}, {71837, 4029}, {55089, 3090}, {102338, 5741}, {94072, 5279}, {15387, 892}, {265139, 15986}, {12139, 756}, {8649, 561}, {12789, 836}, {6446, 438}, {6377, 449}, {31027, 2358}, {7319, 565}, {10946, 845}, {10635, 836}, {14131, 1134}, {5328, 442}, {5256, 438}, {5230, 441}});
+    TestOptimalLinearization("846ea73e00846ebc68018540ab6602846ebc68038540ab6604846ebc6805846ea73e06846ebc68078540c33208846ebc6809846ea73e0a8540ab660b8540ab660c8517a9520a0c8517a9520a098517a952030c8540ab660e000e8540ab660e000d8540ab660d000d8540ab660e030a8540c3320d000d8540ab660e000d8540c3320d000c8540ab660e000c8540ab660b02098540ab660e00098540ab660a020d8540ab6601178540c3320e010a8540ab66021b8517c00c01198540ab6609071b8540ab660907178540ab660d02198540ab6609090d8540ab660e021b8540ab660c041b8540ab660a00178540ab660a04138540c3320702168540ab660605178540ab6604031b8540ab660411108540ab6601228540ab6605031a8540ab66020b168540ab66050e108653b72a0a00032800"_hex_v_u8, {{3956, 750}, {3956, 750}, {3956, 750}, {3956, 750}, {3956, 750}, {4377, 832}, {4377, 832}, {6968, 1582}, {17006, 4078}, {10111, 2496}, {20807, 5971}, {2591, 750}, {2591, 750}, {2729, 791}, {2729, 791}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}, {2867, 832}});
+    TestOptimalLinearization("836880d74800836880d74801836880d74802836880d74803834c80cf100303836880d7480403834c80cf100403836880d7480503834c80cf100503836880d7480603836880d7480603834c80cf100703834c80cf10060d836880d748070d834c80cf10060c836880d748070c834c80cf10060b836880d748070b834c80cf10070a834c80cf100519836880d7480619836880d7480516834c80cf100616836880d7480513834c80cf100613834c80cf100423836880d7480523834c80cf10051e836880d748061e834c80cf100519836880d7480619834c80cf10042c836880d748052c834c80cf100426836880d7480526834c80cf10041f834c80cf100334834c80cf10022b887685bb3e0301010b0300"_hex_v_u8, {{316363, 12974}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}, {13320, 588}});
+    TestOptimalLinearization("808934829e280083348c28000183348c28010083348c28020083348c28030083348c28040083348c28050083348c28060083348c28070083348c28080083348c28090083348c280a0083348c280b0083348c280c0083348c280d0083348c280e0083348c280f0083348c28100083348c28110083348c28120083348c28130083348c28140083348c28150083348c28160083348c28170083348c28180083348c28190083348c281a0083348c281b0083348c281c0083348c281d0083348c281e0083348c281f0083348c28200083348c28210083348c28220083348c28230083348c28240083348c28250083348c28260083348c28270083348c28280083348c28290083348c282a0000"_hex_v_u8, {{63216, 41968}});
+    TestOptimalLinearization("80af1a838c0a0080b37b82af76018335854e028335a64e03867cb2760483358a0c0580cd6485e13206854c8f3a0606823586e37207068241894608068750901a0906857cf2400a06823aab020b06824194060c068541bc500d068608f3440e068241a2000e06854ebd420f06823588b41610068500e13e11068241a2501206894480c21413068500905a1406854d8f3a150683368766160683358a0c1306823a983a1306823586bd7e140685458f261506833da17616068242a0341321854dc0641d000a83318a02061d854dc064120d8751901a0124b524808a58091200000000000200"_hex_v_u8, {{128151, 26614}, {4001, 846}, {127437, 27752}, {2535, 565}, {116824, 26905}, {2235, 573}, {1629, 442}, {3323, 1020}, {1347, 449}, {3239, 1554}, {675, 449}, {1133, 768}, {2125, 1691}, {1053, 844}, {9363, 7513}, {1053, 845}, {1043, 837}, {1101, 1105}, {563, 566}});
+    TestOptimalLinearization("818241dbac3c0081c70c809fe6240180d740e79b0c0280eb5af7b4420380bf15cec96a0480fa208081cf4c0580ee2bf89d3a06950d8a8d7e0780c557e3bb7c0881866980839b52098235829f6a090982359fbf3209098335818f5a0a098331818d620b09823596fa1e0b09847882bc280c09823580e97e0d09845081de320e09823592c7020e09847482d4420f0985428291041306824281ec6c1208847882955c12098235a1b3181209863083f66a1309823580fa20130982358fec3c1409823593a460140984788298581608823680dc761609824180d87c1807863d83f32e160982358fc3761709823596ca261709857c82de401809823a80805019098239cb261b088948ce1c1b09a04c90d5682400228449829160220015866083b07022010c845181fa581f000b875183ee50210304857c82f460082186618381462800001e896d849d302500001200"_hex_v_u8, {{1073483, 28599}, {974262, 25978}, {28500, 760}, {1176771, 31491}, {1583595, 42433}, {1276412, 34206}, {1159437, 31072}, {998800, 26825}, {1208196, 32597}, {16080, 437}, {35960, 992}, {25776, 713}, {39912, 1105}, {62800, 1784}, {26220, 760}, {15039, 437}, {26030, 760}, {24300, 721}, {32931, 993}, {14203, 438}, {91071, 2829}, {22489, 720}, {13950, 449}, {17453, 565}, {17329, 561}, {42904, 1389}, {953801, 38788}, {8296, 442}, {4883, 441}, {5070, 1352}});
+    TestOptimalLinearization("a91cb4e81c00fc20809ebc6801a454aef86e02ad6cbad74c03e044fba04e04c020d2950605a004a9893e06a004a9893e07a454aef86e089b38a39a1009a928b4e81c0a8d4c91cc040b8d4c91cc040c81940681dfa368000000000000000000000000000000"_hex_v_u8, {{440910, 5404}, {681347, 8352}, {152386, 1868}, {152386, 1868}, {488998, 5996}, {1017959, 12484}, {344735, 4228}, {344735, 4228}, {392823, 4820}, {392823, 4820}, {296648, 3640}, {1306484, 16032}, {440910, 5416}, {2885940, 35462}});
+    TestOptimalLinearization("836181ba1c0088318bdc580000a34a97cd280000a34a97cd280100a34a97cd280200a34a97cd280300832a82965e0303832a82965e0403832a82965e0503832a82965e0603832a82965e0703832a82965e0803832a82965e0903832a82965e0a03832a82965e0b03832a82965e0c03832a82965e0d03832a82965e0e03832a82965e0f03832a82965e1003832a82965e1103832a82965e1203832a82965e1303832a82965e1403832a82965e1503832a82965e1603832a82965e1703832a82965e1803832a82965e1903832a82965e1a03832a82965e1902832a82965e1b01832a82965e1c01832a82965e1d01832a82965e1d02832a82965e1f01832a82965e1f02832a82965e2002832a82965e2201832a82965e2301832a82965e2302832a82965e2402832a82965e2502832a82965e2701832a82965e2801832a82965e2901832a82965e2a01832a82965e2a02832a82965e2b02832a82965e2d01832a82965e2d02832a82965e2f01832a82965e300100"_hex_v_u8, {{124474, 1810}, {827900, 17978}, {540855, 11884}, {462570, 10222}, {201620, 4682}});
+    TestOptimalLinearization("921a84f92a008312809d6801841280c870028b7082891803945985e91004997e87ad7c0580b815ada40006941185c61807974d86cf62089f0a88f80209926d85932e0a963686a0560b945a85dc400c8d2183b53c0d9c5288972a0e9b4e87ee380f943585d12c108e1183d818119625869b5a128f3184896213911a84d154149305859a6415914284de0816980986e22e17920d84f54e18841280c2061818875c82817a1918854d818c5c1518823583bf4c1518861c818d101717857080d7481718866081cc2017188235fe2c1618866281d13e1518847880e9441518857880eb781318894c82b7781218850df5601018847c80ed601018854d80e51e0f18847480ed601018854280a71e1018850081a50002298d7f84983828000025dd44a5ec3425000025823980ac38014e866081f670022726ac7cc3fd5016000000000000000000000000000000000001042900"_hex_v_u8, {{1679688, 62029}, {24765, 1116}, {21663, 994}, {76772, 3548}, {21328, 992}, {28220, 1356}, {33551, 1613}, {17262, 845}, {790344, 39015}, {15280, 756}, {15280, 764}, {15010, 760}, {12483, 658}, {17288, 924}, {49284, 2640}, {8150, 437}, {15164, 888}, {13860, 880}, {10767, 834}, {7600, 781}});
+    TestOptimalLinearization("836880832c00850d80a738000000"_hex_v_u8, {{19250, 1397}});
+    TestOptimalLinearization("836883680084428f4c01836883680284428f4c03836883680483688368058368836806836883680783688368088368836809836883680a836883680b80a70f80a7100b0b809b7c809b7c0a0a809947809948090b809b3e809b40090b80a12b80a12c090b809a2d809a30090b809c0b809c0c090b809554809554090b809913809914090b809b53809b54090b854e80aa4c091f854e80a13a091c872d9804140111854e80a76a0a1b854e80a44e0a1a854e80a9000a19854e80a1440a18854e80a44a0a17854e809d0a0a16854e80a3140a15854e80a13c0a1484418f4c082e867a80c3560628854e8188060c131f854e81887c0c121d84428f4c033184428f4c0034854e80ea2a0d002c84418f4c012a867a80bc3407062b84418f4c012b84418f4c002984428f4c002684428f4c0023854e80a45003072284428f4c0123886080be340a020427854e80a300050620854ed83c05051d886080be7402090524854ed84600092900"_hex_v_u8, {{38835, 23106}, {40075, 24533}, {37668, 23160}, {110289, 72339}, {1062, 705}, {1062, 705}, {1062, 706}, {1062, 706}, {1062, 706}, {33045, 22510}, {30667, 21592}, {31176, 22039}, {26458, 22359}});
+    TestOptimalLinearization("8a4481f65e008f7783dc7c00008f7783c70801008f6f83c70801008f7083c7080100008f7783bf620100008f7783bf620100008f7783bf620100008f7783c70801019b1686e862000200"_hex_v_u8, {{313375, 18069}, {36913, 2167}, {36913, 2167}});
+    TestOptimalLinearization("dd5096a94c00db479a8f2201de64999944028236809310020285008082080302847c8083020402857c80830205028a5480d9140602847080f950070285008083020802857cfc38090283318c9b520a02823686d3220a02824187b83c0b02823680ad120c028236e65c0d028478fd180e028239c5640f028a5480d91410028a4880d60811028544e5301202854588ba341302847c8082641402823a87f5101402823687ab7e1502823680a1121602823580ad121702823680a7121802833e80c05e1902823ae9161a028241e1381b02850080966c1c0284788083361d028500fe641e02857c8083021f028a4480d9142002847cee0021028578ff7622028a4480d32423028500eb0024028a4c80cf582502833dc52826028a4c80d914280016824185df5e1128823a80ad1211288a4480cf582a000100"_hex_v_u8, {{431706, 13571}, {421921, 14027}, {11145, 437}, {11145, 438}, {11145, 442}, {10761, 438}, {299471, 12673}, {9480, 438}, {12399, 574}, {16040, 752}, {6795, 442}, {6638, 438}, {6300, 449}, {9718, 768}, {8475, 760}, {8449, 764}, {8434, 764}, {8449, 768}, {8388, 768}, {8178, 768}, {8076, 760}, {4530, 441}, {8449, 892}, {8449, 892}, {13962, 1476}, {13962, 1484}, {13962, 1492}, {13962, 1492}, {13764, 1480}, {7104, 764}, {8251, 888}, {13586, 1476}, {13356, 1476}, {6912, 768}, {8028, 892}, {13356, 1484}, {4500, 573}, {6552, 836}});
+    TestOptimalLinearization("e05381ab28008756a16001904deb4a02a2608a900003971e81fb4604f32981e44005f179829b2606a51f80ea6a07e15182bc4208e55583b34e099029ed540a8d7adb1c0b882cc9200c8d29d72e0d9235f6600ef77284982a0f823581ea3c0f0f8235975c100b8600e1000c0f823582ab740d0f8265900c0e0f823581ed660e0f964181f340110d9838829b241609823a80cc6a100f857ceb40100f823580da10110f8474829172120f8235b94c130f8235fb58130f82419504160c82358c76140e82428c76150e85429632190b823980a002130f854480b348140f823580a61a140f80c7638487361e000418809e1a83c44421000000002080cf6484a24207130000000e9121d5361800000003020500"_hex_v_u8, {{91200, 4576}, {48195, 6111}, {29525, 3762}, {28266, 5337}, {79016, 15147}, {68868, 16192}, {4752, 1196}, {1582, 437}, {56602, 16222}, {53282, 15911}, {49862, 15150}, {44115, 13578}, {7082, 2217}, {1410, 449}, {5655, 1833}, {6949, 2253}, {5902, 1914}, {5531, 2337}, {1094, 485}, {891, 437}, {2224, 1110}, {891, 450}, {37218, 20378}, {1497, 834}, {43233, 26724}, {41499, 25699}});
+    TestOptimalLinearization("80d25b87e93a0081fc0b8ef06a01d96182e34002d51082ca6603c36081ee3c04e02a83865e05d43882c72606c24581e7500780a61285fb1a08bc3f81c73409d87582df160ac74d8282560bce0f82a5480c808b3084ec3a0dc57681f96a0e80852c84cc0a0fce1482a54810be2b81d12011833e9c0011118241956e121183158e5013118450a3501311857c80b80414118242956e15118416ad3e1211857ced5e131182419b20141182399c3e1411847480971a1511880fde3414118544bc7614118331977015118336aa7e1511847cd30015118608f34416118449f54c1611854dc40a17118241a2141711844ab62c17118335993218118241921419118a5080b574181183369b4c1911847ca3001a11954880fc6026058451a540270583158e50193d8474808526183c8451a3502800218331aa56123483168e50035983168358005caa17c280442200000000000000000000000000000000002d00"_hex_v_u8, {{1360002, 282751}, {2975, 662}, {1887, 441}, {1808, 449}, {2464, 721}, {1463, 449}, {2344, 720}, {1463, 450}, {2344, 721}, {1856, 574}, {1830, 566}, {2304, 764}, {1689, 565}, {1592, 561}, {1226, 449}, {1000, 533}, {1000, 533}, {1000, 534}, {300, 534}});
+
+    // Hard clusters (according to various metrics) in synthetically generated clusters, with 26-64 transactions.
+    TestOptimalLinearization("826db830008414a23c01744d028723d67e0103845cb0480201846ca1060202802d8b0e030104852dc545040104800e825f040283548424000f830aba39010a8241991402068612d67503030d8360b66301108712eb58070003843b905805040d8449865e05000b8503cd1908040003825ca40b03060204844b8a3c03030313852e8456030404000c834c9d1107000103000b8717b2590a00000200000b8035901106030003000f810c8a1c0a00000003000f862ea7130608000b816aa87706040400188112905b05070a8327bb040d02000000000d844cce410a05010009807994720502040e803c84690a0202020000058061813301050520800e8d6f0906010000001c84288f45090204000100001f820aa37607020206000d8073857c0602091f8539c4120602020502001a8728c826050c01078364c673060c0106832da9030b02020300000000286c877903040a00258466be7b050606000020840e9b7105010a23815f9321080300040002000000867fdf300500000a02002285168b50060008000100010123841ac7210704000200000101001c834d816706020302020000000022845ace070505000000010000000f81419e650207000002002c844eb3520b0000000100000000001582129f1c0b000000020000000008807b98060a0200020000000000038011825908010102000000000100001580378e3006040200000000038561ac27030103020e82459c170002000202000b8336a9420203000000000000000f00"_hex_v_u8, {{3672, 493}, {9871, 2079}, {7901, 1719}, {3172, 732}, {1434, 591}, {1470, 1295}, {734, 715}, {-3533, 9003}, {-3439, 2406}, {-1059, 680}, {-15211, 8262}, {-2491, 993}, {-1297, 351}, {-11899, 3148}, {-1868, 453}});
+    TestOptimalLinearization("823f9b1b00864fa2680182328c07028017890c02038607d0770105864dd04a0205852f80020108801e8c6c0208840aac1c050006813f9b0e010e826b9340040006806b856006000969823108000000870bb1230403010c837cb754040502867f934c0600010983388872050100088549c578060001010f861b812304040109872daf3004050109841f8a3208010100000a86008b0d04000407824ea36902090015850f802d01081881068d7f0501000310862fab02000915827e961f0308000011855ac76f030405028668b31a0202061c8602a81b020700001e82029017010a8351af460105000009801b866601030300010e837aa96602030200010e8420af76020400000008850fb76701000201000014861fc37804000100001000"_hex_v_u8, {{9571, 3032}, {9352, 6065}, {1318, 1023}, {633, 568}, {729, 671}, {7060, 11184}, {-8300, 1641}});
+    TestOptimalLinearization("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"_hex_v_u8, {{2315, 321}, {4683, 667}, {1002, 144}, {4179, 613}, {1369, 254}, {2847, 541}, {2534, 489}, {4242, 963}, {1944, 760}, {832, 472}, {577, 475}, {828, 920}, {643, 967}, {82, 142}, {3527, 21301}, {-455, 904}, {-396, 651}, {-677, 781}, {-381, 398}, {-849, 765}, {-1920, 892}, {-2336, 737}, {-3443, 676}, {-5589, 801}, {-4948, 678}});
+    TestOptimalLinearization("8741984d008704eb3f01815799390281319457038626a424048661dc1705861fbf1106814685750782448178088331af0c098525ae120a8662aa220b816d450c8210a2430d870e9a160e804692290f845690751081158744118029844312871ac2091381589435148520ad471580548441168512d313178422b948188647b82e198267a50f1a81479b4d1b815c8c291c8640a8031d851faa720000000000000000000000000000000000000000000000000000000000001d813587770100000000000000000000000000000000000000000000000000000000001d84268e170200000000000000000000000000000000000000000000000000000000001a815f99300300000000000000000000000000000000000000000000000000000000001783569c6c04000000000000000000000000000000000000000000000000000000000016850fa31c05000000000000000000000000000000000000000000000000000000000015833eac460600000000000000000000000000000000000000000000000000000000001081589c4e0700000000000000000000000000000000000000000000000000000000000c805395560800000000000000000000000000000000000000000000000000000000000b817a83730900000000000000000000000000000000000000000000000000000000000a807e8e530a00000000000000000000000000000000000000000000000000000000000a842ac5360b000000000000000000000000000000000000000000000000000000000009803388160c00000000000000000000000000000000000000000000000000000000000785069b4d0d000000000000000000000000000000000000000000000000000000000007831b9e0b0e000000000000000000000000000000000000000000000000000000000003803989220f0000000000000000000000000000000000000000000000000000000000038663ca511000000000000000000000000000000000000000000000000000000000000383789013110000000000000000000000000000000000000000000000000000000000028418907f1200000000000000000000000000000000000000000000000000000000000286178422130000000000000000000000000000000000000000000000000000000000028072935e140000000000000000000000000000000000000000000000000000000000018222825e1500000000000000000000000000000000000000000000000000000000000000"_hex_v_u8, {{3748, 674}, {3078, 561}, {3671, 967}, {3017, 805}, {2769, 994}, {2386, 934}, {546, 277}, {1739, 1038}, {188, 452}, {-35, 365}, {-443, 326}, {-27524, 18833}, {-1152, 664}, {-1098, 632}, {-572, 309}, {-1831, 774}, {-1990, 539}, {-1002, 254}, {-4841, 995}});
+    TestOptimalLinearization("814e9f7400857edb66018043813402821fa96e038608bd4c048348bc2d05815ca33c06833387610780068b7408842ca841098059823d0a835382320b85418e4b0c84079d380d814b93520e83218a1a0f816b83491084088a4f11802e910512810a8e67138418c1541480408b2715845aaf6d1682529e5c000000000000000000000000000000000000000000000016837e88730100000000000000000000000000000000000000000000148733ce200200000000000000000000000000000000000000000000118279913c0300000000000000000000000000000000000000000000118276af0204000000000000000000000000000000000000000000000f80598c2405000000000000000000000000000000000000000000000f8734e31706000000000000000000000000000000000000000000000e804b803507000000000000000000000000000000000000000000000a85308b320800000000000000000000000000000000000000000000098418c039090000000000000000000000000000000000000000000008852898740a0000000000000000000000000000000000000000000006807596680b000000000000000000000000000000000000000000000585389e3e0c00000000000000000000000000000000000000000000058612cd260d00000000000000000000000000000000000000000000048338a41c0e000000000000000000000000000000000000000000000486068d430f0000000000000000000000000000000000000000000004806595121000000000000000000000000000000000000000000000038719de681100000000000000000000000000000000000000000000038301ab6912000000000000000000000000000000000000000000000380158b2b1300000000000000000000000000000000000000000000038138844b1400000000000000000000000000000000000000000000038465cb1615000000000000000000000000000000000000000000000386768e491600000000000000000000000000000000000000000000028072920f17000000000000000000000000000000000000000000000200"_hex_v_u8, {{2334, 348}, {5939, 894}, {2743, 415}, {4266, 664}, {2106, 334}, {826, 134}, {4006, 904}, {1321, 331}, {1948, 647}, {22824, 14732}, {793, 816}, {-91, 203}, {-997, 1014}, {-634, 638}, {-930, 902}, {-358, 312}, {-1224, 242}, {-790, 149}, {-2869, 513}, {-6412, 1076}, {-4189, 664}});
+    TestOptimalLinearization("84648d7e00851fb02200018604a232010185649025020084139c5b0300863fc31200000384248d2d010003843d822e020002816f9c360400018432830704000009851fa258060000048045826d060001008618c665070000000881138c4305010008825497140305038263985006030002845e9d0404030000000c8140884a010402000986549e79030401000380198b7c03030001011382409164060300000011831598630701000000001181778c2b070200000000000f82118565040005098464b735040300000000007b8863010501001181229368020501000e82039006000300038014817f010001000000000003804e8d080100010000001b00"_hex_v_u8, {{4112, 1539}, {2265, 900}, {8705, 4603}, {2414, 2781}, {76, 1413}, {-1707, 2591}, {-854, 375}, {-4513, 1397}, {-3611, 740}});
+    TestOptimalLinearization("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"_hex_v_u8, {{4584, 725}, {4364, 762}, {1750, 317}, {4185, 1078}, {1232, 326}, {683, 183}, {408, 114}, {1745, 1029}, {198, 189}, {18555, 18373}, {188, 267}, {96, 292}, {68, 257}, {-196, 469}, {-630, 604}, {-774, 712}, {-203, 165}, {-1478, 974}, {-291, 180}, {-1945, 470}, {-738, 172}, {-3548, 702}, {-755, 134}, {-2029, 359}, {-1206, 186}, {-1582, 220}, {-3524, 460}});
+    TestOptimalLinearization("832a8e4f008160850201854bbe4e0283429e1e0382558b2404872c937d05831593610672801d0780088b0c088708a5330982159d510a865db6010b83618d160c8526b8030d824f89520e813090590f80598d62108637b42a1181348e6d12863eb44a13863bc76d1483329779158543b65816813d9a141781198f4618810d934d00000000000000000000000000000000000000000000000000188319ad1601000000000000000000000000000000000000000000000000188634c8740200000000000000000000000000000000000000000000000017826087340300000000000000000000000000000000000000000000000011830d82050400000000000000000000000000000000000000000000000011860b8356050000000000000000000000000000000000000000000000000e807c9141060000000000000000000000000000000000000000000000000985349100070000000000000000000000000000000000000000000000000100"_hex_v_u8, {{774, 136}, {1738, 317}, {4071, 843}, {945, 217}, {3564, 835}, {1059, 281}, {3413, 951}, {3429, 958}, {1999, 578}, {786, 469}, {907, 609}, {681, 463}, {385, 352}, {-79, 114}, {-14191, 11733}, {-1185, 252}, {-1319, 269}});
+    TestOptimalLinearization("806c883b00852cb52d0184028f590285248a01000584149e6d0203872de672040284648f2905028554b02800000b8637b471010006860ca51a0402028405a80706000009842ebb39020307845d814d03030006817da346040300058453a9760700010003835c8f680309804a8f0e070200108739ae4c070200010580588310090002000382738e6f090200000c8559c940040501000d87198e190005188417a5560202040e816e803203010600098112956402031d8450a5700a000000000100188117981f0b00000000010013820ba5100406021a8311b240080201000101188060933d0106011b846dc679050301030b840db86c000b0b83619c26080003000000000e842a93440c0000000000000000068675cf6a070005000000001d817b92730307000000178608ac780401001384158255070301000000128449b62709000000000100108124824f020800001e82059501000201000000002281398258020100000001000e00"_hex_v_u8, {{6043, 1305}, {2111, 1592}, {16829, 16660}, {2522, 3629}, {-232, 292}, {-1546, 885}, {-4578, 1405}, {-1409, 389}});
+    TestOptimalLinearization("853d9a0300872ce27c01855dc769028042831b0380268234048670b972058159931a0109815b9c66040782548d5d000b8263ab21020a805f86510401088261ab3b06000204811e816802060a8070805704050a8701ad740501010c852fb83f09000001000880538b4c0305048510c24904000a85479a3b030302128413b0290207078409aa5d060500000480518a4103090a805f8413080500000009841ead02040f80058173001b842d802d0903000002098448a96004030617841aba6a09000012835c950c030b011783099f700211840eb8440502080d810e8f79040a010f81588229020704058040080500050302068619a95d0d0003000000068440a122060a010000068518a070030a04248177957b05090104855cca650802040420830c850508050401010d8348a8690206022e71871f000104020728870ec35d020001000000000200"_hex_v_u8, {{6398, 1068}, {3769, 1008}, {1511, 511}, {6, 7736}, {-2660, 6557}, {-1198, 1987}, {-717, 747}, {-2735, 921}, {-2555, 645}, {-2677, 584}, {-9778, 2011}});
+    TestOptimalLinearization("80278170008458b93c01840e9c220284358d1b0377800c04871ca3470580338c00068219a40807861f9b4f088200977309810a847c0a82398b2e0b814e9b760c8177915c0d8657a5360e872ba73a0f81290810847db55111854cae4300000000000000000000000000000000000012852bbb420100000000000000000000000000000000001181168d270200000000000000000000000000000000001186049933030000000000000000000000000000000000118304a5550400000000000000000000000000000000000f8338926b0500000000000000000000000000000000000f853c830e0600000000000000000000000000000000000f8530ba630700000000000000000000000000000000000f853191580800000000000000000000000000000000000e870d85570900000000000000000000000000000000000b827e83180a00000000000000000000000000000000000b874abd420b000000000000000000000000000000000008803689030c000000000000000000000000000000000008826287720d000000000000000000000000000000000007836daf3b0e0000000000000000000000000000000000078678ba550f000000000000000000000000000000000006855e877610000000000000000000000000000000000006815385071100000000000000000000000000000000000681200d120000000000000000000000000000000000058350af75130000000000000000000000000000000000028713db5e140000000000000000000000000000000000008257813b1500000000000000000000000000000000000000"_hex_v_u8, {{2372, 409}, {1851, 334}, {3742, 728}, {832, 179}, {1198, 375}, {1873, 654}, {2459, 983}, {2589, 1067}, {791, 441}, {382, 266}, {184, 167}, {6046, 9350}, {268, 510}, {263, 828}, {-7, 288}, {-158, 471}, {-428, 1037}, {-388, 339}, {-1690, 900}, {-1270, 568}, {-916, 278}, {-642, 182}, {-3042, 844}, {-3819, 1016}, {-3826, 816}, {-2475, 516}, {-3102, 621}, {-3131, 592}});
+    TestOptimalLinearization("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"_hex_v_u8, {{7128, 1003}, {1584, 223}, {4155, 641}, {4115, 666}, {4415, 919}, {797, 210}, {3016, 970}, {677, 355}, {1212, 857}, {878, 867}, {327, 975}, {111, 369}, {-1440, 17399}, {-303, 893}, {-339, 488}, {-586, 825}, {-1001, 633}, {-1284, 732}, {-510, 281}, {-438, 203}, {-745, 340}, {-2403, 806}, {-925, 266}, {-4294, 1052}, {-4252, 993}, {-4536, 885}, {-5353, 964}, {-7198, 1072}});
+    TestOptimalLinearization("83158670008454b00201853eae2100038357ac07010384369d5c02028429822b0007801e887b010482216f050001800a877a0600008603a0410403800c873105000c8559ab0c040886199159070001038374b0290103108050807c0205010a830cb359040003010e8413926f04030107807c85220703000000058631af6009000001000a8637a46305050185609360070102000110846cc57b08020100000d6587160805000a8240a87007020201158551874806040101128177974c03080d84368c5f060400041a8559905a040204000c8422903002070513850ead0c09000401001d853dbd51070202020101018574d03d060009001c8104885e0c0200010103867b853c050007010b8158803c00090301118019847605060001000100038361ae5807020202000000058566ac5a0401040100010101835b854f07010000030001098237a37c0402010002001986608e5102040102001f855da12f0201000000010000"_hex_v_u8, {{3137, 724}, {1966, 694}, {2184, 1015}, {1077, 671}, {-56, 417}, {-4305, 19152}, {-424, 603}, {-2200, 861}, {-6216, 1876}});
+    TestOptimalLinearization("8711d24400834a8e460180458b4302841fbf3200028025883800068672d2640104841fc210020104856fbd3001078039820e050000018175930b03038174915d070000008469864b011086248a4004098475a8040701000a844e925c080000000d8157a0540302108442c13504020f8162895105020685169902050401128559c2360101020b81568a5207000300028427c340060500001180118d520400000204137a835c0901010001118318ad6606010204000a847c8f39050805835da52600248455cb19050206048400b27b010c048604b97b0302080a842695560024835f96790002158530bc2f030703038365a02f012d807481580800040003001c801e851e01218631a40503050004218535c7030405000413800e82080202040602846ec55f09020002000000000017831fb37904020104000000001f85588150030005010101000885449c3d0600010400000f872e8f3f080101000100000e804a825106000100011e81619a5c03010200000c80118b1301010102002c00"_hex_v_u8, {{5346, 1041}, {12977, 2549}, {3992, 879}, {604, 165}, {9466, 2925}, {10459, 5394}, {1398, 1369}, {-5465, 2673}, {-3270, 1378}, {-25877, 8528}, {-4167, 688}});
+    TestOptimalLinearization("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"_hex_v_u8, {{7621, 1016}, {3067, 429}, {5953, 838}, {3365, 481}, {1165, 177}, {4390, 676}, {4241, 770}, {3694, 826}, {880, 197}, {1746, 492}, {2419, 699}, {2891, 1040}, {2540, 1008}, {32264, 19146}, {945, 606}, {202, 989}, {-244, 394}, {-556, 703}, {-1018, 1057}, {-566, 469}, {-1564, 1000}, {-2434, 921}, {-2446, 631}, {-2401, 588}, {-6088, 956}, {-3397, 515}, {-6952, 1035}});
+    TestOptimalLinearization("805683130081759877018501ac560282608b1e038703b72f048554861d058445a50606856db672078359a70f08864abd4f097e86010a806d82030b82048b470000000000000000000000000c8712ce7e0100000000000000000000000c8470947b0200000000000000000000000c840e9d100300000000000000000000000b84539e0e0400000000000000000000000a8613b00b0500000000000000000000000a8346863906000000000000000000000009863ac27507000000000000000000000006870ebe7f08000000000000000000000005860d842109000000000000000000000005845589030a000000000000000000000002845588460b00000000000000000000000180198b490c000000000000000000000001812b972b0d0000000000000000000000008328a3770e000000000000000000000000872fa0700f00000000000000000000000000"_hex_v_u8, {{3577, 877}, {2923, 769}, {2435, 709}, {783, 480}, {-1399, 8615}, {-337, 909}, {-477, 582}, {-642, 725}, {-1406, 752}, {-804, 388}, {-3142, 915}, {-4096, 1038}, {-2364, 552}, {-4347, 954}, {-1558, 299}, {-805, 153}});
+    TestOptimalLinearization("8327982d0080608f67000085299d2a0100847b8207020082769438030082479f0b0202822a996a01000887298a350100098432a61f010883029b5b04000006870ec96a03048172812b03010008824d916f010102000c833aa8040110801a847f0402000002832c862104000000000a873d9c060202010383208e7803010110815d1101041268870f050001851254010e8124804a020411822c9028060001000e866d8a77030105836ba27e001a8503890804030116857b8f620110850ba7510008188704b103010201001c857cc54f000001000000"_hex_v_u8, {{8000, 4089}, {-935, 11933}, {-3202, 1028}, {-2601, 779}, {-4520, 892}});
+    TestOptimalLinearization("8678e51700857aca3901844ab2170282049f5f038003895f048638b6740405861f7e0208804491420206842e83130301078100901e02010b852bac6104030281759b31030301058533a67d02098275aa0108000000028178865107010001098336942a02050f841d99450305010e8501ba150304010a820b853205040a836eb53c060501057a83340904000004815e846b050416820d852b03090e845ebb310b020100000b8702835d0212815f9044000d09867ea171001e80359138020705178106880e09010000050f864fc97c040504011683109034030b010b824c8737080202000300000e847d8045090202000101000d835587720507030018862c9d00060500050b820587090608030000008461a5000103020003208601ab780106010102000183069130010305058734844f050200010100000004872fdb12050000000102000100078313ab200203020000248404a92503000101000100"_hex_v_u8, {{497, 327}, {-4592, 24583}, {-360, 1076}, {-2707, 644}});
+    TestOptimalLinearization("87139152008053853701864db30c0280338815038544b2040486788f4f05841e841e06862ea22907823d8f150886706f09837b872e0a830e9f7f0b8465c07b0c831eab0b0d810d825d0e832b81100f8435a76a108602b63811810f897c000000000000000000000000000000000000118445b63d01000000000000000000000000000000000011847fc24c0200000000000000000000000000000000001080558c3f03000000000000000000000000000000000010861fbd0304000000000000000000000000000000000010871fde1805000000000000000000000000000000000010815c93240600000000000000000000000000000000000f8726b74c0700000000000000000000000000000000000e817c823b0800000000000000000000000000000000000e865e8c220900000000000000000000000000000000000c8309833a0a00000000000000000000000000000000000b8000854d0b00000000000000000000000000000000000b83049e620c00000000000000000000000000000000000a82619d510d00000000000000000000000000000000000a870899120e00000000000000000000000000000000000a7d670f00000000000000000000000000000000000a8354a83c1000000000000000000000000000000000000a8159941111000000000000000000000000000000000008821da75e12000000000000000000000000000000000007807c8f6013000000000000000000000000000000000007835d840f140000000000000000000000000000000000038212a00a1500000000000000000000000000000000000383039a0c160000000000000000000000000000000000018605c2501700000000000000000000000000000000000100"_hex_v_u8, {{3548, 898}, {3266, 836}, {2613, 693}, {3334, 973}, {21647, 16912}, {849, 990}, {285, 521}, {-52, 125}, {-328, 605}, {-222, 380}, {-423, 128}, {-1353, 345}, {-864, 213}, {-1961, 481}, {-3970, 927}, {-3551, 709}});
+    TestOptimalLinearization("8225830d00801c874a01832393380281088e7c038600d033048639927a0581249631068324b3150782649f4c08816840098527b34b0a802c816c0b850a8f040c866cc57e0d811b90350e801a8d5e0f80308c2710810f917011800b835f00000000000000000000000000000000000012836ebc6d0100000000000000000000000000000000001281659b6c020000000000000000000000000000000000128375980a030000000000000000000000000000000000128746857a040000000000000000000000000000000000128170960d050000000000000000000000000000000000118025825f0600000000000000000000000000000000000d810098330700000000000000000000000000000000000c8572b06c0800000000000000000000000000000000000b852da800090000000000000000000000000000000000098427a87c0a000000000000000000000000000000000009806c83380b0000000000000000000000000000000000098470bd020c000000000000000000000000000000000008852b845c0d000000000000000000000000000000000008825f6d0e0000000000000000000000000000000000078151902b0f00000000000000000000000000000000000382369d1d10000000000000000000000000000000000003835f8a7e11000000000000000000000000000000000003855f864c120000000000000000000000000000000000038640bc4013000000000000000000000000000000000003861fa83e140000000000000000000000000000000000038447ba3e15000000000000000000000000000000000003802c8e54160000000000000000000000000000000000018653d11b170000000000000000000000000000000000018638cb2518000000000000000000000000000000000000866fbb471900000000000000000000000000000000000000"_hex_v_u8, {{943, 154}, {4543, 1004}, {1208, 271}, {2086, 484}, {1022, 264}, {549, 156}, {1308, 547}, {1277, 953}, {1026, 778}, {12943, 11680}, {486, 863}, {366, 811}, {445, 1094}, {-55, 479}, {-240, 165}, {-304, 139}, {-1110, 337}, {-3876, 1007}, {-1479, 368}, {-1935, 438}, {-4883, 952}, {-5262, 979}, {-1626, 256}, {-3959, 622}});
+    TestOptimalLinearization("813c865a0080178a6f0183449e0202836ca622038446c40d0485028e6e0405816fa17203026c865604028419c03b000e82148c0f0500098351997a070103861b9f0405020a8542a07b07010002861383700111832e89530111860a830c000c8342b138020b810e97660704000006821ba6330803000008855fc612050401000d8028915e03040308832cb03c0a020000000000048509c97d0605000100118167820f07040200086586710703010000000b85762804080104851dcd4105050217854acb3a0a0301000000000f8514976b04080c83449a100808000009874485630b000102010c85799c750d00020001001b80368d0f07030005098259a0700c00000002010a8056876b050b0000001581328a660e0000000100001b807f800405060600098569850a0307050012860a933506040003000200058463b22f09020004000000000021805188430401020602188052853305010203020204824b9e150c0001000101000000248114842c0501030101030a851d944c0503010300238449a2560a0201000000000000000023844ea548070700000000000f8277ae15020700011981479a7e070500000000000000000d81339c5a070003020000000000000016867395490702000200000100001080278938030302000100007a81150400020001318457b11200010201000002827fb116010000010000002300"_hex_v_u8, {{4709, 1055}, {2513, 620}, {2218, 909}, {6605, 3186}, {6218, 3702}, {703, 1507}, {20, 886}, {-2372, 6067}, {-10262, 12450}});
+    TestOptimalLinearization("803a8f330086548209018265ac21028521bf2e0104800b844d02018321a05d0006835e933e040003835792230400048047865703068201a07d04068662a16d0308865ad476000e8431bb620200020b8264841503010c8625ba5704000209837d9d52021686378e68020e837b8174020e840e80590301060383329a4007020100118262885c0305010a834d8d2a02128133964d0600040d8437ac2a0503040005816b810705020419840cb2440d00000100000b865ad07005030003118419ae21060201030586748076060005000c80068a0e050103030006870dc31208020000020010863bc91f060100020301000a80218b4f0400020d817c8e6f080100020201000880108c4f010d1b834db0320607000017841ca15c0500040000020478853200020100000000001300"_hex_v_u8, {{3922, 1781}, {3529, 2772}, {16566, 14073}, {579, 1338}, {-1016, 380}, {-7368, 1740}, {-808, 161}, {-872, 144}});
+    TestOptimalLinearization("83049f4a0083539553018011896b02843fae55000583309e310201841ba76701028628b504010204850ea4570009820c846d030000078451a60303010006802c8877030203857a9e280304805e857005010c83798c7001050c8441811d0403018550bd5f0305008636c9210701000e846d9e1d010311821d933c06020006847e961a0503000a7a8945060200148610bf4d0115842fa97b0402040476841c010716872d28040201058631a10a0104001a81579d3a060001000100001681078c43020401011b8438844406000001000000000f83678264070000000000000c820c8800040101010017814c9103030300000011840c912200000000001200"_hex_v_u8, {{2085, 516}, {-1, 2091}, {-214, 2450}, {-2803, 3167}, {-16800, 11295}});
+    TestOptimalLinearization("8600ce6f00678071018613875102865ed14301000384579a0c010103854cbe730201028376900f03010278810703068355833202058354ab7e03000b844b9a370402098269a4780303068300a66e020001010c8519a4670300020a84319c090600000007698027030204872ac12f05010100000782369e5106010000000f82549d5006000100000f845b9a7b0601010c8536a42e0601000b8325b33a0503010006826498040400050d80488e5702158206906e0702020b6b86170b000100088745ad1703108406aa3b03090e823b9117010b01821394500107148626c44e0b00000001000f82019f2a0103030001128153900a040401000000000d866bde1c03060000000d80548e180503020001068455a7100604010000001e867fd30e0a00020000000000058505891f060101000000000004840b9d3a0303010000000000268631bc12050100020000000500"_hex_v_u8, {{9901, 20654}, {1369, 3124}, {-656, 773}});
+    TestOptimalLinearization("851a8e58008454b44d01841a8c2902856eb42e0380314404841bbf4b0582368b3a068067897407823ca94d088420823a098555be160a823a87700b835086700c8350845e0d8747984d0e8137870c0f810f8006108417ab0911842fae6c1280358071138571c674148734d83f158327aa76168228892a178706d45018821e97001983479b591a826ca46b1b856daf59000000000000000000000000000000000000000000000000000000001b8428b309010000000000000000000000000000000000000000000000000000001a826f9021020000000000000000000000000000000000000000000000000000001a86729e61030000000000000000000000000000000000000000000000000000001a8643880604000000000000000000000000000000000000000000000000000000158646cc0e0500000000000000000000000000000000000000000000000000000012846e935e06000000000000000000000000000000000000000000000000000000128551884f0700000000000000000000000000000000000000000000000000000012811e9836080000000000000000000000000000000000000000000000000000000f82308c66090000000000000000000000000000000000000000000000000000000d865ea4640a0000000000000000000000000000000000000000000000000000000884269c770b00000000000000000000000000000000000000000000000000000008831d80570c000000000000000000000000000000000000000000000000000000068531b4620d00000000000000000000000000000000000000000000000000000005865e92390e00000000000000000000000000000000000000000000000000000004855f892d0f00000000000000000000000000000000000000000000000000000003863c8b0110000000000000000000000000000000000000000000000000000000038374aa22110000000000000000000000000000000000000000000000000000000381078e2712000000000000000000000000000000000000000000000000000000038153932c13000000000000000000000000000000000000000000000000000000018321ad5814000000000000000000000000000000000000000000000000000000018318ba1b15000000000000000000000000000000000000000000000000000000018469a57516000000000000000000000000000000000000000000000000000000018310854e17000000000000000000000000000000000000000000000000000000018543a57e180000000000000000000000000000000000000000000000000000000000"_hex_v_u8, {{5480, 1030}, {4602, 881}, {2811, 551}, {4043, 853}, {3062, 687}, {3415, 878}, {1536, 414}, {698, 231}, {797, 438}, {518, 311}, {661, 424}, {568, 442}, {1004, 794}, {504, 592}, {367, 592}, {221, 672}, {67, 271}, {34, 177}, {-526, 14670}, {-108, 541}, {-616, 849}, {-663, 863}, {-769, 956}, {-1245, 990}, {-2033, 1010}, {-1105, 495}, {-1916, 678}, {-2491, 745}, {-3117, 877}, {-980, 263}, {-3333, 680}, {-3790, 536}});
+    TestOptimalLinearization("82549265008464d27c01866ab47902837da12a0380368f74048738dc4d05842e8b3b06853dc84a078661ab22088454a16b09865f957f0a8279ab2b0b837b84050c837dc31a0d837db5180e7b816f0f8346ac4310800b883d1180148709128349a63c1380629800148638ae3f15802c8b59168223ae4117801d8e1718812f893319853bdc3b1a841caa5b1b8354aa55000000000000000000000000000000000000000000000000000000001c870abd4d010000000000000000000000000000000000000000000000000000001b85768103020000000000000000000000000000000000000000000000000000001a801c8861030000000000000000000000000000000000000000000000000000001980658e150400000000000000000000000000000000000000000000000000000019826da47005000000000000000000000000000000000000000000000000000000198100884506000000000000000000000000000000000000000000000000000000188528d056070000000000000000000000000000000000000000000000000000001880718a5d08000000000000000000000000000000000000000000000000000000178677ba060900000000000000000000000000000000000000000000000000000017815889110a00000000000000000000000000000000000000000000000000000016813187200b00000000000000000000000000000000000000000000000000000015804a800a0c00000000000000000000000000000000000000000000000000000015847a81550d0000000000000000000000000000000000000000000000000000001486799e420e00000000000000000000000000000000000000000000000000000013835cb8120f00000000000000000000000000000000000000000000000000000012865ff84910000000000000000000000000000000000000000000000000000000118403ac6111000000000000000000000000000000000000000000000000000000108656db361200000000000000000000000000000000000000000000000000000010815da06013000000000000000000000000000000000000000000000000000000108740f30c1400000000000000000000000000000000000000000000000000000010843ad1361500000000000000000000000000000000000000000000000000000010806a92421600000000000000000000000000000000000000000000000000000010874acc3017000000000000000000000000000000000000000000000000000000108001897218000000000000000000000000000000000000000000000000000000108213a100190000000000000000000000000000000000000000000000000000001085159f141a0000000000000000000000000000000000000000000000000000000e806288681b0000000000000000000000000000000000000000000000000000000c842d86401c0000000000000000000000000000000000000000000000000000000b860bb3081d00000000000000000000000000000000000000000000000000000008814ca17f1e0000000000000000000000000000000000000000000000000000000680418c4e1f00000000000000000000000000000000000000000000000000000006820e98212000000000000000000000000000000000000000000000000000000006856db851210000000000000000000000000000000000000000000000000000000300"_hex_v_u8, {{5374, 740}, {1600, 226}, {4365, 637}, {1082, 182}, {4709, 829}, {3468, 637}, {2526, 585}, {2197, 637}, {2833, 993}, {14949, 22604}, {69, 202}, {-130, 886}, {-171, 762}, {-649, 344}, {-611, 256}, {-751, 241}, {-4007, 1034}, {-625, 156}, {-1617, 398}, {-3689, 877}, {-971, 229}, {-2929, 643}, {-2795, 596}, {-2240, 332}, {-7781, 991}});
+    TestOptimalLinearization("863e9b20008701a22e0182579614010281579c03010381008737030180078e2603028345911504028417a101030981318d650508867b9a11070006823c924f0105058647a60b050101058579a75b07010001861bdf4c060001010c834e841d0700010106855dca03070102008633dc7f03060d8654bf39090000020c854bc4370802000103846aac180c000100018058811e03138727b30b0a0200010a845a902206050104804191120703010108844cc60f030b00188530b810090000030d8434be3403070d833fad1b00298038953206051d801a520606000f8216a05a030b218007891e020911815b9716030b0b867ab553050709802391740f030000010007817896370d010003000200168041880803080518816ea42a050902040e872d8a09080200050302000e8576960e050b010400098330bb6e0c06020200098418ad6a1002000300000000148704c07008020405030011851f8657060d040e8619be7016000101000000088559d32c0213078307891a08040a00011e8313b627010c0104001e853ad64004070300051b815d834205030c038423aa3904040701030001128155a3390f000000000500308262a43b0a000107010b8136861d0505000701010f82359b1307010005000401001e8028841605000603010200002981679d16030705000300298710cd6c080601010000000101308055803e0802040100010002001681758e2a090400010100000100258741ac0d0a00030001030000000680738e2c06020500000001001783629a68020703000001098707dd08000001030000001000"_hex_v_u8, {{3242, 1160}, {9343, 4022}, {7247, 25626}, {-574, 1753}, {-2604, 5019}, {-2887, 1089}});
+    TestOptimalLinearization("83638b0300845bac6801871ac51d028278937a036a5004855494040405814883580405872dd30f030203816f9009030301856bb80f0501000684008658030406805380100400068632a8520500010b80658e2f0403010580068a340702000002845cae500802000000806b8c350400040584319f5a0900000000086f827c09000100000184627b06000004038341844d0603000000001181208d070502000102048043760600000200000010862fad260603000000000a817786690402000003000e84059e410305020004861eb63a0401020001138016862600080486419756020500010008833ca46f04040000001182019658020000000200000800"_hex_v_u8, {{2932, 731}, {1341, 504}, {3541, 2737}, {492, 640}, {40, 106}, {72, 211}, {-779, 2654}, {-2914, 8443}, {-359, 577}, {-2424, 572}});
+    TestOptimalLinearization("8015812700866ade5401811c8f7b028442ac3003866fc73d00058220984901048676c4440204813194740500057b8b1b060005845fa71e050106837bb34d060003853abd55070001008519ab1102030e824f94580602000a8405b15c0403020b806a8b78040303088724be690603020380708230080003000d851f9b5d05050000008674dc540401050011864f9652060200020110841c8a61090001000101832c8819060303000005814b9c160601010400068109885a06050002018304b203050001061686419e69020b00128638c97d0a010100000000000018856dc2060302080000028419b54c0307030781568573090300000000000000028428a7150702000100001d864db25f020207000a85409403000700000018822f920c0300010201001483409a1a0501000100000013856ac8200400010000010011803e8f620500000000000019836692540302000000208548895a00000000000c867ecc2801000000000a00"_hex_v_u8, {{6122, 1002}, {7354, 1720}, {2575, 735}, {1254, 454}, {1609, 1061}, {302, 747}, {-6224, 20869}});
+    TestOptimalLinearization("8677a44400823d9b1101847c893e0102831ea2130201865b944502028560ac640301856cc01101088644cc2c0302867ea77d0008843d8949040202843a9d0307000081528f5707000005804e8c5b0403000585169c7e06000201834e8e0d0503000d835e96250500000f8628a9550104078018847d0302000201821f90780301000002000681648442030103028433976b070000000000000e844a9116040202000d82349016000880158b240600010100108006831101060001850bb04e0101010100088723835a010002010c830593360203000003811a8e150400000000001c7f8168010000001300"_hex_v_u8, {{2402, 1015}, {2700, 1506}, {671, 764}, {1129, 1309}, {-7302, 12461}, {-1410, 818}, {-971, 282}});
+    TestOptimalLinearization("8744ad0c008552be55018377a07f02844ec32802038655a103020482109b72020006867ee92c030006847fb879040003867cc5770301098620c77d06000001834e9c6b050102831ea745070000048736e7040309854bb64e04000a82129d600303068327847c03060c81749e6a0604000c8616af13070400008062915d08010200078007880206030301823e815106000609862ab9220502178451b018080000010c82469e2a0803000001058579c33c090000020116852f8b210704000001068168a05d04070001148616c21d0801020001000e8327991f05000f8025860a0b000002010003862f8a250c00010100000b8002480a00010002000b801f877005000600011e8539be10010b011c8341b558060302000001001a83758b0c09030000000000038738d71b070500000000010000088527c943070005000001001d81789e5204060300001c850eb12a0b03000100000000058676d84b0602010103000b834aaa310202020001000100001c8425af0c0302020001000100000d8107942e02010201000200001c830f9f330000000002000012830ea4700200000000000000000d00"_hex_v_u8, {{7322, 1810}, {2404, 2903}, {8842, 11211}, {4511, 6807}, {764, 2139}, {-1680, 551}, {-4367, 1277}, {-10769, 2999}, {-2074, 527}});
+    TestOptimalLinearization("82159935008379b66e01830bae7202803d87690203826ea53b0302821a993303038408b52a0502864de64005028326bc7b050106827a9b050508842ace1c010f836f966204020865810a080106816ba5640703018270844306010301851f8e69050201000d8500866c0505000b8357ac7d040500098542881e040109822f8451050303048257985708010400028555bd29020e8116875e0603010211865c9f0906010408846db41b0206050786259654050503000011855ac662080300010100068655c91b020910830bb7540d0000020000000d8563da4d0e0000010000001481148d1f0e010000010012831193360a000004010a860ece440807000100068402b614060404020e8712da6e06080001028377997c070401040000018224a23c040800041e805f976e0c0201000200018655e22305060501088656a83c0801000401011e8248a140010a02002385633903010703011c80528207080302000200002780038e130c01000300000000268421330701020103010b800682590a0102020000001f863ca66005050202012b831fb146070300000202000024834c9f5d060003000100010d840dc01a040201010319857a8a2606010101000001000009824f814701040301136e876d05000202010000000c871cad4d0107002c803d884203000402008446cd4e0000010000000d00"_hex_v_u8, {{10199, 1606}, {3065, 523}, {1786, 1053}, {1089, 913}, {792, 773}, {1104, 1232}, {13868, 19409}, {-4512, 8170}, {-567, 110}});
+    TestOptimalLinearization("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"_hex_v_u8, {{1532, 222}, {2915, 429}, {697, 126}, {3528, 696}, {4357, 912}, {4628, 1011}, {1679, 380}, {1411, 343}, {4387, 1081}, {415, 106}, {2696, 766}, {3104, 890}, {3306, 1007}, {672, 389}, {411, 244}, {296, 219}, {906, 713}, {134, 132}, {-227, 896}, {-3629, 13571}, {-188, 691}, {-356, 844}, {-500, 1083}, {-468, 910}, {-1696, 1065}, {-899, 558}, {-330, 161}, {-2614, 797}, {-3343, 867}, {-3385, 863}, {-3047, 706}, {-2051, 404}, {-2043, 324}, {-2980, 458}});
+    TestOptimalLinearization("8063850a0084718e1f018627d96c028369c06503842ec7070480158a0505853fbf200683719c3e07806f906a088611df4e09816fa0570a863e94760b800485030c8307b4590d8642e7400e8459bf1d0f803461108259aa03118671ad171280708651138257907e14821986091582203b168527c013178315aa081880558e67198664c5511a872afc330000000000000000000000000000000000000000000000000000001b863b8d480100000000000000000000000000000000000000000000000000001b847f81610200000000000000000000000000000000000000000000000000001b8526852d03000000000000000000000000000000000000000000000000000018857d901b0400000000000000000000000000000000000000000000000000001884238e240500000000000000000000000000000000000000000000000000001885049c610600000000000000000000000000000000000000000000000000001880401a070000000000000000000000000000000000000000000000000000168349a2100800000000000000000000000000000000000000000000000000001581539c5f09000000000000000000000000000000000000000000000000000015810f96030a0000000000000000000000000000000000000000000000000000148406b8190b0000000000000000000000000000000000000000000000000000138005801a0c000000000000000000000000000000000000000000000000000013863c99570d000000000000000000000000000000000000000000000000000013842ea1130e000000000000000000000000000000000000000000000000000012810b8a5e0f000000000000000000000000000000000000000000000000000011861c8474100000000000000000000000000000000000000000000000000000118117903911000000000000000000000000000000000000000000000000000010850b981d12000000000000000000000000000000000000000000000000000010822d9d73130000000000000000000000000000000000000000000000000000108655c73614000000000000000000000000000000000000000000000000000010862baf0c15000000000000000000000000000000000000000000000000000010758c001600000000000000000000000000000000000000000000000000000f80739a7f1700000000000000000000000000000000000000000000000000000f8070856b1800000000000000000000000000000000000000000000000000000f837c8d4e1900000000000000000000000000000000000000000000000000000e806888691a00000000000000000000000000000000000000000000000000000b8570de661b0000000000000000000000000000000000000000000000000000098332bb0b1c0000000000000000000000000000000000000000000000000000098240ae6b1d000000000000000000000000000000000000000000000000000008861599711e000000000000000000000000000000000000000000000000000006821da71e1f0000000000000000000000000000000000000000000000000000038334af692000000000000000000000000000000000000000000000000000000200"_hex_v_u8, {{6688, 962}, {6183, 913}, {5814, 935}, {2756, 533}, {4112, 831}, {1141, 239}, {1887, 625}, {1151, 471}, {389, 227}, {1403, 958}, {-30, 416}, {-49, 180}, {-13972, 17369}, {-1102, 893}, {-1708, 956}, {-438, 240}, {-1721, 917}, {-1615, 779}, {-1905, 772}, {-629, 232}, {-2186, 686}, {-1117, 279}, {-1978, 429}, {-1474, 271}, {-3125, 564}, {-1904, 339}, {-3661, 646}, {-3062, 448}, {-3846, 562}, {-1792, 243}, {-8026, 1066}});
+    TestOptimalLinearization("822f8a1500813c8e2c01812b92570280708513038608a92804835ca704058668d931068417a738078402a65b08853f9749098176994f0a81438c730b8261827e0c816c816f0d831d8a450e825a901f0f8105852600000000000000000000000000000000108338ab330100000000000000000000000000000010852dbe30020000000000000000000000000000000e82419630030000000000000000000000000000000d813c867c040000000000000000000000000000000b831b9d1a050000000000000000000000000000000b84069108060000000000000000000000000000000b854b967b070000000000000000000000000000000b8031820b080000000000000000000000000000000b81518a2e090000000000000000000000000000000b83208e010a0000000000000000000000000000000a8670d4660b0000000000000000000000000000000a860dce2a0c0000000000000000000000000000000a8451c1270d000000000000000000000000000000098543b1490e0000000000000000000000000000000883609b660f00000000000000000000000000000006843da97210000000000000000000000000000000068028897f1100000000000000000000000000000000842ab52d120000000000000000000000000000000000"_hex_v_u8, {{2562, 604}, {2588, 663}, {982, 316}, {2708, 904}, {8802, 12587}, {-198, 177}, {-961, 544}, {-1534, 843}, {-3237, 835}, {-704, 168}, {-2842, 568}, {-3479, 682}, {-4244, 721}});
+    TestOptimalLinearization("8333b0280080278a4701831688680002870ecd590102866f74010581298e1203000280238a42030006648603040006850aac5b05000680048845020c8314866b000f8355b84a06000005856d814a070000058172823103020f8409b86904020c8664e05502050b824eab0501030681708f410014847dc92c090000000000018511993e0302010681548c17001a8276a87b050201000012816b933e0401030d853fa06b020604857ec0300901000000000b872dde14020700000f8252851c04000313813a8d0305000500088051816a04070000018228913a02081b8323854d002183458170050501000b8517ca10050201020015802f89210204178509c61503041682529401050102010686269150010003031a806e821c000002010204856798430100000101020e845498700104002000"_hex_v_u8, {{3156, 563}, {1594, 1161}, {3115, 10582}, {-3684, 5344}, {-423, 547}, {-4401, 3628}, {-1634, 871}});
+    TestOptimalLinearization("810c8e3d008316881a01863fa11b02831dad01038049881804873d9a410203822e9f420302822299290204842d32040208874a8734020b80278a6b020b6884100408803b812505000e857ba64a0801000a874bc7760604088600aa69060980618e7a05060a8472a23a010b0b873bcf000604000e816d97620a01020f86409a730215872c8e22010c04801b8963010a18855c8b3f0a00010200000015864c98150701000401000a81428f60080005098458c254040601020d837cae5c04010a0c8273a56209050101000000058507b07b080200061080519068090003010100118310a0050503020000010000148727d92f0502020200001785599e740207000201000b8421905004010102010124854d8b0f00050003002200"_hex_v_u8, {{588, 201}, {3571, 2051}, {6111, 4552}, {5853, 5439}, {4559, 5181}, {-800, 860}, {-4457, 3265}, {-2115, 528}, {-5784, 1063}});
+    TestOptimalLinearization("850c8f35008651ce2f0165807a028725d844038227a4150481378e1c058729b702068279a853076f8878088239a3380981228d300a805c85710b86559b420c8653a67a0d860eac270e823d8c0a0f82539142000000000000000000000000000000000f80068543010000000000000000000000000000000f825f8156020000000000000000000000000000000d83459166030000000000000000000000000000000b84209c0a040000000000000000000000000000000b807e9509050000000000000000000000000000000a80709452060000000000000000000000000000000a70823d070000000000000000000000000000000a8301a000080000000000000000000000000000000a8168806c090000000000000000000000000000000a8120865e0a00000000000000000000000000000009801583190b00000000000000000000000000000009857ed1480c00000000000000000000000000000006806082300d00000000000000000000000000000004801f89590e000000000000000000000000000000038103965a0f00000000000000000000000000000003801d822d10000000000000000000000000000000038459a3031100000000000000000000000000000002872eaf7f1200000000000000000000000000000002854b9658130000000000000000000000000000000100"_hex_v_u8, {{636, 111}, {5730, 1061}, {2332, 441}, {3585, 1065}, {920, 290}, {974, 311}, {2557, 979}, {837, 445}, {1825, 981}, {125, 101}, {2546, 9635}, {-215, 157}, {-269, 149}, {-223, 112}, {-3136, 1070}, {-418, 134}, {-2306, 729}, {-685, 159}, {-1413, 254}});
+    TestOptimalLinearization("844f8835008631d1440183318e0a02801b896803863dc83402048525bb440304811a937e04000581669911040006872aaa100600058452b04607000480208c7005020681319777060200852dcc3c0701000b821ea3640801000481168f0808000201860c843204088715df6f0c00000000870ebd7b07030013816f9831021a82778d4200188018854a0c01000103825093730601011684298a2b0402070011832dad31030603098571cc760c00000001000000058704dd7b0b0000000000000000000b8257845005050000000000000000178630c00e04060000000001108435c159090101000000000100078474ba01050004068447ba4506030102000200028408490901030000000111850db1610a00020100000000001a8557c6570307000000011d8275ab4706000000010217648325010303188419801d04000600010012837ebd2202091785548e2f050000000103108028852702030001030383689059040300020102862aa26c010003000000002086199a08020003000000001300"_hex_v_u8, {{5282, 945}, {4698, 957}, {3874, 805}, {692, 155}, {14104, 3949}, {6151, 2252}, {345, 908}, {-589, 2663}, {-696, 870}, {-892, 981}, {-1375, 1112}, {-32657, 11825}});
+    TestOptimalLinearization("824b8e1200805c8610018129801f028373a87d0380767f0486319546058649b858068623a50f07871ca14908805c9121098637af790a8668d1220b6480290c801e827d0d845eb6420e857ec3680f8600c332108517857f118126880100000000000000000000000000000000000012806b917101000000000000000000000000000000000011815e8069020000000000000000000000000000000000118468a40e0300000000000000000000000000000000000d8355ae150400000000000000000000000000000000000b832c99610500000000000000000000000000000000000a8720cb11060000000000000000000000000000000000098623b37c0700000000000000000000000000000000000880668f1b08000000000000000000000000000000000008835b9813090000000000000000000000000000000000088279892f0a000000000000000000000000000000000006802488110b0000000000000000000000000000000000038337a31a0c0000000000000000000000000000000000038574aa730d00000000000000000000000000000000000100"_hex_v_u8, {{5265, 1000}, {4404, 894}, {4377, 896}, {3553, 734}, {3692, 969}, {969, 459}, {456, 220}, {1443, 945}, {-64, 246}, {-80, 297}, {-448, 791}, {-4017, 6631}, {-664, 505}, {-577, 294}, {-1610, 603}, {-1713, 556}, {-2810, 884}, {-585, 164}, {-1038, 230}, {-4873, 1056}, {-3019, 597}, {-1209, 235}});
+    TestOptimalLinearization("866db148008305944a018340810400038721c963010282528f4802028532a1260301852e954c030685778653050002668530010c806a4a020c8451aa0f030102866c8e250202000b812e9071060000000009852f875105010000000d834e98750400020003814b8b63040000020007840fa646050000020001812c891d0203021082428c7606000001000d822e875d01118502bf170701000006840a8e6c050002010a820c9b1c0204107c871f030100031682259a480401000300188676815a0107128034845b03030002138458a24205000000000013861ca528050000000001048560b41e0200000101000e80618757020200001300"_hex_v_u8, {{3236, 1005}, {3576, 1335}, {1060, 466}, {1984, 1492}, {37, 234}, {-3095, 13613}, {-556, 225}});
+    TestOptimalLinearization("8260991f008662892d0001837fa91b01008401a85d0001870cad1f0101810c8658010681356a0206846b824c0400058661c47805000183058c7104028609914d06000a864fc143070004852fb7020601078132943c03040008845eb202040201048626a67f02000682358c18040004000384249049050000030781428c4c02020c8361962f030204028078873307000001010008821b986c0205010005853b8a0e070001000000000c8260956c0301040c862ca078030000010200186b825d010401000c807d930100040101821196590500000000000000088235880e020000001300"_hex_v_u8, {{1910, 8479}, {-3111, 8308}, {-1517, 401}, {-1281, 253}});
+    TestOptimalLinearization("842ba05d0083138d6d018720e40a0268816b038548bc49000684269a620105840dab78030007850cc00c010009835486260200088667873a0300078065811006000103865b943f050303836db67905078749c8200700010b8742c257080001000d8351a3460500098604a67e060000108355896d0407000c8712b40005050004832e854607000400128421a30704060f8416944b020a01804e8d5207020100001081598f290209088422862b0700030306867cb04a06030100128733c8370005050e840a884d020105031b8477ba4404050100020886669d270203051886378d2e04030100020000000d8745db65020700000000198465845e0205001382059f3a07020001000000001c843ca06304060100001c854d8f670208000b81519352000004000f84598017000001000200"_hex_v_u8, {{6469, 1056}, {1595, 782}, {12744, 6989}, {-189, 1663}, {-1826, 9149}, {-470, 674}, {-615, 650}, {-8266, 5425}, {-5939, 1093}});
+    TestOptimalLinearization("810e982400840a9a7e018619dc02028157a542038640a10b04844ec93a058055805f06872eb8660783718a1f08874bcc070980477a0a820194780b8345a66d0c8310a0420d8437b4660e8672af300f8225957310801a826f11807b877e128558d32c136e87581483299c7a00000000000000000000000000000000000000000015805f904d01000000000000000000000000000000000000000015831f922a020000000000000000000000000000000000000000158570be5d03000000000000000000000000000000000000000015863c88160400000000000000000000000000000000000000001480178919050000000000000000000000000000000000000000128563816406000000000000000000000000000000000000000012864bc86307000000000000000000000000000000000000000012841c9a7b0800000000000000000000000000000000000000001182029c6e0900000000000000000000000000000000000000000f8234922d0a00000000000000000000000000000000000000000d800582520b00000000000000000000000000000000000000000d8570cb7d0c00000000000000000000000000000000000000000c8471c94d0d00000000000000000000000000000000000000000c8013865b0e00000000000000000000000000000000000000000c83348a680f00000000000000000000000000000000000000000b811496721000000000000000000000000000000000000000000b850cd3641100000000000000000000000000000000000000000b8738905f1200000000000000000000000000000000000000000b6d812e1300000000000000000000000000000000000000000a7a81501400000000000000000000000000000000000000000a836ba6171500000000000000000000000000000000000000000a8736e1381600000000000000000000000000000000000000000a834a833c170000000000000000000000000000000000000000078340af00180000000000000000000000000000000000000000068460cd141900000000000000000000000000000000000000000686429d651a00000000000000000000000000000000000000000382179f3d1b0000000000000000000000000000000000000000038651b36c1c0000000000000000000000000000000000000000038405c04b1d000000000000000000000000000000000000000002874182401e0000000000000000000000000000000000000000028127827d1f00000000000000000000000000000000000000000100"_hex_v_u8, {{2465, 343}, {4765, 718}, {5953, 921}, {5398, 856}, {1618, 270}, {556, 110}, {3443, 695}, {2145, 528}, {1404, 385}, {3699, 1070}, {3096, 1010}, {1791, 650}, {575, 251}, {17859, 10290}, {151, 109}, {168, 122}, {756, 564}, {587, 956}, {286, 586}, {224, 1089}, {178, 867}, {-255, 295}, {-1136, 1080}, {-1971, 962}, {-1790, 668}, {-1239, 436}, {-494, 147}, {-2508, 619}, {-653, 151}, {-4079, 880}, {-4722, 971}, {-1127, 223}, {-2079, 407}, {-4927, 880}, {-4775, 753}, {-4198, 645}});
+    TestOptimalLinearization("852dbb7700865eeb7601817ca676028220a65e000580368e660204850932030281369816030106872caf420208861bdc08020209861eba7403020880378d6703020b8253965b040209823f95360013826ab4040402048713bd3606010101817f88540009837cb26c060003000d81628e4e07000300058009811605000511817a9c10090002000005821e9379040700048656d7620500060b850e8d6803080008841a9f44040700138239a535060005010f842e81630605000114822a8f73040800000a8539b3580b010000028407c670020a0e811f0b050702058616cb1303081c8315ae6406040301001c806f9921020c16860fe23e040c038563cf050a0001040f8023842d020e16803f885c050700040182109c010206080d8242ae6702042c813ca3320209041f843ec61401030a1082659641080201020223864cbc42010e1e8442a279012980608866010b0010836c991e0106010f8637903f09010002001e820998050a0500000000108328b41c0200050a825a8d63000b0f827bb9030009108152923704020300020080298155060201020000048023802102093283758a2c000600010035805a8403030203218516c7410300010000000200"_hex_v_u8, {{6971, 990}, {2555, 380}, {2543, 416}, {1011, 182}, {9375, 2190}, {3834, 926}, {7100, 2111}, {24543, 8471}, {999, 354}, {948, 782}, {3401, 2813}, {599, 974}, {-2440, 4852}, {-946, 474}, {-9312, 3117}, {-3594, 1125}, {-1603, 393}, {-4641, 790}});
+    TestOptimalLinearization("803894000087239a23018325873d02812fa0580100028315a2570200027c8a3f0300028608b21b030102870aeb0c05000283728121060000853fcb4d070000856ddb50020b802c927803030b8361c41105030a874af55b050209814d825101168319b7420600040e752f0601030e8054947c0700000d841ca56f0409817a26080501827cb2340108020c83239b340301060d8155a0020a0000000207867cea37010b06836bc00905060101000001836abc570a0300000000001680228f7d0703030000108400ac050703000002168302853b08000103000100068418c6790602010002020017865793550603001c803d84280d00000001000011850c812901168671af190a01010004000783159302060029850a6102081f8718ee2b010703218544d150040b0008835680790607020200804c8d43010f27870b9069030d00218168a83f0117857fe51c06080102001c80248c6b070604001c8526a136060308188607ad41030d010c8576ca010d03000102088545b84a050d0000002e805e934e020a0500078539a877040003092a825e977203040102348342bc010408020101000000198622e778010d000017801582190300000802822b833a07020003000000000000338702ca070108000000002c806c957307000001000100000000028350c36105000200000200002b8315a53205020000000001002000"_hex_v_u8, {{1344, 184}, {14532, 3445}, {2929, 1712}, {19, 378}, {-2610, 2705}, {-19575, 18795}, {-12674, 4996}, {-2889, 974}, {-4804, 1026}, {-1466, 236}, {-3905, 578}, {-4401, 592}});
+    TestOptimalLinearization("8705ca08008231997201826b964d02872adf1b03807f994d0303861d9d0d01000584008f3502000281029c0703000283678c2804000104860ad4540500010480308a0e030580028e0d00108266a15d070000048134826d06010e8576806b0600000f82098f6a0a0000000c821e95270506088535826c060303865ca8310104147e8c3b06000e832090420600020311861d995305020202018330901f05000100148511bf1d050202030002833d92660801000200028337805606060000001380528f6206020301000007830cac650406000117813698660a00020000000000000683688f1c04020006000011814b8e63020614857592200c010000000007810f872e05080000028634ac16020c1980148e2800288309893f09050001000000028704af74012a8546a0300c010201000381658c090401288068905e0201278135956303070100010026855aab5109020200000000000016813d933d030402041d874bb051030a0000158577650501040300000009817f9c1e0205030c84419f6c0502040001000d8457d22c03030600001c8033883c0205041e80698b0e080202010000000c84058726010801278222876e0c0000000100000001871c820001080100208747e02f030100000117864585210003001084789b5a0002002200"_hex_v_u8, {{4804, 1029}, {1721, 433}, {-813, 15413}, {-1617, 12598}, {-7653, 3678}});
+    TestOptimalLinearization("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"_hex_v_u8, {{4594, 602}, {1855, 249}, {1121, 151}, {5310, 719}, {7657, 1052}, {5449, 1012}, {2001, 416}, {2550, 1090}, {18542, 18063}, {240, 241}, {198, 209}, {187, 758}, {-92, 337}, {-238, 831}, {-132, 262}, {-570, 447}, {-1294, 753}, {-1293, 585}, {-2195, 868}, {-1374, 498}, {-1902, 649}, {-2493, 710}, {-1277, 262}, {-3037, 614}, {-759, 120}, {-3684, 573}, {-2233, 336}, {-1498, 215}});
+
+    // Clusters which admit repeated states in SFL.
+    TestOptimalLinearization("862ea341008713833c018745817502827a814f0382528b6704813381280581308548010005815a8e7a0100010684019f0005000003802783720500000009856cae0005000001028601ac0e050000000475811a0601000000008135834c070000000000088007863e0800000000000284299b710900000000000200"_hex_v_u8, {{7533, 8149}, {-1849, 681}});
+    TestOptimalLinearization("82759235008069896c0186438e3d028244912600000003851ba405010000038214845c0200000183018a4b03000001807f841f00000000078573823a0100000007820f8a65020000000164805703000000018622ab5804000000018412936600000000000c82749c04010000000008832b977602000000000700"_hex_v_u8, {{694, 233}, {2856, 7908}});
+    TestOptimalLinearization("85478e3b00823c904101820c893f0283179c5903814c893104854282530583429f140100000103830d8509010001000284409a70020100000181168c190300000001088718b06a0400000001058553ac2c0500000000000b8506a22e060000000000008552803a0000000008800f861e020000010008817c844802000100010700"_hex_v_u8, {{6613, 7335}, {-322, 2176}});
+    TestOptimalLinearization("8146845100804b890d0186768b55028406a32f03863ca23104832f8e3b05810a892b0680358253078502ac5d08872d96700983718004000100000002018273952801010001000100097b3c02020000000100058562a14203010000000000010d8718817804000000010000000c862f956c050000000000000000000900"_hex_v_u8, {{1528, 1069}, {-5842, 9025}});
+    TestOptimalLinearization("8460992400872dbd1901867fb07f02852a817d00000003852d87540100000181348f60020000018435942b03000000837f8943000000000681608e730100000005857da67f0200000005843794080300000004658217040000000086628a1500000000000b8708805401000000000a847fa32402000000000700"_hex_v_u8, {{1682, 736}, {-8507, 10189}});
+    TestOptimalLinearization("81668e3500804e844f018435927302861f9d5f03846ea342010000018261897a010000018165831102000100863e895003000000078232985e04000000018606823f000001000986318a570200000009804300020100000981408323040000000885179a260400000000068510af7800000000000b8360966f01000000000000"_hex_v_u8, {{4144, 9101}, {-1528, 608}});
+    TestOptimalLinearization("861e862e00851aa57f018060816b02831ba009038628b818048576b3010580072a068478911d07854fa8600003000007816d86560200000000048576b11403000000010009850aa7100300000100010782178f040400010000010280758a22050100000000000d860eb344060000000000010c8501975a070000000001000500"_hex_v_u8, {{3660, 936}, {6832, 9471}});
+    TestOptimalLinearization("802e7300824b95370000821c8a5e0002827a89580102813185560201867ba17f0301810e83580000000000835d9a0c010000000087218c1602000000008458905a03000000008319937d00000000068216900801000000068677ab2a0200000005826f91710300000004864f4404000000038702ac3c00000000000900"_hex_v_u8, {{6067, 6956}, {392, 3033}});
+    TestOptimalLinearization("8151801500823e835201842ba81902837b881e038674b461048676897a058369894306873e8511078514a802010001010001833a8f51010001000100078236885502000101000003872cab780300000101000381035605000000000000038123825305010000000000018152847106000000000000000100"_hex_v_u8, {{5948, 5991}, {-8330, 3591}});
+    TestOptimalLinearization("6f845f008472960a01842084330286779f7903800786310481588d0505865994390683449e480100000000000387218e3a02000000000000811d22020000000100008500812a0300000000000003825e970e04000000000000028436815a05000000000000027c812e060000000000000000"_hex_v_u8, {{1477, 754}, {-526, 7248}});
+    TestOptimalLinearization("83419a7b00860e9172000183289a1901018157824f020183209e53030085398e5a040081458e2d00010000068334a04c010000000005840d8f1d02000000000281398b70030000000000872f8f5a040000000000816a8070010000000b843ba5140100000109823a91680200000000078267903303000000000700"_hex_v_u8, {{2212, 8180}, {-1114, 487}});
+    TestOptimalLinearization("867e816800827e9a7101811c8f470000018613905501000080708c0e020000865c963a030000873a834e0400008267921900000000000486238a5a0100000000028614914a020000000002823083560300000000008652993e040000000000813c8e03010000000a803c817601010000028507990402000000000a00"_hex_v_u8, {{3395, 9748}, {-962, 316}});
+    TestOptimalLinearization("856d9d530083029d1d0186429d3f02866b927b038234947a000201835389400101028460895c0201000582128f5303000100803183290400000184358f790500010082779924060000000682416d0700000006867b9a4003000000000a83149b200100010100000482488f62020100000000000b00"_hex_v_u8, {{-524, 9354}});
+    TestOptimalLinearization("8748865d0082558d3d01825d8f7a0281678623000003815e8b750100000277831e02000001873d8f3a03000000805b841f0001000682548f0b010000018376891e0200000007826d8320030000000482288b71040000000282078b0c000000000d82288e26010000000d872994040200010009800e800a03000000000b00"_hex_v_u8, {{1085, 477}, {513, 7734}});
+    TestOptimalLinearization("817b8f1100832c965701811b8a4400000281418f16010002804f86370200028573941d0300028179820f04000280238743000000000006845291470100000000037f826c0200000000018602a563030000000001850d902000000000058652826301000000058673a03602000000028379970d030000000200"_hex_v_u8, {{-3780, 7686}, {-1543, 633}});
+    TestOptimalLinearization("85179c690081659269018635831a02866289680385438d3704867eae70058726b035068009856307816e926001000100048742b83801000000010a822190360201000001098721b05603000000000108861db2580401000001000080758a30050000010000000d8354a334060100000000000d8629a87c070000010000000a00"_hex_v_u8, {{3064, 1022}, {11548, 10758}});
+    TestOptimalLinearization("813d894b008263966701802d827f028375997a00000003861891180100000387219a68020000018462827503000001821a924504000001833a9d16000000000003810e8d2d01000000000284299632020000000001820993160300000000008656b4780000000009845c8f03010000000300"_hex_v_u8, {{7961, 7623}, {-1026, 732}});
+    TestOptimalLinearization("86639b0b0084139655018156830f000002872895040100028567862f02000280468504030001830c8427040000870b987900000000000680527801000000000280148635020000000001860c952a0300000000018216867600000000098426a04c010000000481658d55020000000100"_hex_v_u8, {{-583, 8038}, {-939, 357}});
+    TestOptimalLinearization("8718a9310084369903018666a2270000018207936e0100018470800102000084609c240300008324985c04000086418d2100000000000285708d7c0100000000028362875802000000000182519504030000000001854fa01a000000000b851fa3120100000008834d8b47020000000300"_hex_v_u8, {{4600, 9729}, {-804, 589}});
+
+    // Clusters which have lots of potential SFL states/transitions.
+    TestOptimalLinearization("84559211008539851b01825098430285268d1e00010181008e700100028425a22e02000005860a9c1403000005830b924004000005810d87040500000483768808060000038731854007000003862b9066000001010a83799a540100020104850c9a5702010000020482098c0003000002000002826897580400010000010000"_hex_v_u8, {{10878, 9607}, {-1772, 780}});
+    TestOptimalLinearization("8657833900865d887e018043894b0287338377038624880100010001851fa82401000000038421990e02000000038723af560300000003866dae0a04000000028265860005000000028031863800000001088353a12c0101000000088630b51a02000000000003866ba1650300000000000300"_hex_v_u8, {{15815, 9911}, {-2227, 1003}});
+    TestOptimalLinearization("852a9d7d008350920901825193330280691201000181428c25010001823d8d1f020000018355460300000182448c0f040000008608994d05000000843ea14a01000100078511a07001000200058737ad5802000200058569ae3f04010000026e80520401000000058509ac7605000000010400"_hex_v_u8, {{1641, 8273}, {-3040, 873}});
+    TestOptimalLinearization("803a88570078825101806a88390282048777038430920a000003811b841f010000038003801c0200000006822092420300000002821a96380400000001820280110500000001806d8834000001000006871aaf2b01000000000003806a8a2a02000000000001864c9e600300000000000100"_hex_v_u8, {{4968, 4685}, {-3094, 1050}});
+    TestOptimalLinearization("8437801e00845d833f01816b907800000286438821010002867cac720200028202895e030000861db23d00000000068419a47301000000048404966b0200000002812a817c000000058438824b01000004822c980e0200000286168f4c03000002860c8a5b040000008542997a00000000000a8247815101000000000800"_hex_v_u8, {{4563, 3197}, {-4405, 7734}});
+    TestOptimalLinearization("8556877f0081658a7b01803865028412813e03810e816d048743b56e0581398d070680378048010100000001812e85280100000100000780018226020001000000078370891403000000000100824a994a05000000000000822c835a050000000000000980608376060000000000000100"_hex_v_u8, {{3511, 1091}, {1365, 4984}});
+    TestOptimalLinearization("66844f008651aa61018409810902816f814d03823084080000000004843b8144010000000483528d16020000000082758c5403000000008342927f000000000886780c01000000088656802302000000088637b649000004855f8f4001000009815a8c5002000009814b8d240300000900"_hex_v_u8, {{292, 8437}, {-3557, 951}});
+    TestOptimalLinearization("825d842900824a800401864bb0360281598d13038039835f04834a80310585568663068555862e00000000000000078552935e010000000000000785738c5c02000000000000058163864403000000000000058069837e040000000000000480708610050000000000000000"_hex_v_u8, {{3163, 971}, {1861, 6319}});
+    TestOptimalLinearization("83249365008149926b01817a925202874bba1f038631ab2b0484788e55058613992d06857aa671078367883600000100000001844f916e010100010000008179867002000100000100847a90600300000000000007842c902a0500000000000004825e856b0500000000000000068016831206000000000000000200"_hex_v_u8, {{1257, 378}, {-10088, 9271}});
+    TestOptimalLinearization("802488410085669221018528aa5b02800a8539038278921601000382338719010103802b8744030102842b8404050002857b886a040102864d9317050100088267920006000001806b813407000100863a5d080000000182529b23000000010000010884259254010000010100000781739540030000000000000600"_hex_v_u8, {{-125, 8361}, {-1810, 466}});
+    TestOptimalLinearization("81528b45008715a71201834c8c090102802f85320202866a89320301812985680001068120817301010005837a836a020000000581448a060300000005846e6b0400000001814c9355000100000582758c5a0101000002833b872d02000000000884539c000300000000068459a140000000000b83098f5a010000000300"_hex_v_u8, {{2569, 1045}, {4798, 7773}});
+    TestOptimalLinearization("8635a94d00866f9a5901847ea66802821c81640203856694370101018713b00d030001813b8b3603000000811980480400000086108960000100000881068b4301000001028033866202000001008556b22f030000000003835ba028040000000001815789540100000006823d903e01010000058629b01202000000000500"_hex_v_u8, {{2548, 766}, {-3769, 9412}});
+    TestOptimalLinearization("81188d5500822c855b01821c3a02863a9117038425930d048207906f057243068235804f07853f8b16000002000108822a8a5601000100010880738e07020001000008850d8c4605010000000681038c2205010000010681628b4a050001000007840a8d440600000002000a8538986a070000000001000000"_hex_v_u8, {{1557, 7818}, {-964, 243}});
+    TestOptimalLinearization("8522934b00812a8b15018610b44e0285789a1f0386509173048233901705840f914906857a924f07831d8e58020000000107860b806502000000010380328724030200000000824b5f0301010000000181518964040000010000000c816e8b24060000000000000b853f45070000000000000400"_hex_v_u8, {{3431, 912}, {-5784, 8563}});
+    TestOptimalLinearization("832f8f59008730831a018022822b02801239038275987b048520a0590582448b6506826398500001010007854b971a0100020000088105894c0201000001068737992603000101000387249424040001010003815b82220500000001028706934a0600000100000d8602ae3d0701000000000c844789560801000000000100"_hex_v_u8, {{3440, 9506}, {-3039, 898}});
+    TestOptimalLinearization("8458a65900850aac29018201855f02854fab75038461877504821e86330584328d3706861b8d7107844e9d2808847c9250000000030004836d8d3e040000000000098179916402020000010005825b95700400000100000000867dae5e04000000000001000a8162941e05000000000100000682628a4e06000000010000000600"_hex_v_u8, {{1940, 718}, {-1665, 9596}});
+    TestOptimalLinearization("8147814100805389410185059d29028045833103850834048073883f05803580330000000106832b9f6c0101000105821c0b020000000000068519a8600300000000000484759a66010000018339a07201000001854ea048020000018730ba160400000086409d3c040000000c00"_hex_v_u8, {{12873, 8672}});
+    TestOptimalLinearization("8219866f008118842f01854ba30b0283058a1f038614921b04866a807005840f9b140000000000000584339d1601000000000004834d925402000000000004811d8b3403000000000003844f8552040000000000038217821e0500000000000100"_hex_v_u8, {{1429, 7313}});
+    TestOptimalLinearization("8177892100831b9b490181418f05027d803603872c8040048438837805852ea30200000000000006871e956c01000000000005824c9036020000000000018471972203000000000001865d8e28040000000000008566a4100500000000000000"_hex_v_u8, {{6781, 8064}});
+    TestOptimalLinearization("8534a80f008374901f018379995e000002807a8c4201000285438d340200028019856403000282178b22040001830b930605000080608b06000000000000048621ad3601000000000001842ba10a02000000000000825494320300000000000000"_hex_v_u8, {{9556, 6553}});
+    TestOptimalLinearization("81398a1700805f84750183639f61028032835f0387498f1b048526992b0581688f4e0000000000000480028348010000000000038005821c02000000000003864fad6803000000000003816c9156040000000000038715b5320500000000000000"_hex_v_u8, {{3013, 6235}});
+    TestOptimalLinearization("83799c23008671ad4901815c896b02854fab3303810481680000000004803181130100000003845f8743020000000383258862030000000381658f6d0400000002802384590000000000058318876701000000000380758d020000038618951201000366812a02000200"_hex_v_u8, {{-7815, 6881}});
+    TestOptimalLinearization("8225945300815931018413962f02836a9635038720b46d04842b840f058659974a0000000000000587179118010000000000058710a5540200000000000187169242030000000000018620ac6c04000000000001844182700500000000000000"_hex_v_u8, {{1461, 9533}});
+    TestOptimalLinearization("806e801500871ca421018125845d02841a9c3703845da477048528997d058510a820000000000000068745946e01000000000004840f9b1202000000000004822d8e280300000000000484599f0004000000000004807d81050500000000000200"_hex_v_u8, {{2, 7480}, {-131, 253}});
+    TestOptimalLinearization("84098a0d008000811f01812f831902867a843a038124890f04821e821905870b9e4400000000000004840aa00601000000000002852e97020200000000000284769b18030000000000018042847604000000000001853290160500000000000100"_hex_v_u8, {{7324, 7073}});
+    TestOptimalLinearization("834a9b5f00820a89790180598b3f0273815703816e807004805683370580308062068417a42c0000000000000002865098610100000000000000831a93590200000000000000801981000000000a856eb5520100000786409000020000058336903803000005836b9a020400000583599c0c0500000500"_hex_v_u8, {{5272, 8022}});
+    TestOptimalLinearization("85268b4c0082748120018068802102807986310381428d770480268659058340994e00000000000004806b8a3e01000000000004811f8c3c02000000000002840a8d6c030000000000018608af5604000000000001822492100500000000000000"_hex_v_u8, {{7536, 5347}});
+    TestOptimalLinearization("83718f5300862d9663018700ae190281338d3303825c865104832c916705851b9c64000000000000068419a256010000000000028510a35802000000000001816b861a030000000000018564ad6804000000000001832e85480500000000000100"_hex_v_u8, {{2190, 7962}});
+    TestOptimalLinearization("842a980f008356951f01805c82570282308f4303802d8317048415a13705863e51000000000000058530a15201000000000004827c865402000000000004845e93260300000000000281638e68040000000000028121832e0500000000000100"_hex_v_u8, {{-1542, 6426}});
+    TestOptimalLinearization("855f8024008024816501807c81020284629b030383078631048044895c000002048078100100000000068315856a020000000004800784130300000000028167800c04000000000281758a14010000000885249a1a0100010004852ca63e020000010300"_hex_v_u8, {{3618, 5996}});
+    TestOptimalLinearization("855f97230080678a4f018210925d02856113038105892b04854e996105805a8a480000000000000283028b7a01000000000002846d9f080200000000000283189656030000000000018277862e0400000000000185508d200500000000000000"_hex_v_u8, {{573, 6834}});
+    TestOptimalLinearization("866faa23008646b71501851f96130282588f1103804d851c0000000003822097600100000003850a8f310200000003856e9201000000038656935f01000003855b8f5f020000018743923a0000000a812b810b010000098403a328020000068712970203000005833e98400400000200"_hex_v_u8, {{-4960, 11011}});
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/depend/bitcoin/src/test/coins_tests.cpp b/depend/bitcoin/src/test/coins_tests.cpp
index a1152d24..e2361d41 100644
--- a/depend/bitcoin/src/test/coins_tests.cpp
+++ b/depend/bitcoin/src/test/coins_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2022 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
@@ -386,15 +386,15 @@ BOOST_FIXTURE_TEST_CASE(updatecoins_simulation_test, UpdateTest)
                     auto utxod = FindRandomFrom(disconnected_coins);
                     tx = CMutableTransaction{std::get<0>(utxod->second)};
                     prevout = tx.vin[0].prevout;
-                    if (!CTransaction(tx).IsCoinBase() && !utxoset.count(prevout)) {
+                    if (!CTransaction(tx).IsCoinBase() && !utxoset.contains(prevout)) {
                         disconnected_coins.erase(utxod->first);
                         continue;
                     }
 
                     // If this tx is already IN the UTXO, then it must be a coinbase, and it must be a duplicate
-                    if (utxoset.count(utxod->first)) {
+                    if (utxoset.contains(utxod->first)) {
                         assert(CTransaction(tx).IsCoinBase());
-                        assert(duplicate_coins.count(utxod->first));
+                        assert(duplicate_coins.contains(utxod->first));
                     }
                     disconnected_coins.erase(utxod->first);
                 }
@@ -417,7 +417,7 @@ BOOST_FIXTURE_TEST_CASE(updatecoins_simulation_test, UpdateTest)
 
                 // The test is designed to ensure spending a duplicate coinbase will work properly
                 // if that ever happens and not resurrect the previously overwritten coinbase
-                if (duplicate_coins.count(prevout)) {
+                if (duplicate_coins.contains(prevout)) {
                     spent_a_duplicate_coinbase = true;
                 }
 
diff --git a/depend/bitcoin/src/test/coinstatsindex_tests.cpp b/depend/bitcoin/src/test/coinstatsindex_tests.cpp
index 7d54f0fd..74e5f454 100644
--- a/depend/bitcoin/src/test/coinstatsindex_tests.cpp
+++ b/depend/bitcoin/src/test/coinstatsindex_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
@@ -6,12 +6,15 @@
 #include <index/coinstatsindex.h>
 #include <interfaces/chain.h>
 #include <kernel/coinstats.h>
+#include <kernel/types.h>
 #include <test/util/setup_common.h>
 #include <test/util/validation.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
 
+using kernel::ChainstateRole;
+
 BOOST_AUTO_TEST_SUITE(coinstatsindex_tests)
 
 BOOST_FIXTURE_TEST_CASE(coinstatsindex_initial_sync, TestChain100Setup)
@@ -101,7 +104,7 @@ BOOST_FIXTURE_TEST_CASE(coinstatsindex_unclean_shutdown, TestChain100Setup)
         // Send block connected notification, then stop the index without
         // sending a chainstate flushed notification. Prior to #24138, this
         // would cause the index to be corrupted and fail to reload.
-        ValidationInterfaceTest::BlockConnected(ChainstateRole::NORMAL, index, new_block, new_block_index);
+        ValidationInterfaceTest::BlockConnected(ChainstateRole{}, index, new_block, new_block_index);
         index.Stop();
     }
 
diff --git a/depend/bitcoin/src/test/cuckoocache_tests.cpp b/depend/bitcoin/src/test/cuckoocache_tests.cpp
index f08c4d44..5c723596 100644
--- a/depend/bitcoin/src/test/cuckoocache_tests.cpp
+++ b/depend/bitcoin/src/test/cuckoocache_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2021 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/dbwrapper_tests.cpp b/depend/bitcoin/src/test/dbwrapper_tests.cpp
index 804830d4..53cd0046 100644
--- a/depend/bitcoin/src/test/dbwrapper_tests.cpp
+++ b/depend/bitcoin/src/test/dbwrapper_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/descriptor_tests.cpp b/depend/bitcoin/src/test/descriptor_tests.cpp
index 97f416dd..82e010bf 100644
--- a/depend/bitcoin/src/test/descriptor_tests.cpp
+++ b/depend/bitcoin/src/test/descriptor_tests.cpp
@@ -456,7 +456,7 @@ void DoCheck(std::string prv, std::string pub, const std::string& norm_pub, int
             // Test whether the observed key path is present in the 'paths' variable (which contains expected, unobserved paths),
             // and then remove it from that set.
             for (const auto& origin : script_provider.origins) {
-                BOOST_CHECK_MESSAGE(paths.count(origin.second.second.path), "Unexpected key path: " + prv);
+                BOOST_CHECK_MESSAGE(paths.contains(origin.second.second.path), "Unexpected key path: " + prv);
                 left_paths.erase(origin.second.second.path);
             }
         }
diff --git a/depend/bitcoin/src/test/disconnected_transactions.cpp b/depend/bitcoin/src/test/disconnected_transactions.cpp
index 7897e5f1..a363fe81 100644
--- a/depend/bitcoin/src/test/disconnected_transactions.cpp
+++ b/depend/bitcoin/src/test/disconnected_transactions.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 //
diff --git a/depend/bitcoin/src/test/feerounder_tests.cpp b/depend/bitcoin/src/test/feerounder_tests.cpp
index 3fbbec22..82cd7d65 100644
--- a/depend/bitcoin/src/test/feerounder_tests.cpp
+++ b/depend/bitcoin/src/test/feerounder_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/flatfile_tests.cpp b/depend/bitcoin/src/test/flatfile_tests.cpp
index 5ef603ca..a14c7c63 100644
--- a/depend/bitcoin/src/test/flatfile_tests.cpp
+++ b/depend/bitcoin/src/test/flatfile_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/fs_tests.cpp b/depend/bitcoin/src/test/fs_tests.cpp
index 89188904..7fd1de00 100644
--- a/depend/bitcoin/src/test/fs_tests.cpp
+++ b/depend/bitcoin/src/test/fs_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 //
diff --git a/depend/bitcoin/src/test/fuzz/CMakeLists.txt b/depend/bitcoin/src/test/fuzz/CMakeLists.txt
index 607723b9..3d2ff8f3 100644
--- a/depend/bitcoin/src/test/fuzz/CMakeLists.txt
+++ b/depend/bitcoin/src/test/fuzz/CMakeLists.txt
@@ -19,6 +19,7 @@ add_executable(fuzz
   block.cpp
   block_header.cpp
   block_index.cpp
+  block_index_tree.cpp
   blockfilter.cpp
   bloom_filter.cpp
   buffered_file.cpp
diff --git a/depend/bitcoin/src/test/fuzz/addition_overflow.cpp b/depend/bitcoin/src/test/fuzz/addition_overflow.cpp
index 071e5fb0..7f361a88 100644
--- a/depend/bitcoin/src/test/fuzz/addition_overflow.cpp
+++ b/depend/bitcoin/src/test/fuzz/addition_overflow.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/asmap.cpp b/depend/bitcoin/src/test/fuzz/asmap.cpp
index 1720f8e0..fe019f93 100644
--- a/depend/bitcoin/src/test/fuzz/asmap.cpp
+++ b/depend/bitcoin/src/test/fuzz/asmap.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/autofile.cpp b/depend/bitcoin/src/test/fuzz/autofile.cpp
index 0de85566..5aa5d8c1 100644
--- a/depend/bitcoin/src/test/fuzz/autofile.cpp
+++ b/depend/bitcoin/src/test/fuzz/autofile.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/banman.cpp b/depend/bitcoin/src/test/fuzz/banman.cpp
index 5b77cddf..e65b4da0 100644
--- a/depend/bitcoin/src/test/fuzz/banman.cpp
+++ b/depend/bitcoin/src/test/fuzz/banman.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/base_encode_decode.cpp b/depend/bitcoin/src/test/fuzz/base_encode_decode.cpp
index 45088187..1d2f4d7e 100644
--- a/depend/bitcoin/src/test/fuzz/base_encode_decode.cpp
+++ b/depend/bitcoin/src/test/fuzz/base_encode_decode.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/bitdeque.cpp b/depend/bitcoin/src/test/fuzz/bitdeque.cpp
index d5cc9cfd..bf6e6ea5 100644
--- a/depend/bitcoin/src/test/fuzz/bitdeque.cpp
+++ b/depend/bitcoin/src/test/fuzz/bitdeque.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/block.cpp b/depend/bitcoin/src/test/fuzz/block.cpp
index e38b8717..43e3df36 100644
--- a/depend/bitcoin/src/test/fuzz/block.cpp
+++ b/depend/bitcoin/src/test/fuzz/block.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/block_header.cpp b/depend/bitcoin/src/test/fuzz/block_header.cpp
index 2e446b16..6c765a53 100644
--- a/depend/bitcoin/src/test/fuzz/block_header.cpp
+++ b/depend/bitcoin/src/test/fuzz/block_header.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/block_index.cpp b/depend/bitcoin/src/test/fuzz/block_index.cpp
index 8e7210e5..c2d9f30f 100644
--- a/depend/bitcoin/src/test/fuzz/block_index.cpp
+++ b/depend/bitcoin/src/test/fuzz/block_index.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/fuzz/block_index_tree.cpp b/depend/bitcoin/src/test/fuzz/block_index_tree.cpp
new file mode 100644
index 00000000..df46ebad
--- /dev/null
+++ b/depend/bitcoin/src/test/fuzz/block_index_tree.cpp
@@ -0,0 +1,228 @@
+// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+
+#include <chain.h>
+#include <chainparams.h>
+#include <flatfile.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
+#include <test/fuzz/FuzzedDataProvider.h>
+#include <test/fuzz/fuzz.h>
+#include <test/fuzz/util.h>
+#include <test/util/setup_common.h>
+#include <test/util/validation.h>
+#include <validation.h>
+
+#include <ranges>
+#include <vector>
+
+const TestingSetup* g_setup;
+
+CBlockHeader ConsumeBlockHeader(FuzzedDataProvider& provider, uint256 prev_hash, int& nonce_counter)
+{
+    CBlockHeader header;
+    header.nVersion = provider.ConsumeIntegral<decltype(header.nVersion)>();
+    header.hashPrevBlock = prev_hash;
+    header.hashMerkleRoot = uint256{}; // never used
+    header.nTime = provider.ConsumeIntegral<decltype(header.nTime)>();
+    header.nBits = Params().GenesisBlock().nBits; // not fuzzed because not used (validation is mocked).
+    header.nNonce = nonce_counter++;              // prevent creating multiple block headers with the same hash
+    return header;
+}
+
+void initialize_block_index_tree()
+{
+    static const auto testing_setup = MakeNoLogFileContext<const TestingSetup>();
+    g_setup = testing_setup.get();
+}
+
+FUZZ_TARGET(block_index_tree, .init = initialize_block_index_tree)
+{
+    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
+    SetMockTime(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];
+    int nonce_counter = 0;
+    std::vector<CBlockIndex*> blocks;
+    blocks.push_back(genesis);
+    bool abort_run{false};
+
+    std::vector<CBlockIndex*> pruned_blocks;
+
+    LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 1000)
+    {
+        if (abort_run) break;
+        CallOneOf(
+            fuzzed_data_provider,
+            [&] {
+                // Receive a header building on an existing valid one. This assumes headers are valid, so PoW is not relevant here.
+                LOCK(cs_main);
+                CBlockIndex* prev_block = PickValue(fuzzed_data_provider, blocks);
+                if (!(prev_block->nStatus & BLOCK_FAILED_MASK)) {
+                    CBlockHeader header = ConsumeBlockHeader(fuzzed_data_provider, prev_block->GetBlockHash(), nonce_counter);
+                    CBlockIndex* index = blockman.AddToBlockIndex(header, chainman.m_best_header);
+                    assert(index->nStatus & BLOCK_VALID_TREE);
+                    assert(index->pprev == prev_block);
+                    blocks.push_back(index);
+                }
+            },
+            [&] {
+                // Receive a full block (valid or invalid) for an existing header, but don't attempt to connect it yet
+                LOCK(cs_main);
+                CBlockIndex* index = PickValue(fuzzed_data_provider, blocks);
+                // Must be new to us and not known to be invalid (e.g. because of an invalid ancestor).
+                if (index->nTx == 0 && !(index->nStatus & BLOCK_FAILED_MASK)) {
+                    if (fuzzed_data_provider.ConsumeBool()) { // Invalid
+                        BlockValidationState state;
+                        state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "consensus-invalid");
+                        chainman.InvalidBlockFound(index, state);
+                    } else {
+                        size_t nTx = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(1, 1000);
+                        CBlock block; // Dummy block, so that ReceivedBlockTransactions can infer a nTx value.
+                        block.vtx = std::vector<CTransactionRef>(nTx);
+                        FlatFilePos pos(0, fuzzed_data_provider.ConsumeIntegralInRange<int>(1, 1000));
+                        chainman.ReceivedBlockTransactions(block, index, pos);
+                        assert(index->nStatus & BLOCK_VALID_TRANSACTIONS);
+                        assert(index->nStatus & BLOCK_HAVE_DATA);
+                    }
+                }
+            },
+            [&] {
+                // Simplified ActivateBestChain(): Try to move to a chain with more work - with the possibility of finding blocks to be invalid on the way
+                LOCK(cs_main);
+                auto& chain = chainman.ActiveChain();
+                CBlockIndex* old_tip = chain.Tip();
+                assert(old_tip);
+                do {
+                    CBlockIndex* best_tip = chainman.FindMostWorkChain();
+                    assert(best_tip);                   // Should at least return current tip
+                    if (best_tip == chain.Tip()) break; // Nothing to do
+                    // Rewind chain to forking point
+                    const CBlockIndex* fork = chain.FindFork(best_tip);
+                    // If we can't go back to the fork point due to pruned data, abort this run. In reality, a pruned node would also currently just crash in this scenario.
+                    // This is very unlikely to happen due to the minimum pruning threshold of 550MiB.
+                    CBlockIndex* it = chain.Tip();
+                    while (it && it->nHeight != fork->nHeight) {
+                        if (!(it->nStatus & BLOCK_HAVE_UNDO)) {
+                            assert(blockman.m_have_pruned);
+                            abort_run = true;
+                            return;
+                        }
+                        it = it->pprev;
+                    }
+                    chain.SetTip(*chain[fork->nHeight]);
+
+                    // Prepare new blocks to connect
+                    std::vector<CBlockIndex*> to_connect;
+                    it = best_tip;
+                    while (it && it->nHeight != fork->nHeight) {
+                        to_connect.push_back(it);
+                        it = it->pprev;
+                    }
+                    // Connect blocks, possibly fail
+                    for (CBlockIndex* block : to_connect | std::views::reverse) {
+                        assert(!(block->nStatus & BLOCK_FAILED_MASK));
+                        assert(block->nStatus & BLOCK_HAVE_DATA);
+                        if (!block->IsValid(BLOCK_VALID_SCRIPTS)) {
+                            if (fuzzed_data_provider.ConsumeBool()) { // Invalid
+                                BlockValidationState state;
+                                state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "consensus-invalid");
+                                chainman.InvalidBlockFound(block, state);
+                                // This results in duplicate calls to InvalidChainFound, but mirrors the behavior in validation
+                                chainman.InvalidChainFound(to_connect.front());
+                                break;
+                            } else {
+                                block->RaiseValidity(BLOCK_VALID_SCRIPTS);
+                                block->nStatus |= BLOCK_HAVE_UNDO;
+                            }
+                        }
+                        chain.SetTip(*block);
+                        chainman.ActiveChainstate().PruneBlockIndexCandidates();
+                        // ActivateBestChainStep may release cs_main / not connect all blocks in one go - but only if we have at least as much chain work as we had at the start.
+                        if (block->nChainWork > old_tip->nChainWork && fuzzed_data_provider.ConsumeBool()) {
+                            break;
+                        }
+                    }
+                } while (node::CBlockIndexWorkComparator()(chain.Tip(), old_tip));
+                assert(chain.Tip()->nChainWork >= old_tip->nChainWork);
+            },
+            [&] {
+                // Prune chain - dealing with block files is beyond the scope of this test, so just prune random blocks, making no assumptions
+                // about what blocks are pruned together because they are in the same block file.
+                // Also don't prune blocks outside of the chain for now - this would make the fuzzer crash because of the problem described in
+                // https://github.com/bitcoin/bitcoin/issues/31512
+                LOCK(cs_main);
+                auto& chain = chainman.ActiveChain();
+                int prune_height = fuzzed_data_provider.ConsumeIntegralInRange<int>(0, chain.Height());
+                CBlockIndex* prune_block{chain[prune_height]};
+                if (prune_block != chain.Tip() && (prune_block->nStatus & BLOCK_HAVE_DATA)) {
+                    blockman.m_have_pruned = true;
+                    prune_block->nStatus &= ~BLOCK_HAVE_DATA;
+                    prune_block->nStatus &= ~BLOCK_HAVE_UNDO;
+                    prune_block->nFile = 0;
+                    prune_block->nDataPos = 0;
+                    prune_block->nUndoPos = 0;
+                    auto range = blockman.m_blocks_unlinked.equal_range(prune_block->pprev);
+                    while (range.first != range.second) {
+                        std::multimap<CBlockIndex*, CBlockIndex*>::iterator _it = range.first;
+                        range.first++;
+                        if (_it->second == prune_block) {
+                            blockman.m_blocks_unlinked.erase(_it);
+                        }
+                    }
+                    pruned_blocks.push_back(prune_block);
+                }
+            },
+            [&] {
+                // Download a previously pruned block
+                LOCK(cs_main);
+                size_t num_pruned = pruned_blocks.size();
+                if (num_pruned == 0) return;
+                size_t i = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, num_pruned - 1);
+                CBlockIndex* index = pruned_blocks[i];
+                assert(!(index->nStatus & BLOCK_HAVE_DATA));
+                CBlock block;
+                block.vtx = std::vector<CTransactionRef>(index->nTx); // Set the number of tx to the prior value.
+                FlatFilePos pos(0, fuzzed_data_provider.ConsumeIntegralInRange<int>(1, 1000));
+                chainman.ReceivedBlockTransactions(block, index, pos);
+                assert(index->nStatus & BLOCK_VALID_TRANSACTIONS);
+                assert(index->nStatus & BLOCK_HAVE_DATA);
+                pruned_blocks.erase(pruned_blocks.begin() + i);
+            });
+    }
+    if (!abort_run) {
+        chainman.CheckBlockIndex();
+    }
+
+    // clean up global state changed by last iteration and prepare for next iteration
+    {
+        LOCK(cs_main);
+        genesis->nStatus |= BLOCK_HAVE_DATA;
+        genesis->nStatus |= BLOCK_HAVE_UNDO;
+        chainman.m_best_header = genesis;
+        chainman.ResetBestInvalid();
+        chainman.nBlockSequenceId = 2;
+        chainman.ActiveChain().SetTip(*genesis);
+        chainman.ActiveChainstate().setBlockIndexCandidates.clear();
+        chainman.m_cached_finished_ibd = false;
+        blockman.m_blocks_unlinked.clear();
+        blockman.m_have_pruned = false;
+        blockman.CleanupForFuzzing();
+        // Delete all blocks but Genesis from block index
+        uint256 genesis_hash = genesis->GetBlockHash();
+        for (auto it = blockman.m_block_index.begin(); it != blockman.m_block_index.end();) {
+            if (it->first != genesis_hash) {
+                it = blockman.m_block_index.erase(it);
+            } else {
+                ++it;
+            }
+        }
+        chainman.ActiveChainstate().TryAddBlockIndexCandidate(genesis);
+        assert(blockman.m_block_index.size() == 1);
+        assert(chainman.ActiveChainstate().setBlockIndexCandidates.size() == 1);
+        assert(chainman.ActiveChain().Height() == 0);
+    }
+}
diff --git a/depend/bitcoin/src/test/fuzz/blockfilter.cpp b/depend/bitcoin/src/test/fuzz/blockfilter.cpp
index 17e99ac9..ed0f9e0d 100644
--- a/depend/bitcoin/src/test/fuzz/blockfilter.cpp
+++ b/depend/bitcoin/src/test/fuzz/blockfilter.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/bloom_filter.cpp b/depend/bitcoin/src/test/fuzz/bloom_filter.cpp
index 5dbb463a..af6d8ae4 100644
--- a/depend/bitcoin/src/test/fuzz/bloom_filter.cpp
+++ b/depend/bitcoin/src/test/fuzz/bloom_filter.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/buffered_file.cpp b/depend/bitcoin/src/test/fuzz/buffered_file.cpp
index 75ef8f31..9ba8db2c 100644
--- a/depend/bitcoin/src/test/fuzz/buffered_file.cpp
+++ b/depend/bitcoin/src/test/fuzz/buffered_file.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/chain.cpp b/depend/bitcoin/src/test/fuzz/chain.cpp
index 09053e48..23499dd0 100644
--- a/depend/bitcoin/src/test/fuzz/chain.cpp
+++ b/depend/bitcoin/src/test/fuzz/chain.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/checkqueue.cpp b/depend/bitcoin/src/test/fuzz/checkqueue.cpp
index e053fa61..5b858ffa 100644
--- a/depend/bitcoin/src/test/fuzz/checkqueue.cpp
+++ b/depend/bitcoin/src/test/fuzz/checkqueue.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/cluster_linearize.cpp b/depend/bitcoin/src/test/fuzz/cluster_linearize.cpp
index 61b95c71..ccf1be68 100644
--- a/depend/bitcoin/src/test/fuzz/cluster_linearize.cpp
+++ b/depend/bitcoin/src/test/fuzz/cluster_linearize.cpp
@@ -24,29 +24,22 @@
  *          possibly by comparison with other implementations (at the end of the line ->).
  *   <<---: The right side is implemented using the left side.
  *
- *   +-----------------------+
- *   | SearchCandidateFinder | <<---------------------\
- *   +-----------------------+                        |
- *     |                                            +-----------+
- *     |                                            | Linearize |
- *     |                                            +-----------+
- *     |        +-------------------------+           |  |
- *     |        | AncestorCandidateFinder | <<--------/  |
- *     |        +-------------------------+              |
- *     |          |                     ^                |        ^^  PRODUCTION CODE
- *     |          |                     |                |        ||
+ *   +---------------------+                        +-----------+
+ *   | SpanningForestState | <<-------------------- | Linearize |
+ *   +---------------------+                        +-----------+
+ *               |                                       |
+ *               |                                       |        ^^  PRODUCTION CODE
+ *               |                                       |        ||
  *  ==============================================================================================
- *     |          |                     |                |        ||
- *     | clusterlin_ancestor_finder*    |                |        vv  TEST CODE
- *     |                                |                |
- *     |-clusterlin_search_finder*      |                |-clusterlin_linearize*
- *     |                                |                |
- *     v                                |                v
- *   +-----------------------+          |           +-----------------+
+ *               |                                       |        ||
+ *               |-clusterlin_sfl*                       |        vv  TEST CODE
+ *               |                                       |
+ *               \------------------------------------\  |-clusterlin_linearize*
+ *                                                    |  |
+ *                                                    v  v
+ *   +-----------------------+                      +-----------------+
  *   | SimpleCandidateFinder | <<-------------------| SimpleLinearize |
- *   +-----------------------+          |           +-----------------+
- *                  |                   |                |
- *                  +-------------------/                |
+ *   +-----------------------+                      +-----------------+
  *                  |                                    |
  *                  |-clusterlin_simple_finder*          |-clusterlin_simple_linearize*
  *                  v                                    v
@@ -59,15 +52,12 @@
  *   - clusterlin_depgraph_sim
  *   - clusterlin_depgraph_serialization
  *   - clusterlin_components
- * - ChunkLinearization and LinearizationChunking tests:
+ * - ChunkLinearization and ChunkLinearizationInfo tests:
  *   - clusterlin_chunking
- *   - clusterlin_linearization_chunking
  * - PostLinearize tests:
  *   - clusterlin_postlinearize
  *   - clusterlin_postlinearize_tree
  *   - clusterlin_postlinearize_moved_leaf
- * - MergeLinearization tests:
- *   - clusterlin_merge
  * - FixLinearization tests:
  *   - clusterlin_fix_linearization
  * - MakeConnected tests (a test-only function):
@@ -78,11 +68,8 @@ using namespace cluster_linearize;
 
 namespace {
 
-/** A simple finder class for candidate sets.
- *
- * This class matches SearchCandidateFinder in interface and behavior, though with fewer
- * optimizations.
- */
+/** A simple finder class for candidate sets (topologically-valid subsets with high feerate), only
+ *  used by SimpleLinearize below. */
 template<typename SetType>
 class SimpleCandidateFinder
 {
@@ -153,7 +140,8 @@ class SimpleCandidateFinder
 /** A very simple finder class for optimal candidate sets, which tries every subset.
  *
  * It is even simpler than SimpleCandidateFinder, and exists just to help test the correctness of
- * SimpleCandidateFinder, which is then used to test the correctness of SearchCandidateFinder.
+ * SimpleCandidateFinder, so that it can be used in SimpleLinearize, which is then used to test the
+ * correctness of Linearize.
  */
 template<typename SetType>
 class ExhaustiveCandidateFinder
@@ -204,8 +192,8 @@ class ExhaustiveCandidateFinder
 /** A simple linearization algorithm.
  *
  * This matches Linearize() in interface and behavior, though with fewer optimizations, lacking
- * the ability to pass in an existing linearization, and using just SimpleCandidateFinder rather
- * than AncestorCandidateFinder and SearchCandidateFinder.
+ * the ability to pass in an existing linearization, and linearizing by simply finding the
+ * consecutive remaining highest-feerate topological subset using SimpleCandidateFinder.
  */
 template<typename SetType>
 std::pair<std::vector<DepGraphIndex>, bool> SimpleLinearize(const DepGraph<SetType>& depgraph, uint64_t max_iterations)
@@ -328,18 +316,24 @@ SetType ReadTopologicalSet(const DepGraph<SetType>& depgraph, const SetType& tod
 
 /** Given a dependency graph, construct any valid linearization for it, reading from a SpanReader. */
 template<typename BS>
-std::vector<DepGraphIndex> ReadLinearization(const DepGraph<BS>& depgraph, SpanReader& reader)
+std::vector<DepGraphIndex> ReadLinearization(const DepGraph<BS>& depgraph, SpanReader& reader, bool topological=true)
 {
     std::vector<DepGraphIndex> linearization;
     TestBitSet todo = depgraph.Positions();
-    // In every iteration one topologically-valid transaction is appended to linearization.
+    // In every iteration one transaction is appended to linearization.
     while (todo.Any()) {
-        // Compute the set of transactions with no not-yet-included ancestors.
+        // Compute the set of transactions to select from.
         TestBitSet potential_next;
-        for (auto j : todo) {
-            if ((depgraph.Ancestors(j) & todo) == TestBitSet::Singleton(j)) {
-                potential_next.Set(j);
+        if (topological) {
+            // Find all transactions with no not-yet-included ancestors.
+            for (auto j : todo) {
+                if ((depgraph.Ancestors(j) & todo) == TestBitSet::Singleton(j)) {
+                    potential_next.Set(j);
+                }
             }
+        } else {
+            // Allow any element to be selected next, regardless of topology.
+            potential_next = todo;
         }
         // There must always be one (otherwise there is a cycle in the graph).
         assert(potential_next.Any());
@@ -364,6 +358,45 @@ std::vector<DepGraphIndex> ReadLinearization(const DepGraph<BS>& depgraph, SpanR
     return linearization;
 }
 
+/** Given a dependency graph, construct a tree-structured graph.
+ *
+ * Copies the nodes from the depgraph, but only keeps the first parent (even direction)
+ * or the first child (odd direction) for each transaction.
+ */
+template<typename BS>
+DepGraph<BS> BuildTreeGraph(const DepGraph<BS>& depgraph, uint8_t direction)
+{
+    DepGraph<BS> depgraph_tree;
+    for (DepGraphIndex i = 0; i < depgraph.PositionRange(); ++i) {
+        if (depgraph.Positions()[i]) {
+            depgraph_tree.AddTransaction(depgraph.FeeRate(i));
+        } else {
+            // For holes, add a dummy transaction which is deleted below, so that non-hole
+            // transactions retain their position.
+            depgraph_tree.AddTransaction(FeeFrac{});
+        }
+    }
+    depgraph_tree.RemoveTransactions(BS::Fill(depgraph.PositionRange()) - depgraph.Positions());
+
+    if (direction & 1) {
+        for (DepGraphIndex i : depgraph.Positions()) {
+            auto children = depgraph.GetReducedChildren(i);
+            if (children.Any()) {
+                depgraph_tree.AddDependencies(BS::Singleton(i), children.First());
+            }
+        }
+    } else {
+        for (DepGraphIndex i : depgraph.Positions()) {
+            auto parents = depgraph.GetReducedParents(i);
+            if (parents.Any()) {
+                depgraph_tree.AddDependencies(BS::Singleton(parents.First()), i);
+            }
+        }
+    }
+
+    return depgraph_tree;
+}
+
 } // namespace
 
 FUZZ_TARGET(clusterlin_depgraph_sim)
@@ -693,8 +726,16 @@ FUZZ_TARGET(clusterlin_chunking)
     // Read a valid linearization for depgraph.
     auto linearization = ReadLinearization(depgraph, reader);
 
-    // Invoke the chunking function.
+    // Invoke the chunking functions.
     auto chunking = ChunkLinearization(depgraph, linearization);
+    auto chunking_info = ChunkLinearizationInfo(depgraph, linearization);
+
+    // Verify consistency between the two functions.
+    assert(chunking.size() == chunking_info.size());
+    for (size_t i = 0; i < chunking.size(); ++i) {
+        assert(chunking[i] == chunking_info[i].feerate);
+        assert(SetInfo(depgraph, chunking_info[i].transactions) == chunking_info[i]);
+    }
 
     // Verify that chunk feerates are monotonically non-increasing.
     for (size_t i = 1; i < chunking.size(); ++i) {
@@ -703,7 +744,7 @@ FUZZ_TARGET(clusterlin_chunking)
 
     // Naively recompute the chunks (each is the highest-feerate prefix of what remains).
     auto todo = depgraph.Positions();
-    for (const auto& chunk_feerate : chunking) {
+    for (const auto& [chunk_set, chunk_feerate] : chunking_info) {
         assert(todo.Any());
         SetInfo<TestBitSet> accumulator, best;
         for (DepGraphIndex idx : linearization) {
@@ -715,74 +756,24 @@ FUZZ_TARGET(clusterlin_chunking)
             }
         }
         assert(chunk_feerate == best.feerate);
+        assert(chunk_set == best.transactions);
         assert(best.transactions.IsSubsetOf(todo));
         todo -= best.transactions;
     }
     assert(todo.None());
 }
 
-FUZZ_TARGET(clusterlin_ancestor_finder)
-{
-    // Verify that AncestorCandidateFinder works as expected.
-
-    // Retrieve a depgraph from the fuzz input.
-    SpanReader reader(buffer);
-    DepGraph<TestBitSet> depgraph;
-    try {
-        reader >> Using<DepGraphFormatter>(depgraph);
-    } catch (const std::ios_base::failure&) {}
-
-    AncestorCandidateFinder anc_finder(depgraph);
-    auto todo = depgraph.Positions();
-    while (todo.Any()) {
-        // Call the ancestor finder's FindCandidateSet for what remains of the graph.
-        assert(!anc_finder.AllDone());
-        assert(todo.Count() == anc_finder.NumRemaining());
-        auto best_anc = anc_finder.FindCandidateSet();
-        // Sanity check the result.
-        assert(best_anc.transactions.Any());
-        assert(best_anc.transactions.IsSubsetOf(todo));
-        assert(depgraph.FeeRate(best_anc.transactions) == best_anc.feerate);
-        assert(depgraph.IsConnected(best_anc.transactions));
-        // Check that it is topologically valid.
-        for (auto i : best_anc.transactions) {
-            assert((depgraph.Ancestors(i) & todo).IsSubsetOf(best_anc.transactions));
-        }
-
-        // Compute all remaining ancestor sets.
-        std::optional<SetInfo<TestBitSet>> real_best_anc;
-        for (auto i : todo) {
-            SetInfo info(depgraph, todo & depgraph.Ancestors(i));
-            if (!real_best_anc.has_value() || info.feerate > real_best_anc->feerate) {
-                real_best_anc = info;
-            }
-        }
-        // The set returned by anc_finder must equal the real best ancestor sets.
-        assert(real_best_anc.has_value());
-        assert(*real_best_anc == best_anc);
-
-        // Find a non-empty topologically valid subset of transactions to remove from the graph.
-        // Using an empty set would mean the next iteration is identical to the current one, and
-        // could cause an infinite loop.
-        auto del_set = ReadTopologicalSet(depgraph, todo, reader, /*non_empty=*/true);
-        todo -= del_set;
-        anc_finder.MarkDone(del_set);
-    }
-    assert(anc_finder.AllDone());
-    assert(anc_finder.NumRemaining() == 0);
-}
-
 static constexpr auto MAX_SIMPLE_ITERATIONS = 300000;
 
 FUZZ_TARGET(clusterlin_simple_finder)
 {
     // Verify that SimpleCandidateFinder works as expected by sanity checking the results
     // and comparing them (if claimed to be optimal) against the sets found by
-    // ExhaustiveCandidateFinder and AncestorCandidateFinder.
+    // ExhaustiveCandidateFinder.
     //
     // Note that SimpleCandidateFinder is only used in tests; the purpose of this fuzz test is to
-    // establish confidence in SimpleCandidateFinder, so that it can be used to test
-    // SearchCandidateFinder below.
+    // establish confidence in SimpleCandidateFinder, so that it can be used in SimpleLinearize,
+    // which is then used to test Linearize below.
 
     // Retrieve a depgraph from the fuzz input.
     SpanReader reader(buffer);
@@ -791,18 +782,15 @@ FUZZ_TARGET(clusterlin_simple_finder)
         reader >> Using<DepGraphFormatter>(depgraph);
     } catch (const std::ios_base::failure&) {}
 
-    // Instantiate the SimpleCandidateFinder to be tested, and the ExhaustiveCandidateFinder and
-    // AncestorCandidateFinder it is being tested against.
+    // Instantiate the SimpleCandidateFinder to be tested, and the ExhaustiveCandidateFinder it is
+    // being tested against.
     SimpleCandidateFinder smp_finder(depgraph);
     ExhaustiveCandidateFinder exh_finder(depgraph);
-    AncestorCandidateFinder anc_finder(depgraph);
 
     auto todo = depgraph.Positions();
     while (todo.Any()) {
         assert(!smp_finder.AllDone());
         assert(!exh_finder.AllDone());
-        assert(!anc_finder.AllDone());
-        assert(anc_finder.NumRemaining() == todo.Count());
 
         // Call SimpleCandidateFinder.
         auto [found, iterations_done] = smp_finder.FindCandidateSet(MAX_SIMPLE_ITERATIONS);
@@ -829,10 +817,6 @@ FUZZ_TARGET(clusterlin_simple_finder)
 
         // Perform further quality checks only if SimpleCandidateFinder claims an optimal result.
         if (optimal) {
-            // Compare with AncestorCandidateFinder.
-            auto anc = anc_finder.FindCandidateSet();
-            assert(anc.feerate <= found.feerate);
-
             if (todo.Count() <= 12) {
                 // Compare with ExhaustiveCandidateFinder. This quickly gets computationally
                 // expensive for large clusters (O(2^n)), so only do it for sufficiently small ones.
@@ -853,234 +837,10 @@ FUZZ_TARGET(clusterlin_simple_finder)
         todo -= del_set;
         smp_finder.MarkDone(del_set);
         exh_finder.MarkDone(del_set);
-        anc_finder.MarkDone(del_set);
     }
 
     assert(smp_finder.AllDone());
     assert(exh_finder.AllDone());
-    assert(anc_finder.AllDone());
-    assert(anc_finder.NumRemaining() == 0);
-}
-
-FUZZ_TARGET(clusterlin_search_finder)
-{
-    // Verify that SearchCandidateFinder works as expected by sanity checking the results
-    // and comparing with the results from SimpleCandidateFinder and AncestorCandidateFinder,
-    // if the result is claimed to be optimal.
-
-    // Retrieve an RNG seed, a depgraph, and whether to make it connected, from the fuzz input.
-    SpanReader reader(buffer);
-    DepGraph<TestBitSet> depgraph;
-    uint64_t rng_seed{0};
-    uint8_t make_connected{1};
-    try {
-        reader >> Using<DepGraphFormatter>(depgraph) >> rng_seed >> make_connected;
-    } catch (const std::ios_base::failure&) {}
-    // The most complicated graphs are connected ones (other ones just split up). Optionally force
-    // the graph to be connected.
-    if (make_connected) MakeConnected(depgraph);
-
-    // Instantiate the candidate finders.
-    SearchCandidateFinder src_finder(depgraph, rng_seed);
-    SimpleCandidateFinder smp_finder(depgraph);
-    AncestorCandidateFinder anc_finder(depgraph);
-
-    auto todo = depgraph.Positions();
-    while (todo.Any()) {
-        assert(!src_finder.AllDone());
-        assert(!smp_finder.AllDone());
-        assert(!anc_finder.AllDone());
-        assert(anc_finder.NumRemaining() == todo.Count());
-
-        // For each iteration, read an iteration count limit from the fuzz input.
-        uint64_t max_iterations = 1;
-        try {
-            reader >> VARINT(max_iterations);
-        } catch (const std::ios_base::failure&) {}
-        max_iterations &= 0xfffff;
-
-        // Read an initial subset from the fuzz input (allowed to be empty).
-        auto init_set = ReadTopologicalSet(depgraph, todo, reader, /*non_empty=*/false);
-        SetInfo init_best(depgraph, init_set);
-
-        // Call the search finder's FindCandidateSet for what remains of the graph.
-        auto [found, iterations_done] = src_finder.FindCandidateSet(max_iterations, init_best);
-        bool optimal = iterations_done < max_iterations;
-
-        // Sanity check the result.
-        assert(iterations_done <= max_iterations);
-        assert(found.transactions.Any());
-        assert(found.transactions.IsSubsetOf(todo));
-        assert(depgraph.FeeRate(found.transactions) == found.feerate);
-        if (!init_best.feerate.IsEmpty()) assert(found.feerate >= init_best.feerate);
-        // Check that it is topologically valid.
-        for (auto i : found.transactions) {
-            assert(found.transactions.IsSupersetOf(depgraph.Ancestors(i) & todo));
-        }
-
-        // At most 2^(N-1) iterations can be required: the maximum number of non-empty topological
-        // subsets a (connected) cluster with N transactions can have. Even when the cluster is no
-        // longer connected after removing certain transactions, this holds, because the connected
-        // components are searched separately.
-        assert(iterations_done <= (uint64_t{1} << (todo.Count() - 1)));
-        // Additionally, test that no more than sqrt(2^N)+1 iterations are required. This is just
-        // an empirical bound that seems to hold, without proof. Still, add a test for it so we
-        // can learn about counterexamples if they exist.
-        if (iterations_done >= 1 && todo.Count() <= 63) {
-            Assume((iterations_done - 1) * (iterations_done - 1) <= uint64_t{1} << todo.Count());
-        }
-
-        // Perform quality checks only if SearchCandidateFinder claims an optimal result.
-        if (optimal) {
-            // Optimal sets are always connected.
-            assert(depgraph.IsConnected(found.transactions));
-
-            // Compare with SimpleCandidateFinder.
-            auto [simple, simple_iters] = smp_finder.FindCandidateSet(MAX_SIMPLE_ITERATIONS);
-            assert(found.feerate >= simple.feerate);
-            if (simple_iters < MAX_SIMPLE_ITERATIONS) {
-                assert(found.feerate == simple.feerate);
-            }
-
-            // Compare with AncestorCandidateFinder;
-            auto anc = anc_finder.FindCandidateSet();
-            assert(found.feerate >= anc.feerate);
-
-            // Compare with a non-empty topological set read from the fuzz input (comparing with an
-            // empty set is not interesting).
-            auto read_topo = ReadTopologicalSet(depgraph, todo, reader, /*non_empty=*/true);
-            assert(found.feerate >= depgraph.FeeRate(read_topo));
-        }
-
-        // Find a non-empty topologically valid subset of transactions to remove from the graph.
-        // Using an empty set would mean the next iteration is identical to the current one, and
-        // could cause an infinite loop.
-        auto del_set = ReadTopologicalSet(depgraph, todo, reader, /*non_empty=*/true);
-        todo -= del_set;
-        src_finder.MarkDone(del_set);
-        smp_finder.MarkDone(del_set);
-        anc_finder.MarkDone(del_set);
-    }
-
-    assert(src_finder.AllDone());
-    assert(smp_finder.AllDone());
-    assert(anc_finder.AllDone());
-    assert(anc_finder.NumRemaining() == 0);
-}
-
-FUZZ_TARGET(clusterlin_linearization_chunking)
-{
-    // Verify the behavior of LinearizationChunking.
-
-    // Retrieve a depgraph from the fuzz input.
-    SpanReader reader(buffer);
-    DepGraph<TestBitSet> depgraph;
-    try {
-        reader >> Using<DepGraphFormatter>(depgraph);
-    } catch (const std::ios_base::failure&) {}
-
-    // Retrieve a topologically-valid subset of depgraph (allowed to be empty, because the argument
-    // to LinearizationChunking::Intersect is allowed to be empty).
-    auto todo = depgraph.Positions();
-    auto subset = SetInfo(depgraph, ReadTopologicalSet(depgraph, todo, reader, /*non_empty=*/false));
-
-    // Retrieve a valid linearization for depgraph.
-    auto linearization = ReadLinearization(depgraph, reader);
-
-    // Construct a LinearizationChunking object, initially for the whole linearization.
-    LinearizationChunking chunking(depgraph, linearization);
-
-    // Incrementally remove transactions from the chunking object, and check various properties at
-    // every step.
-    while (todo.Any()) {
-        assert(chunking.NumChunksLeft() > 0);
-
-        // Construct linearization with just todo.
-        std::vector<DepGraphIndex> linearization_left;
-        for (auto i : linearization) {
-            if (todo[i]) linearization_left.push_back(i);
-        }
-
-        // Compute the chunking for linearization_left.
-        auto chunking_left = ChunkLinearization(depgraph, linearization_left);
-
-        // Verify that it matches the feerates of the chunks of chunking.
-        assert(chunking.NumChunksLeft() == chunking_left.size());
-        for (DepGraphIndex i = 0; i < chunking.NumChunksLeft(); ++i) {
-            assert(chunking.GetChunk(i).feerate == chunking_left[i]);
-        }
-
-        // Check consistency of chunking.
-        TestBitSet combined;
-        for (DepGraphIndex i = 0; i < chunking.NumChunksLeft(); ++i) {
-            const auto& chunk_info = chunking.GetChunk(i);
-            // Chunks must be non-empty.
-            assert(chunk_info.transactions.Any());
-            // Chunk feerates must be monotonically non-increasing.
-            if (i > 0) assert(!(chunk_info.feerate >> chunking.GetChunk(i - 1).feerate));
-            // Chunks must be a subset of what is left of the linearization.
-            assert(chunk_info.transactions.IsSubsetOf(todo));
-            // Chunks' claimed feerates must match their transactions' aggregate feerate.
-            assert(depgraph.FeeRate(chunk_info.transactions) == chunk_info.feerate);
-            // Chunks must be the highest-feerate remaining prefix.
-            SetInfo<TestBitSet> accumulator, best;
-            for (auto j : linearization) {
-                if (todo[j] && !combined[j]) {
-                    accumulator.Set(depgraph, j);
-                    if (best.feerate.IsEmpty() || accumulator.feerate > best.feerate) {
-                        best = accumulator;
-                    }
-                }
-            }
-            assert(best.transactions == chunk_info.transactions);
-            assert(best.feerate == chunk_info.feerate);
-            // Chunks cannot overlap.
-            assert(!chunk_info.transactions.Overlaps(combined));
-            combined |= chunk_info.transactions;
-            // Chunks must be topological.
-            for (auto idx : chunk_info.transactions) {
-                assert((depgraph.Ancestors(idx) & todo).IsSubsetOf(combined));
-            }
-        }
-        assert(combined == todo);
-
-        // Verify the expected properties of LinearizationChunking::IntersectPrefixes:
-        auto intersect = chunking.IntersectPrefixes(subset);
-        // - Intersecting again doesn't change the result.
-        assert(chunking.IntersectPrefixes(intersect) == intersect);
-        // - The intersection is topological.
-        TestBitSet intersect_anc;
-        for (auto idx : intersect.transactions) {
-            intersect_anc |= (depgraph.Ancestors(idx) & todo);
-        }
-        assert(intersect.transactions == intersect_anc);
-        // - The claimed intersection feerate matches its transactions.
-        assert(intersect.feerate == depgraph.FeeRate(intersect.transactions));
-        // - The intersection may only be empty if its input is empty.
-        assert(intersect.transactions.Any() == subset.transactions.Any());
-        // - The intersection feerate must be as high as the input.
-        assert(intersect.feerate >= subset.feerate);
-        // - No non-empty intersection between the intersection and a prefix of the chunks of the
-        //   remainder of the linearization may be better than the intersection.
-        TestBitSet prefix;
-        for (DepGraphIndex i = 0; i < chunking.NumChunksLeft(); ++i) {
-            prefix |= chunking.GetChunk(i).transactions;
-            auto reintersect = SetInfo(depgraph, prefix & intersect.transactions);
-            if (!reintersect.feerate.IsEmpty()) {
-                assert(reintersect.feerate <= intersect.feerate);
-            }
-        }
-
-        // Find a non-empty topologically valid subset of transactions to remove from the graph.
-        // Using an empty set would mean the next iteration is identical to the current one, and
-        // could cause an infinite loop.
-        auto done = ReadTopologicalSet(depgraph, todo, reader, /*non_empty=*/true);
-        todo -= done;
-        chunking.MarkDone(done);
-        subset = SetInfo(depgraph, subset.transactions - done);
-    }
-
-    assert(chunking.NumChunksLeft() == 0);
 }
 
 FUZZ_TARGET(clusterlin_simple_linearize)
@@ -1130,6 +890,104 @@ FUZZ_TARGET(clusterlin_simple_linearize)
     }
 }
 
+FUZZ_TARGET(clusterlin_sfl)
+{
+    // Verify the individual steps of the SFL algorithm.
+
+    SpanReader reader(buffer);
+    DepGraph<TestBitSet> depgraph;
+    uint8_t flags{1};
+    uint64_t rng_seed{0};
+    try {
+        reader >> rng_seed >> flags >> Using<DepGraphFormatter>(depgraph);
+    } catch (const std::ios_base::failure&) {}
+    if (depgraph.TxCount() <= 1) return;
+    InsecureRandomContext rng(rng_seed);
+    /** Whether to make the depgraph connected. */
+    const bool make_connected = flags & 1;
+    /** Whether to load some input linearization into the state. */
+    const bool load_linearization = flags & 2;
+    /** Whether that input linearization is topological. */
+    const bool load_topological = load_linearization && (flags & 4);
+
+    // Initialize SFL state.
+    if (make_connected) MakeConnected(depgraph);
+    SpanningForestState sfl(depgraph, rng.rand64());
+
+    // Function to test the state.
+    std::vector<FeeFrac> last_diagram;
+    auto test_fn = [&](bool is_optimal = false) {
+        if (rng.randbits(4) == 0) {
+            // Perform sanity checks from time to time (too computationally expensive to do after
+            // every step).
+            sfl.SanityCheck(depgraph);
+        }
+        auto diagram = sfl.GetDiagram();
+        if (rng.randbits(4) == 0) {
+            // Verify that the diagram of GetLinearization() is at least as good as GetDiagram(),
+            // from time to time.
+            auto lin = sfl.GetLinearization();
+            auto lin_diagram = ChunkLinearization(depgraph, lin);
+            auto cmp_lin = CompareChunks(lin_diagram, diagram);
+            assert(cmp_lin >= 0);
+            // If we're in an allegedly optimal state, they must match.
+            if (is_optimal) assert(cmp_lin == 0);
+        }
+        // Verify that subsequent calls to GetDiagram() never get worse/incomparable.
+        if (!last_diagram.empty()) {
+            auto cmp = CompareChunks(diagram, last_diagram);
+            assert(cmp >= 0);
+        }
+        last_diagram = std::move(diagram);
+    };
+
+    if (load_linearization) {
+        auto input_lin = ReadLinearization(depgraph, reader, load_topological);
+        sfl.LoadLinearization(input_lin);
+        if (load_topological) {
+            // The diagram of the loaded linearization forms an initial lower bound on future
+            // diagrams.
+            last_diagram = ChunkLinearization(depgraph, input_lin);
+        } else {
+            // The input linearization may have been non-topological, so invoke MakeTopological to
+            // fix it still.
+            sfl.MakeTopological();
+        }
+    } else {
+        // Invoke MakeTopological to create an initial from-scratch topological state.
+        sfl.MakeTopological();
+    }
+
+    // Loop until optimal.
+    test_fn();
+    sfl.StartOptimizing();
+    while (true) {
+        test_fn();
+        if (!sfl.OptimizeStep()) break;
+    }
+    test_fn(/*is_optimal=*/true);
+
+    // Verify that optimality is reached within an expected amount of work. This protects against
+    // hypothetical bugs that hugely increase the amount of work needed to reach optimality.
+    assert(sfl.GetCost() <= MaxOptimalLinearizationIters(depgraph.TxCount()));
+
+    // The result must be as good as SimpleLinearize.
+    auto [simple_linearization, simple_optimal] = SimpleLinearize(depgraph, MAX_SIMPLE_ITERATIONS / 10);
+    auto simple_diagram = ChunkLinearization(depgraph, simple_linearization);
+    auto simple_cmp = CompareChunks(last_diagram, simple_diagram);
+    assert(simple_cmp >= 0);
+    if (simple_optimal) assert(simple_cmp == 0);
+
+    // We can compare with any arbitrary linearization, and the diagram must be at least as good as
+    // each.
+    for (int i = 0; i < 10; ++i) {
+        auto read_lin = ReadLinearization(depgraph, reader);
+        auto read_diagram = ChunkLinearization(depgraph, read_lin);
+        auto cmp = CompareChunks(last_diagram, read_diagram);
+        assert(cmp >= 0);
+    }
+}
+
 FUZZ_TARGET(clusterlin_linearize)
 {
     // Verify the behavior of Linearize().
@@ -1164,7 +1022,6 @@ FUZZ_TARGET(clusterlin_linearize)
     // Invoke Linearize().
     iter_count &= 0x7ffff;
     auto [linearization, optimal, cost] = Linearize(depgraph, iter_count, rng_seed, old_linearization);
-    assert(cost <= iter_count);
     SanityCheck(depgraph, linearization);
     auto chunking = ChunkLinearization(depgraph, linearization);
 
@@ -1176,7 +1033,7 @@ FUZZ_TARGET(clusterlin_linearize)
     }
 
     // If the iteration count is sufficiently high, an optimal linearization must be found.
-    if (iter_count >= MaxOptimalLinearizationIters(depgraph.TxCount())) {
+    if (iter_count > MaxOptimalLinearizationIters(depgraph.TxCount())) {
         assert(optimal);
     }
 
@@ -1191,9 +1048,13 @@ FUZZ_TARGET(clusterlin_linearize)
         // If SimpleLinearize finds the optimal result too, they must be equal (if not,
         // SimpleLinearize is broken).
         if (simple_optimal) assert(cmp == 0);
-        // If simple_chunking is diagram-optimal, it cannot have more chunks than chunking (as
-        // chunking is claimed to be optimal, which implies minimal chunks).
-        if (cmp == 0) assert(chunking.size() >= simple_chunking.size());
+
+        // Temporarily disabled, as Linearize() currently does not guarantee minimal chunks, even
+        // when it reports an optimal result. This will be re-introduced in a later commit.
+        //
+        // // If simple_chunking is diagram-optimal, it cannot have more chunks than chunking (as
+        // // chunking is claimed to be optimal, which implies minimal chunks).
+        // if (cmp == 0) assert(chunking.size() >= simple_chunking.size());
 
         // Compare with a linearization read from the fuzz input.
         auto read = ReadLinearization(depgraph, reader);
@@ -1239,10 +1100,9 @@ FUZZ_TARGET(clusterlin_postlinearize)
     assert(cmp >= 0);
 
     // The chunks that come out of postlinearizing are always connected.
-    LinearizationChunking linchunking(depgraph, post_linearization);
-    while (linchunking.NumChunksLeft()) {
-        assert(depgraph.IsConnected(linchunking.GetChunk(0).transactions));
-        linchunking.MarkDone(linchunking.GetChunk(0).transactions);
+    auto linchunking = ChunkLinearizationInfo(depgraph, post_linearization);
+    for (const auto& [chunk_set, _chunk_feerate] : linchunking) {
+        assert(depgraph.IsConnected(chunk_set));
     }
 }
 
@@ -1260,35 +1120,7 @@ FUZZ_TARGET(clusterlin_postlinearize_tree)
         reader >> direction >> rng_seed >> Using<DepGraphFormatter>(depgraph_gen);
     } catch (const std::ios_base::failure&) {}
 
-    // Now construct a new graph, copying the nodes, but leaving only the first parent (even
-    // direction) or the first child (odd direction).
-    DepGraph<TestBitSet> depgraph_tree;
-    for (DepGraphIndex i = 0; i < depgraph_gen.PositionRange(); ++i) {
-        if (depgraph_gen.Positions()[i]) {
-            depgraph_tree.AddTransaction(depgraph_gen.FeeRate(i));
-        } else {
-            // For holes, add a dummy transaction which is deleted below, so that non-hole
-            // transactions retain their position.
-            depgraph_tree.AddTransaction(FeeFrac{});
-        }
-    }
-    depgraph_tree.RemoveTransactions(TestBitSet::Fill(depgraph_gen.PositionRange()) - depgraph_gen.Positions());
-
-    if (direction & 1) {
-        for (DepGraphIndex i = 0; i < depgraph_gen.TxCount(); ++i) {
-            auto children = depgraph_gen.GetReducedChildren(i);
-            if (children.Any()) {
-                depgraph_tree.AddDependencies(TestBitSet::Singleton(i), children.First());
-            }
-         }
-    } else {
-        for (DepGraphIndex i = 0; i < depgraph_gen.TxCount(); ++i) {
-            auto parents = depgraph_gen.GetReducedParents(i);
-            if (parents.Any()) {
-                depgraph_tree.AddDependencies(TestBitSet::Singleton(parents.First()), i);
-            }
-        }
-    }
+    auto depgraph_tree = BuildTreeGraph(depgraph_gen, direction);
 
     // Retrieve a linearization from the fuzz input.
     std::vector<DepGraphIndex> linearization;
@@ -1309,8 +1141,8 @@ FUZZ_TARGET(clusterlin_postlinearize_tree)
     // Verify that post-linearizing again does not change the diagram. The result must be identical
     // as post_linearization ought to be optimal already with a tree-structured graph.
     auto post_post_linearization = post_linearization;
-    PostLinearize(depgraph_tree, post_linearization);
-    SanityCheck(depgraph_tree, post_linearization);
+    PostLinearize(depgraph_tree, post_post_linearization);
+    SanityCheck(depgraph_tree, post_post_linearization);
     auto post_post_chunking = ChunkLinearization(depgraph_tree, post_post_linearization);
     auto cmp_post = CompareChunks(post_post_chunking, post_chunking);
     assert(cmp_post == 0);
@@ -1366,32 +1198,6 @@ FUZZ_TARGET(clusterlin_postlinearize_moved_leaf)
     assert(cmp >= 0);
 }
 
-FUZZ_TARGET(clusterlin_merge)
-{
-    // Construct an arbitrary graph from the fuzz input.
-    SpanReader reader(buffer);
-    DepGraph<TestBitSet> depgraph;
-    try {
-        reader >> Using<DepGraphFormatter>(depgraph);
-    } catch (const std::ios_base::failure&) {}
-
-    // Retrieve two linearizations from the fuzz input.
-    auto lin1 = ReadLinearization(depgraph, reader);
-    auto lin2 = ReadLinearization(depgraph, reader);
-
-    // Merge the two.
-    auto lin_merged = MergeLinearizations(depgraph, lin1, lin2);
-
-    // Compute chunkings and compare.
-    auto chunking1 = ChunkLinearization(depgraph, lin1);
-    auto chunking2 = ChunkLinearization(depgraph, lin2);
-    auto chunking_merged = ChunkLinearization(depgraph, lin_merged);
-    auto cmp1 = CompareChunks(chunking_merged, chunking1);
-    assert(cmp1 >= 0);
-    auto cmp2 = CompareChunks(chunking_merged, chunking2);
-    assert(cmp2 >= 0);
-}
-
 FUZZ_TARGET(clusterlin_fix_linearization)
 {
     // Verify expected properties of FixLinearization() on arbitrary linearizations.
@@ -1404,33 +1210,14 @@ FUZZ_TARGET(clusterlin_fix_linearization)
     } catch (const std::ios_base::failure&) {}
 
     // Construct an arbitrary linearization (not necessarily topological for depgraph).
-    std::vector<DepGraphIndex> linearization;
-    /** Which transactions of depgraph are yet to be included in linearization. */
-    TestBitSet todo = depgraph.Positions();
-    while (todo.Any()) {
-        // Read a number from the fuzz input in range [0, todo.Count()).
-        uint64_t val{0};
-        try {
-            reader >> VARINT(val);
-        } catch (const std::ios_base::failure&) {}
-        val %= todo.Count();
-        // Find the val'th element in todo, remove it from todo, and append it to linearization.
-        for (auto idx : todo) {
-            if (val == 0) {
-                linearization.push_back(idx);
-                todo.Reset(idx);
-                break;
-            }
-            --val;
-        }
-    }
+    std::vector<DepGraphIndex> linearization = ReadLinearization(depgraph, reader, /*topological=*/false);
     assert(linearization.size() == depgraph.TxCount());
 
     // Determine what prefix of linearization is topological, i.e., the position of the first entry
     // in linearization which corresponds to a transaction that is not preceded by all its
     // ancestors.
     size_t topo_prefix = 0;
-    todo = depgraph.Positions();
+    auto todo = depgraph.Positions();
     while (topo_prefix < linearization.size()) {
         DepGraphIndex idx = linearization[topo_prefix];
         todo.Reset(idx);
diff --git a/depend/bitcoin/src/test/fuzz/coinscache_sim.cpp b/depend/bitcoin/src/test/fuzz/coinscache_sim.cpp
index 82e5f1fc..b4ee57e6 100644
--- a/depend/bitcoin/src/test/fuzz/coinscache_sim.cpp
+++ b/depend/bitcoin/src/test/fuzz/coinscache_sim.cpp
@@ -155,7 +155,7 @@ class CoinsViewBottom final : public CCoinsView
 
     bool HaveCoin(const COutPoint& outpoint) const final
     {
-        return m_data.count(outpoint);
+        return m_data.contains(outpoint);
     }
 
     uint256 GetBestBlock() const final { return {}; }
diff --git a/depend/bitcoin/src/test/fuzz/connman.cpp b/depend/bitcoin/src/test/fuzz/connman.cpp
index 5f9841da..4a8b7b21 100644
--- a/depend/bitcoin/src/test/fuzz/connman.cpp
+++ b/depend/bitcoin/src/test/fuzz/connman.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/crypto.cpp b/depend/bitcoin/src/test/fuzz/crypto.cpp
index aa478277..ff918f98 100644
--- a/depend/bitcoin/src/test/fuzz/crypto.cpp
+++ b/depend/bitcoin/src/test/fuzz/crypto.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/crypto_aes256.cpp b/depend/bitcoin/src/test/fuzz/crypto_aes256.cpp
index c5dd79a6..d35919f2 100644
--- a/depend/bitcoin/src/test/fuzz/crypto_aes256.cpp
+++ b/depend/bitcoin/src/test/fuzz/crypto_aes256.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/crypto_aes256cbc.cpp b/depend/bitcoin/src/test/fuzz/crypto_aes256cbc.cpp
index 72bf962f..87064b66 100644
--- a/depend/bitcoin/src/test/fuzz/crypto_aes256cbc.cpp
+++ b/depend/bitcoin/src/test/fuzz/crypto_aes256cbc.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/crypto_common.cpp b/depend/bitcoin/src/test/fuzz/crypto_common.cpp
index 5a76d4e1..415e2d74 100644
--- a/depend/bitcoin/src/test/fuzz/crypto_common.cpp
+++ b/depend/bitcoin/src/test/fuzz/crypto_common.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/crypto_diff_fuzz_chacha20.cpp b/depend/bitcoin/src/test/fuzz/crypto_diff_fuzz_chacha20.cpp
index ab7fa513..5e2f84d6 100644
--- a/depend/bitcoin/src/test/fuzz/crypto_diff_fuzz_chacha20.cpp
+++ b/depend/bitcoin/src/test/fuzz/crypto_diff_fuzz_chacha20.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/crypto_hkdf_hmac_sha256_l32.cpp b/depend/bitcoin/src/test/fuzz/crypto_hkdf_hmac_sha256_l32.cpp
index af6d108c..f5ca9aee 100644
--- a/depend/bitcoin/src/test/fuzz/crypto_hkdf_hmac_sha256_l32.cpp
+++ b/depend/bitcoin/src/test/fuzz/crypto_hkdf_hmac_sha256_l32.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/crypto_poly1305.cpp b/depend/bitcoin/src/test/fuzz/crypto_poly1305.cpp
index 6ce6648f..5a4404cf 100644
--- a/depend/bitcoin/src/test/fuzz/crypto_poly1305.cpp
+++ b/depend/bitcoin/src/test/fuzz/crypto_poly1305.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/cuckoocache.cpp b/depend/bitcoin/src/test/fuzz/cuckoocache.cpp
index f8a5bde3..65468899 100644
--- a/depend/bitcoin/src/test/fuzz/cuckoocache.cpp
+++ b/depend/bitcoin/src/test/fuzz/cuckoocache.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/decode_tx.cpp b/depend/bitcoin/src/test/fuzz/decode_tx.cpp
index 57431e65..194e2c47 100644
--- a/depend/bitcoin/src/test/fuzz/decode_tx.cpp
+++ b/depend/bitcoin/src/test/fuzz/decode_tx.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2020 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/descriptor_parse.cpp b/depend/bitcoin/src/test/fuzz/descriptor_parse.cpp
index 765daa3d..daad5e80 100644
--- a/depend/bitcoin/src/test/fuzz/descriptor_parse.cpp
+++ b/depend/bitcoin/src/test/fuzz/descriptor_parse.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/difference_formatter.cpp b/depend/bitcoin/src/test/fuzz/difference_formatter.cpp
index 15aeda99..1418520d 100644
--- a/depend/bitcoin/src/test/fuzz/difference_formatter.cpp
+++ b/depend/bitcoin/src/test/fuzz/difference_formatter.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2025 The Bitcoin Core developers
+// Copyright (c) 2025-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/fuzz/eval_script.cpp b/depend/bitcoin/src/test/fuzz/eval_script.cpp
index 43e35466..27a78f4e 100644
--- a/depend/bitcoin/src/test/fuzz/eval_script.cpp
+++ b/depend/bitcoin/src/test/fuzz/eval_script.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/feefrac.cpp b/depend/bitcoin/src/test/fuzz/feefrac.cpp
index 6bad3919..d52a4658 100644
--- a/depend/bitcoin/src/test/fuzz/feefrac.cpp
+++ b/depend/bitcoin/src/test/fuzz/feefrac.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2024 The Bitcoin Core developers
+// Copyright (c) 2024-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/fuzz/flatfile.cpp b/depend/bitcoin/src/test/fuzz/flatfile.cpp
index b5c82c14..2ac14e61 100644
--- a/depend/bitcoin/src/test/fuzz/flatfile.cpp
+++ b/depend/bitcoin/src/test/fuzz/flatfile.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/fuzz.cpp b/depend/bitcoin/src/test/fuzz/fuzz.cpp
index ec5b6384..d4d82695 100644
--- a/depend/bitcoin/src/test/fuzz/fuzz.cpp
+++ b/depend/bitcoin/src/test/fuzz/fuzz.cpp
@@ -51,7 +51,7 @@ static std::vector<const char*> g_args;
 static void SetArgs(int argc, char** argv) {
     for (int i = 1; i < argc; ++i) {
         // Only take into account arguments that start with `--`. The others are for the fuzz engine:
-        // `fuzz -runs=1 fuzz_corpora/address_deserialize_v2 --checkaddrman=5`
+        // `fuzz -runs=1 fuzz_corpora/address_deserialize --checkaddrman=5`
         if (strlen(argv[i]) > 2 && argv[i][0] == '-' && argv[i][1] == '-') {
             g_args.push_back(argv[i]);
         }
diff --git a/depend/bitcoin/src/test/fuzz/fuzz.h b/depend/bitcoin/src/test/fuzz/fuzz.h
index c468cd39..f51310eb 100644
--- a/depend/bitcoin/src/test/fuzz/fuzz.h
+++ b/depend/bitcoin/src/test/fuzz/fuzz.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/golomb_rice.cpp b/depend/bitcoin/src/test/fuzz/golomb_rice.cpp
index 066c1686..a09126be 100644
--- a/depend/bitcoin/src/test/fuzz/golomb_rice.cpp
+++ b/depend/bitcoin/src/test/fuzz/golomb_rice.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/http_request.cpp b/depend/bitcoin/src/test/fuzz/http_request.cpp
index f13f1c72..9241060b 100644
--- a/depend/bitcoin/src/test/fuzz/http_request.cpp
+++ b/depend/bitcoin/src/test/fuzz/http_request.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/integer.cpp b/depend/bitcoin/src/test/fuzz/integer.cpp
index 89c29dbc..fcbe76c4 100644
--- a/depend/bitcoin/src/test/fuzz/integer.cpp
+++ b/depend/bitcoin/src/test/fuzz/integer.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/key_io.cpp b/depend/bitcoin/src/test/fuzz/key_io.cpp
index aefdefe2..80365a1b 100644
--- a/depend/bitcoin/src/test/fuzz/key_io.cpp
+++ b/depend/bitcoin/src/test/fuzz/key_io.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/kitchen_sink.cpp b/depend/bitcoin/src/test/fuzz/kitchen_sink.cpp
index 2ff0841a..ec60786f 100644
--- a/depend/bitcoin/src/test/fuzz/kitchen_sink.cpp
+++ b/depend/bitcoin/src/test/fuzz/kitchen_sink.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/load_external_block_file.cpp b/depend/bitcoin/src/test/fuzz/load_external_block_file.cpp
index b5293dd1..06eccf01 100644
--- a/depend/bitcoin/src/test/fuzz/load_external_block_file.cpp
+++ b/depend/bitcoin/src/test/fuzz/load_external_block_file.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/locale.cpp b/depend/bitcoin/src/test/fuzz/locale.cpp
index c0289172..0336f77a 100644
--- a/depend/bitcoin/src/test/fuzz/locale.cpp
+++ b/depend/bitcoin/src/test/fuzz/locale.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/merkle.cpp b/depend/bitcoin/src/test/fuzz/merkle.cpp
index 9ba461bb..0de1c027 100644
--- a/depend/bitcoin/src/test/fuzz/merkle.cpp
+++ b/depend/bitcoin/src/test/fuzz/merkle.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2025 The Bitcoin Core developers
+// Copyright (c) 2025-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -52,7 +52,7 @@ FUZZ_TARGET(merkle)
 
     // Test ComputeMerkleRoot
     bool mutated = fuzzed_data_provider.ConsumeBool(); // output param, initial value shouldn't matter
-    const uint256 merkle_root = ComputeMerkleRoot(tx_hashes, &mutated);
+    const uint256 merkle_root = ComputeMerkleRoot(tx_hashes, fuzzed_data_provider.ConsumeBool() ? &mutated : nullptr);
 
     // Basic sanity checks for ComputeMerkleRoot
     if (tx_hashes.size() == 1) {
diff --git a/depend/bitcoin/src/test/fuzz/merkleblock.cpp b/depend/bitcoin/src/test/fuzz/merkleblock.cpp
index b203acb0..86916fdf 100644
--- a/depend/bitcoin/src/test/fuzz/merkleblock.cpp
+++ b/depend/bitcoin/src/test/fuzz/merkleblock.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/message.cpp b/depend/bitcoin/src/test/fuzz/message.cpp
index 99bbad65..c420552a 100644
--- a/depend/bitcoin/src/test/fuzz/message.cpp
+++ b/depend/bitcoin/src/test/fuzz/message.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/miniscript.cpp b/depend/bitcoin/src/test/fuzz/miniscript.cpp
index 42195313..5d9a39bb 100644
--- a/depend/bitcoin/src/test/fuzz/miniscript.cpp
+++ b/depend/bitcoin/src/test/fuzz/miniscript.cpp
@@ -687,7 +687,7 @@ struct SmartInfo
         while (true) {
             size_t set_size = useful_types.size();
             for (const auto& [type, recipes] : table) {
-                if (useful_types.count(type) != 0) {
+                if (useful_types.contains(type)) {
                     for (const auto& [_, subtypes] : recipes) {
                         for (auto subtype : subtypes) useful_types.insert(subtype);
                     }
@@ -697,7 +697,7 @@ struct SmartInfo
         }
         // Remove all rules that construct uninteresting types.
         for (auto type_it = table.begin(); type_it != table.end();) {
-            if (useful_types.count(type_it->first) == 0) {
+            if (!useful_types.contains(type_it->first)) {
                 type_it = table.erase(type_it);
             } else {
                 ++type_it;
@@ -710,7 +710,7 @@ struct SmartInfo
          * because they can only be constructed using recipes that involve otherwise
          * non-constructible types, or because they require infinite recursion. */
         std::set<Type> constructible_types{};
-        auto known_constructible = [&](Type type) { return constructible_types.count(type) != 0; };
+        auto known_constructible = [&](Type type) { return constructible_types.contains(type); };
         // Find the transitive closure by adding types until the set of types does not change.
         while (true) {
             size_t set_size = constructible_types.size();
@@ -1177,13 +1177,13 @@ void TestNode(const MsCtx script_ctx, const NodeRef& node, FuzzedDataProvider& p
         case Fragment::AFTER:
             return node.k & 1;
         case Fragment::SHA256:
-            return TEST_DATA.sha256_preimages.count(node.data);
+            return TEST_DATA.sha256_preimages.contains(node.data);
         case Fragment::HASH256:
-            return TEST_DATA.hash256_preimages.count(node.data);
+            return TEST_DATA.hash256_preimages.contains(node.data);
         case Fragment::RIPEMD160:
-            return TEST_DATA.ripemd160_preimages.count(node.data);
+            return TEST_DATA.ripemd160_preimages.contains(node.data);
         case Fragment::HASH160:
-            return TEST_DATA.hash160_preimages.count(node.data);
+            return TEST_DATA.hash160_preimages.contains(node.data);
         default:
             assert(false);
         }
diff --git a/depend/bitcoin/src/test/fuzz/minisketch.cpp b/depend/bitcoin/src/test/fuzz/minisketch.cpp
index 698cb15f..48b211af 100644
--- a/depend/bitcoin/src/test/fuzz/minisketch.cpp
+++ b/depend/bitcoin/src/test/fuzz/minisketch.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/fuzz/multiplication_overflow.cpp b/depend/bitcoin/src/test/fuzz/multiplication_overflow.cpp
index a762a4df..0d2184fe 100644
--- a/depend/bitcoin/src/test/fuzz/multiplication_overflow.cpp
+++ b/depend/bitcoin/src/test/fuzz/multiplication_overflow.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/net.cpp b/depend/bitcoin/src/test/fuzz/net.cpp
index 1a0de7aa..7b6615bc 100644
--- a/depend/bitcoin/src/test/fuzz/net.cpp
+++ b/depend/bitcoin/src/test/fuzz/net.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/net_permissions.cpp b/depend/bitcoin/src/test/fuzz/net_permissions.cpp
index 811c0de4..f00fb232 100644
--- a/depend/bitcoin/src/test/fuzz/net_permissions.cpp
+++ b/depend/bitcoin/src/test/fuzz/net_permissions.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/netaddress.cpp b/depend/bitcoin/src/test/fuzz/netaddress.cpp
index 71990e12..fdf44854 100644
--- a/depend/bitcoin/src/test/fuzz/netaddress.cpp
+++ b/depend/bitcoin/src/test/fuzz/netaddress.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/netbase_dns_lookup.cpp b/depend/bitcoin/src/test/fuzz/netbase_dns_lookup.cpp
index ba313152..ebcf84f5 100644
--- a/depend/bitcoin/src/test/fuzz/netbase_dns_lookup.cpp
+++ b/depend/bitcoin/src/test/fuzz/netbase_dns_lookup.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/fuzz/node_eviction.cpp b/depend/bitcoin/src/test/fuzz/node_eviction.cpp
index e4743260..04eab335 100644
--- a/depend/bitcoin/src/test/fuzz/node_eviction.cpp
+++ b/depend/bitcoin/src/test/fuzz/node_eviction.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/package_eval.cpp b/depend/bitcoin/src/test/fuzz/package_eval.cpp
index db4e4933..1cc2caa3 100644
--- a/depend/bitcoin/src/test/fuzz/package_eval.cpp
+++ b/depend/bitcoin/src/test/fuzz/package_eval.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/fuzz/parse_hd_keypath.cpp b/depend/bitcoin/src/test/fuzz/parse_hd_keypath.cpp
index 9a2d9a73..45aa1e87 100644
--- a/depend/bitcoin/src/test/fuzz/parse_hd_keypath.cpp
+++ b/depend/bitcoin/src/test/fuzz/parse_hd_keypath.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/parse_numbers.cpp b/depend/bitcoin/src/test/fuzz/parse_numbers.cpp
index 6102647d..a09c42d7 100644
--- a/depend/bitcoin/src/test/fuzz/parse_numbers.cpp
+++ b/depend/bitcoin/src/test/fuzz/parse_numbers.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/parse_script.cpp b/depend/bitcoin/src/test/fuzz/parse_script.cpp
index 060ad3db..0ec77701 100644
--- a/depend/bitcoin/src/test/fuzz/parse_script.cpp
+++ b/depend/bitcoin/src/test/fuzz/parse_script.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/partially_downloaded_block.cpp b/depend/bitcoin/src/test/fuzz/partially_downloaded_block.cpp
index 41e7c906..0bbe9991 100644
--- a/depend/bitcoin/src/test/fuzz/partially_downloaded_block.cpp
+++ b/depend/bitcoin/src/test/fuzz/partially_downloaded_block.cpp
@@ -95,12 +95,12 @@ FUZZ_TARGET(partially_downloaded_block, .init = initialize_pdb)
     for (size_t i = 0; i < cmpctblock.BlockTxCount(); i++) {
         // If init_status == READ_STATUS_OK then a available transaction in the
         // compact block (i.e. IsTxAvailable(i) == true) implies that we marked
-        // that transaction as available above (i.e. available.count(i) > 0).
+        // that transaction as available above (i.e. available.contains(i)).
         // The reverse is not true, due to possible compact block short id
-        // collisions (i.e. available.count(i) > 0 does not imply
+        // collisions (i.e. available.contains(i) does not imply
         // IsTxAvailable(i) == true).
         if (init_status == READ_STATUS_OK) {
-            assert(!pdb.IsTxAvailable(i) || available.count(i) > 0);
+            assert(!pdb.IsTxAvailable(i) || available.contains(i));
         }
 
         bool skip{fuzzed_data_provider.ConsumeBool()};
diff --git a/depend/bitcoin/src/test/fuzz/pcp.cpp b/depend/bitcoin/src/test/fuzz/pcp.cpp
index 0beebe10..4f1faa98 100644
--- a/depend/bitcoin/src/test/fuzz/pcp.cpp
+++ b/depend/bitcoin/src/test/fuzz/pcp.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2024 The Bitcoin Core developers
+// Copyright (c) 2024-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/fuzz/policy_estimator_io.cpp b/depend/bitcoin/src/test/fuzz/policy_estimator_io.cpp
index 3a634124..a95faff0 100644
--- a/depend/bitcoin/src/test/fuzz/policy_estimator_io.cpp
+++ b/depend/bitcoin/src/test/fuzz/policy_estimator_io.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/pow.cpp b/depend/bitcoin/src/test/fuzz/pow.cpp
index dba999ce..a9151ca5 100644
--- a/depend/bitcoin/src/test/fuzz/pow.cpp
+++ b/depend/bitcoin/src/test/fuzz/pow.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/prevector.cpp b/depend/bitcoin/src/test/fuzz/prevector.cpp
index fffa0993..aba6dca1 100644
--- a/depend/bitcoin/src/test/fuzz/prevector.cpp
+++ b/depend/bitcoin/src/test/fuzz/prevector.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/primitives_transaction.cpp b/depend/bitcoin/src/test/fuzz/primitives_transaction.cpp
index 64f1c8cf..9659f347 100644
--- a/depend/bitcoin/src/test/fuzz/primitives_transaction.cpp
+++ b/depend/bitcoin/src/test/fuzz/primitives_transaction.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/protocol.cpp b/depend/bitcoin/src/test/fuzz/protocol.cpp
index 71132f38..5eed5c89 100644
--- a/depend/bitcoin/src/test/fuzz/protocol.cpp
+++ b/depend/bitcoin/src/test/fuzz/protocol.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/psbt.cpp b/depend/bitcoin/src/test/fuzz/psbt.cpp
index 37fa159c..a7b2490e 100644
--- a/depend/bitcoin/src/test/fuzz/psbt.cpp
+++ b/depend/bitcoin/src/test/fuzz/psbt.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/random.cpp b/depend/bitcoin/src/test/fuzz/random.cpp
index 6b2d4273..53214565 100644
--- a/depend/bitcoin/src/test/fuzz/random.cpp
+++ b/depend/bitcoin/src/test/fuzz/random.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/rolling_bloom_filter.cpp b/depend/bitcoin/src/test/fuzz/rolling_bloom_filter.cpp
index 1bea0ba9..977b1c4b 100644
--- a/depend/bitcoin/src/test/fuzz/rolling_bloom_filter.cpp
+++ b/depend/bitcoin/src/test/fuzz/rolling_bloom_filter.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/rpc.cpp b/depend/bitcoin/src/test/fuzz/rpc.cpp
index abaa9ba1..ba052d3c 100644
--- a/depend/bitcoin/src/test/fuzz/rpc.cpp
+++ b/depend/bitcoin/src/test/fuzz/rpc.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/fuzz/script.cpp b/depend/bitcoin/src/test/fuzz/script.cpp
index 9d3ce27a..8d2d0e2c 100644
--- a/depend/bitcoin/src/test/fuzz/script.cpp
+++ b/depend/bitcoin/src/test/fuzz/script.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/script_assets_test_minimizer.cpp b/depend/bitcoin/src/test/fuzz/script_assets_test_minimizer.cpp
index b26aa84e..fc6f9fb1 100644
--- a/depend/bitcoin/src/test/fuzz/script_assets_test_minimizer.cpp
+++ b/depend/bitcoin/src/test/fuzz/script_assets_test_minimizer.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/script_descriptor_cache.cpp b/depend/bitcoin/src/test/fuzz/script_descriptor_cache.cpp
index ceb5cfe1..329a04ea 100644
--- a/depend/bitcoin/src/test/fuzz/script_descriptor_cache.cpp
+++ b/depend/bitcoin/src/test/fuzz/script_descriptor_cache.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/script_flags.cpp b/depend/bitcoin/src/test/fuzz/script_flags.cpp
index ca38c6a6..310f0e86 100644
--- a/depend/bitcoin/src/test/fuzz/script_flags.cpp
+++ b/depend/bitcoin/src/test/fuzz/script_flags.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/script_format.cpp b/depend/bitcoin/src/test/fuzz/script_format.cpp
index e26c42ae..d486841d 100644
--- a/depend/bitcoin/src/test/fuzz/script_format.cpp
+++ b/depend/bitcoin/src/test/fuzz/script_format.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/script_interpreter.cpp b/depend/bitcoin/src/test/fuzz/script_interpreter.cpp
index 2c2ce855..61e3dded 100644
--- a/depend/bitcoin/src/test/fuzz/script_interpreter.cpp
+++ b/depend/bitcoin/src/test/fuzz/script_interpreter.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/script_ops.cpp b/depend/bitcoin/src/test/fuzz/script_ops.cpp
index 12247679..2e84038d 100644
--- a/depend/bitcoin/src/test/fuzz/script_ops.cpp
+++ b/depend/bitcoin/src/test/fuzz/script_ops.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/script_sigcache.cpp b/depend/bitcoin/src/test/fuzz/script_sigcache.cpp
index 702a056d..e78259a0 100644
--- a/depend/bitcoin/src/test/fuzz/script_sigcache.cpp
+++ b/depend/bitcoin/src/test/fuzz/script_sigcache.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/script_sign.cpp b/depend/bitcoin/src/test/fuzz/script_sign.cpp
index 9fa5e0b7..e4cf8c2a 100644
--- a/depend/bitcoin/src/test/fuzz/script_sign.cpp
+++ b/depend/bitcoin/src/test/fuzz/script_sign.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/scriptnum_ops.cpp b/depend/bitcoin/src/test/fuzz/scriptnum_ops.cpp
index 0681aaf9..eab774db 100644
--- a/depend/bitcoin/src/test/fuzz/scriptnum_ops.cpp
+++ b/depend/bitcoin/src/test/fuzz/scriptnum_ops.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/secp256k1_ec_seckey_import_export_der.cpp b/depend/bitcoin/src/test/fuzz/secp256k1_ec_seckey_import_export_der.cpp
index 585cfcd1..30b34f60 100644
--- a/depend/bitcoin/src/test/fuzz/secp256k1_ec_seckey_import_export_der.cpp
+++ b/depend/bitcoin/src/test/fuzz/secp256k1_ec_seckey_import_export_der.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/secp256k1_ecdsa_signature_parse_der_lax.cpp b/depend/bitcoin/src/test/fuzz/secp256k1_ecdsa_signature_parse_der_lax.cpp
index c6e31e4d..bc8c9d8e 100644
--- a/depend/bitcoin/src/test/fuzz/secp256k1_ecdsa_signature_parse_der_lax.cpp
+++ b/depend/bitcoin/src/test/fuzz/secp256k1_ecdsa_signature_parse_der_lax.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/signet.cpp b/depend/bitcoin/src/test/fuzz/signet.cpp
index 6f199657..e3cf7d74 100644
--- a/depend/bitcoin/src/test/fuzz/signet.cpp
+++ b/depend/bitcoin/src/test/fuzz/signet.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/socks5.cpp b/depend/bitcoin/src/test/fuzz/socks5.cpp
index 2e6e2a94..72d69310 100644
--- a/depend/bitcoin/src/test/fuzz/socks5.cpp
+++ b/depend/bitcoin/src/test/fuzz/socks5.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/strprintf.cpp b/depend/bitcoin/src/test/fuzz/strprintf.cpp
index c7f24fbd..00bf6146 100644
--- a/depend/bitcoin/src/test/fuzz/strprintf.cpp
+++ b/depend/bitcoin/src/test/fuzz/strprintf.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/system.cpp b/depend/bitcoin/src/test/fuzz/system.cpp
index 2ab5b7ed..12c70c7a 100644
--- a/depend/bitcoin/src/test/fuzz/system.cpp
+++ b/depend/bitcoin/src/test/fuzz/system.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/torcontrol.cpp b/depend/bitcoin/src/test/fuzz/torcontrol.cpp
index 6189b3c0..62c2ad57 100644
--- a/depend/bitcoin/src/test/fuzz/torcontrol.cpp
+++ b/depend/bitcoin/src/test/fuzz/torcontrol.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/transaction.cpp b/depend/bitcoin/src/test/fuzz/transaction.cpp
index c9eb1122..b96fb71b 100644
--- a/depend/bitcoin/src/test/fuzz/transaction.cpp
+++ b/depend/bitcoin/src/test/fuzz/transaction.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/tx_in.cpp b/depend/bitcoin/src/test/fuzz/tx_in.cpp
index d0ef467d..932c0e18 100644
--- a/depend/bitcoin/src/test/fuzz/tx_in.cpp
+++ b/depend/bitcoin/src/test/fuzz/tx_in.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2020 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/tx_out.cpp b/depend/bitcoin/src/test/fuzz/tx_out.cpp
index 37f86822..392300ce 100644
--- a/depend/bitcoin/src/test/fuzz/tx_out.cpp
+++ b/depend/bitcoin/src/test/fuzz/tx_out.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/tx_pool.cpp b/depend/bitcoin/src/test/fuzz/tx_pool.cpp
index 4dcfd30a..f70dd710 100644
--- a/depend/bitcoin/src/test/fuzz/tx_pool.cpp
+++ b/depend/bitcoin/src/test/fuzz/tx_pool.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/fuzz/txdownloadman.cpp b/depend/bitcoin/src/test/fuzz/txdownloadman.cpp
index 2bb64eeb..89a3f060 100644
--- a/depend/bitcoin/src/test/fuzz/txdownloadman.cpp
+++ b/depend/bitcoin/src/test/fuzz/txdownloadman.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/fuzz/txgraph.cpp b/depend/bitcoin/src/test/fuzz/txgraph.cpp
index 79ee0a16..d44cf559 100644
--- a/depend/bitcoin/src/test/fuzz/txgraph.cpp
+++ b/depend/bitcoin/src/test/fuzz/txgraph.cpp
@@ -1230,10 +1230,9 @@ FUZZ_TARGET(txgraph)
                     // Construct a chunking object for the simulated graph, using the reported cluster
                     // linearization as ordering, and compare it against the reported chunk feerates.
                     if (sims.size() == 1 || level == TxGraph::Level::MAIN) {
-                        cluster_linearize::LinearizationChunking simlinchunk(sim.graph, simlin);
+                        auto simlinchunk = ChunkLinearizationInfo(sim.graph, simlin);
                         DepGraphIndex idx{0};
-                        for (unsigned chunknum = 0; chunknum < simlinchunk.NumChunksLeft(); ++chunknum) {
-                            auto chunk = simlinchunk.GetChunk(chunknum);
+                        for (auto& chunk : simlinchunk) {
                             // Require that the chunks of cluster linearizations are connected (this must
                             // be the case as all linearizations inside are PostLinearized).
                             assert(sim.graph.IsConnected(chunk.transactions));
diff --git a/depend/bitcoin/src/test/fuzz/txorphan.cpp b/depend/bitcoin/src/test/fuzz/txorphan.cpp
index b6a6d855..f6720ffb 100644
--- a/depend/bitcoin/src/test/fuzz/txorphan.cpp
+++ b/depend/bitcoin/src/test/fuzz/txorphan.cpp
@@ -339,7 +339,7 @@ FUZZ_TARGET(txorphan_protected, .init = initialize_orphanage)
                     }
                 },
                 [&] { // EraseTx
-                    if (protected_wtxids.count(tx->GetWitnessHash())) {
+                    if (protected_wtxids.contains(tx->GetWitnessHash())) {
                         protected_wtxids.erase(wtxid);
                     }
                     orphanage->EraseTx(wtxid);
@@ -616,7 +616,7 @@ FUZZ_TARGET(txorphanage_sim)
                 real->EraseForBlock(block);
                 std::erase_if(sim_announcements, [&](auto& ann) {
                     for (auto& txin : txn[ann.tx]->vin) {
-                        if (spent.count(txin.prevout)) return true;
+                        if (spent.contains(txin.prevout)) return true;
                     }
                     return false;
                 });
diff --git a/depend/bitcoin/src/test/fuzz/txrequest.cpp b/depend/bitcoin/src/test/fuzz/txrequest.cpp
index c1585d7c..18c5921b 100644
--- a/depend/bitcoin/src/test/fuzz/txrequest.cpp
+++ b/depend/bitcoin/src/test/fuzz/txrequest.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/util.h b/depend/bitcoin/src/test/fuzz/util.h
index 28dd9805..0575b157 100644
--- a/depend/bitcoin/src/test/fuzz/util.h
+++ b/depend/bitcoin/src/test/fuzz/util.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/util/net.h b/depend/bitcoin/src/test/fuzz/util/net.h
index fd07f572..90c018a4 100644
--- a/depend/bitcoin/src/test/fuzz/util/net.h
+++ b/depend/bitcoin/src/test/fuzz/util/net.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/utxo_snapshot.cpp b/depend/bitcoin/src/test/fuzz/utxo_snapshot.cpp
index 56d36155..e6ae29a8 100644
--- a/depend/bitcoin/src/test/fuzz/utxo_snapshot.cpp
+++ b/depend/bitcoin/src/test/fuzz/utxo_snapshot.cpp
@@ -110,7 +110,7 @@ void utxo_snapshot_fuzz(FuzzBufferType buffer)
 
     const auto snapshot_path = gArgs.GetDataDirNet() / "fuzzed_snapshot.dat";
 
-    Assert(!chainman.SnapshotBlockhash());
+    Assert(!chainman.ActiveChainstate().m_from_snapshot_blockhash);
 
     {
         AutoFile outfile{fsbridge::fopen(snapshot_path, "wb")};
@@ -183,15 +183,13 @@ void utxo_snapshot_fuzz(FuzzBufferType buffer)
     if (ActivateFuzzedSnapshot()) {
         LOCK(::cs_main);
         Assert(!chainman.ActiveChainstate().m_from_snapshot_blockhash->IsNull());
-        Assert(*chainman.ActiveChainstate().m_from_snapshot_blockhash ==
-               *chainman.SnapshotBlockhash());
         const auto& coinscache{chainman.ActiveChainstate().CoinsTip()};
         for (const auto& block : *g_chain) {
             Assert(coinscache.HaveCoin(COutPoint{block->vtx.at(0)->GetHash(), 0}));
             const auto* index{chainman.m_blockman.LookupBlockIndex(block->GetHash())};
             Assert(index);
             Assert(index->nTx == 0);
-            if (index->nHeight == chainman.GetSnapshotBaseHeight()) {
+            if (index->nHeight == chainman.ActiveChainstate().SnapshotBase()->nHeight) {
                 auto params{chainman.GetParams().AssumeutxoForHeight(index->nHeight)};
                 Assert(params.has_value());
                 Assert(params.value().m_chain_tx_count == index->m_chain_tx_count);
@@ -202,7 +200,6 @@ void utxo_snapshot_fuzz(FuzzBufferType buffer)
         Assert(g_chain->size() == coinscache.GetCacheSize());
         dirty_chainman = true;
     } else {
-        Assert(!chainman.SnapshotBlockhash());
         Assert(!chainman.ActiveChainstate().m_from_snapshot_blockhash);
     }
     // Snapshot should refuse to load a second time regardless of validity
diff --git a/depend/bitcoin/src/test/fuzz/utxo_total_supply.cpp b/depend/bitcoin/src/test/fuzz/utxo_total_supply.cpp
index 1348962a..d27ca347 100644
--- a/depend/bitcoin/src/test/fuzz/utxo_total_supply.cpp
+++ b/depend/bitcoin/src/test/fuzz/utxo_total_supply.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/validation_load_mempool.cpp b/depend/bitcoin/src/test/fuzz/validation_load_mempool.cpp
index 4f901388..ed036eb1 100644
--- a/depend/bitcoin/src/test/fuzz/validation_load_mempool.cpp
+++ b/depend/bitcoin/src/test/fuzz/validation_load_mempool.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/fuzz/versionbits.cpp b/depend/bitcoin/src/test/fuzz/versionbits.cpp
index 5a7722d8..a2085e6a 100644
--- a/depend/bitcoin/src/test/fuzz/versionbits.cpp
+++ b/depend/bitcoin/src/test/fuzz/versionbits.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/getarg_tests.cpp b/depend/bitcoin/src/test/getarg_tests.cpp
index 8734735f..ee369272 100644
--- a/depend/bitcoin/src/test/getarg_tests.cpp
+++ b/depend/bitcoin/src/test/getarg_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/httpserver_tests.cpp b/depend/bitcoin/src/test/httpserver_tests.cpp
index c95a777e..2770c0c3 100644
--- a/depend/bitcoin/src/test/httpserver_tests.cpp
+++ b/depend/bitcoin/src/test/httpserver_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/i2p_tests.cpp b/depend/bitcoin/src/test/i2p_tests.cpp
index da9cbb5d..2b89d4d0 100644
--- a/depend/bitcoin/src/test/i2p_tests.cpp
+++ b/depend/bitcoin/src/test/i2p_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -56,7 +56,7 @@ BOOST_AUTO_TEST_CASE(unlimited_recv)
     i2p::sam::Session session(gArgs.GetDataDirNet() / "test_i2p_private_key", sam_proxy, interrupt);
 
     {
-        ASSERT_DEBUG_LOG("Creating persistent SAM session");
+        ASSERT_DEBUG_LOG("Creating persistent I2P SAM session");
         ASSERT_DEBUG_LOG("too many bytes without a terminator");
 
         i2p::Connection conn;
@@ -121,10 +121,10 @@ BOOST_AUTO_TEST_CASE(listen_ok_accept_fail)
 
     i2p::Connection conn;
     for (size_t i = 0; i < 5; ++i) {
-        ASSERT_DEBUG_LOG("Creating persistent SAM session");
-        ASSERT_DEBUG_LOG("Persistent SAM session" /* ... created */);
+        ASSERT_DEBUG_LOG("Creating persistent I2P SAM session");
+        ASSERT_DEBUG_LOG("Persistent I2P SAM session" /* ... created */);
         ASSERT_DEBUG_LOG("Error accepting");
-        ASSERT_DEBUG_LOG("Destroying SAM session");
+        ASSERT_DEBUG_LOG("Destroying I2P SAM session");
         BOOST_REQUIRE(session.Listen(conn));
         BOOST_REQUIRE(!session.Accept(conn));
     }
@@ -161,7 +161,7 @@ BOOST_AUTO_TEST_CASE(damaged_private_key)
         i2p::sam::Session session(i2p_private_key_file, sam_proxy, interrupt);
 
         {
-            ASSERT_DEBUG_LOG("Creating persistent SAM session");
+            ASSERT_DEBUG_LOG("Creating persistent I2P SAM session");
             ASSERT_DEBUG_LOG(expected_error);
 
             i2p::Connection conn;
diff --git a/depend/bitcoin/src/test/interfaces_tests.cpp b/depend/bitcoin/src/test/interfaces_tests.cpp
index 29f0aea3..da0f5eec 100644
--- a/depend/bitcoin/src/test/interfaces_tests.cpp
+++ b/depend/bitcoin/src/test/interfaces_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/kernel/block_data.h b/depend/bitcoin/src/test/kernel/block_data.h
index 45a982c5..f4d693c0 100644
--- a/depend/bitcoin/src/test/kernel/block_data.h
+++ b/depend/bitcoin/src/test/kernel/block_data.h
@@ -1,3 +1,7 @@
+// Copyright (c) The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or https://opensource.org/license/mit.
+
 #ifndef BITCOIN_TEST_KERNEL_BLOCK_DATA_H
 #define BITCOIN_TEST_KERNEL_BLOCK_DATA_H
 #include <array>
diff --git a/depend/bitcoin/src/test/kernel/test_kernel.cpp b/depend/bitcoin/src/test/kernel/test_kernel.cpp
index f31a9a02..07f1d3cf 100644
--- a/depend/bitcoin/src/test/kernel/test_kernel.cpp
+++ b/depend/bitcoin/src/test/kernel/test_kernel.cpp
@@ -218,7 +218,7 @@ class TestValidationInterface : public ValidationInterface
 void run_verify_test(
     const ScriptPubkey& spent_script_pubkey,
     const Transaction& spending_tx,
-    std::span<TransactionOutput> spent_outputs,
+    const PrecomputedTransactionData* precomputed_txdata,
     int64_t amount,
     unsigned int input_index,
     bool taproot)
@@ -229,7 +229,7 @@ void run_verify_test(
         BOOST_CHECK(spent_script_pubkey.Verify(
             amount,
             spending_tx,
-            spent_outputs,
+            precomputed_txdata,
             input_index,
             ScriptVerificationFlags::ALL,
             status));
@@ -238,7 +238,7 @@ void run_verify_test(
         BOOST_CHECK(!spent_script_pubkey.Verify(
             amount,
             spending_tx,
-            spent_outputs,
+            precomputed_txdata,
             input_index,
             ScriptVerificationFlags::ALL,
             status));
@@ -248,7 +248,7 @@ void run_verify_test(
     BOOST_CHECK(spent_script_pubkey.Verify(
         amount,
         spending_tx,
-        spent_outputs,
+        precomputed_txdata,
         input_index,
         VERIFY_ALL_PRE_TAPROOT,
         status));
@@ -257,7 +257,7 @@ void run_verify_test(
     BOOST_CHECK(spent_script_pubkey.Verify(
         0,
         spending_tx,
-        spent_outputs,
+        precomputed_txdata,
         input_index,
         VERIFY_ALL_PRE_SEGWIT,
         status));
@@ -499,37 +499,114 @@ BOOST_AUTO_TEST_CASE(btck_transaction_input)
     CheckHandle(point_0, point_1);
 }
 
+BOOST_AUTO_TEST_CASE(btck_precomputed_txdata) {
+    auto tx_data{hex_string_to_byte_vec("02000000013f7cebd65c27431a90bba7f796914fe8cc2ddfc3f2cbd6f7e5f2fc854534da95000000006b483045022100de1ac3bcdfb0332207c4a91f3832bd2c2915840165f876ab47c5f8996b971c3602201c6c053d750fadde599e6f5c4e1963df0f01fc0d97815e8157e3d59fe09ca30d012103699b464d1d8bc9e47d4fb1cdaa89a1c5783d68363c4dbc4b524ed3d857148617feffffff02836d3c01000000001976a914fc25d6d5c94003bf5b0c7b640a248e2c637fcfb088ac7ada8202000000001976a914fbed3d9b11183209a57999d54d59f67c019e756c88ac6acb0700")};
+    auto tx{Transaction{tx_data}};
+    auto tx_data_2{hex_string_to_byte_vec("02000000000101904f4ee5c87d20090b642f116e458cd6693292ad9ece23e72f15fb6c05b956210500000000fdffffff02e2010000000000002251200839a723933b56560487ec4d67dda58f09bae518ffa7e148313c5696ac837d9f10060000000000002251205826bcdae7abfb1c468204170eab00d887b61ab143464a4a09e1450bdc59a3340140f26e7af574e647355830772946356c27e7bbc773c5293688890f58983499581be84de40be7311a14e6d6422605df086620e75adae84ff06b75ce5894de5e994a00000000")};
+    auto tx2{Transaction{tx_data_2}};
+    auto precomputed_txdata{PrecomputedTransactionData{
+        /*tx_to=*/tx,
+        /*spent_outputs=*/{},
+    }};
+    auto precomputed_txdata_2{PrecomputedTransactionData{
+        /*tx_to=*/tx2,
+        /*spent_outputs=*/{},
+    }};
+    CheckHandle(precomputed_txdata, precomputed_txdata_2);
+}
+
 BOOST_AUTO_TEST_CASE(btck_script_verify_tests)
 {
     // Legacy transaction aca326a724eda9a461c10a876534ecd5ae7b27f10f26c3862fb996f80ea2d45d
+    auto legacy_spent_script_pubkey{ScriptPubkey{hex_string_to_byte_vec("76a9144bfbaf6afb76cc5771bc6404810d1cc041a6933988ac")}};
+    auto legacy_spending_tx{Transaction{hex_string_to_byte_vec("02000000013f7cebd65c27431a90bba7f796914fe8cc2ddfc3f2cbd6f7e5f2fc854534da95000000006b483045022100de1ac3bcdfb0332207c4a91f3832bd2c2915840165f876ab47c5f8996b971c3602201c6c053d750fadde599e6f5c4e1963df0f01fc0d97815e8157e3d59fe09ca30d012103699b464d1d8bc9e47d4fb1cdaa89a1c5783d68363c4dbc4b524ed3d857148617feffffff02836d3c01000000001976a914fc25d6d5c94003bf5b0c7b640a248e2c637fcfb088ac7ada8202000000001976a914fbed3d9b11183209a57999d54d59f67c019e756c88ac6acb0700")}};
+    run_verify_test(
+        /*spent_script_pubkey=*/legacy_spent_script_pubkey,
+        /*spending_tx=*/legacy_spending_tx,
+        /*precomputed_txdata=*/nullptr,
+        /*amount=*/0,
+        /*input_index=*/0,
+        /*taproot=*/false);
+
+    // Legacy transaction aca326a724eda9a461c10a876534ecd5ae7b27f10f26c3862fb996f80ea2d45d with precomputed_txdata
+    auto legacy_precomputed_txdata{PrecomputedTransactionData{
+        /*tx_to=*/legacy_spending_tx,
+        /*spent_outputs=*/{},
+    }};
     run_verify_test(
-        /*spent_script_pubkey*/ ScriptPubkey{hex_string_to_byte_vec("76a9144bfbaf6afb76cc5771bc6404810d1cc041a6933988ac")},
-        /*spending_tx*/ Transaction{hex_string_to_byte_vec("02000000013f7cebd65c27431a90bba7f796914fe8cc2ddfc3f2cbd6f7e5f2fc854534da95000000006b483045022100de1ac3bcdfb0332207c4a91f3832bd2c2915840165f876ab47c5f8996b971c3602201c6c053d750fadde599e6f5c4e1963df0f01fc0d97815e8157e3d59fe09ca30d012103699b464d1d8bc9e47d4fb1cdaa89a1c5783d68363c4dbc4b524ed3d857148617feffffff02836d3c01000000001976a914fc25d6d5c94003bf5b0c7b640a248e2c637fcfb088ac7ada8202000000001976a914fbed3d9b11183209a57999d54d59f67c019e756c88ac6acb0700")},
-        /*spent_outputs*/ {},
-        /*amount*/ 0,
-        /*input_index*/ 0,
-        /*is_taproot*/ false);
+        /*spent_script_pubkey=*/legacy_spent_script_pubkey,
+        /*spending_tx=*/legacy_spending_tx,
+        /*precomputed_txdata=*/&legacy_precomputed_txdata,
+        /*amount=*/0,
+        /*input_index=*/0,
+        /*taproot=*/false);
 
     // Segwit transaction 1a3e89644985fbbb41e0dcfe176739813542b5937003c46a07de1e3ee7a4a7f3
+    auto segwit_spent_script_pubkey{ScriptPubkey{hex_string_to_byte_vec("0020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d")}};
+    auto segwit_spending_tx{Transaction{hex_string_to_byte_vec("010000000001011f97548fbbe7a0db7588a66e18d803d0089315aa7d4cc28360b6ec50ef36718a0100000000ffffffff02df1776000000000017a9146c002a686959067f4866b8fb493ad7970290ab728757d29f0000000000220020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d04004730440220565d170eed95ff95027a69b313758450ba84a01224e1f7f130dda46e94d13f8602207bdd20e307f062594022f12ed5017bbf4a055a06aea91c10110a0e3bb23117fc014730440220647d2dc5b15f60bc37dc42618a370b2a1490293f9e5c8464f53ec4fe1dfe067302203598773895b4b16d37485cbe21b337f4e4b650739880098c592553add7dd4355016952210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae00000000")}};
+    run_verify_test(
+        /*spent_script_pubkey=*/segwit_spent_script_pubkey,
+        /*spending_tx=*/segwit_spending_tx,
+        /*precomputed_txdata=*/nullptr,
+        /*amount=*/18393430,
+        /*input_index=*/0,
+        /*taproot=*/false);
+
+    // Segwit transaction 1a3e89644985fbbb41e0dcfe176739813542b5937003c46a07de1e3ee7a4a7f3 with precomputed_txdata
+    auto segwit_precomputed_txdata{PrecomputedTransactionData{
+        /*tx_to=*/segwit_spending_tx,
+        /*spent_outputs=*/{},
+    }};
     run_verify_test(
-        /*spent_script_pubkey*/ ScriptPubkey{hex_string_to_byte_vec("0020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d")},
-        /*spending_tx*/ Transaction{hex_string_to_byte_vec("010000000001011f97548fbbe7a0db7588a66e18d803d0089315aa7d4cc28360b6ec50ef36718a0100000000ffffffff02df1776000000000017a9146c002a686959067f4866b8fb493ad7970290ab728757d29f0000000000220020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d04004730440220565d170eed95ff95027a69b313758450ba84a01224e1f7f130dda46e94d13f8602207bdd20e307f062594022f12ed5017bbf4a055a06aea91c10110a0e3bb23117fc014730440220647d2dc5b15f60bc37dc42618a370b2a1490293f9e5c8464f53ec4fe1dfe067302203598773895b4b16d37485cbe21b337f4e4b650739880098c592553add7dd4355016952210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae00000000")},
-        /*spent_outputs*/ {},
-        /*amount*/ 18393430,
-        /*input_index*/ 0,
-        /*is_taproot*/ false);
+        /*spent_script_pubkey=*/segwit_spent_script_pubkey,
+        /*spending_tx=*/segwit_spending_tx,
+        /*precomputed_txdata=*/&segwit_precomputed_txdata,
+        /*amount=*/18393430,
+        /*input_index=*/0,
+        /*taproot=*/false);
 
     // Taproot transaction 33e794d097969002ee05d336686fc03c9e15a597c1b9827669460fac98799036
     auto taproot_spent_script_pubkey{ScriptPubkey{hex_string_to_byte_vec("5120339ce7e165e67d93adb3fef88a6d4beed33f01fa876f05a225242b82a631abc0")}};
-    std::vector<TransactionOutput> spent_outputs;
-    spent_outputs.emplace_back(taproot_spent_script_pubkey, 88480);
+    auto taproot_spending_tx{Transaction{hex_string_to_byte_vec("01000000000101d1f1c1f8cdf6759167b90f52c9ad358a369f95284e841d7a2536cef31c0549580100000000fdffffff020000000000000000316a2f49206c696b65205363686e6f7272207369677320616e6420492063616e6e6f74206c69652e204062697462756734329e06010000000000225120a37c3903c8d0db6512e2b40b0dffa05e5a3ab73603ce8c9c4b7771e5412328f90140a60c383f71bac0ec919b1d7dbc3eb72dd56e7aa99583615564f9f99b8ae4e837b758773a5b2e4c51348854c8389f008e05029db7f464a5ff2e01d5e6e626174affd30a00")}};
+    std::vector<TransactionOutput> taproot_spent_outputs;
+    taproot_spent_outputs.emplace_back(taproot_spent_script_pubkey, 88480);
+    auto taproot_precomputed_txdata{PrecomputedTransactionData{
+        /*tx_to=*/taproot_spending_tx,
+        /*spent_outputs=*/taproot_spent_outputs,
+    }};
+    run_verify_test(
+        /*spent_script_pubkey=*/taproot_spent_script_pubkey,
+        /*spending_tx=*/taproot_spending_tx,
+        /*precomputed_txdata=*/&taproot_precomputed_txdata,
+        /*amount=*/88480,
+        /*input_index=*/0,
+        /*taproot=*/true);
+
+    // Two-input taproot transaction e8e8320f40c31ed511570e9cdf1d241f8ec9a5cc392e6105240ac8dbea2098de
+    auto taproot2_spent_script_pubkey0{ScriptPubkey{hex_string_to_byte_vec("5120b7da80f57e36930b0515eb09293e25858d13e6b91fee6184943f5a584cb4248e")}};
+    auto taproot2_spent_script_pubkey1{ScriptPubkey{hex_string_to_byte_vec("5120ab78e077d062e7b8acd7063668b4db5355a1b5d5fd2a46a8e98e62e5e63fab77")}};
+    auto taproot2_spending_tx{Transaction{hex_string_to_byte_vec("02000000000102c0f01ead18750892c84b1d4f595149ad38f16847df1fbf490e235b3b78c1f98a0100000000ffffffff456764a19c2682bf5b1567119f06a421849ad1664cf42b5ef95b69d6e2159e9d0000000000ffffffff022202000000000000225120b6c0c2a8ee25a2ae0322ab7f1a06f01746f81f6b90d179c3c2a51a356e6188f1d70e020000000000225120b7da80f57e36930b0515eb09293e25858d13e6b91fee6184943f5a584cb4248e0141933fdc49eb1af1f08ed1e9cf5559259309a8acd25ff1e6999b6955124438aef4fceaa4e6a5f85286631e24837329563595bc3cf4b31e1c687442abb01c4206818101401c9620faf1e8c84187762ad14d04ae3857f59a2f03f1dcbb99290e16dfc572a63b4ea435780a5787af59beb5742fd71cda8a95381517a1ff14b4c67996c4bf8100000000")}};
+    std::vector<TransactionOutput> taproot2_spent_outputs;
+    taproot2_spent_outputs.emplace_back(taproot2_spent_script_pubkey0, 546);
+    taproot2_spent_outputs.emplace_back(taproot2_spent_script_pubkey1, 135125);
+    auto taproot2_precomputed_txdata{PrecomputedTransactionData{
+        /*tx_to=*/taproot2_spending_tx,
+        /*spent_outputs=*/taproot2_spent_outputs,
+    }};
+    run_verify_test(
+        /*spent_script_pubkey=*/taproot2_spent_script_pubkey0,
+        /*spending_tx=*/taproot2_spending_tx,
+        /*precomputed_txdata=*/&taproot2_precomputed_txdata,
+        /*amount=*/546,
+        /*input_index=*/0,
+        /*taproot=*/true);
     run_verify_test(
-        /*spent_script_pubkey*/ taproot_spent_script_pubkey,
-        /*spending_tx*/ Transaction{hex_string_to_byte_vec("01000000000101d1f1c1f8cdf6759167b90f52c9ad358a369f95284e841d7a2536cef31c0549580100000000fdffffff020000000000000000316a2f49206c696b65205363686e6f7272207369677320616e6420492063616e6e6f74206c69652e204062697462756734329e06010000000000225120a37c3903c8d0db6512e2b40b0dffa05e5a3ab73603ce8c9c4b7771e5412328f90140a60c383f71bac0ec919b1d7dbc3eb72dd56e7aa99583615564f9f99b8ae4e837b758773a5b2e4c51348854c8389f008e05029db7f464a5ff2e01d5e6e626174affd30a00")},
-        /*spent_outputs*/ spent_outputs,
-        /*amount*/ 88480,
-        /*input_index*/ 0,
-        /*is_taproot*/ true);
+        /*spent_script_pubkey=*/taproot2_spent_script_pubkey1,
+        /*spending_tx=*/taproot2_spending_tx,
+        /*precomputed_txdata=*/&taproot2_precomputed_txdata,
+        /*amount=*/135125,
+        /*input_index=*/1,
+        /*taproot=*/true);
 }
 
 BOOST_AUTO_TEST_CASE(logging_tests)
@@ -954,8 +1031,9 @@ BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)
             }
             BOOST_CHECK(inputs.size() == spent_outputs.size());
             ScriptVerifyStatus status = ScriptVerifyStatus::OK;
+            const PrecomputedTransactionData precomputed_txdata{transaction, spent_outputs};
             for (size_t i{0}; i < inputs.size(); ++i) {
-                BOOST_CHECK(spent_outputs[i].GetScriptPubkey().Verify(spent_outputs[i].Amount(), transaction, spent_outputs, i, ScriptVerificationFlags::ALL, status));
+                BOOST_CHECK(spent_outputs[i].GetScriptPubkey().Verify(spent_outputs[i].Amount(), transaction, &precomputed_txdata, i, ScriptVerificationFlags::ALL, status));
             }
         }
     }
diff --git a/depend/bitcoin/src/test/key_io_tests.cpp b/depend/bitcoin/src/test/key_io_tests.cpp
index 4dd77edc..2ea9c0b8 100644
--- a/depend/bitcoin/src/test/key_io_tests.cpp
+++ b/depend/bitcoin/src/test/key_io_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/test/logging_tests.cpp b/depend/bitcoin/src/test/logging_tests.cpp
index 42658e94..8ead946f 100644
--- a/depend/bitcoin/src/test/logging_tests.cpp
+++ b/depend/bitcoin/src/test/logging_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
@@ -118,45 +118,27 @@ BOOST_FIXTURE_TEST_CASE(logging_LogPrintStr, LogSetup)
         BCLog::LogFlags category;
         BCLog::Level level;
         std::string prefix;
-        std::source_location loc;
+        SourceLocation loc;
     };
 
     std::vector<Case> cases = {
-        {"foo1: bar1", BCLog::NET, BCLog::Level::Debug, "[net] ", std::source_location::current()},
-        {"foo2: bar2", BCLog::NET, BCLog::Level::Info, "[net:info] ", std::source_location::current()},
-        {"foo3: bar3", BCLog::ALL, BCLog::Level::Debug, "[debug] ", std::source_location::current()},
-        {"foo4: bar4", BCLog::ALL, BCLog::Level::Info, "", std::source_location::current()},
-        {"foo5: bar5", BCLog::NONE, BCLog::Level::Debug, "[debug] ", std::source_location::current()},
-        {"foo6: bar6", BCLog::NONE, BCLog::Level::Info, "", std::source_location::current()},
+        {"foo1: bar1", BCLog::NET, BCLog::Level::Debug, "[net] ", SourceLocation{__func__}},
+        {"foo2: bar2", BCLog::NET, BCLog::Level::Info, "[net:info] ", SourceLocation{__func__}},
+        {"foo3: bar3", BCLog::ALL, BCLog::Level::Debug, "[debug] ", SourceLocation{__func__}},
+        {"foo4: bar4", BCLog::ALL, BCLog::Level::Info, "", SourceLocation{__func__}},
+        {"foo5: bar5", BCLog::NONE, BCLog::Level::Debug, "[debug] ", SourceLocation{__func__}},
+        {"foo6: bar6", BCLog::NONE, BCLog::Level::Info, "", SourceLocation{__func__}},
     };
 
     std::vector<std::string> expected;
     for (auto& [msg, category, level, prefix, loc] : cases) {
-        expected.push_back(tfm::format("[%s:%s] [%s] %s%s", util::RemovePrefix(loc.file_name(), "./"), loc.line(), loc.function_name(), prefix, msg));
+        expected.push_back(tfm::format("[%s:%s] [%s] %s%s", util::RemovePrefix(loc.file_name(), "./"), loc.line(), loc.function_name_short(), prefix, msg));
         LogInstance().LogPrintStr(msg, std::move(loc), category, level, /*should_ratelimit=*/false);
     }
     std::vector<std::string> log_lines{ReadDebugLogLines()};
     BOOST_CHECK_EQUAL_COLLECTIONS(log_lines.begin(), log_lines.end(), expected.begin(), expected.end());
 }
 
-BOOST_FIXTURE_TEST_CASE(logging_LogPrintMacrosDeprecated, LogSetup)
-{
-    LogInstance().EnableCategory(BCLog::NET);
-    LogPrintLevel(BCLog::NET, BCLog::Level::Trace, "foo4: %s\n", "bar4"); // not logged
-    LogPrintLevel(BCLog::NET, BCLog::Level::Debug, "foo7: %s\n", "bar7");
-    LogPrintLevel(BCLog::NET, BCLog::Level::Info, "foo8: %s\n", "bar8");
-    LogPrintLevel(BCLog::NET, BCLog::Level::Warning, "foo9: %s\n", "bar9");
-    LogPrintLevel(BCLog::NET, BCLog::Level::Error, "foo10: %s\n", "bar10");
-    std::vector<std::string> log_lines{ReadDebugLogLines()};
-    std::vector<std::string> expected{
-        "[net] foo7: bar7",
-        "[net:info] foo8: bar8",
-        "[net:warning] foo9: bar9",
-        "[net:error] foo10: bar10",
-    };
-    BOOST_CHECK_EQUAL_COLLECTIONS(log_lines.begin(), log_lines.end(), expected.begin(), expected.end());
-}
-
 BOOST_FIXTURE_TEST_CASE(logging_LogPrintMacros, LogSetup)
 {
     LogInstance().EnableCategory(BCLog::NET);
@@ -203,26 +185,25 @@ BOOST_FIXTURE_TEST_CASE(logging_LogPrintMacros_CategoryName, LogSetup)
 
 BOOST_FIXTURE_TEST_CASE(logging_SeverityLevels, LogSetup)
 {
+    LogInstance().SetLogLevel(BCLog::Level::Debug);
     LogInstance().EnableCategory(BCLog::LogFlags::ALL);
     LogInstance().SetCategoryLogLevel(/*category_str=*/"net", /*level_str=*/"info");
 
     // Global log level
-    LogPrintLevel(BCLog::HTTP, BCLog::Level::Info, "foo1: %s\n", "bar1");
-    LogPrintLevel(BCLog::MEMPOOL, BCLog::Level::Trace, "foo2: %s. This log level is lower than the global one.\n", "bar2");
-    LogPrintLevel(BCLog::VALIDATION, BCLog::Level::Warning, "foo3: %s\n", "bar3");
-    LogPrintLevel(BCLog::RPC, BCLog::Level::Error, "foo4: %s\n", "bar4");
+    LogInfo("info_%s", 1);
+    LogTrace(BCLog::HTTP, "trace_%s. This log level is lower than the global one.", 2);
+    LogDebug(BCLog::HTTP, "debug_%s", 3);
+    LogWarning("warn_%s", 4);
+    LogError("err_%s", 5);
 
     // Category-specific log level
-    LogPrintLevel(BCLog::NET, BCLog::Level::Warning, "foo5: %s\n", "bar5");
-    LogPrintLevel(BCLog::NET, BCLog::Level::Debug, "foo6: %s. This log level is the same as the global one but lower than the category-specific one, which takes precedence. \n", "bar6");
-    LogPrintLevel(BCLog::NET, BCLog::Level::Error, "foo7: %s\n", "bar7");
+    LogDebug(BCLog::NET, "debug_%s. This log level is the same as the global one but lower than the category-specific one, which takes precedence.", 6);
 
     std::vector<std::string> expected = {
-        "[http:info] foo1: bar1",
-        "[validation:warning] foo3: bar3",
-        "[rpc:error] foo4: bar4",
-        "[net:warning] foo5: bar5",
-        "[net:error] foo7: bar7",
+        "info_1",
+        "[http] debug_3",
+        "[warning] warn_4",
+        "[error] err_5",
     };
     std::vector<std::string> log_lines{ReadDebugLogLines()};
     BOOST_CHECK_EQUAL_COLLECTIONS(log_lines.begin(), log_lines.end(), expected.begin(), expected.end());
@@ -325,8 +306,8 @@ BOOST_AUTO_TEST_CASE(logging_log_rate_limiter)
     auto& limiter{*Assert(limiter_)};
 
     using Status = BCLog::LogRateLimiter::Status;
-    auto source_loc_1{std::source_location::current()};
-    auto source_loc_2{std::source_location::current()};
+    auto source_loc_1{SourceLocation{__func__}};
+    auto source_loc_2{SourceLocation{__func__}};
 
     // A fresh limiter should not have any suppressions
     BOOST_CHECK(!limiter.SuppressionsActive());
diff --git a/depend/bitcoin/src/test/main.cpp b/depend/bitcoin/src/test/main.cpp
index 67740ece..0b7c451a 100644
--- a/depend/bitcoin/src/test/main.cpp
+++ b/depend/bitcoin/src/test/main.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/test/mempool_tests.cpp b/depend/bitcoin/src/test/mempool_tests.cpp
index f6186406..67e26438 100644
--- a/depend/bitcoin/src/test/mempool_tests.cpp
+++ b/depend/bitcoin/src/test/mempool_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/test/merkle_tests.cpp b/depend/bitcoin/src/test/merkle_tests.cpp
index 649da07c..ee748c5d 100644
--- a/depend/bitcoin/src/test/merkle_tests.cpp
+++ b/depend/bitcoin/src/test/merkle_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2020 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/test/merkleblock_tests.cpp b/depend/bitcoin/src/test/merkleblock_tests.cpp
index 48a61a3f..00a1f0b9 100644
--- a/depend/bitcoin/src/test/merkleblock_tests.cpp
+++ b/depend/bitcoin/src/test/merkleblock_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2021 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
@@ -24,10 +24,10 @@ BOOST_AUTO_TEST_CASE(merkleblock_construct_from_txids_found)
     std::set<Txid> txids;
 
     // Last txn in block.
-    Txid txhash1{Txid::FromHex("74d681e0e03bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20").value()};
+    constexpr Txid txhash1{"74d681e0e03bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20"};
 
     // Second txn in block.
-    Txid txhash2{Txid::FromHex("f9fc751cb7dc372406a9f8d738d5e6f8f63bab71986a39cf36ee70ee17036d07").value()};
+    constexpr Txid txhash2{"f9fc751cb7dc372406a9f8d738d5e6f8f63bab71986a39cf36ee70ee17036d07"};
 
     txids.insert(txhash1);
     txids.insert(txhash2);
@@ -63,7 +63,7 @@ BOOST_AUTO_TEST_CASE(merkleblock_construct_from_txids_not_found)
     CBlock block = getBlock13b8a();
 
     std::set<Txid> txids2;
-    txids2.insert(Txid::FromHex("c0ffee00003bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20").value());
+    txids2.insert(Txid{"c0ffee00003bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20"});
     CMerkleBlock merkleBlock(block, txids2);
 
     BOOST_CHECK_EQUAL(merkleBlock.header.GetHash().GetHex(), block.GetHash().GetHex());
diff --git a/depend/bitcoin/src/test/miner_tests.cpp b/depend/bitcoin/src/test/miner_tests.cpp
index b148c806..a1f5a6d0 100644
--- a/depend/bitcoin/src/test/miner_tests.cpp
+++ b/depend/bitcoin/src/test/miner_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/test/miniminer_tests.cpp b/depend/bitcoin/src/test/miniminer_tests.cpp
index 95b83dfa..de4a310a 100644
--- a/depend/bitcoin/src/test/miniminer_tests.cpp
+++ b/depend/bitcoin/src/test/miniminer_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #include <node/mini_miner.h>
@@ -103,7 +103,7 @@ BOOST_FIXTURE_TEST_CASE(miniminer_negative, TestChain100Setup)
     mini_miner_no_target.BuildMockTemplate(std::nullopt);
     const auto template_txids{mini_miner_no_target.GetMockTemplateTxids()};
     BOOST_CHECK_EQUAL(template_txids.size(), 1);
-    BOOST_CHECK(template_txids.count(tx_mod_negative->GetHash()) > 0);
+    BOOST_CHECK(template_txids.contains(tx_mod_negative->GetHash()));
 }
 
 BOOST_FIXTURE_TEST_CASE(miniminer_1p1c, TestChain100Setup)
diff --git a/depend/bitcoin/src/test/miniscript_tests.cpp b/depend/bitcoin/src/test/miniscript_tests.cpp
index 4d31968c..70563d51 100644
--- a/depend/bitcoin/src/test/miniscript_tests.cpp
+++ b/depend/bitcoin/src/test/miniscript_tests.cpp
@@ -207,17 +207,17 @@ struct Satisfier : public KeyConverter {
 
     //! Implement simplified CLTV logic: stack value must exactly match an entry in `supported`.
     bool CheckAfter(uint32_t value) const {
-        return supported.count(Challenge(ChallengeType::AFTER, value));
+        return supported.contains(Challenge(ChallengeType::AFTER, value));
     }
 
     //! Implement simplified CSV logic: stack value must exactly match an entry in `supported`.
     bool CheckOlder(uint32_t value) const {
-        return supported.count(Challenge(ChallengeType::OLDER, value));
+        return supported.contains(Challenge(ChallengeType::OLDER, value));
     }
 
     //! Produce a signature for the given key.
     miniscript::Availability Sign(const CPubKey& key, std::vector<unsigned char>& sig) const {
-        if (supported.count(Challenge(ChallengeType::PK, ChallengeNumber(key)))) {
+        if (supported.contains(Challenge(ChallengeType::PK, ChallengeNumber(key)))) {
             if (!miniscript::IsTapscript(m_script_ctx)) {
                 auto it = g_testdata->signatures.find(key);
                 if (it == g_testdata->signatures.end()) return miniscript::Availability::NO;
@@ -234,7 +234,7 @@ struct Satisfier : public KeyConverter {
 
     //! Helper function for the various hash based satisfactions.
     miniscript::Availability SatHash(const std::vector<unsigned char>& hash, std::vector<unsigned char>& preimage, ChallengeType chtype) const {
-        if (!supported.count(Challenge(chtype, ChallengeNumber(hash)))) return miniscript::Availability::NO;
+        if (!supported.contains(Challenge(chtype, ChallengeNumber(hash)))) return miniscript::Availability::NO;
         const auto& m =
             chtype == ChallengeType::SHA256 ? g_testdata->sha256_preimages :
             chtype == ChallengeType::HASH256 ? g_testdata->hash256_preimages :
diff --git a/depend/bitcoin/src/test/minisketch_tests.cpp b/depend/bitcoin/src/test/minisketch_tests.cpp
index 3d2a8351..1d6f2a12 100644
--- a/depend/bitcoin/src/test/minisketch_tests.cpp
+++ b/depend/bitcoin/src/test/minisketch_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/multisig_tests.cpp b/depend/bitcoin/src/test/multisig_tests.cpp
index 7134cef6..932b83fe 100644
--- a/depend/bitcoin/src/test/multisig_tests.cpp
+++ b/depend/bitcoin/src/test/multisig_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/test/net_peer_eviction_tests.cpp b/depend/bitcoin/src/test/net_peer_eviction_tests.cpp
index d9e1c233..5dc2061a 100644
--- a/depend/bitcoin/src/test/net_peer_eviction_tests.cpp
+++ b/depend/bitcoin/src/test/net_peer_eviction_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -40,12 +40,12 @@ bool IsProtected(int num_peers,
 
     size_t unprotected_count{0};
     for (const NodeEvictionCandidate& candidate : candidates) {
-        if (protected_peer_ids.count(candidate.id)) {
+        if (protected_peer_ids.contains(candidate.id)) {
             // this peer should have been removed from the eviction candidates
             BOOST_TEST_MESSAGE(strprintf("expected candidate to be protected: %d", candidate.id));
             return false;
         }
-        if (unprotected_peer_ids.count(candidate.id)) {
+        if (unprotected_peer_ids.contains(candidate.id)) {
             // this peer remains in the eviction candidates, as expected
             ++unprotected_count;
         }
@@ -577,7 +577,7 @@ bool IsEvicted(std::vector<NodeEvictionCandidate> candidates, const std::unorder
     if (!evicted_node_id) {
         return false;
     }
-    return node_ids.count(*evicted_node_id);
+    return node_ids.contains(*evicted_node_id);
 }
 
 // Create number_of_nodes random nodes, apply setup function candidate_setup_fn,
diff --git a/depend/bitcoin/src/test/node_init_tests.cpp b/depend/bitcoin/src/test/node_init_tests.cpp
index 90eab38f..a4292e66 100644
--- a/depend/bitcoin/src/test/node_init_tests.cpp
+++ b/depend/bitcoin/src/test/node_init_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2025 The Bitcoin Core developers
+// Copyright (c) 2025-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/orphanage_tests.cpp b/depend/bitcoin/src/test/orphanage_tests.cpp
index 17ddc71a..933736dc 100644
--- a/depend/bitcoin/src/test/orphanage_tests.cpp
+++ b/depend/bitcoin/src/test/orphanage_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/test/pmt_tests.cpp b/depend/bitcoin/src/test/pmt_tests.cpp
index b7bf5062..da955b3f 100644
--- a/depend/bitcoin/src/test/pmt_tests.cpp
+++ b/depend/bitcoin/src/test/pmt_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/pow_tests.cpp b/depend/bitcoin/src/test/pow_tests.cpp
index 76e46004..8de76ff2 100644
--- a/depend/bitcoin/src/test/pow_tests.cpp
+++ b/depend/bitcoin/src/test/pow_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/test/raii_event_tests.cpp b/depend/bitcoin/src/test/raii_event_tests.cpp
index 7d1079fb..3a797dff 100644
--- a/depend/bitcoin/src/test/raii_event_tests.cpp
+++ b/depend/bitcoin/src/test/raii_event_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/test/random_tests.cpp b/depend/bitcoin/src/test/random_tests.cpp
index 538d4112..213465fd 100644
--- a/depend/bitcoin/src/test/random_tests.cpp
+++ b/depend/bitcoin/src/test/random_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/test/rbf_tests.cpp b/depend/bitcoin/src/test/rbf_tests.cpp
index 4527ea5e..175ca82e 100644
--- a/depend/bitcoin/src/test/rbf_tests.cpp
+++ b/depend/bitcoin/src/test/rbf_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #include <common/system.h>
diff --git a/depend/bitcoin/src/test/rest_tests.cpp b/depend/bitcoin/src/test/rest_tests.cpp
index 20dfe4b4..5dc12250 100644
--- a/depend/bitcoin/src/test/rest_tests.cpp
+++ b/depend/bitcoin/src/test/rest_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/result_tests.cpp b/depend/bitcoin/src/test/result_tests.cpp
index 42848644..dfb6da2e 100644
--- a/depend/bitcoin/src/test/result_tests.cpp
+++ b/depend/bitcoin/src/test/result_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/test/reverselock_tests.cpp b/depend/bitcoin/src/test/reverselock_tests.cpp
index 6abf55c8..b792dbe4 100644
--- a/depend/bitcoin/src/test/reverselock_tests.cpp
+++ b/depend/bitcoin/src/test/reverselock_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2021 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/test/rpc_tests.cpp b/depend/bitcoin/src/test/rpc_tests.cpp
index 99d1c658..f8d75a80 100644
--- a/depend/bitcoin/src/test/rpc_tests.cpp
+++ b/depend/bitcoin/src/test/rpc_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/sanity_tests.cpp b/depend/bitcoin/src/test/sanity_tests.cpp
index 68f82b76..9c038db4 100644
--- a/depend/bitcoin/src/test/sanity_tests.cpp
+++ b/depend/bitcoin/src/test/sanity_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/scheduler_tests.cpp b/depend/bitcoin/src/test/scheduler_tests.cpp
index 95e725de..1ec8e8da 100644
--- a/depend/bitcoin/src/test/scheduler_tests.cpp
+++ b/depend/bitcoin/src/test/scheduler_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/script_p2sh_tests.cpp b/depend/bitcoin/src/test/script_p2sh_tests.cpp
index b4641118..2f93d0a8 100644
--- a/depend/bitcoin/src/test/script_p2sh_tests.cpp
+++ b/depend/bitcoin/src/test/script_p2sh_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/script_parse_tests.cpp b/depend/bitcoin/src/test/script_parse_tests.cpp
index 004c1a9a..a4e01120 100644
--- a/depend/bitcoin/src/test/script_parse_tests.cpp
+++ b/depend/bitcoin/src/test/script_parse_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/script_segwit_tests.cpp b/depend/bitcoin/src/test/script_segwit_tests.cpp
index 2bad5980..fd165e29 100644
--- a/depend/bitcoin/src/test/script_segwit_tests.cpp
+++ b/depend/bitcoin/src/test/script_segwit_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2021 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/script_standard_tests.cpp b/depend/bitcoin/src/test/script_standard_tests.cpp
index 9a63426e..c6d3b125 100644
--- a/depend/bitcoin/src/test/script_standard_tests.cpp
+++ b/depend/bitcoin/src/test/script_standard_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/test/script_tests.cpp b/depend/bitcoin/src/test/script_tests.cpp
index 99e38f37..58958850 100644
--- a/depend/bitcoin/src/test/script_tests.cpp
+++ b/depend/bitcoin/src/test/script_tests.cpp
@@ -892,7 +892,7 @@ BOOST_AUTO_TEST_CASE(script_build)
 #ifdef UPDATE_JSON_TESTS
         strGen += str + ",\n";
 #else
-        if (tests_set.count(str) == 0) {
+        if (!tests_set.contains(str)) {
             BOOST_CHECK_MESSAGE(false, "Missing auto script_valid test: " + test.GetComment());
         }
 #endif
diff --git a/depend/bitcoin/src/test/serfloat_tests.cpp b/depend/bitcoin/src/test/serfloat_tests.cpp
index 4464b0a0..2d62f39a 100644
--- a/depend/bitcoin/src/test/serfloat_tests.cpp
+++ b/depend/bitcoin/src/test/serfloat_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2021 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/test/settings_tests.cpp b/depend/bitcoin/src/test/settings_tests.cpp
index 00a566d7..54d3b058 100644
--- a/depend/bitcoin/src/test/settings_tests.cpp
+++ b/depend/bitcoin/src/test/settings_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/test/sighash_tests.cpp b/depend/bitcoin/src/test/sighash_tests.cpp
index 6e2ec800..42728216 100644
--- a/depend/bitcoin/src/test/sighash_tests.cpp
+++ b/depend/bitcoin/src/test/sighash_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2013-2022 The Bitcoin Core developers
+// Copyright (c) 2013-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.
 
diff --git a/depend/bitcoin/src/test/sigopcount_tests.cpp b/depend/bitcoin/src/test/sigopcount_tests.cpp
index 41a4304f..d3fec0f9 100644
--- a/depend/bitcoin/src/test/sigopcount_tests.cpp
+++ b/depend/bitcoin/src/test/sigopcount_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/skiplist_tests.cpp b/depend/bitcoin/src/test/skiplist_tests.cpp
index 7ffa6f64..ce44b3e3 100644
--- a/depend/bitcoin/src/test/skiplist_tests.cpp
+++ b/depend/bitcoin/src/test/skiplist_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2022 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/test/sock_tests.cpp b/depend/bitcoin/src/test/sock_tests.cpp
index 06d9f7d3..98f25279 100644
--- a/depend/bitcoin/src/test/sock_tests.cpp
+++ b/depend/bitcoin/src/test/sock_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/sync_tests.cpp b/depend/bitcoin/src/test/sync_tests.cpp
index dcd1b1ce..9240691b 100644
--- a/depend/bitcoin/src/test/sync_tests.cpp
+++ b/depend/bitcoin/src/test/sync_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2022 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/test/system_tests.cpp b/depend/bitcoin/src/test/system_tests.cpp
index dec4d418..0b7cc5b2 100644
--- a/depend/bitcoin/src/test/system_tests.cpp
+++ b/depend/bitcoin/src/test/system_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 //
diff --git a/depend/bitcoin/src/test/testnet4_miner_tests.cpp b/depend/bitcoin/src/test/testnet4_miner_tests.cpp
index 54ca8e32..5b3582ac 100644
--- a/depend/bitcoin/src/test/testnet4_miner_tests.cpp
+++ b/depend/bitcoin/src/test/testnet4_miner_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2025 The Bitcoin Core developers
+// Copyright (c) 2025-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/transaction_tests.cpp b/depend/bitcoin/src/test/transaction_tests.cpp
index 0ab9fbb4..3919f226 100644
--- a/depend/bitcoin/src/test/transaction_tests.cpp
+++ b/depend/bitcoin/src/test/transaction_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
@@ -60,7 +60,7 @@ script_verify_flags ParseScriptFlags(std::string strFlags)
     std::vector<std::string> words = SplitString(strFlags, ',');
     for (const std::string& word : words)
     {
-        if (!mapFlagNames.count(word)) {
+        if (!mapFlagNames.contains(word)) {
             BOOST_ERROR("Bad test: unknown verification flag '" << word << "'");
             continue;
         }
@@ -90,7 +90,7 @@ bool CheckTxScripts(const CTransaction& tx, const std::map<COutPoint, CScript>&
     ScriptError err = expect_valid ? SCRIPT_ERR_UNKNOWN_ERROR : SCRIPT_ERR_OK;
     for (unsigned int i = 0; i < tx.vin.size() && tx_valid; ++i) {
         const CTxIn input = tx.vin[i];
-        const CAmount amount = map_prevout_values.count(input.prevout) ? map_prevout_values.at(input.prevout) : 0;
+        const CAmount amount = map_prevout_values.contains(input.prevout) ? map_prevout_values.at(input.prevout) : 0;
         try {
             tx_valid = VerifyScript(input.scriptSig, map_prevout_scriptPubKeys.at(input.prevout),
                 &input.scriptWitness, flags, TransactionSignatureChecker(&tx, i, amount, txdata, MissingDataBehavior::ASSERT_FAIL), &err);
@@ -509,7 +509,7 @@ BOOST_AUTO_TEST_CASE(test_big_witness_transaction)
     // create a big transaction of 4500 inputs signed by the same key
     for(uint32_t ij = 0; ij < 4500; ij++) {
         uint32_t i = mtx.vin.size();
-        COutPoint outpoint(Txid::FromHex("0000000000000000000000000000000000000000000000000000000000000100").value(), i);
+        COutPoint outpoint{Txid{"0000000000000000000000000000000000000000000000000000000000000100"}, i};
 
         mtx.vin.resize(mtx.vin.size() + 1);
         mtx.vin[i].prevout = outpoint;
diff --git a/depend/bitcoin/src/test/translation_tests.cpp b/depend/bitcoin/src/test/translation_tests.cpp
index 4935830c..369bd9f4 100644
--- a/depend/bitcoin/src/test/translation_tests.cpp
+++ b/depend/bitcoin/src/test/translation_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/txdownload_tests.cpp b/depend/bitcoin/src/test/txdownload_tests.cpp
index 8b367148..e9c6160e 100644
--- a/depend/bitcoin/src/test/txdownload_tests.cpp
+++ b/depend/bitcoin/src/test/txdownload_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/test/txindex_tests.cpp b/depend/bitcoin/src/test/txindex_tests.cpp
index e06735e1..82a60039 100644
--- a/depend/bitcoin/src/test/txindex_tests.cpp
+++ b/depend/bitcoin/src/test/txindex_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/test/txpackage_tests.cpp b/depend/bitcoin/src/test/txpackage_tests.cpp
index d82bd93c..bb4b83ed 100644
--- a/depend/bitcoin/src/test/txpackage_tests.cpp
+++ b/depend/bitcoin/src/test/txpackage_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -73,9 +73,9 @@ BOOST_AUTO_TEST_CASE(package_hash_tests)
     CTransactionRef ptx_3{MakeTransactionRef(tx_3)};
 
     // It's easy to see that wtxids are sorted in lexicographical order:
-    Wtxid wtxid_1{Wtxid::FromHex("85cd1a31eb38f74ed5742ec9cb546712ab5aaf747de28a9168b53e846cbda17f").value()};
-    Wtxid wtxid_2{Wtxid::FromHex("b4749f017444b051c44dfd2720e88f314ff94f3dd6d56d40ef65854fcd7fff6b").value()};
-    Wtxid wtxid_3{Wtxid::FromHex("e065bac15f62bb4e761d761db928ddee65a47296b2b776785abb912cdec474e3").value()};
+    constexpr Wtxid wtxid_1{"85cd1a31eb38f74ed5742ec9cb546712ab5aaf747de28a9168b53e846cbda17f"};
+    constexpr Wtxid wtxid_2{"b4749f017444b051c44dfd2720e88f314ff94f3dd6d56d40ef65854fcd7fff6b"};
+    constexpr Wtxid wtxid_3{"e065bac15f62bb4e761d761db928ddee65a47296b2b776785abb912cdec474e3"};
     BOOST_CHECK_EQUAL(tx_1.GetWitnessHash(), wtxid_1);
     BOOST_CHECK_EQUAL(tx_2.GetWitnessHash(), wtxid_2);
     BOOST_CHECK_EQUAL(tx_3.GetWitnessHash(), wtxid_3);
@@ -84,9 +84,9 @@ BOOST_AUTO_TEST_CASE(package_hash_tests)
     BOOST_CHECK(wtxid_2.GetHex() < wtxid_3.GetHex());
 
     // The txids are not (we want to test that sorting and hashing use wtxid, not txid):
-    Txid txid_1{Txid::FromHex("bd0f71c1d5e50589063e134fad22053cdae5ab2320db5bf5e540198b0b5a4e69").value()};
-    Txid txid_2{Txid::FromHex("b4749f017444b051c44dfd2720e88f314ff94f3dd6d56d40ef65854fcd7fff6b").value()};
-    Txid txid_3{Txid::FromHex("ee707be5201160e32c4fc715bec227d1aeea5940fb4295605e7373edce3b1a93").value()};
+    constexpr Txid txid_1{"bd0f71c1d5e50589063e134fad22053cdae5ab2320db5bf5e540198b0b5a4e69"};
+    constexpr Txid txid_2{"b4749f017444b051c44dfd2720e88f314ff94f3dd6d56d40ef65854fcd7fff6b"};
+    constexpr Txid txid_3{"ee707be5201160e32c4fc715bec227d1aeea5940fb4295605e7373edce3b1a93"};
     BOOST_CHECK_EQUAL(tx_1.GetHash(), txid_1);
     BOOST_CHECK_EQUAL(tx_2.GetHash(), txid_2);
     BOOST_CHECK_EQUAL(tx_3.GetHash(), txid_3);
@@ -908,10 +908,10 @@ BOOST_AUTO_TEST_CASE(package_cpfp_tests)
         } else {
             BOOST_CHECK_EQUAL(submit_cpfp_deprio.m_state.GetResult(), PackageValidationResult::PCKG_TX);
             BOOST_CHECK_EQUAL(submit_cpfp_deprio.m_tx_results.find(tx_parent->GetWitnessHash())->second.m_state.GetResult(),
-                              TxValidationResult::TX_MEMPOOL_POLICY);
+                              TxValidationResult::TX_RECONSIDERABLE);
             BOOST_CHECK_EQUAL(submit_cpfp_deprio.m_tx_results.find(tx_child->GetWitnessHash())->second.m_state.GetResult(),
-                              TxValidationResult::TX_MISSING_INPUTS);
-            BOOST_CHECK(submit_cpfp_deprio.m_tx_results.find(tx_parent->GetWitnessHash())->second.m_state.GetRejectReason() == "min relay fee not met");
+                              TxValidationResult::TX_RECONSIDERABLE);
+            BOOST_CHECK_EQUAL(submit_cpfp_deprio.m_tx_results.find(tx_parent->GetWitnessHash())->second.m_state.GetRejectReason(), "mempool min fee not met");
             BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
         }
     }
@@ -1067,8 +1067,8 @@ BOOST_AUTO_TEST_CASE(package_cpfp_tests)
                     strprintf("rich parent: expected fee %s, got %s", high_parent_fee, it_parent->second.m_base_fees.value()));
             BOOST_CHECK(it_parent->second.m_effective_feerate == CFeeRate(high_parent_fee, GetVirtualTransactionSize(*tx_parent_rich)));
             BOOST_CHECK_EQUAL(it_child->second.m_result_type, MempoolAcceptResult::ResultType::INVALID);
-            BOOST_CHECK_EQUAL(it_child->second.m_state.GetResult(), TxValidationResult::TX_MEMPOOL_POLICY);
-            BOOST_CHECK(it_child->second.m_state.GetRejectReason() == "min relay fee not met");
+            BOOST_CHECK_EQUAL(it_child->second.m_state.GetResult(), TxValidationResult::TX_RECONSIDERABLE);
+            BOOST_CHECK_EQUAL(it_child->second.m_state.GetRejectReason(), "mempool min fee not met");
         }
         expected_pool_size += 1;
         BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
diff --git a/depend/bitcoin/src/test/txreconciliation_tests.cpp b/depend/bitcoin/src/test/txreconciliation_tests.cpp
index 75e6d1c7..d4ed3511 100644
--- a/depend/bitcoin/src/test/txreconciliation_tests.cpp
+++ b/depend/bitcoin/src/test/txreconciliation_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/txrequest_tests.cpp b/depend/bitcoin/src/test/txrequest_tests.cpp
index ba82a986..87e91974 100644
--- a/depend/bitcoin/src/test/txrequest_tests.cpp
+++ b/depend/bitcoin/src/test/txrequest_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/test/txvalidation_tests.cpp b/depend/bitcoin/src/test/txvalidation_tests.cpp
index 4bd5d7e6..b16b6047 100644
--- a/depend/bitcoin/src/test/txvalidation_tests.cpp
+++ b/depend/bitcoin/src/test/txvalidation_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2021 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/test/txvalidationcache_tests.cpp b/depend/bitcoin/src/test/txvalidationcache_tests.cpp
index 46cb8482..9ea39c91 100644
--- a/depend/bitcoin/src/test/txvalidationcache_tests.cpp
+++ b/depend/bitcoin/src/test/txvalidationcache_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/test/uint256_tests.cpp b/depend/bitcoin/src/test/uint256_tests.cpp
index 80e10104..a4ebc049 100644
--- a/depend/bitcoin/src/test/uint256_tests.cpp
+++ b/depend/bitcoin/src/test/uint256_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2021 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/test/util/blockfilter.cpp b/depend/bitcoin/src/test/util/blockfilter.cpp
index 8716af9f..3492ca72 100644
--- a/depend/bitcoin/src/test/util/blockfilter.cpp
+++ b/depend/bitcoin/src/test/util/blockfilter.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/util/blockfilter.h b/depend/bitcoin/src/test/util/blockfilter.h
index 789ce5d3..dc8761d2 100644
--- a/depend/bitcoin/src/test/util/blockfilter.h
+++ b/depend/bitcoin/src/test/util/blockfilter.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/util/chainstate.h b/depend/bitcoin/src/test/util/chainstate.h
index aac7816e..1e0d41cd 100644
--- a/depend/bitcoin/src/test/util/chainstate.h
+++ b/depend/bitcoin/src/test/util/chainstate.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 //
@@ -81,7 +81,7 @@ CreateAndActivateUTXOSnapshot(
             Chainstate& chain = node.chainman->ActiveChainstate();
             Assert(chain.LoadGenesisBlock());
             // These cache values will be corrected shortly in `MaybeRebalanceCaches`.
-            chain.InitCoinsDB(1 << 20, true, false, "");
+            chain.InitCoinsDB(1 << 20, /*in_memory=*/true, /*should_wipe=*/false);
             chain.InitCoinsCache(1 << 20);
             chain.CoinsTip().SetBestBlock(gen_hash);
             chain.setBlockIndexCandidates.insert(node.chainman->m_blockman.LookupBlockIndex(gen_hash));
diff --git a/depend/bitcoin/src/test/util/cluster_linearize.h b/depend/bitcoin/src/test/util/cluster_linearize.h
index c79f414a..f57c486b 100644
--- a/depend/bitcoin/src/test/util/cluster_linearize.h
+++ b/depend/bitcoin/src/test/util/cluster_linearize.h
@@ -331,7 +331,7 @@ void SanityCheck(const DepGraph<SetType>& depgraph)
         VectorWriter writer(ser, 0);
         writer << Using<DepGraphFormatter>(depgraph);
         SpanReader reader(ser);
-        DepGraph<TestBitSet> decoded_depgraph;
+        DepGraph<SetType> decoded_depgraph;
         reader >> Using<DepGraphFormatter>(decoded_depgraph);
         assert(depgraph == decoded_depgraph);
         assert(reader.empty());
@@ -384,37 +384,36 @@ void SanityCheck(const DepGraph<SetType>& depgraph, std::span<const DepGraphInde
 {
     // Check completeness.
     assert(linearization.size() == depgraph.TxCount());
-    TestBitSet done;
+    SetType done;
     for (auto i : linearization) {
         // Check transaction position is in range.
         assert(depgraph.Positions()[i]);
         // Check topology and lack of duplicates.
-        assert((depgraph.Ancestors(i) - done) == TestBitSet::Singleton(i));
+        assert((depgraph.Ancestors(i) - done) == SetType::Singleton(i));
         done.Set(i);
     }
 }
 
 inline uint64_t MaxOptimalLinearizationIters(DepGraphIndex cluster_count)
 {
-    // We assume sqrt(2^k)+1 candidate-finding iterations per candidate to be found, plus ceil(k/4)
-    // startup cost when up to k unlinearization transactions remain, plus ceil(n^2/64) overall
-    // startup cost in Linearize. Thus, we can compute the upper bound for a whole linearization
-    // (summing for k=1..n) using the Python expression:
-    //
-    //   [sum((k+3)//4 + math.isqrt(2**k) + 1 for k in range(1, n + 1)) + (n**2 + 63) // 64 for n in range(0, 65)]
-    //
-    // Note that these are just assumptions, as the proven upper bound grows with 2^k, not
-    // sqrt(2^k).
-    static constexpr uint64_t MAX_OPTIMAL_ITERS[65] = {
-        0, 4, 8, 12, 18, 26, 37, 51, 70, 97, 133, 182, 251, 346, 480, 666, 927, 1296, 1815, 2545,
-        3576, 5031, 7087, 9991, 14094, 19895, 28096, 39690, 56083, 79263, 112041, 158391, 223936,
-        316629, 447712, 633086, 895241, 1265980, 1790280, 2531747, 3580335, 5063259, 7160424,
-        10126257, 14320575, 20252230, 28640853, 40504150, 57281380, 81007962, 114562410, 162015557,
-        229124437, 324030718, 458248463, 648061011, 916496483, 1296121563, 1832992493, 2592242635,
-        3665984477, 5184484745, 7331968412, 10368968930, 14663936244
+    // These are the largest numbers seen returned as cost by Linearize(), in a large randomized
+    // trial. There exist almost certainly far worse cases, but they are unlikely to be
+    // encountered in randomized tests. The purpose of these numbers is guaranteeing that for
+    // *some* reasonable cost bound, optimal linearizations are always found.
+    static constexpr uint64_t ITERS[65] = {
+        0,
+        0, 2, 8, 21, 51, 96, 162, 200,
+        273, 323, 413, 506, 602, 788, 883, 948,
+        1153, 1187, 1367, 1619, 1854, 2271, 2257, 2707,
+        2904, 3275, 3342, 4209, 4648, 4146, 4273, 4905,
+        5358, 5767, 5977, 6777, 7812, 7689, 8478, 8425,
+        9561, 11765, 10743, 11806, 12812, 12838, 15421, 16778,
+        16661, 19393, 17995, 23947, 23314, 24564, 26209, 29267,
+        24719, 31065, 31794, 29185, 32465, 35432, 39986, 36865
     };
-    assert(cluster_count < sizeof(MAX_OPTIMAL_ITERS) / sizeof(MAX_OPTIMAL_ITERS[0]));
-    return MAX_OPTIMAL_ITERS[cluster_count];
+    assert(cluster_count < std::size(ITERS));
+    // Multiply the table number by two, to account for the fact that they are not absolutes.
+    return ITERS[cluster_count] * 2;
 }
 
 } // namespace
diff --git a/depend/bitcoin/src/test/util/coins.h b/depend/bitcoin/src/test/util/coins.h
index 89a9e7b3..4f729be8 100644
--- a/depend/bitcoin/src/test/util/coins.h
+++ b/depend/bitcoin/src/test/util/coins.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/util/logging.cpp b/depend/bitcoin/src/test/util/logging.cpp
index 78ad9c83..e8d45399 100644
--- a/depend/bitcoin/src/test/util/logging.cpp
+++ b/depend/bitcoin/src/test/util/logging.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/util/logging.h b/depend/bitcoin/src/test/util/logging.h
index cd6cb14d..ed3ee19e 100644
--- a/depend/bitcoin/src/test/util/logging.h
+++ b/depend/bitcoin/src/test/util/logging.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/util/mining.cpp b/depend/bitcoin/src/test/util/mining.cpp
index 0dacf71b..da15e678 100644
--- a/depend/bitcoin/src/test/util/mining.cpp
+++ b/depend/bitcoin/src/test/util/mining.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/util/mining.h b/depend/bitcoin/src/test/util/mining.h
index 9ad86922..9be01507 100644
--- a/depend/bitcoin/src/test/util/mining.h
+++ b/depend/bitcoin/src/test/util/mining.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/util/poolresourcetester.h b/depend/bitcoin/src/test/util/poolresourcetester.h
index 7c06980e..0c82a34d 100644
--- a/depend/bitcoin/src/test/util/poolresourcetester.h
+++ b/depend/bitcoin/src/test/util/poolresourcetester.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/test/util/script.cpp b/depend/bitcoin/src/test/util/script.cpp
index 34c30233..1efa19ab 100644
--- a/depend/bitcoin/src/test/util/script.cpp
+++ b/depend/bitcoin/src/test/util/script.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/util/script.h b/depend/bitcoin/src/test/util/script.h
index 2f11fa79..44d9acd9 100644
--- a/depend/bitcoin/src/test/util/script.h
+++ b/depend/bitcoin/src/test/util/script.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/util/str.cpp b/depend/bitcoin/src/test/util/str.cpp
index c517fe44..32a6825d 100644
--- a/depend/bitcoin/src/test/util/str.cpp
+++ b/depend/bitcoin/src/test/util/str.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/util/str.h b/depend/bitcoin/src/test/util/str.h
index ef94692d..39e2bafc 100644
--- a/depend/bitcoin/src/test/util/str.h
+++ b/depend/bitcoin/src/test/util/str.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/util/transaction_utils.cpp b/depend/bitcoin/src/test/util/transaction_utils.cpp
index a588e619..7b1e2eb3 100644
--- a/depend/bitcoin/src/test/util/transaction_utils.cpp
+++ b/depend/bitcoin/src/test/util/transaction_utils.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2020 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/util/transaction_utils.h b/depend/bitcoin/src/test/util/transaction_utils.h
index 4a18ab6a..867554f8 100644
--- a/depend/bitcoin/src/test/util/transaction_utils.h
+++ b/depend/bitcoin/src/test/util/transaction_utils.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2020 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/test/util/txmempool.cpp b/depend/bitcoin/src/test/util/txmempool.cpp
index b158713d..a019c830 100644
--- a/depend/bitcoin/src/test/util/txmempool.cpp
+++ b/depend/bitcoin/src/test/util/txmempool.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
@@ -60,7 +60,7 @@ std::optional<std::string> CheckPackageMempoolAcceptResult(const Package& txns,
     }
     for (const auto& tx : txns) {
         const auto& wtxid = tx->GetWitnessHash();
-        if (result.m_tx_results.count(wtxid) == 0) {
+        if (!result.m_tx_results.contains(wtxid)) {
             return strprintf("result not found for tx %s", wtxid.ToString());
         }
 
diff --git a/depend/bitcoin/src/test/util/txmempool.h b/depend/bitcoin/src/test/util/txmempool.h
index f0b66deb..ac3f5038 100644
--- a/depend/bitcoin/src/test/util/txmempool.h
+++ b/depend/bitcoin/src/test/util/txmempool.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/test/util/validation.cpp b/depend/bitcoin/src/test/util/validation.cpp
index ce558078..bb9c6db2 100644
--- a/depend/bitcoin/src/test/util/validation.cpp
+++ b/depend/bitcoin/src/test/util/validation.cpp
@@ -1,23 +1,35 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <test/util/validation.h>
 
+#include <node/blockstorage.h>
 #include <util/check.h>
 #include <util/time.h>
 #include <validation.h>
 #include <validationinterface.h>
 
+using kernel::ChainstateRole;
+
+void TestBlockManager::CleanupForFuzzing()
+{
+    m_dirty_blockindex.clear();
+    m_dirty_fileinfo.clear();
+    m_blockfile_info.resize(1);
+}
+
 void TestChainstateManager::DisableNextWrite()
 {
     struct TestChainstate : public Chainstate {
         void ResetNextWrite() { m_next_write = NodeClock::time_point::max() - 1s; }
     };
-    for (auto* cs : GetAll()) {
-        static_cast<TestChainstate*>(cs)->ResetNextWrite();
+    LOCK(::cs_main);
+    for (const auto& cs : m_chainstates) {
+        static_cast<TestChainstate&>(*cs).ResetNextWrite();
     }
 }
+
 void TestChainstateManager::ResetIbd()
 {
     m_cached_finished_ibd = false;
@@ -32,10 +44,50 @@ void TestChainstateManager::JumpOutOfIbd()
 }
 
 void ValidationInterfaceTest::BlockConnected(
-        ChainstateRole role,
-        CValidationInterface& obj,
-        const std::shared_ptr<const CBlock>& block,
-        const CBlockIndex* pindex)
+    const ChainstateRole& role,
+    CValidationInterface& obj,
+    const std::shared_ptr<const CBlock>& block,
+    const CBlockIndex* pindex)
 {
     obj.BlockConnected(role, block, pindex);
 }
+void TestChainstateManager::InvalidBlockFound(CBlockIndex* pindex, const BlockValidationState& state)
+{
+    struct TestChainstate : public Chainstate {
+        void CallInvalidBlockFound(CBlockIndex* pindex, const BlockValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
+        {
+            InvalidBlockFound(pindex, state);
+        }
+    };
+
+    static_cast<TestChainstate*>(&ActiveChainstate())->CallInvalidBlockFound(pindex, state);
+}
+
+void TestChainstateManager::InvalidChainFound(CBlockIndex* pindexNew)
+{
+    struct TestChainstate : public Chainstate {
+        void CallInvalidChainFound(CBlockIndex* pindexNew) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
+        {
+            InvalidChainFound(pindexNew);
+        }
+    };
+
+    static_cast<TestChainstate*>(&ActiveChainstate())->CallInvalidChainFound(pindexNew);
+}
+
+CBlockIndex* TestChainstateManager::FindMostWorkChain()
+{
+    struct TestChainstate : public Chainstate {
+        CBlockIndex* CallFindMostWorkChain() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
+        {
+            return FindMostWorkChain();
+        }
+    };
+
+    return static_cast<TestChainstate*>(&ActiveChainstate())->CallFindMostWorkChain();
+}
+
+void TestChainstateManager::ResetBestInvalid()
+{
+    m_best_invalid = nullptr;
+}
diff --git a/depend/bitcoin/src/test/util/validation.h b/depend/bitcoin/src/test/util/validation.h
index f9c6a8ac..1be3f6a6 100644
--- a/depend/bitcoin/src/test/util/validation.h
+++ b/depend/bitcoin/src/test/util/validation.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
@@ -7,8 +7,16 @@
 
 #include <validation.h>
 
+namespace node {
+class BlockManager;
+}
 class CValidationInterface;
 
+struct TestBlockManager : public node::BlockManager {
+    /** Test-only method to clear internal state for fuzzing */
+    void CleanupForFuzzing();
+};
+
 struct TestChainstateManager : public ChainstateManager {
     /** Disable the next write of all chainstates */
     void DisableNextWrite();
@@ -16,13 +24,18 @@ struct TestChainstateManager : public ChainstateManager {
     void ResetIbd();
     /** Toggle IsInitialBlockDownload from true to false */
     void JumpOutOfIbd();
+    /** Wrappers that avoid making chainstatemanager internals public for tests */
+    void InvalidBlockFound(CBlockIndex* pindex, const BlockValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    void InvalidChainFound(CBlockIndex* pindexNew) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    CBlockIndex* FindMostWorkChain() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    void ResetBestInvalid() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 };
 
 class ValidationInterfaceTest
 {
 public:
     static void BlockConnected(
-        ChainstateRole role,
+        const kernel::ChainstateRole& role,
         CValidationInterface& obj,
         const std::shared_ptr<const CBlock>& block,
         const CBlockIndex* pindex);
diff --git a/depend/bitcoin/src/test/util_threadnames_tests.cpp b/depend/bitcoin/src/test/util_threadnames_tests.cpp
index efa0b273..f22eb12d 100644
--- a/depend/bitcoin/src/test/util_threadnames_tests.cpp
+++ b/depend/bitcoin/src/test/util_threadnames_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 The Bitcoin Core developers
+// 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.
 
@@ -58,7 +58,7 @@ BOOST_AUTO_TEST_CASE(util_threadnames_test_rename_threaded)
 
     // Names "test_thread.[n]" should exist for n = [0, 99]
     for (int i = 0; i < 100; ++i) {
-        BOOST_CHECK(names.find(TEST_THREAD_NAME_BASE + ToString(i)) != names.end());
+        BOOST_CHECK(names.contains(TEST_THREAD_NAME_BASE + ToString(i)));
     }
 
 }
diff --git a/depend/bitcoin/src/test/util_trace_tests.cpp b/depend/bitcoin/src/test/util_trace_tests.cpp
index 06fbcf3b..ebd8cedc 100644
--- a/depend/bitcoin/src/test/util_trace_tests.cpp
+++ b/depend/bitcoin/src/test/util_trace_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/test/validation_block_tests.cpp b/depend/bitcoin/src/test/validation_block_tests.cpp
index a0b23f5d..9f574be8 100644
--- a/depend/bitcoin/src/test/validation_block_tests.cpp
+++ b/depend/bitcoin/src/test/validation_block_tests.cpp
@@ -19,6 +19,7 @@
 
 #include <thread>
 
+using kernel::ChainstateRole;
 using node::BlockAssembler;
 
 namespace validation_block_tests {
@@ -43,7 +44,7 @@ struct TestSubscriber final : public CValidationInterface {
         BOOST_CHECK_EQUAL(m_expected_tip, pindexNew->GetBlockHash());
     }
 
-    void BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override
+    void BlockConnected(const ChainstateRole& role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override
     {
         BOOST_CHECK_EQUAL(m_expected_tip, block->hashPrevBlock);
         BOOST_CHECK_EQUAL(m_expected_tip, pindex->pprev->GetBlockHash());
diff --git a/depend/bitcoin/src/test/validation_chainstate_tests.cpp b/depend/bitcoin/src/test/validation_chainstate_tests.cpp
index 7204f168..9e2c7109 100644
--- a/depend/bitcoin/src/test/validation_chainstate_tests.cpp
+++ b/depend/bitcoin/src/test/validation_chainstate_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 //
@@ -95,7 +95,7 @@ BOOST_FIXTURE_TEST_CASE(chainstate_update_tip, TestChain100Setup)
         this, NoMalleation, /*reset_chainstate=*/ true));
 
     // Ensure our active chain is the snapshot chainstate.
-    BOOST_CHECK(WITH_LOCK(::cs_main, return chainman.IsSnapshotActive()));
+    BOOST_CHECK(WITH_LOCK(::cs_main, return chainman.CurrentChainstate().m_from_snapshot_blockhash));
 
     curr_tip = get_notify_tip();
 
@@ -107,16 +107,7 @@ BOOST_FIXTURE_TEST_CASE(chainstate_update_tip, TestChain100Setup)
 
     curr_tip = get_notify_tip();
 
-    BOOST_CHECK_EQUAL(chainman.GetAll().size(), 2);
-
-    Chainstate& background_cs{*Assert([&]() -> Chainstate* {
-        for (Chainstate* cs : chainman.GetAll()) {
-            if (cs != &chainman.ActiveChainstate()) {
-                return cs;
-            }
-        }
-        return nullptr;
-    }())};
+    Chainstate& background_cs{*Assert(WITH_LOCK(::cs_main, return chainman.HistoricalChainstate()))};
 
     // Append the first block to the background chain.
     BlockValidationState state;
diff --git a/depend/bitcoin/src/test/validation_chainstatemanager_tests.cpp b/depend/bitcoin/src/test/validation_chainstatemanager_tests.cpp
index bf440ca6..24122bd3 100644
--- a/depend/bitcoin/src/test/validation_chainstatemanager_tests.cpp
+++ b/depend/bitcoin/src/test/validation_chainstatemanager_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 //
@@ -40,19 +40,19 @@ BOOST_FIXTURE_TEST_SUITE(validation_chainstatemanager_tests, TestingSetup)
 BOOST_FIXTURE_TEST_CASE(chainstatemanager, TestChain100Setup)
 {
     ChainstateManager& manager = *m_node.chainman;
-    std::vector<Chainstate*> chainstates;
 
-    BOOST_CHECK(!manager.SnapshotBlockhash().has_value());
+    BOOST_CHECK(WITH_LOCK(::cs_main, return !manager.CurrentChainstate().m_from_snapshot_blockhash));
 
     // Create a legacy (IBD) chainstate.
     //
     Chainstate& c1 = manager.ActiveChainstate();
-    chainstates.push_back(&c1);
 
-    BOOST_CHECK(!manager.IsSnapshotActive());
-    BOOST_CHECK(WITH_LOCK(::cs_main, return !manager.IsSnapshotValidated()));
-    auto all = manager.GetAll();
-    BOOST_CHECK_EQUAL_COLLECTIONS(all.begin(), all.end(), chainstates.begin(), chainstates.end());
+    BOOST_CHECK(WITH_LOCK(::cs_main, return !manager.CurrentChainstate().m_from_snapshot_blockhash));
+    {
+        LOCK(manager.GetMutex());
+        BOOST_CHECK_EQUAL(manager.m_chainstates.size(), 1);
+        BOOST_CHECK_EQUAL(manager.m_chainstates[0].get(), &c1);
+    }
 
     auto& active_chain = WITH_LOCK(manager.GetMutex(), return manager.ActiveChain());
     BOOST_CHECK_EQUAL(&active_chain, &c1.m_chain);
@@ -64,13 +64,12 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager, TestChain100Setup)
     auto exp_tip = c1.m_chain.Tip();
     BOOST_CHECK_EQUAL(active_tip, exp_tip);
 
-    BOOST_CHECK(!manager.SnapshotBlockhash().has_value());
+    BOOST_CHECK(WITH_LOCK(::cs_main, return !manager.CurrentChainstate().m_from_snapshot_blockhash));
 
     // Create a snapshot-based chainstate.
     //
     const uint256 snapshot_blockhash = active_tip->GetBlockHash();
-    Chainstate& c2 = WITH_LOCK(::cs_main, return manager.ActivateExistingSnapshot(snapshot_blockhash));
-    chainstates.push_back(&c2);
+    Chainstate& c2{WITH_LOCK(::cs_main, return manager.AddChainstate(std::make_unique<Chainstate>(nullptr, manager.m_blockman, manager, snapshot_blockhash)))};
     c2.InitCoinsDB(
         /*cache_size_bytes=*/1 << 23, /*in_memory=*/true, /*should_wipe=*/false);
     {
@@ -83,13 +82,16 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager, TestChain100Setup)
     BlockValidationState _;
     BOOST_CHECK(c2.ActivateBestChain(_, nullptr));
 
-    BOOST_CHECK_EQUAL(manager.SnapshotBlockhash().value(), snapshot_blockhash);
-    BOOST_CHECK(manager.IsSnapshotActive());
-    BOOST_CHECK(WITH_LOCK(::cs_main, return !manager.IsSnapshotValidated()));
+    BOOST_CHECK_EQUAL(WITH_LOCK(::cs_main, return *manager.CurrentChainstate().m_from_snapshot_blockhash), snapshot_blockhash);
+    BOOST_CHECK(WITH_LOCK(::cs_main, return manager.CurrentChainstate().m_assumeutxo == Assumeutxo::UNVALIDATED));
     BOOST_CHECK_EQUAL(&c2, &manager.ActiveChainstate());
     BOOST_CHECK(&c1 != &manager.ActiveChainstate());
-    auto all2 = manager.GetAll();
-    BOOST_CHECK_EQUAL_COLLECTIONS(all2.begin(), all2.end(), chainstates.begin(), chainstates.end());
+    {
+        LOCK(manager.GetMutex());
+        BOOST_CHECK_EQUAL(manager.m_chainstates.size(), 2);
+        BOOST_CHECK_EQUAL(manager.m_chainstates[0].get(), &c1);
+        BOOST_CHECK_EQUAL(manager.m_chainstates[1].get(), &c2);
+    }
 
     auto& active_chain2 = WITH_LOCK(manager.GetMutex(), return manager.ActiveChain());
     BOOST_CHECK_EQUAL(&active_chain2, &c2.m_chain);
@@ -135,7 +137,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_rebalance_caches, TestChain100Setup)
     // Create a snapshot-based chainstate.
     //
     CBlockIndex* snapshot_base{WITH_LOCK(manager.GetMutex(), return manager.ActiveChain()[manager.ActiveChain().Height() / 2])};
-    Chainstate& c2 = WITH_LOCK(cs_main, return manager.ActivateExistingSnapshot(*snapshot_base->phashBlock));
+    Chainstate& c2{WITH_LOCK(::cs_main, return manager.AddChainstate(std::make_unique<Chainstate>(nullptr, manager.m_blockman, manager, *snapshot_base->phashBlock)))};
     chainstates.push_back(&c2);
     c2.InitCoinsDB(
         /*cache_size_bytes=*/1 << 23, /*in_memory=*/true, /*should_wipe=*/false);
@@ -182,12 +184,10 @@ struct SnapshotTestSetup : TestChain100Setup {
     {
         ChainstateManager& chainman = *Assert(m_node.chainman);
 
-        BOOST_CHECK(!chainman.IsSnapshotActive());
-
         {
             LOCK(::cs_main);
-            BOOST_CHECK(!chainman.IsSnapshotValidated());
-            BOOST_CHECK(!node::FindSnapshotChainstateDir(chainman.m_options.datadir));
+            BOOST_CHECK(!chainman.CurrentChainstate().m_from_snapshot_blockhash);
+            BOOST_CHECK(!node::FindAssumeutxoChainstateDir(chainman.m_options.datadir));
         }
 
         size_t initial_size;
@@ -215,7 +215,6 @@ struct SnapshotTestSetup : TestChain100Setup {
         // Snapshot should refuse to load at this height.
         BOOST_REQUIRE(!CreateAndActivateUTXOSnapshot(this));
         BOOST_CHECK(!chainman.ActiveChainstate().m_from_snapshot_blockhash);
-        BOOST_CHECK(!chainman.SnapshotBlockhash());
 
         // Mine 10 more blocks, putting at us height 110 where a valid assumeutxo value can
         // be found.
@@ -240,7 +239,7 @@ struct SnapshotTestSetup : TestChain100Setup {
                 auto_infile >> coin;
         }));
 
-        BOOST_CHECK(!node::FindSnapshotChainstateDir(chainman.m_options.datadir));
+        BOOST_CHECK(!node::FindAssumeutxoChainstateDir(chainman.m_options.datadir));
 
         BOOST_REQUIRE(!CreateAndActivateUTXOSnapshot(
             this, [](AutoFile& auto_infile, SnapshotMetadata& metadata) {
@@ -264,25 +263,22 @@ struct SnapshotTestSetup : TestChain100Setup {
         }));
 
         BOOST_REQUIRE(CreateAndActivateUTXOSnapshot(this));
-        BOOST_CHECK(fs::exists(*node::FindSnapshotChainstateDir(chainman.m_options.datadir)));
+        BOOST_CHECK(fs::exists(*node::FindAssumeutxoChainstateDir(chainman.m_options.datadir)));
 
         // Ensure our active chain is the snapshot chainstate.
         BOOST_CHECK(!chainman.ActiveChainstate().m_from_snapshot_blockhash->IsNull());
-        BOOST_CHECK_EQUAL(
-            *chainman.ActiveChainstate().m_from_snapshot_blockhash,
-            *chainman.SnapshotBlockhash());
 
         Chainstate& snapshot_chainstate = chainman.ActiveChainstate();
 
         {
             LOCK(::cs_main);
 
-            fs::path found = *node::FindSnapshotChainstateDir(chainman.m_options.datadir);
+            fs::path found = *node::FindAssumeutxoChainstateDir(chainman.m_options.datadir);
 
             // Note: WriteSnapshotBaseBlockhash() is implicitly tested above.
             BOOST_CHECK_EQUAL(
                 *node::ReadSnapshotBaseBlockhash(found),
-                *chainman.SnapshotBlockhash());
+                *Assert(chainman.CurrentChainstate().m_from_snapshot_blockhash));
         }
 
         const auto& au_data = ::Params().AssumeutxoForHeight(snapshot_height);
@@ -291,7 +287,7 @@ struct SnapshotTestSetup : TestChain100Setup {
         BOOST_CHECK_EQUAL(tip->m_chain_tx_count, au_data->m_chain_tx_count);
 
         // To be checked against later when we try loading a subsequent snapshot.
-        uint256 loaded_snapshot_blockhash{*chainman.SnapshotBlockhash()};
+        uint256 loaded_snapshot_blockhash{*Assert(WITH_LOCK(chainman.GetMutex(), return chainman.CurrentChainstate().m_from_snapshot_blockhash))};
 
         // Make some assertions about the both chainstates. These checks ensure the
         // legacy chainstate hasn't changed and that the newly created chainstate
@@ -300,7 +296,7 @@ struct SnapshotTestSetup : TestChain100Setup {
             LOCK(::cs_main);
             int chains_tested{0};
 
-            for (Chainstate* chainstate : chainman.GetAll()) {
+            for (const auto& chainstate : chainman.m_chainstates) {
                 BOOST_TEST_MESSAGE("Checking coins in " << chainstate->ToString());
                 CCoinsViewCache& coinscache = chainstate->CoinsTip();
 
@@ -333,10 +329,10 @@ struct SnapshotTestSetup : TestChain100Setup {
             size_t coins_in_background{0};
             size_t coins_missing_from_background{0};
 
-            for (Chainstate* chainstate : chainman.GetAll()) {
+            for (const auto& chainstate : chainman.m_chainstates) {
                 BOOST_TEST_MESSAGE("Checking coins in " << chainstate->ToString());
                 CCoinsViewCache& coinscache = chainstate->CoinsTip();
-                bool is_background = chainstate != &chainman.ActiveChainstate();
+                bool is_background = chainstate.get() != &chainman.ActiveChainstate();
 
                 for (CTransactionRef& txn : m_coinbase_txns) {
                     COutPoint op{txn->GetHash(), 0};
@@ -373,15 +369,17 @@ struct SnapshotTestSetup : TestChain100Setup {
 
         BOOST_TEST_MESSAGE("Simulating node restart");
         {
-            for (Chainstate* cs : chainman.GetAll()) {
-                LOCK(::cs_main);
-                cs->ForceFlushStateToDisk();
+            LOCK(chainman.GetMutex());
+            for (const auto& cs : chainman.m_chainstates) {
+                if (cs->CanFlushToDisk()) cs->ForceFlushStateToDisk();
             }
+        }
+        {
             // Process all callbacks referring to the old manager before wiping it.
             m_node.validation_signals->SyncWithValidationInterfaceQueue();
             LOCK(::cs_main);
             chainman.ResetChainstates();
-            BOOST_CHECK_EQUAL(chainman.GetAll().size(), 0);
+            BOOST_CHECK_EQUAL(chainman.m_chainstates.size(), 0);
             m_node.notifications = std::make_unique<KernelNotifications>(Assert(m_node.shutdown_request), m_node.exit_status, *Assert(m_node.warnings));
             const ChainstateManager::Options chainman_opts{
                 .chainparams = ::Params(),
@@ -446,17 +444,16 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_loadblockindex, TestChain100Setup)
     BOOST_CHECK_EQUAL(assumed_tip->nHeight, 120);
 
     auto reload_all_block_indexes = [&]() {
+        LOCK(chainman.GetMutex());
         // For completeness, we also reset the block sequence counters to
         // ensure that no state which affects the ranking of tip-candidates is
         // retained (even though this isn't strictly necessary).
-        WITH_LOCK(::cs_main, return chainman.ResetBlockSequenceCounters());
-        for (Chainstate* cs : chainman.GetAll()) {
-            LOCK(::cs_main);
+        chainman.ResetBlockSequenceCounters();
+        for (const auto& cs : chainman.m_chainstates) {
             cs->ClearBlockIndexCandidates();
             BOOST_CHECK(cs->setBlockIndexCandidates.empty());
         }
-
-        WITH_LOCK(::cs_main, chainman.LoadBlockIndex());
+        chainman.LoadBlockIndex();
     };
 
     // Ensure that without any assumed-valid BlockIndex entries, only the current tip is
@@ -489,8 +486,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_loadblockindex, TestChain100Setup)
     }
 
     // Note: cs2's tip is not set when ActivateExistingSnapshot is called.
-    Chainstate& cs2 = WITH_LOCK(::cs_main,
-        return chainman.ActivateExistingSnapshot(*assumed_base->phashBlock));
+    Chainstate& cs2{WITH_LOCK(::cs_main, return chainman.AddChainstate(std::make_unique<Chainstate>(nullptr, chainman.m_blockman, chainman, *assumed_base->phashBlock)))};
 
     // Set tip of the fully validated chain to be the validated tip
     cs1.m_chain.SetTip(*validated_tip);
@@ -557,7 +553,8 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_loadblockindex, TestChain100Setup)
     BOOST_CHECK_EQUAL(cs2.setBlockIndexCandidates.size(), num_indexes - last_assumed_valid_idx + 1);
 }
 
-//! Ensure that snapshot chainstates initialize properly when found on disk.
+//! Ensure that snapshot chainstate can be loaded when found on disk after a
+//! restart, and that new blocks can be connected to both chainstates.
 BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_init, SnapshotTestSetup)
 {
     ChainstateManager& chainman = *Assert(m_node.chainman);
@@ -565,16 +562,15 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_init, SnapshotTestSetup)
 
     this->SetupSnapshot();
 
-    fs::path snapshot_chainstate_dir = *node::FindSnapshotChainstateDir(chainman.m_options.datadir);
+    fs::path snapshot_chainstate_dir = *node::FindAssumeutxoChainstateDir(chainman.m_options.datadir);
     BOOST_CHECK(fs::exists(snapshot_chainstate_dir));
     BOOST_CHECK_EQUAL(snapshot_chainstate_dir, gArgs.GetDataDirNet() / "chainstate_snapshot");
 
-    BOOST_CHECK(chainman.IsSnapshotActive());
+    BOOST_CHECK(WITH_LOCK(::cs_main, return chainman.CurrentChainstate().m_from_snapshot_blockhash));
     const uint256 snapshot_tip_hash = WITH_LOCK(chainman.GetMutex(),
         return chainman.ActiveTip()->GetBlockHash());
 
-    auto all_chainstates = chainman.GetAll();
-    BOOST_CHECK_EQUAL(all_chainstates.size(), 2);
+    BOOST_CHECK_EQUAL(WITH_LOCK(chainman.GetMutex(), return chainman.m_chainstates.size()), 2);
 
     // "Rewind" the background chainstate so that its tip is not at the
     // base block of the snapshot - this is so after simulating a node restart,
@@ -591,8 +587,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_init, SnapshotTestSetup)
     BOOST_CHECK_EQUAL(bg_chainstate.m_chain.Height(), 109);
 
     // Test that simulating a shutdown (resetting ChainstateManager) and then performing
-    // chainstate reinitializing successfully cleans up the background-validation
-    // chainstate data, and we end up with a single chainstate that is at tip.
+    // chainstate reinitializing successfully reloads both chainstates.
     ChainstateManager& chainman_restarted = this->SimulateNodeRestart();
 
     BOOST_TEST_MESSAGE("Performing Load/Verify/Activate of chainstate");
@@ -602,12 +597,20 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_init, SnapshotTestSetup)
 
     {
         LOCK(chainman_restarted.GetMutex());
-        BOOST_CHECK_EQUAL(chainman_restarted.GetAll().size(), 2);
-        BOOST_CHECK(chainman_restarted.IsSnapshotActive());
-        BOOST_CHECK(!chainman_restarted.IsSnapshotValidated());
+        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates.size(), 2);
+        // Background chainstate has height of 109 not 110 here due to a quirk
+        // of the LoadVerifyActivate only calling ActivateBestChain on one
+        // chainstate. The height would be 110 after a real restart, but it's
+        // fine for this test which is focused on the snapshot chainstate.
+        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates[0]->m_chain.Height(), 109);
+        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates[1]->m_chain.Height(), 210);
+
+        BOOST_CHECK(chainman_restarted.CurrentChainstate().m_from_snapshot_blockhash);
+        BOOST_CHECK(chainman_restarted.CurrentChainstate().m_assumeutxo == Assumeutxo::UNVALIDATED);
 
         BOOST_CHECK_EQUAL(chainman_restarted.ActiveTip()->GetBlockHash(), snapshot_tip_hash);
         BOOST_CHECK_EQUAL(chainman_restarted.ActiveHeight(), 210);
+        BOOST_CHECK_EQUAL(chainman_restarted.HistoricalChainstate()->m_chain.Height(), 109);
     }
 
     BOOST_TEST_MESSAGE(
@@ -618,12 +621,11 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_init, SnapshotTestSetup)
         BOOST_CHECK_EQUAL(chainman_restarted.ActiveHeight(), 220);
 
         // Background chainstate should be unaware of new blocks on the snapshot
-        // chainstate.
-        for (Chainstate* cs : chainman_restarted.GetAll()) {
-            if (cs != &chainman_restarted.ActiveChainstate()) {
-                BOOST_CHECK_EQUAL(cs->m_chain.Height(), 109);
-            }
-        }
+        // chainstate, but the block disconnected above is now reattached.
+        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates.size(), 2);
+        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates[0]->m_chain.Height(), 110);
+        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates[1]->m_chain.Height(), 220);
+        BOOST_CHECK_EQUAL(chainman_restarted.HistoricalChainstate(), nullptr);
     }
 }
 
@@ -633,37 +635,35 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_completion, SnapshotTestSetup
 
     ChainstateManager& chainman = *Assert(m_node.chainman);
     Chainstate& active_cs = chainman.ActiveChainstate();
+    Chainstate& validated_cs{*Assert(WITH_LOCK(cs_main, return chainman.HistoricalChainstate()))};
     auto tip_cache_before_complete = active_cs.m_coinstip_cache_size_bytes;
     auto db_cache_before_complete = active_cs.m_coinsdb_cache_size_bytes;
 
     SnapshotCompletionResult res;
     m_node.notifications->m_shutdown_on_fatal_error = false;
 
-    fs::path snapshot_chainstate_dir = *node::FindSnapshotChainstateDir(chainman.m_options.datadir);
+    fs::path snapshot_chainstate_dir = *node::FindAssumeutxoChainstateDir(chainman.m_options.datadir);
     BOOST_CHECK(fs::exists(snapshot_chainstate_dir));
     BOOST_CHECK_EQUAL(snapshot_chainstate_dir, gArgs.GetDataDirNet() / "chainstate_snapshot");
 
-    BOOST_CHECK(chainman.IsSnapshotActive());
+    BOOST_CHECK(WITH_LOCK(::cs_main, return chainman.CurrentChainstate().m_from_snapshot_blockhash));
     const uint256 snapshot_tip_hash = WITH_LOCK(chainman.GetMutex(),
         return chainman.ActiveTip()->GetBlockHash());
 
-    res = WITH_LOCK(::cs_main, return chainman.MaybeCompleteSnapshotValidation());
+    res = WITH_LOCK(::cs_main, return chainman.MaybeValidateSnapshot(validated_cs, active_cs));
     BOOST_CHECK_EQUAL(res, SnapshotCompletionResult::SUCCESS);
 
-    WITH_LOCK(::cs_main, BOOST_CHECK(chainman.IsSnapshotValidated()));
-    BOOST_CHECK(chainman.IsSnapshotActive());
+    BOOST_CHECK(WITH_LOCK(::cs_main, return chainman.CurrentChainstate().m_assumeutxo == Assumeutxo::VALIDATED));
+    BOOST_CHECK(WITH_LOCK(::cs_main, return chainman.CurrentChainstate().m_from_snapshot_blockhash));
+    BOOST_CHECK_EQUAL(WITH_LOCK(chainman.GetMutex(), return chainman.HistoricalChainstate()), nullptr);
 
     // Cache should have been rebalanced and reallocated to the "only" remaining
     // chainstate.
     BOOST_CHECK(active_cs.m_coinstip_cache_size_bytes > tip_cache_before_complete);
     BOOST_CHECK(active_cs.m_coinsdb_cache_size_bytes > db_cache_before_complete);
 
-    auto all_chainstates = chainman.GetAll();
-    BOOST_CHECK_EQUAL(all_chainstates.size(), 1);
-    BOOST_CHECK_EQUAL(all_chainstates[0], &active_cs);
-
     // Trying completion again should return false.
-    res = WITH_LOCK(::cs_main, return chainman.MaybeCompleteSnapshotValidation());
+    res = WITH_LOCK(::cs_main, return chainman.MaybeValidateSnapshot(validated_cs, active_cs));
     BOOST_CHECK_EQUAL(res, SnapshotCompletionResult::SKIPPED);
 
     // The invalid snapshot path should not have been used.
@@ -691,9 +691,8 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_completion, SnapshotTestSetup
 
     {
         LOCK(chainman_restarted.GetMutex());
-        BOOST_CHECK_EQUAL(chainman_restarted.GetAll().size(), 1);
-        BOOST_CHECK(!chainman_restarted.IsSnapshotActive());
-        BOOST_CHECK(!chainman_restarted.IsSnapshotValidated());
+        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates.size(), 1);
+        BOOST_CHECK(!chainman_restarted.CurrentChainstate().m_from_snapshot_blockhash);
         BOOST_CHECK(active_cs2.m_coinstip_cache_size_bytes > tip_cache_before_complete);
         BOOST_CHECK(active_cs2.m_coinsdb_cache_size_bytes > db_cache_before_complete);
 
@@ -714,6 +713,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_completion_hash_mismatch, Sna
 {
     auto chainstates = this->SetupSnapshot();
     Chainstate& validation_chainstate = *std::get<0>(chainstates);
+    Chainstate& unvalidated_cs = *std::get<1>(chainstates);
     ChainstateManager& chainman = *Assert(m_node.chainman);
     SnapshotCompletionResult res;
     m_node.notifications->m_shutdown_on_fatal_error = false;
@@ -734,14 +734,18 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_completion_hash_mismatch, Sna
 
     {
         ASSERT_DEBUG_LOG("failed to validate the -assumeutxo snapshot state");
-        res = WITH_LOCK(::cs_main, return chainman.MaybeCompleteSnapshotValidation());
+        res = WITH_LOCK(::cs_main, return chainman.MaybeValidateSnapshot(validation_chainstate, unvalidated_cs));
         BOOST_CHECK_EQUAL(res, SnapshotCompletionResult::HASH_MISMATCH);
     }
 
-    auto all_chainstates = chainman.GetAll();
-    BOOST_CHECK_EQUAL(all_chainstates.size(), 1);
-    BOOST_CHECK_EQUAL(all_chainstates[0], &validation_chainstate);
-    BOOST_CHECK_EQUAL(&chainman.ActiveChainstate(), &validation_chainstate);
+    {
+        LOCK(chainman.GetMutex());
+        BOOST_CHECK_EQUAL(chainman.m_chainstates.size(), 2);
+        BOOST_CHECK(chainman.m_chainstates[0]->m_assumeutxo == Assumeutxo::VALIDATED);
+        BOOST_CHECK(!chainman.m_chainstates[0]->SnapshotBase());
+        BOOST_CHECK(chainman.m_chainstates[1]->m_assumeutxo == Assumeutxo::INVALID);
+        BOOST_CHECK(chainman.m_chainstates[1]->SnapshotBase());
+    }
 
     fs::path snapshot_invalid_dir = gArgs.GetDataDirNet() / "chainstate_snapshot_INVALID";
     BOOST_CHECK(fs::exists(snapshot_invalid_dir));
@@ -762,9 +766,8 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_completion_hash_mismatch, Sna
 
     {
         LOCK(::cs_main);
-        BOOST_CHECK_EQUAL(chainman_restarted.GetAll().size(), 1);
-        BOOST_CHECK(!chainman_restarted.IsSnapshotActive());
-        BOOST_CHECK(!chainman_restarted.IsSnapshotValidated());
+        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates.size(), 1);
+        BOOST_CHECK(!chainman_restarted.CurrentChainstate().m_from_snapshot_blockhash);
         BOOST_CHECK_EQUAL(chainman_restarted.ActiveHeight(), 210);
     }
 
diff --git a/depend/bitcoin/src/test/validation_tests.cpp b/depend/bitcoin/src/test/validation_tests.cpp
index 5d4c3ee1..80f32897 100644
--- a/depend/bitcoin/src/test/validation_tests.cpp
+++ b/depend/bitcoin/src/test/validation_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2021 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/test/validationinterface_tests.cpp b/depend/bitcoin/src/test/validationinterface_tests.cpp
index 8a24b282..08b6d94e 100644
--- a/depend/bitcoin/src/test/validationinterface_tests.cpp
+++ b/depend/bitcoin/src/test/validationinterface_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
@@ -8,7 +8,6 @@
 #include <scheduler.h>
 #include <test/util/setup_common.h>
 #include <util/check.h>
-#include <kernel/chain.h>
 #include <validationinterface.h>
 
 #include <atomic>
diff --git a/depend/bitcoin/src/test/versionbits_tests.cpp b/depend/bitcoin/src/test/versionbits_tests.cpp
index 9de57393..ea104402 100644
--- a/depend/bitcoin/src/test/versionbits_tests.cpp
+++ b/depend/bitcoin/src/test/versionbits_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2022 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/threadsafety.h b/depend/bitcoin/src/threadsafety.h
index d897dd24..b79d4c76 100644
--- a/depend/bitcoin/src/threadsafety.h
+++ b/depend/bitcoin/src/threadsafety.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/torcontrol.cpp b/depend/bitcoin/src/torcontrol.cpp
index 175621fc..50c3148e 100644
--- a/depend/bitcoin/src/torcontrol.cpp
+++ b/depend/bitcoin/src/torcontrol.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-present The Bitcoin Core developers
 // Copyright (c) 2017 The Zcash developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
@@ -586,17 +586,17 @@ void TorController::protocolinfo_cb(TorControlConnection& _conn, const TorContro
          */
         std::string torpassword = gArgs.GetArg("-torpassword", "");
         if (!torpassword.empty()) {
-            if (methods.count("HASHEDPASSWORD")) {
+            if (methods.contains("HASHEDPASSWORD")) {
                 LogDebug(BCLog::TOR, "Using HASHEDPASSWORD authentication\n");
                 ReplaceAll(torpassword, "\"", "\\\"");
                 _conn.Command("AUTHENTICATE \"" + torpassword + "\"", std::bind(&TorController::auth_cb, this, std::placeholders::_1, std::placeholders::_2));
             } else {
                 LogWarning("tor: Password provided with -torpassword, but HASHEDPASSWORD authentication is not available");
             }
-        } else if (methods.count("NULL")) {
+        } else if (methods.contains("NULL")) {
             LogDebug(BCLog::TOR, "Using NULL authentication\n");
             _conn.Command("AUTHENTICATE", std::bind(&TorController::auth_cb, this, std::placeholders::_1, std::placeholders::_2));
-        } else if (methods.count("SAFECOOKIE")) {
+        } else if (methods.contains("SAFECOOKIE")) {
             // Cookie: hexdump -e '32/1 "%02x""\n"'  ~/.tor/control_auth_cookie
             LogDebug(BCLog::TOR, "Using SAFECOOKIE authentication, reading cookie authentication from %s\n", cookiefile);
             std::pair<bool,std::string> status_cookie = ReadBinaryFile(fs::PathFromString(cookiefile), TOR_COOKIE_SIZE);
@@ -613,7 +613,7 @@ void TorController::protocolinfo_cb(TorControlConnection& _conn, const TorContro
                     LogWarning("tor: Authentication cookie %s could not be opened (check permissions)", cookiefile);
                 }
             }
-        } else if (methods.count("HASHEDPASSWORD")) {
+        } else if (methods.contains("HASHEDPASSWORD")) {
             LogWarning("tor: The only supported authentication mechanism left is password, but no password provided with -torpassword");
         } else {
             LogWarning("tor: No supported authentication method");
diff --git a/depend/bitcoin/src/torcontrol.h b/depend/bitcoin/src/torcontrol.h
index c9866bf8..e64f9d38 100644
--- a/depend/bitcoin/src/torcontrol.h
+++ b/depend/bitcoin/src/torcontrol.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2021 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/txdb.cpp b/depend/bitcoin/src/txdb.cpp
index 843cb9b1..5244067e 100644
--- a/depend/bitcoin/src/txdb.cpp
+++ b/depend/bitcoin/src/txdb.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/txdb.h b/depend/bitcoin/src/txdb.h
index ea0cf9d7..bd5ed6e8 100644
--- a/depend/bitcoin/src/txdb.h
+++ b/depend/bitcoin/src/txdb.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
@@ -53,9 +53,6 @@ class CCoinsViewDB final : public CCoinsView
 
     //! Dynamically alter the underlying leveldb cache size.
     void ResizeCache(size_t new_cache_size) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-
-    //! @returns filesystem path to on-disk storage or std::nullopt if in memory.
-    std::optional<fs::path> StoragePath() { return m_db->StoragePath(); }
 };
 
 #endif // BITCOIN_TXDB_H
diff --git a/depend/bitcoin/src/txgraph.cpp b/depend/bitcoin/src/txgraph.cpp
index 23094bd8..8a4fc28c 100644
--- a/depend/bitcoin/src/txgraph.cpp
+++ b/depend/bitcoin/src/txgraph.cpp
@@ -1013,11 +1013,11 @@ void GenericClusterImpl::Updated(TxGraphImpl& graph, int level) noexcept
     // ACCEPTABLE, so it is pointless to compute these if we haven't reached that quality level
     // yet.
     if (level == 0 && IsAcceptable()) {
-        const LinearizationChunking chunking(m_depgraph, m_linearization);
+        auto chunking = ChunkLinearizationInfo(m_depgraph, m_linearization);
         LinearizationIndex lin_idx{0};
         // Iterate over the chunks.
-        for (unsigned chunk_idx = 0; chunk_idx < chunking.NumChunksLeft(); ++chunk_idx) {
-            auto chunk = chunking.GetChunk(chunk_idx);
+        for (unsigned chunk_idx = 0; chunk_idx < chunking.size(); ++chunk_idx) {
+            auto& chunk = chunking[chunk_idx];
             auto chunk_count = chunk.transactions.Count();
             Assume(chunk_count > 0);
             // Iterate over the transactions in the linearization, which must match those in chunk.
@@ -1031,7 +1031,7 @@ void GenericClusterImpl::Updated(TxGraphImpl& graph, int level) noexcept
                 chunk.transactions.Reset(idx);
                 if (chunk.transactions.None()) {
                     // Last transaction in the chunk.
-                    if (chunk_count == 1 && chunk_idx + 1 == chunking.NumChunksLeft()) {
+                    if (chunk_count == 1 && chunk_idx + 1 == chunking.size()) {
                         // If this is the final chunk of the cluster, and it contains just a single
                         // transaction (which will always be true for the very common singleton
                         // clusters), store the special value -1 as chunk count.
@@ -1311,13 +1311,12 @@ void SingletonClusterImpl::AppendChunkFeerates(std::vector<FeeFrac>& ret) const
 
 uint64_t GenericClusterImpl::AppendTrimData(std::vector<TrimTxData>& ret, std::vector<std::pair<GraphIndex, GraphIndex>>& deps) const noexcept
 {
-    const LinearizationChunking linchunking(m_depgraph, m_linearization);
+    auto linchunking = ChunkLinearizationInfo(m_depgraph, m_linearization);
     LinearizationIndex pos{0};
     uint64_t size{0};
     auto prev_index = GraphIndex(-1);
     // Iterate over the chunks of this cluster's linearization.
-    for (unsigned i = 0; i < linchunking.NumChunksLeft(); ++i) {
-        const auto& [chunk, chunk_feerate] = linchunking.GetChunk(i);
+    for (const auto& [chunk, chunk_feerate] : linchunking) {
         // Iterate over the transactions of that chunk, in linearization order.
         auto chunk_tx_count = chunk.Count();
         for (unsigned j = 0; j < chunk_tx_count; ++j) {
@@ -2091,9 +2090,10 @@ std::pair<uint64_t, bool> GenericClusterImpl::Relinearize(TxGraphImpl& graph, in
     // Invoke the actual linearization algorithm (passing in the existing one).
     uint64_t rng_seed = graph.m_rng.rand64();
     auto [linearization, optimal, cost] = Linearize(m_depgraph, max_iters, rng_seed, m_linearization);
-    // Postlinearize if the result isn't optimal already. This guarantees (among other things)
-    // that the chunks of the resulting linearization are all connected.
-    if (!optimal) PostLinearize(m_depgraph, linearization);
+    // Postlinearize to undo some of the non-determinism caused by randomizing the linearization.
+    // This also guarantees that all chunks are connected (which is not guaranteed by SFL
+    // currently, even when optimal).
+    PostLinearize(m_depgraph, linearization);
     // Update the linearization.
     m_linearization = std::move(linearization);
     // Update the Cluster's quality.
@@ -2758,7 +2758,8 @@ void GenericClusterImpl::SanityCheck(const TxGraphImpl& graph, int level) const
     }
 
     // Compute the chunking of m_linearization.
-    LinearizationChunking linchunking(m_depgraph, m_linearization);
+    auto linchunking = ChunkLinearizationInfo(m_depgraph, m_linearization);
+    unsigned chunk_num{0};
 
     // Verify m_linearization.
     SetType m_done;
@@ -2778,14 +2779,14 @@ void GenericClusterImpl::SanityCheck(const TxGraphImpl& graph, int level) const
         if (level == 0 && IsAcceptable()) {
             assert(entry.m_main_lin_index == linindex);
             ++linindex;
-            if (!linchunking.GetChunk(0).transactions[lin_pos]) {
-                linchunking.MarkDone(linchunking.GetChunk(0).transactions);
+            if (!linchunking[chunk_num].transactions[lin_pos]) {
+                ++chunk_num;
                 chunk_pos = 0;
             }
-            assert(entry.m_main_chunk_feerate == linchunking.GetChunk(0).feerate);
+            assert(entry.m_main_chunk_feerate == linchunking[chunk_num].feerate);
             // Verify that an entry in the chunk index exists for every chunk-ending transaction.
             ++chunk_pos;
-            bool is_chunk_end = (chunk_pos == linchunking.GetChunk(0).transactions.Count());
+            bool is_chunk_end = (chunk_pos == linchunking[chunk_num].transactions.Count());
             assert((entry.m_main_chunkindex_iterator != graph.m_main_chunkindex.end()) == is_chunk_end);
             if (is_chunk_end) {
                 auto& chunk_data = *entry.m_main_chunkindex_iterator;
@@ -2796,7 +2797,7 @@ void GenericClusterImpl::SanityCheck(const TxGraphImpl& graph, int level) const
                 }
             }
             // If this Cluster has an acceptable quality level, its chunks must be connected.
-            assert(m_depgraph.IsConnected(linchunking.GetChunk(0).transactions));
+            assert(m_depgraph.IsConnected(linchunking[chunk_num].transactions));
         }
     }
     // Verify that each element of m_depgraph occurred in m_linearization.
@@ -2917,7 +2918,7 @@ void TxGraphImpl::SanityCheck() const
 
                 // Check the sequence number.
                 assert(cluster.m_sequence < m_next_sequence_counter);
-                assert(sequences.count(cluster.m_sequence) == 0);
+                assert(!sequences.contains(cluster.m_sequence));
                 sequences.insert(cluster.m_sequence);
                 // Remember we saw this Cluster (only if it is non-empty; empty Clusters aren't
                 // expected to be referenced by the Entry vector).
diff --git a/depend/bitcoin/src/txmempool.cpp b/depend/bitcoin/src/txmempool.cpp
index 49961896..4dc692bf 100644
--- a/depend/bitcoin/src/txmempool.cpp
+++ b/depend/bitcoin/src/txmempool.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/txmempool.h b/depend/bitcoin/src/txmempool.h
index e8bead51..166a0248 100644
--- a/depend/bitcoin/src/txmempool.h
+++ b/depend/bitcoin/src/txmempool.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
@@ -566,7 +566,7 @@ class CTxMemPool
     bool IsUnbroadcastTx(const Txid& txid) const EXCLUSIVE_LOCKS_REQUIRED(cs)
     {
         AssertLockHeld(cs);
-        return m_unbroadcast_txids.count(txid) != 0;
+        return m_unbroadcast_txids.contains(txid);
     }
 
     /** Guards this internal counter for external reporting */
diff --git a/depend/bitcoin/src/uint256.cpp b/depend/bitcoin/src/uint256.cpp
index 052e3e73..717f402d 100644
--- a/depend/bitcoin/src/uint256.cpp
+++ b/depend/bitcoin/src/uint256.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/undo.h b/depend/bitcoin/src/undo.h
index 1fb9ac06..5591fe6c 100644
--- a/depend/bitcoin/src/undo.h
+++ b/depend/bitcoin/src/undo.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/univalue/test/object.cpp b/depend/bitcoin/src/univalue/test/object.cpp
index 2577c682..1d072c34 100644
--- a/depend/bitcoin/src/univalue/test/object.cpp
+++ b/depend/bitcoin/src/univalue/test/object.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2014 BitPay Inc.
-// Copyright (c) 2014-2022 The Bitcoin Core developers
+// Copyright (c) 2014-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/any.h b/depend/bitcoin/src/util/any.h
index 4562c5bd..7fe77dd4 100644
--- a/depend/bitcoin/src/util/any.h
+++ b/depend/bitcoin/src/util/any.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/asmap.cpp b/depend/bitcoin/src/util/asmap.cpp
index 4c20bd81..c7388c77 100644
--- a/depend/bitcoin/src/util/asmap.cpp
+++ b/depend/bitcoin/src/util/asmap.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/util/asmap.h b/depend/bitcoin/src/util/asmap.h
index 08a88f1b..87260869 100644
--- a/depend/bitcoin/src/util/asmap.h
+++ b/depend/bitcoin/src/util/asmap.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/util/batchpriority.cpp b/depend/bitcoin/src/util/batchpriority.cpp
index c0ed1233..15442346 100644
--- a/depend/bitcoin/src/util/batchpriority.cpp
+++ b/depend/bitcoin/src/util/batchpriority.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/batchpriority.h b/depend/bitcoin/src/util/batchpriority.h
index 5ffc8dd6..76b34674 100644
--- a/depend/bitcoin/src/util/batchpriority.h
+++ b/depend/bitcoin/src/util/batchpriority.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/bip32.h b/depend/bitcoin/src/util/bip32.h
index ea5f192c..af48147a 100644
--- a/depend/bitcoin/src/util/bip32.h
+++ b/depend/bitcoin/src/util/bip32.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/util/bitdeque.h b/depend/bitcoin/src/util/bitdeque.h
index 21934e02..70556a7d 100644
--- a/depend/bitcoin/src/util/bitdeque.h
+++ b/depend/bitcoin/src/util/bitdeque.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/util/bytevectorhash.cpp b/depend/bitcoin/src/util/bytevectorhash.cpp
index 79e4a21f..943517ad 100644
--- a/depend/bitcoin/src/util/bytevectorhash.cpp
+++ b/depend/bitcoin/src/util/bytevectorhash.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/util/bytevectorhash.h b/depend/bitcoin/src/util/bytevectorhash.h
index 07938567..80a7c3a1 100644
--- a/depend/bitcoin/src/util/bytevectorhash.h
+++ b/depend/bitcoin/src/util/bytevectorhash.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/util/chaintype.cpp b/depend/bitcoin/src/util/chaintype.cpp
index 272466e7..5059ff7e 100644
--- a/depend/bitcoin/src/util/chaintype.cpp
+++ b/depend/bitcoin/src/util/chaintype.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/chaintype.h b/depend/bitcoin/src/util/chaintype.h
index 2fe734b6..3b246ea4 100644
--- a/depend/bitcoin/src/util/chaintype.h
+++ b/depend/bitcoin/src/util/chaintype.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/epochguard.h b/depend/bitcoin/src/util/epochguard.h
index 25ae3ac7..e908b281 100644
--- a/depend/bitcoin/src/util/epochguard.h
+++ b/depend/bitcoin/src/util/epochguard.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/util/exception.cpp b/depend/bitcoin/src/util/exception.cpp
index 3f8be7d1..a4421226 100644
--- a/depend/bitcoin/src/util/exception.cpp
+++ b/depend/bitcoin/src/util/exception.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2023 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/util/exception.h b/depend/bitcoin/src/util/exception.h
index 946eb264..1d108fb3 100644
--- a/depend/bitcoin/src/util/exception.h
+++ b/depend/bitcoin/src/util/exception.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2023 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/util/exec.cpp b/depend/bitcoin/src/util/exec.cpp
index 0f13d1d4..6b140613 100644
--- a/depend/bitcoin/src/util/exec.cpp
+++ b/depend/bitcoin/src/util/exec.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2025 The Bitcoin Core developers
+// Copyright (c) 2025-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/exec.h b/depend/bitcoin/src/util/exec.h
index 4c207265..b9cc1bf5 100644
--- a/depend/bitcoin/src/util/exec.h
+++ b/depend/bitcoin/src/util/exec.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2025 The Bitcoin Core developers
+// Copyright (c) 2025-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/fastrange.h b/depend/bitcoin/src/util/fastrange.h
index 87a24159..67966052 100644
--- a/depend/bitcoin/src/util/fastrange.h
+++ b/depend/bitcoin/src/util/fastrange.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/util/fs_helpers.cpp b/depend/bitcoin/src/util/fs_helpers.cpp
index b23b2dc2..98646c02 100644
--- a/depend/bitcoin/src/util/fs_helpers.cpp
+++ b/depend/bitcoin/src/util/fs_helpers.cpp
@@ -50,7 +50,7 @@ LockResult LockDirectory(const fs::path& directory, const fs::path& lockfile_nam
     fs::path pathLockFile = directory / lockfile_name;
 
     // If a lock for this directory already exists in the map, don't try to re-lock it
-    if (dir_locks.count(fs::PathToString(pathLockFile))) {
+    if (dir_locks.contains(fs::PathToString(pathLockFile))) {
         return LockResult::Success;
     }
 
diff --git a/depend/bitcoin/src/util/fs_helpers.h b/depend/bitcoin/src/util/fs_helpers.h
index 4d11f828..d39ae115 100644
--- a/depend/bitcoin/src/util/fs_helpers.h
+++ b/depend/bitcoin/src/util/fs_helpers.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2023 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/util/golombrice.h b/depend/bitcoin/src/util/golombrice.h
index 63402c5e..fb1d0e21 100644
--- a/depend/bitcoin/src/util/golombrice.h
+++ b/depend/bitcoin/src/util/golombrice.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/util/hash_type.h b/depend/bitcoin/src/util/hash_type.h
index 5b4f93b8..19cba62e 100644
--- a/depend/bitcoin/src/util/hash_type.h
+++ b/depend/bitcoin/src/util/hash_type.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/util/insert.h b/depend/bitcoin/src/util/insert.h
index 5332eca6..995b382a 100644
--- a/depend/bitcoin/src/util/insert.h
+++ b/depend/bitcoin/src/util/insert.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/macros.h b/depend/bitcoin/src/util/macros.h
index 11aa6831..9ad2fa6e 100644
--- a/depend/bitcoin/src/util/macros.h
+++ b/depend/bitcoin/src/util/macros.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/util/moneystr.cpp b/depend/bitcoin/src/util/moneystr.cpp
index 1ed3b2ac..4d74f9b8 100644
--- a/depend/bitcoin/src/util/moneystr.cpp
+++ b/depend/bitcoin/src/util/moneystr.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/util/moneystr.h b/depend/bitcoin/src/util/moneystr.h
index dba0ce67..ecadf646 100644
--- a/depend/bitcoin/src/util/moneystr.h
+++ b/depend/bitcoin/src/util/moneystr.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/util/overflow.h b/depend/bitcoin/src/util/overflow.h
index ab20faf8..8b8511f8 100644
--- a/depend/bitcoin/src/util/overflow.h
+++ b/depend/bitcoin/src/util/overflow.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/rbf.cpp b/depend/bitcoin/src/util/rbf.cpp
index ef536bdc..bc28c6bb 100644
--- a/depend/bitcoin/src/util/rbf.cpp
+++ b/depend/bitcoin/src/util/rbf.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2019 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/util/rbf.h b/depend/bitcoin/src/util/rbf.h
index a9576173..387ca5bd 100644
--- a/depend/bitcoin/src/util/rbf.h
+++ b/depend/bitcoin/src/util/rbf.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/util/readwritefile.cpp b/depend/bitcoin/src/util/readwritefile.cpp
index 773d7ad1..82b596f9 100644
--- a/depend/bitcoin/src/util/readwritefile.cpp
+++ b/depend/bitcoin/src/util/readwritefile.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-present The Bitcoin Core developers
 // Copyright (c) 2017 The Zcash developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
diff --git a/depend/bitcoin/src/util/readwritefile.h b/depend/bitcoin/src/util/readwritefile.h
index 6ddfcb4f..2a9ccf5f 100644
--- a/depend/bitcoin/src/util/readwritefile.h
+++ b/depend/bitcoin/src/util/readwritefile.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2021 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/util/result.h b/depend/bitcoin/src/util/result.h
index fa774fb3..00005d97 100644
--- a/depend/bitcoin/src/util/result.h
+++ b/depend/bitcoin/src/util/result.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/serfloat.cpp b/depend/bitcoin/src/util/serfloat.cpp
index 8edca924..a46786aa 100644
--- a/depend/bitcoin/src/util/serfloat.cpp
+++ b/depend/bitcoin/src/util/serfloat.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/serfloat.h b/depend/bitcoin/src/util/serfloat.h
index 0dbba6ee..59bcffdf 100644
--- a/depend/bitcoin/src/util/serfloat.h
+++ b/depend/bitcoin/src/util/serfloat.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/signalinterrupt.cpp b/depend/bitcoin/src/util/signalinterrupt.cpp
index f36f3dbf..76db5591 100644
--- a/depend/bitcoin/src/util/signalinterrupt.cpp
+++ b/depend/bitcoin/src/util/signalinterrupt.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/util/signalinterrupt.h b/depend/bitcoin/src/util/signalinterrupt.h
index 605d1242..027dd153 100644
--- a/depend/bitcoin/src/util/signalinterrupt.h
+++ b/depend/bitcoin/src/util/signalinterrupt.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 The Bitcoin Core developers
+// Copyright (c) 2023-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/string.cpp b/depend/bitcoin/src/util/string.cpp
index 47c6b74d..507d9d31 100644
--- a/depend/bitcoin/src/util/string.cpp
+++ b/depend/bitcoin/src/util/string.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/util/syserror.cpp b/depend/bitcoin/src/util/syserror.cpp
index 4b456db8..e06ed0cd 100644
--- a/depend/bitcoin/src/util/syserror.cpp
+++ b/depend/bitcoin/src/util/syserror.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/util/syserror.h b/depend/bitcoin/src/util/syserror.h
index eb02141b..d62c873f 100644
--- a/depend/bitcoin/src/util/syserror.h
+++ b/depend/bitcoin/src/util/syserror.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2010-2022 The Bitcoin Core developers
+// Copyright (c) 2010-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.
 
diff --git a/depend/bitcoin/src/util/thread.cpp b/depend/bitcoin/src/util/thread.cpp
index e63fd6cf..7f8fa20a 100644
--- a/depend/bitcoin/src/util/thread.cpp
+++ b/depend/bitcoin/src/util/thread.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/thread.h b/depend/bitcoin/src/util/thread.h
index 8a2de84a..cb1dd86a 100644
--- a/depend/bitcoin/src/util/thread.h
+++ b/depend/bitcoin/src/util/thread.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/threadinterrupt.cpp b/depend/bitcoin/src/util/threadinterrupt.cpp
index aaa9e831..ed0ec503 100644
--- a/depend/bitcoin/src/util/threadinterrupt.cpp
+++ b/depend/bitcoin/src/util/threadinterrupt.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/util/threadinterrupt.h b/depend/bitcoin/src/util/threadinterrupt.h
index 8b393c26..84ced927 100644
--- a/depend/bitcoin/src/util/threadinterrupt.h
+++ b/depend/bitcoin/src/util/threadinterrupt.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/util/threadnames.cpp b/depend/bitcoin/src/util/threadnames.cpp
index 3e29814f..310f60f6 100644
--- a/depend/bitcoin/src/util/threadnames.cpp
+++ b/depend/bitcoin/src/util/threadnames.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/util/threadnames.h b/depend/bitcoin/src/util/threadnames.h
index adca8c30..b90c174c 100644
--- a/depend/bitcoin/src/util/threadnames.h
+++ b/depend/bitcoin/src/util/threadnames.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2019 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/util/tokenpipe.h b/depend/bitcoin/src/util/tokenpipe.h
index f56be93a..85e98a1f 100644
--- a/depend/bitcoin/src/util/tokenpipe.h
+++ b/depend/bitcoin/src/util/tokenpipe.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/trace.h b/depend/bitcoin/src/util/trace.h
index ab005dd8..482c5231 100644
--- a/depend/bitcoin/src/util/trace.h
+++ b/depend/bitcoin/src/util/trace.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/util/types.h b/depend/bitcoin/src/util/types.h
index e930216a..c987603c 100644
--- a/depend/bitcoin/src/util/types.h
+++ b/depend/bitcoin/src/util/types.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/util/ui_change_type.h b/depend/bitcoin/src/util/ui_change_type.h
index 1db761a1..449a6dcc 100644
--- a/depend/bitcoin/src/util/ui_change_type.h
+++ b/depend/bitcoin/src/util/ui_change_type.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2020 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/util/vector.h b/depend/bitcoin/src/util/vector.h
index 0c5645eb..aa545f22 100644
--- a/depend/bitcoin/src/util/vector.h
+++ b/depend/bitcoin/src/util/vector.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/validation.cpp b/depend/bitcoin/src/validation.cpp
index 3464e588..fe4237db 100644
--- a/depend/bitcoin/src/validation.cpp
+++ b/depend/bitcoin/src/validation.cpp
@@ -20,13 +20,13 @@
 #include <cuckoocache.h>
 #include <flatfile.h>
 #include <hash.h>
-#include <kernel/chain.h>
 #include <kernel/chainparams.h>
 #include <kernel/coinstats.h>
 #include <kernel/disconnected_transactions.h>
 #include <kernel/mempool_entry.h>
 #include <kernel/messagestartchars.h>
 #include <kernel/notifications_interface.h>
+#include <kernel/types.h>
 #include <kernel/warning.h>
 #include <logging.h>
 #include <logging/timer.h>
@@ -77,6 +77,7 @@
 #include <utility>
 
 using kernel::CCoinsStats;
+using kernel::ChainstateRole;
 using kernel::CoinStatsHashType;
 using kernel::ComputeUTXOStats;
 using kernel::Notifications;
@@ -942,18 +943,6 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
         return state.Invalid(TxValidationResult::TX_NOT_STANDARD, "bad-txns-too-many-sigops",
                 strprintf("%d", nSigOpsCost));
 
-    // No individual transactions are allowed below the min relay feerate except from disconnected blocks.
-    // This requirement, unlike CheckFeeRate, cannot be bypassed using m_package_feerates because,
-    // while a tx could be package CPFP'd when entering the mempool, we do not have a DoS-resistant
-    // method of ensuring the tx remains bumped. For example, the fee-bumping child could disappear
-    // due to a replacement.
-    // The only exception is TRUC transactions.
-    if (!bypass_limits && ws.m_ptx->version != TRUC_VERSION && ws.m_modified_fees < m_pool.m_opts.min_relay_feerate.GetFee(ws.m_vsize)) {
-        // Even though this is a fee-related failure, this result is TX_MEMPOOL_POLICY, not
-        // TX_RECONSIDERABLE, because it cannot be bypassed using package validation.
-        return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "min relay fee not met",
-                             strprintf("%d < %d", ws.m_modified_fees, m_pool.m_opts.min_relay_feerate.GetFee(ws.m_vsize)));
-    }
     // No individual transactions are allowed below the mempool min feerate except from disconnected
     // blocks and transactions in a package. Package transactions will be checked using package
     // feerate later.
@@ -1747,9 +1736,9 @@ PackageMempoolAcceptResult MemPoolAccept::AcceptPackage(const Package& package,
 
     for (const auto& tx : package) {
         const auto& wtxid = tx->GetWitnessHash();
-        if (multi_submission_result.m_tx_results.count(wtxid) > 0) {
+        if (multi_submission_result.m_tx_results.contains(wtxid)) {
             // We shouldn't have re-submitted if the tx result was already in results_final.
-            Assume(results_final.count(wtxid) == 0);
+            Assume(!results_final.contains(wtxid));
             // If it was submitted, check to see if the tx is still in the mempool. It could have
             // been evicted due to LimitMempoolSize() above.
             const auto& txresult = multi_submission_result.m_tx_results.at(wtxid);
@@ -1765,7 +1754,7 @@ PackageMempoolAcceptResult MemPoolAccept::AcceptPackage(const Package& package,
             // Already-in-mempool transaction. Check to see if it's still there, as it could have
             // been evicted when LimitMempoolSize() was called.
             Assume(it->second.m_result_type != MempoolAcceptResult::ResultType::INVALID);
-            Assume(individual_results_nonfinal.count(wtxid) == 0);
+            Assume(!individual_results_nonfinal.contains(wtxid));
             // Query by txid to include the same-txid-different-witness ones.
             if (!m_pool.exists(tx->GetHash())) {
                 package_state_final.Invalid(PackageValidationResult::PCKG_TX, "transaction failed");
@@ -1882,8 +1871,18 @@ Chainstate::Chainstate(
     : m_mempool(mempool),
       m_blockman(blockman),
       m_chainman(chainman),
+      m_assumeutxo(from_snapshot_blockhash ? Assumeutxo::UNVALIDATED : Assumeutxo::VALIDATED),
       m_from_snapshot_blockhash(from_snapshot_blockhash) {}
 
+fs::path Chainstate::StoragePath() const
+{
+    fs::path path{m_chainman.m_options.datadir / "chainstate"};
+    if (m_from_snapshot_blockhash) {
+        path += node::SNAPSHOT_CHAINSTATE_SUFFIX;
+    }
+    return path;
+}
+
 const CBlockIndex* Chainstate::SnapshotBase() const
 {
     if (!m_from_snapshot_blockhash) return nullptr;
@@ -1891,19 +1890,37 @@ const CBlockIndex* Chainstate::SnapshotBase() const
     return m_cached_snapshot_base;
 }
 
+const CBlockIndex* Chainstate::TargetBlock() const
+{
+    if (!m_target_blockhash) return nullptr;
+    if (!m_cached_target_block) m_cached_target_block = Assert(m_chainman.m_blockman.LookupBlockIndex(*m_target_blockhash));
+    return m_cached_target_block;
+}
+
+void Chainstate::SetTargetBlock(CBlockIndex* block)
+{
+    if (block) {
+        m_target_blockhash = block->GetBlockHash();
+    } else {
+        m_target_blockhash.reset();
+    }
+    m_cached_target_block = block;
+}
+
+void Chainstate::SetTargetBlockHash(uint256 block_hash)
+{
+    m_target_blockhash = block_hash;
+    m_cached_target_block = nullptr;
+}
+
 void Chainstate::InitCoinsDB(
     size_t cache_size_bytes,
     bool in_memory,
-    bool should_wipe,
-    fs::path leveldb_name)
+    bool should_wipe)
 {
-    if (m_from_snapshot_blockhash) {
-        leveldb_name += node::SNAPSHOT_CHAINSTATE_SUFFIX;
-    }
-
     m_coins_views = std::make_unique<CoinsViews>(
         DBParams{
-            .path = m_chainman.m_options.datadir / leveldb_name,
+            .path = StoragePath(),
             .cache_bytes = cache_size_bytes,
             .memory_only = in_memory,
             .wipe_data = should_wipe,
@@ -1958,7 +1975,7 @@ void Chainstate::CheckForkWarningConditions()
 {
     AssertLockHeld(cs_main);
 
-    if (this->GetRole() == ChainstateRole::BACKGROUND) {
+    if (this->GetRole().historical) {
         return;
     }
 
@@ -2504,7 +2521,8 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
              Ticks<MillisecondsDouble>(m_chainman.time_forks) / m_chainman.num_blocks_total);
 
     const bool fScriptChecks{!!script_check_reason};
-    if (script_check_reason != m_last_script_check_reason_logged && GetRole() == ChainstateRole::NORMAL) {
+    const kernel::ChainstateRole role{GetRole()};
+    if (script_check_reason != m_last_script_check_reason_logged && role.validated && !role.historical) {
         if (fScriptChecks) {
             LogInfo("Enabling script verification at block #%d (%s): %s.",
                     pindex->nHeight, block_hash.ToString(), script_check_reason);
@@ -2755,7 +2773,7 @@ bool Chainstate::FlushStateToDisk(
                 m_blockman.FindFilesToPruneManual(
                     setFilesToPrune,
                     std::min(last_prune, nManualPruneHeight),
-                    *this, m_chainman);
+                    *this);
             } else {
                 LOG_TIME_MILLIS_WITH_CATEGORY("find files to prune", BCLog::BENCH);
 
@@ -3141,13 +3159,17 @@ bool Chainstate::ConnectTip(
              Ticks<SecondsDouble>(m_chainman.time_total),
              Ticks<MillisecondsDouble>(m_chainman.time_total) / m_chainman.num_blocks_total);
 
-    // If we are the background validation chainstate, check to see if we are done
-    // validating the snapshot (i.e. our tip has reached the snapshot's base block).
-    if (this != &m_chainman.ActiveChainstate()) {
-        // This call may set `m_disabled`, which is referenced immediately afterwards in
-        // ActivateBestChain, so that we stop connecting blocks past the snapshot base.
-        m_chainman.MaybeCompleteSnapshotValidation();
-    }
+    // See if this chainstate has reached a target block and can be used to
+    // validate an assumeutxo snapshot. If it can, hashing the UTXO database
+    // will be slow, and cs_main could remain locked here for several minutes.
+    // If the snapshot is validated, the UTXO hash will be saved to
+    // this->m_target_utxohash, causing HistoricalChainstate() to return null
+    // and this chainstate to no longer be used. ActivateBestChain() will also
+    // stop connecting blocks to this chainstate because this->ReachedTarget()
+    // will be true and this->setBlockIndexCandidates will not have additional
+    // blocks.
+    Chainstate& current_cs{m_chainman.CurrentChainstate()};
+    m_chainman.MaybeValidateSnapshot(*this, current_cs);
 
     connectTrace.BlockConnected(pindexNew, std::move(block_to_connect));
     return true;
@@ -3372,12 +3394,11 @@ bool Chainstate::ActivateBestChain(BlockValidationState& state, std::shared_ptr<
     // we use m_chainstate_mutex to enforce mutual exclusion so that only one caller may execute this function at a time
     LOCK(m_chainstate_mutex);
 
-    // Belt-and-suspenders check that we aren't attempting to advance the background
-    // chainstate past the snapshot base block.
-    if (WITH_LOCK(::cs_main, return m_disabled)) {
-        LogError("m_disabled is set - this chainstate should not be in operation. "
-            "Please report this as a bug. %s", CLIENT_BUGREPORT);
-        return false;
+    // Belt-and-suspenders check that we aren't attempting to advance the
+    // chainstate past the target block.
+    if (WITH_LOCK(::cs_main, return m_target_utxohash)) {
+        LogError("%s", STR_INTERNAL_BUG("m_target_utxohash is set - this chainstate should not be in operation."));
+        return Assume(false);
     }
 
     CBlockIndex *pindexMostWork = nullptr;
@@ -3439,12 +3460,8 @@ bool Chainstate::ActivateBestChain(BlockValidationState& state, std::shared_ptr<
                     }
                 }
 
-                // This will have been toggled in
-                // ActivateBestChainStep -> ConnectTip -> MaybeCompleteSnapshotValidation,
-                // if at all, so we should catch it here.
-                //
-                // Break this do-while to ensure we don't advance past the base snapshot.
-                if (m_disabled) {
+                // Break this do-while to ensure we don't advance past the target block.
+                if (ReachedTarget()) {
                     break;
                 }
             } while (!m_chain.Tip() || (starting_tip && CBlockIndexWorkComparator()(m_chain.Tip(), starting_tip)));
@@ -3486,7 +3503,7 @@ bool Chainstate::ActivateBestChain(BlockValidationState& state, std::shared_ptr<
         } // release cs_main
         // When we reach this point, we switched to a new tip (stored in pindexNewTip).
 
-        bool disabled{false};
+        bool reached_target;
         {
             LOCK(m_chainman.GetMutex());
             if (exited_ibd) {
@@ -3500,18 +3517,17 @@ bool Chainstate::ActivateBestChain(BlockValidationState& state, std::shared_ptr<
                 return false;
             }
 
-            disabled = m_disabled;
+            reached_target = ReachedTarget();
         }
 
-        if (disabled) {
-            // Background chainstate has reached the snapshot base block, so exit.
-
-            // Restart indexes to resume indexing for all blocks unique to the snapshot
-            // chain. This resumes indexing "in order" from where the indexing on the
-            // background validation chain left off.
+        if (reached_target) {
+            // Chainstate has reached the target block, so exit.
+            //
+            // Restart indexes so indexes can resync and index new blocks after
+            // the target block.
             //
             // This cannot be done while holding cs_main (within
-            // MaybeCompleteSnapshotValidation) or a cs_main deadlock will occur.
+            // MaybeValidateSnapshot) or a cs_main deadlock will occur.
             if (m_chainman.snapshot_download_completed) {
                 m_chainman.snapshot_download_completed();
             }
@@ -3783,23 +3799,30 @@ void Chainstate::ResetBlockFailureFlags(CBlockIndex *pindex) {
 void Chainstate::TryAddBlockIndexCandidate(CBlockIndex* pindex)
 {
     AssertLockHeld(cs_main);
+
+    // Do not continue building a chainstate that is based on an invalid
+    // snapshot. This is a belt-and-suspenders type of check because if an
+    // invalid snapshot is loaded, the node will shut down to force a manual
+    // intervention. But it is good to handle this case correctly regardless.
+    if (m_assumeutxo == Assumeutxo::INVALID) {
+        return;
+    }
+
     // The block only is a candidate for the most-work-chain if it has the same
     // or more work than our current tip.
     if (m_chain.Tip() != nullptr && setBlockIndexCandidates.value_comp()(pindex, m_chain.Tip())) {
         return;
     }
 
-    bool is_active_chainstate = this == &m_chainman.ActiveChainstate();
-    if (is_active_chainstate) {
-        // The active chainstate should always add entries that have more
+    const CBlockIndex* target_block{TargetBlock()};
+    if (!target_block) {
+        // If no specific target block, add all entries that have more
         // work than the tip.
         setBlockIndexCandidates.insert(pindex);
-    } else if (!m_disabled) {
-        // For the background chainstate, we only consider connecting blocks
-        // towards the snapshot base (which can't be nullptr or else we'll
-        // never make progress).
-        const CBlockIndex* snapshot_base{Assert(m_chainman.GetSnapshotBaseBlock())};
-        if (snapshot_base->GetAncestor(pindex->nHeight) == pindex) {
+    } else {
+        // If there is a target block, only consider connecting blocks
+        // towards the target block.
+        if (target_block->GetAncestor(pindex->nHeight) == pindex) {
             setBlockIndexCandidates.insert(pindex);
         }
     }
@@ -3817,7 +3840,7 @@ void ChainstateManager::ReceivedBlockTransactions(const CBlock& block, CBlockInd
     // m_chain_tx_count value is not zero, assert that value is actually correct.
     auto prev_tx_sum = [](CBlockIndex& block) { return block.nTx + (block.pprev ? block.pprev->m_chain_tx_count : 0); };
     if (!Assume(pindexNew->m_chain_tx_count == 0 || pindexNew->m_chain_tx_count == prev_tx_sum(*pindexNew) ||
-                pindexNew == GetSnapshotBaseBlock())) {
+                std::ranges::any_of(m_chainstates, [&](const auto& cs) EXCLUSIVE_LOCKS_REQUIRED(cs_main) { return cs->SnapshotBase() == pindexNew; }))) {
         LogWarning("Internal bug detected: block %d has unexpected m_chain_tx_count %i that should be %i (%s %s). Please report this issue here: %s\n",
             pindexNew->nHeight, pindexNew->m_chain_tx_count, prev_tx_sum(*pindexNew), CLIENT_NAME, FormatFullVersion(), CLIENT_BUGREPORT);
         pindexNew->m_chain_tx_count = 0;
@@ -3851,7 +3874,7 @@ void ChainstateManager::ReceivedBlockTransactions(const CBlock& block, CBlockInd
             }
             pindex->m_chain_tx_count = prev_tx_sum(*pindex);
             pindex->nSequenceId = nBlockSequenceId++;
-            for (Chainstate *c : GetAll()) {
+            for (const auto& c : m_chainstates) {
                 c->TryAddBlockIndexCandidate(pindex);
             }
             std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> range = m_blockman.m_blocks_unlinked.equal_range(pindex);
@@ -4483,7 +4506,7 @@ bool ChainstateManager::ProcessNewBlock(const std::shared_ptr<const CBlock>& blo
         return false;
     }
 
-    Chainstate* bg_chain{WITH_LOCK(cs_main, return BackgroundSyncInProgress() ? m_ibd_chainstate.get() : nullptr)};
+    Chainstate* bg_chain{WITH_LOCK(cs_main, return HistoricalChainstate())};
     BlockValidationState bg_state;
     if (bg_chain && !bg_chain->ActivateBestChain(bg_state, block)) {
         LogError("%s: [background] ActivateBestChain failed (%s)\n", __func__, bg_state.ToString());
@@ -4632,7 +4655,7 @@ bool Chainstate::LoadChainTip()
               m_chainman.GuessVerificationProgress(tip));
 
     // Ensure KernelNotifications m_tip_block is set even if no new block arrives.
-    if (this->GetRole() != ChainstateRole::BACKGROUND) {
+    if (!this->GetRole().historical) {
         // Ignoring return value for now.
         (void)m_chainman.GetNotifications().blockTip(
             /*state=*/GetSynchronizationState(/*init=*/true, m_chainman.m_blockman.m_blockfiles_indexed),
@@ -4839,14 +4862,14 @@ bool Chainstate::ReplayBlocks()
     const CBlockIndex* pindexNew;            // New tip during the interrupted flush.
     const CBlockIndex* pindexFork = nullptr; // Latest block common to both the old and the new tip.
 
-    if (m_blockman.m_block_index.count(hashHeads[0]) == 0) {
+    if (!m_blockman.m_block_index.contains(hashHeads[0])) {
         LogError("ReplayBlocks(): reorganization to unknown block requested\n");
         return false;
     }
     pindexNew = &(m_blockman.m_block_index[hashHeads[0]]);
 
     if (!hashHeads[1].IsNull()) { // The old tip is allowed to be 0, indicating it's the first flush.
-        if (m_blockman.m_block_index.count(hashHeads[1]) == 0) {
+        if (!m_blockman.m_block_index.contains(hashHeads[1])) {
             LogError("ReplayBlocks(): reorganization from unknown block requested\n");
             return false;
         }
@@ -4934,7 +4957,7 @@ bool ChainstateManager::LoadBlockIndex()
     AssertLockHeld(cs_main);
     // Load block index from databases
     if (m_blockman.m_blockfiles_indexed) {
-        bool ret{m_blockman.LoadBlockIndexDB(SnapshotBlockhash())};
+        bool ret{m_blockman.LoadBlockIndexDB(CurrentChainstate().m_from_snapshot_blockhash)};
         if (!ret) return false;
 
         m_blockman.ScanAndUnlinkAlreadyPrunedFiles();
@@ -4950,11 +4973,11 @@ bool ChainstateManager::LoadBlockIndex()
             // VALID_TRANSACTIONS (eg if we haven't yet downloaded the block),
             // so we special-case the snapshot block as a potential candidate
             // here.
-            if (pindex == GetSnapshotBaseBlock() ||
+            if (pindex == CurrentChainstate().SnapshotBase() ||
                     (pindex->IsValid(BLOCK_VALID_TRANSACTIONS) &&
                      (pindex->HaveNumChainTxs() || pindex->pprev == nullptr))) {
 
-                for (Chainstate* chainstate : GetAll()) {
+                for (const auto& chainstate : m_chainstates) {
                     chainstate->TryAddBlockIndexCandidate(pindex);
                 }
             }
@@ -4978,7 +5001,7 @@ bool Chainstate::LoadGenesisBlock()
     // m_blockman.m_block_index. Note that we can't use m_chain here, since it is
     // set based on the coins db, not the block index db, which is the only
     // thing loaded at this point.
-    if (m_blockman.m_block_index.count(params.GenesisBlock().GetHash()))
+    if (m_blockman.m_block_index.contains(params.GenesisBlock().GetHash()))
         return true;
 
     try {
@@ -5111,16 +5134,8 @@ void ChainstateManager::LoadExternalBlockFile(
                     // until after all of the block files are loaded. ActivateBestChain can be
                     // called by concurrent network message processing. but, that is not
                     // reliable for the purpose of pruning while importing.
-                    bool activation_failure = false;
-                    for (auto c : GetAll()) {
-                        BlockValidationState state;
-                        if (!c->ActivateBestChain(state, pblock)) {
-                            LogDebug(BCLog::REINDEX, "failed to activate chain (%s)\n", state.ToString());
-                            activation_failure = true;
-                            break;
-                        }
-                    }
-                    if (activation_failure) {
+                    if (auto result{ActivateBestChains()}; !result) {
+                        LogDebug(BCLog::REINDEX, "%s\n", util::ErrorString(result).original);
                         break;
                     }
                 }
@@ -5239,7 +5254,7 @@ void ChainstateManager::CheckBlockIndex() const
     // to earlier blocks that have not been downloaded or validated yet, so
     // checks for later blocks can assume the earlier blocks were validated and
     // be stricter, testing for more requirements.
-    const CBlockIndex* snap_base{GetSnapshotBaseBlock()};
+    const CBlockIndex* snap_base{CurrentChainstate().SnapshotBase()};
     const CBlockIndex *snap_first_missing{}, *snap_first_notx{}, *snap_first_notv{}, *snap_first_nocv{}, *snap_first_nosv{};
     auto snap_update_firsts = [&] {
         if (pindex == snap_base) {
@@ -5281,8 +5296,8 @@ void ChainstateManager::CheckBlockIndex() const
         if (pindex->pprev == nullptr) {
             // Genesis block checks.
             assert(pindex->GetBlockHash() == GetConsensus().hashGenesisBlock); // Genesis block's hash must match.
-            for (const Chainstate* c : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
-                if (c && c->m_chain.Genesis() != nullptr) {
+            for (const auto& c : m_chainstates) {
+                if (c->m_chain.Genesis() != nullptr) {
                     assert(pindex == c->m_chain.Genesis()); // The chain's genesis block must be this block.
                 }
             }
@@ -5341,8 +5356,8 @@ void ChainstateManager::CheckBlockIndex() const
         assert((pindex->nStatus & BLOCK_FAILED_MASK) || pindex->nChainWork <= m_best_header->nChainWork);
 
         // Chainstate-specific checks on setBlockIndexCandidates
-        for (const Chainstate* c : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
-            if (!c || c->m_chain.Tip() == nullptr) continue;
+        for (const auto& c : m_chainstates) {
+            if (c->m_chain.Tip() == nullptr) continue;
             // Two main factors determine whether pindex is a candidate in
             // setBlockIndexCandidates:
             //
@@ -5380,12 +5395,12 @@ void ChainstateManager::CheckBlockIndex() const
                     // is the base of the snapshot, pindex is also a potential
                     // candidate.
                     if (pindexFirstMissing == nullptr || pindex == c->m_chain.Tip() || pindex == c->SnapshotBase()) {
-                        // If this chainstate is the active chainstate, pindex
-                        // must be in setBlockIndexCandidates. Otherwise, this
-                        // chainstate is a background validation chainstate, and
-                        // pindex only needs to be added if it is an ancestor of
-                        // the snapshot that is being validated.
-                        if (c == &ActiveChainstate() || snap_base->GetAncestor(pindex->nHeight) == pindex) {
+                        // If this chainstate is not a historical chainstate
+                        // targeting a specific block, pindex must be in
+                        // setBlockIndexCandidates. Otherwise, pindex only
+                        // needs to be added if it is an ancestor of the target
+                        // block.
+                        if (!c->TargetBlock() || c->TargetBlock()->GetAncestor(pindex->nHeight) == pindex) {
                             assert(c->setBlockIndexCandidates.contains(const_cast<CBlockIndex*>(pindex)));
                         }
                     }
@@ -5425,12 +5440,10 @@ void ChainstateManager::CheckBlockIndex() const
             //    tip.
             // So if this block is itself better than any m_chain.Tip() and it wasn't in
             // setBlockIndexCandidates, then it must be in m_blocks_unlinked.
-            for (const Chainstate* c : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
-                if (!c) continue;
-                const bool is_active = c == &ActiveChainstate();
+            for (const auto& c : m_chainstates) {
                 if (!CBlockIndexWorkComparator()(pindex, c->m_chain.Tip()) && !c->setBlockIndexCandidates.contains(const_cast<CBlockIndex*>(pindex))) {
                     if (pindexFirstInvalid == nullptr) {
-                        if (is_active || snap_base->GetAncestor(pindex->nHeight) == pindex) {
+                        if (!c->TargetBlock() || c->TargetBlock()->GetAncestor(pindex->nHeight) == pindex) {
                             assert(foundInUnlinked);
                         }
                     }
@@ -5579,37 +5592,12 @@ double ChainstateManager::GuessVerificationProgress(const CBlockIndex* pindex) c
     return std::min<double>(pindex->m_chain_tx_count / fTxTotal, 1.0);
 }
 
-std::optional<uint256> ChainstateManager::SnapshotBlockhash() const
-{
-    LOCK(::cs_main);
-    if (m_active_chainstate && m_active_chainstate->m_from_snapshot_blockhash) {
-        // If a snapshot chainstate exists, it will always be our active.
-        return m_active_chainstate->m_from_snapshot_blockhash;
-    }
-    return std::nullopt;
-}
-
-std::vector<Chainstate*> ChainstateManager::GetAll()
-{
-    LOCK(::cs_main);
-    std::vector<Chainstate*> out;
-
-    for (Chainstate* cs : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
-        if (this->IsUsable(cs)) out.push_back(cs);
-    }
-
-    return out;
-}
-
 Chainstate& ChainstateManager::InitializeChainstate(CTxMemPool* mempool)
 {
     AssertLockHeld(::cs_main);
-    assert(!m_ibd_chainstate);
-    assert(!m_active_chainstate);
-
-    m_ibd_chainstate = std::make_unique<Chainstate>(mempool, m_blockman, *this);
-    m_active_chainstate = m_ibd_chainstate.get();
-    return *m_active_chainstate;
+    assert(m_chainstates.empty());
+    m_chainstates.emplace_back(std::make_unique<Chainstate>(mempool, m_blockman, *this));
+    return *m_chainstates.back();
 }
 
 [[nodiscard]] static bool DeleteCoinsDBFromDisk(const fs::path db_path, bool is_snapshot)
@@ -5659,15 +5647,14 @@ util::Result<CBlockIndex*> ChainstateManager::ActivateSnapshot(
 {
     uint256 base_blockhash = metadata.m_base_blockhash;
 
-    if (this->SnapshotBlockhash()) {
-        return util::Error{Untranslated("Can't activate a snapshot-based chainstate more than once")};
-    }
-
     CBlockIndex* snapshot_start_block{};
 
     {
         LOCK(::cs_main);
 
+        if (this->CurrentChainstate().m_from_snapshot_blockhash) {
+            return util::Error{Untranslated("Can't activate a snapshot-based chainstate more than once")};
+        }
         if (!GetParams().AssumeutxoForBlockhash(base_blockhash).has_value()) {
             auto available_heights = GetParams().GetAvailableSnapshotHeights();
             std::string heights_formatted = util::Join(available_heights, ", ", [&](const auto& i) { return util::ToString(i); });
@@ -5691,7 +5678,7 @@ util::Result<CBlockIndex*> ChainstateManager::ActivateSnapshot(
             return util::Error{Untranslated("A forked headers-chain with more work than the chain with the snapshot base block header exists. Please proceed to sync without AssumeUtxo.")};
         }
 
-        auto mempool{m_active_chainstate->GetMempool()};
+        auto mempool{CurrentChainstate().GetMempool()};
         if (mempool && mempool->size() > 0) {
             return util::Error{Untranslated("Can't activate a snapshot when mempool not empty")};
         }
@@ -5737,7 +5724,7 @@ util::Result<CBlockIndex*> ChainstateManager::ActivateSnapshot(
         LOCK(::cs_main);
         snapshot_chainstate->InitCoinsDB(
             static_cast<size_t>(current_coinsdb_cache_size * SNAPSHOT_CACHE_PERC),
-            in_memory, false, "chainstate");
+            in_memory, /*should_wipe=*/false);
         snapshot_chainstate->InitCoinsCache(
             static_cast<size_t>(current_coinstip_cache_size * SNAPSHOT_CACHE_PERC));
     }
@@ -5747,7 +5734,7 @@ util::Result<CBlockIndex*> ChainstateManager::ActivateSnapshot(
 
         // PopulateAndValidateSnapshot can return (in error) before the leveldb datadir
         // has been created, so only attempt removal if we got that far.
-        if (auto snapshot_datadir = node::FindSnapshotChainstateDir(m_options.datadir)) {
+        if (auto snapshot_datadir = node::FindAssumeutxoChainstateDir(m_options.datadir)) {
             // We have to destruct leveldb::DB in order to release the db lock, otherwise
             // DestroyDB() (in DeleteCoinsDBFromDisk()) will fail. See `leveldb::~DBImpl()`.
             // Destructing the chainstate (and so resetting the coinsviews object) does this.
@@ -5782,23 +5769,14 @@ util::Result<CBlockIndex*> ChainstateManager::ActivateSnapshot(
         }
     }
 
-    assert(!m_snapshot_chainstate);
-    m_snapshot_chainstate.swap(snapshot_chainstate);
-    const bool chaintip_loaded = m_snapshot_chainstate->LoadChainTip();
+    Chainstate& chainstate{AddChainstate(std::move(snapshot_chainstate))};
+    const bool chaintip_loaded{chainstate.LoadChainTip()};
     assert(chaintip_loaded);
-
-    // Transfer possession of the mempool to the snapshot chainstate.
-    // Mempool is empty at this point because we're still in IBD.
-    Assert(m_active_chainstate->m_mempool->size() == 0);
-    Assert(!m_snapshot_chainstate->m_mempool);
-    m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool;
-    m_active_chainstate->m_mempool = nullptr;
-    m_active_chainstate = m_snapshot_chainstate.get();
-    m_blockman.m_snapshot_height = this->GetSnapshotBaseHeight();
+    m_blockman.m_snapshot_height = Assert(chainstate.SnapshotBase())->nHeight;
 
     LogInfo("[snapshot] successfully activated snapshot %s", base_blockhash.ToString());
     LogInfo("[snapshot] (%.2f MB)",
-        m_snapshot_chainstate->CoinsTip().DynamicMemoryUsage() / (1000 * 1000));
+              chainstate.CoinsTip().DynamicMemoryUsage() / (1000 * 1000));
 
     this->MaybeRebalanceCaches();
     return snapshot_start_block;
@@ -6032,41 +6010,35 @@ util::Result<void> ChainstateManager::PopulateAndValidateSnapshot(
 }
 
 // Currently, this function holds cs_main for its duration, which could be for
-// multiple minutes due to the ComputeUTXOStats call. This hold is necessary
-// because we need to avoid advancing the background validation chainstate
-// farther than the snapshot base block - and this function is also invoked
-// from within ConnectTip, i.e. from within ActivateBestChain, so cs_main is
-// held anyway.
-//
-// Eventually (TODO), we could somehow separate this function's runtime from
-// maintenance of the active chain, but that will either require
+// multiple minutes due to the ComputeUTXOStats call. Holding cs_main used to be
+// necessary (before d43a1f1a2fa3) to avoid advancing validated_cs farther than
+// its target block. Now it should be possible to avoid this, but simply
+// releasing cs_main here would not be possible because this function is invoked
+// by ConnectTip within ActivateBestChain.
 //
-//  (i) setting `m_disabled` immediately and ensuring all chainstate accesses go
-//      through IsUsable() checks, or
-//
-//  (ii) giving each chainstate its own lock instead of using cs_main for everything.
-SnapshotCompletionResult ChainstateManager::MaybeCompleteSnapshotValidation()
+// Eventually (TODO) it would be better to call this function outside of
+// ActivateBestChain, on a separate thread that should not require cs_main to
+// hash, because the UTXO set is only hashed after the historical chainstate
+// reaches its target block and is no longer changing.
+SnapshotCompletionResult ChainstateManager::MaybeValidateSnapshot(Chainstate& validated_cs, Chainstate& unvalidated_cs)
 {
     AssertLockHeld(cs_main);
-    if (m_ibd_chainstate.get() == &this->ActiveChainstate() ||
-            !this->IsUsable(m_snapshot_chainstate.get()) ||
-            !this->IsUsable(m_ibd_chainstate.get()) ||
-            !m_ibd_chainstate->m_chain.Tip()) {
-       // Nothing to do - this function only applies to the background
-       // validation chainstate.
-       return SnapshotCompletionResult::SKIPPED;
-    }
-    const int snapshot_tip_height = this->ActiveHeight();
-    const int snapshot_base_height = *Assert(this->GetSnapshotBaseHeight());
-    const CBlockIndex& index_new = *Assert(m_ibd_chainstate->m_chain.Tip());
 
-    if (index_new.nHeight < snapshot_base_height) {
-        // Background IBD not complete yet.
-        return SnapshotCompletionResult::SKIPPED;
+    // If the snapshot does not need to be validated...
+    if (unvalidated_cs.m_assumeutxo != Assumeutxo::UNVALIDATED ||
+            // Or if either chainstate is unusable...
+            !unvalidated_cs.m_from_snapshot_blockhash ||
+            validated_cs.m_assumeutxo != Assumeutxo::VALIDATED ||
+            !validated_cs.m_chain.Tip() ||
+            // Or the validated chainstate is not targeting the snapshot block...
+            !validated_cs.m_target_blockhash ||
+            *validated_cs.m_target_blockhash != *unvalidated_cs.m_from_snapshot_blockhash ||
+            // Or the validated chainstate has not reached the snapshot block yet...
+            !validated_cs.ReachedTarget()) {
+       // Then the snapshot cannot be validated and there is nothing to do.
+       return SnapshotCompletionResult::SKIPPED;
     }
-
-    assert(SnapshotBlockhash());
-    uint256 snapshot_blockhash = *Assert(SnapshotBlockhash());
+    assert(validated_cs.TargetBlock() == validated_cs.m_chain.Tip());
 
     auto handle_invalid_snapshot = [&]() EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
         bilingual_str user_error = strprintf(_(
@@ -6081,18 +6053,19 @@ SnapshotCompletionResult ChainstateManager::MaybeCompleteSnapshotValidation()
             "Please report this incident to %s, including how you obtained the snapshot. "
             "The invalid snapshot chainstate will be left on disk in case it is "
             "helpful in diagnosing the issue that caused this error."),
-            CLIENT_NAME, snapshot_tip_height, snapshot_base_height, snapshot_base_height, CLIENT_BUGREPORT
-        );
+            CLIENT_NAME, unvalidated_cs.m_chain.Height(),
+            validated_cs.m_chain.Height(),
+            validated_cs.m_chain.Height(), CLIENT_BUGREPORT);
 
         LogError("[snapshot] !!! %s\n", user_error.original);
         LogError("[snapshot] deleting snapshot, reverting to validated chain, and stopping node\n");
 
-        m_active_chainstate = m_ibd_chainstate.get();
-        m_snapshot_chainstate->m_disabled = true;
-        assert(!this->IsUsable(m_snapshot_chainstate.get()));
-        assert(this->IsUsable(m_ibd_chainstate.get()));
+        // Reset chainstate target to network tip instead of snapshot block.
+        validated_cs.SetTargetBlock(nullptr);
+
+        unvalidated_cs.m_assumeutxo = Assumeutxo::INVALID;
 
-        auto rename_result = m_snapshot_chainstate->InvalidateCoinsDBOnDisk();
+        auto rename_result = unvalidated_cs.InvalidateCoinsDBOnDisk();
         if (!rename_result) {
             user_error += Untranslated("\n") + util::ErrorString(rename_result);
         }
@@ -6100,42 +6073,25 @@ SnapshotCompletionResult ChainstateManager::MaybeCompleteSnapshotValidation()
         GetNotifications().fatalError(user_error);
     };
 
-    if (index_new.GetBlockHash() != snapshot_blockhash) {
-        LogWarning("[snapshot] supposed base block %s does not match the "
-          "snapshot base block %s (height %d). Snapshot is not valid.",
-          index_new.ToString(), snapshot_blockhash.ToString(), snapshot_base_height);
-        handle_invalid_snapshot();
-        return SnapshotCompletionResult::BASE_BLOCKHASH_MISMATCH;
-    }
-
-    assert(index_new.nHeight == snapshot_base_height);
-
-    int curr_height = m_ibd_chainstate->m_chain.Height();
-
-    assert(snapshot_base_height == curr_height);
-    assert(snapshot_base_height == index_new.nHeight);
-    assert(this->IsUsable(m_snapshot_chainstate.get()));
-    assert(this->GetAll().size() == 2);
-
-    CCoinsViewDB& ibd_coins_db = m_ibd_chainstate->CoinsDB();
-    m_ibd_chainstate->ForceFlushStateToDisk();
+    CCoinsViewDB& validated_coins_db = validated_cs.CoinsDB();
+    validated_cs.ForceFlushStateToDisk();
 
-    const auto& maybe_au_data = m_options.chainparams.AssumeutxoForHeight(curr_height);
+    const auto& maybe_au_data = m_options.chainparams.AssumeutxoForHeight(validated_cs.m_chain.Height());
     if (!maybe_au_data) {
         LogWarning("[snapshot] assumeutxo data not found for height "
-            "(%d) - refusing to validate snapshot", curr_height);
+            "(%d) - refusing to validate snapshot", validated_cs.m_chain.Height());
         handle_invalid_snapshot();
         return SnapshotCompletionResult::MISSING_CHAINPARAMS;
     }
 
     const AssumeutxoData& au_data = *maybe_au_data;
-    std::optional<CCoinsStats> maybe_ibd_stats;
+    std::optional<CCoinsStats> validated_cs_stats;
     LogInfo("[snapshot] computing UTXO stats for background chainstate to validate "
         "snapshot - this could take a few minutes");
     try {
-        maybe_ibd_stats = ComputeUTXOStats(
+        validated_cs_stats = ComputeUTXOStats(
             CoinStatsHashType::HASH_SERIALIZED,
-            &ibd_coins_db,
+            &validated_coins_db,
             m_blockman,
             [&interrupt = m_interrupt] { SnapshotUTXOHashBreakpoint(interrupt); });
     } catch (StopHashingException const&) {
@@ -6143,7 +6099,7 @@ SnapshotCompletionResult ChainstateManager::MaybeCompleteSnapshotValidation()
     }
 
     // XXX note that this function is slow and will hold cs_main for potentially minutes.
-    if (!maybe_ibd_stats) {
+    if (!validated_cs_stats) {
         LogWarning("[snapshot] failed to generate stats for validation coins db");
         // While this isn't a problem with the snapshot per se, this condition
         // prevents us from validating the snapshot, so we should shut down and let the
@@ -6151,26 +6107,26 @@ SnapshotCompletionResult ChainstateManager::MaybeCompleteSnapshotValidation()
         handle_invalid_snapshot();
         return SnapshotCompletionResult::STATS_FAILED;
     }
-    const auto& ibd_stats = *maybe_ibd_stats;
 
-    // Compare the background validation chainstate's UTXO set hash against the hard-coded
+    // Compare the validated chainstate's UTXO set hash against the hard-coded
     // assumeutxo hash we expect.
     //
     // TODO: For belt-and-suspenders, we could cache the UTXO set
     // hash for the snapshot when it's loaded in its chainstate's leveldb. We could then
     // reference that here for an additional check.
-    if (AssumeutxoHash{ibd_stats.hashSerialized} != au_data.hash_serialized) {
+    if (AssumeutxoHash{validated_cs_stats->hashSerialized} != au_data.hash_serialized) {
         LogWarning("[snapshot] hash mismatch: actual=%s, expected=%s",
-            ibd_stats.hashSerialized.ToString(),
+            validated_cs_stats->hashSerialized.ToString(),
             au_data.hash_serialized.ToString());
         handle_invalid_snapshot();
         return SnapshotCompletionResult::HASH_MISMATCH;
     }
 
     LogInfo("[snapshot] snapshot beginning at %s has been fully validated",
-        snapshot_blockhash.ToString());
+        unvalidated_cs.m_from_snapshot_blockhash->ToString());
 
-    m_ibd_chainstate->m_disabled = true;
+    unvalidated_cs.m_assumeutxo = Assumeutxo::VALIDATED;
+    validated_cs.m_target_utxohash = AssumeutxoHash{validated_cs_stats->hashSerialized};
     this->MaybeRebalanceCaches();
 
     return SnapshotCompletionResult::SUCCESS;
@@ -6179,47 +6135,36 @@ SnapshotCompletionResult ChainstateManager::MaybeCompleteSnapshotValidation()
 Chainstate& ChainstateManager::ActiveChainstate() const
 {
     LOCK(::cs_main);
-    assert(m_active_chainstate);
-    return *m_active_chainstate;
-}
-
-bool ChainstateManager::IsSnapshotActive() const
-{
-    LOCK(::cs_main);
-    return m_snapshot_chainstate && m_active_chainstate == m_snapshot_chainstate.get();
+    return CurrentChainstate();
 }
 
 void ChainstateManager::MaybeRebalanceCaches()
 {
     AssertLockHeld(::cs_main);
-    bool ibd_usable = this->IsUsable(m_ibd_chainstate.get());
-    bool snapshot_usable = this->IsUsable(m_snapshot_chainstate.get());
-    assert(ibd_usable || snapshot_usable);
-
-    if (ibd_usable && !snapshot_usable) {
+    Chainstate& current_cs{CurrentChainstate()};
+    Chainstate* historical_cs{HistoricalChainstate()};
+    if (!historical_cs && !current_cs.m_from_snapshot_blockhash) {
         // Allocate everything to the IBD chainstate. This will always happen
         // when we are not using a snapshot.
-        m_ibd_chainstate->ResizeCoinsCaches(m_total_coinstip_cache, m_total_coinsdb_cache);
-    }
-    else if (snapshot_usable && !ibd_usable) {
+        current_cs.ResizeCoinsCaches(m_total_coinstip_cache, m_total_coinsdb_cache);
+    } else if (!historical_cs) {
         // If background validation has completed and snapshot is our active chain...
         LogInfo("[snapshot] allocating all cache to the snapshot chainstate");
         // Allocate everything to the snapshot chainstate.
-        m_snapshot_chainstate->ResizeCoinsCaches(m_total_coinstip_cache, m_total_coinsdb_cache);
-    }
-    else if (ibd_usable && snapshot_usable) {
+        current_cs.ResizeCoinsCaches(m_total_coinstip_cache, m_total_coinsdb_cache);
+    } else {
         // If both chainstates exist, determine who needs more cache based on IBD status.
         //
         // Note: shrink caches first so that we don't inadvertently overwhelm available memory.
         if (IsInitialBlockDownload()) {
-            m_ibd_chainstate->ResizeCoinsCaches(
+            historical_cs->ResizeCoinsCaches(
                 m_total_coinstip_cache * 0.05, m_total_coinsdb_cache * 0.05);
-            m_snapshot_chainstate->ResizeCoinsCaches(
+            current_cs.ResizeCoinsCaches(
                 m_total_coinstip_cache * 0.95, m_total_coinsdb_cache * 0.95);
         } else {
-            m_snapshot_chainstate->ResizeCoinsCaches(
+            current_cs.ResizeCoinsCaches(
                 m_total_coinstip_cache * 0.05, m_total_coinsdb_cache * 0.05);
-            m_ibd_chainstate->ResizeCoinsCaches(
+            historical_cs->ResizeCoinsCaches(
                 m_total_coinstip_cache * 0.95, m_total_coinsdb_cache * 0.95);
         }
     }
@@ -6227,9 +6172,7 @@ void ChainstateManager::MaybeRebalanceCaches()
 
 void ChainstateManager::ResetChainstates()
 {
-    m_ibd_chainstate.reset();
-    m_snapshot_chainstate.reset();
-    m_active_chainstate = nullptr;
+    m_chainstates.clear();
 }
 
 /**
@@ -6261,38 +6204,42 @@ ChainstateManager::~ChainstateManager()
     m_versionbitscache.Clear();
 }
 
-bool ChainstateManager::DetectSnapshotChainstate()
+Chainstate* ChainstateManager::LoadAssumeutxoChainstate()
 {
-    assert(!m_snapshot_chainstate);
-    std::optional<fs::path> path = node::FindSnapshotChainstateDir(m_options.datadir);
+    assert(!CurrentChainstate().m_from_snapshot_blockhash);
+    std::optional<fs::path> path = node::FindAssumeutxoChainstateDir(m_options.datadir);
     if (!path) {
-        return false;
+        return nullptr;
     }
     std::optional<uint256> base_blockhash = node::ReadSnapshotBaseBlockhash(*path);
     if (!base_blockhash) {
-        return false;
+        return nullptr;
     }
     LogInfo("[snapshot] detected active snapshot chainstate (%s) - loading",
         fs::PathToString(*path));
 
-    this->ActivateExistingSnapshot(*base_blockhash);
-    return true;
+    auto snapshot_chainstate{std::make_unique<Chainstate>(nullptr, m_blockman, *this, base_blockhash)};
+    LogInfo("[snapshot] switching active chainstate to %s", snapshot_chainstate->ToString());
+    return &this->AddChainstate(std::move(snapshot_chainstate));
 }
 
-Chainstate& ChainstateManager::ActivateExistingSnapshot(uint256 base_blockhash)
+Chainstate& ChainstateManager::AddChainstate(std::unique_ptr<Chainstate> chainstate)
 {
-    assert(!m_snapshot_chainstate);
-    m_snapshot_chainstate =
-        std::make_unique<Chainstate>(nullptr, m_blockman, *this, base_blockhash);
-    LogInfo("[snapshot] switching active chainstate to %s", m_snapshot_chainstate->ToString());
-
+    Chainstate& prev_chainstate{CurrentChainstate()};
+    assert(prev_chainstate.m_assumeutxo == Assumeutxo::VALIDATED);
+    // Set target block for historical chainstate to snapshot block.
+    assert(!prev_chainstate.m_target_blockhash);
+    prev_chainstate.m_target_blockhash = chainstate->m_from_snapshot_blockhash;
+    m_chainstates.push_back(std::move(chainstate));
+    Chainstate& curr_chainstate{CurrentChainstate()};
+    assert(&curr_chainstate == m_chainstates.back().get());
+
+    // Transfer possession of the mempool to the chainstate.
     // Mempool is empty at this point because we're still in IBD.
-    Assert(m_active_chainstate->m_mempool->size() == 0);
-    Assert(!m_snapshot_chainstate->m_mempool);
-    m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool;
-    m_active_chainstate->m_mempool = nullptr;
-    m_active_chainstate = m_snapshot_chainstate.get();
-    return *m_snapshot_chainstate;
+    assert(prev_chainstate.m_mempool->size() == 0);
+    assert(!curr_chainstate.m_mempool);
+    std::swap(curr_chainstate.m_mempool, prev_chainstate.m_mempool);
+    return curr_chainstate;
 }
 
 bool IsBIP30Repeat(const CBlockIndex& block_index)
@@ -6307,87 +6254,59 @@ bool IsBIP30Unspendable(const uint256& block_hash, int block_height)
            (block_height==91812 && block_hash == uint256{"00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f"});
 }
 
-static fs::path GetSnapshotCoinsDBPath(Chainstate& cs) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
-{
-    AssertLockHeld(::cs_main);
-    // Should never be called on a non-snapshot chainstate.
-    assert(cs.m_from_snapshot_blockhash);
-    auto storage_path_maybe = cs.CoinsDB().StoragePath();
-    // Should never be called with a non-existent storage path.
-    assert(storage_path_maybe);
-    return *storage_path_maybe;
-}
-
 util::Result<void> Chainstate::InvalidateCoinsDBOnDisk()
 {
-    fs::path snapshot_datadir = GetSnapshotCoinsDBPath(*this);
+    // Should never be called on a non-snapshot chainstate.
+    assert(m_from_snapshot_blockhash);
 
     // Coins views no longer usable.
     m_coins_views.reset();
 
-    auto invalid_path = snapshot_datadir + "_INVALID";
-    std::string dbpath = fs::PathToString(snapshot_datadir);
-    std::string target = fs::PathToString(invalid_path);
-    LogInfo("[snapshot] renaming snapshot datadir %s to %s", dbpath, target);
+    const fs::path db_path{StoragePath()};
+    const fs::path invalid_path{db_path + "_INVALID"};
+    const std::string db_path_str{fs::PathToString(db_path)};
+    const std::string invalid_path_str{fs::PathToString(invalid_path)};
+    LogInfo("[snapshot] renaming snapshot datadir %s to %s", db_path_str, invalid_path_str);
 
-    // The invalid snapshot datadir is simply moved and not deleted because we may
+    // The invalid storage directory is simply moved and not deleted because we may
     // want to do forensics later during issue investigation. The user is instructed
-    // accordingly in MaybeCompleteSnapshotValidation().
+    // accordingly in MaybeValidateSnapshot().
     try {
-        fs::rename(snapshot_datadir, invalid_path);
+        fs::rename(db_path, invalid_path);
     } catch (const fs::filesystem_error& e) {
-        auto src_str = fs::PathToString(snapshot_datadir);
-        auto dest_str = fs::PathToString(invalid_path);
-
         LogError("While invalidating the coins db: Error renaming file '%s' -> '%s': %s",
-                 src_str, dest_str, e.what());
+                 db_path_str, invalid_path_str, e.what());
         return util::Error{strprintf(_(
             "Rename of '%s' -> '%s' failed. "
             "You should resolve this by manually moving or deleting the invalid "
             "snapshot directory %s, otherwise you will encounter the same error again "
             "on the next startup."),
-            src_str, dest_str, src_str)};
+            db_path_str, invalid_path_str, db_path_str)};
     }
     return {};
 }
 
-bool ChainstateManager::DeleteSnapshotChainstate()
+bool ChainstateManager::DeleteChainstate(Chainstate& chainstate)
 {
     AssertLockHeld(::cs_main);
-    Assert(m_snapshot_chainstate);
-    Assert(m_ibd_chainstate);
-
-    fs::path snapshot_datadir = Assert(node::FindSnapshotChainstateDir(m_options.datadir)).value();
-    if (!DeleteCoinsDBFromDisk(snapshot_datadir, /*is_snapshot=*/ true)) {
+    assert(!chainstate.m_coins_views);
+    const fs::path db_path{chainstate.StoragePath()};
+    if (!DeleteCoinsDBFromDisk(db_path, /*is_snapshot=*/bool{chainstate.m_from_snapshot_blockhash})) {
         LogError("Deletion of %s failed. Please remove it manually to continue reindexing.",
-                  fs::PathToString(snapshot_datadir));
+                  fs::PathToString(db_path));
         return false;
     }
-    m_active_chainstate = m_ibd_chainstate.get();
-    m_active_chainstate->m_mempool = m_snapshot_chainstate->m_mempool;
-    m_snapshot_chainstate.reset();
+    std::unique_ptr<Chainstate> prev_chainstate{Assert(RemoveChainstate(chainstate))};
+    Chainstate& curr_chainstate{CurrentChainstate()};
+    assert(prev_chainstate->m_mempool->size() == 0);
+    assert(!curr_chainstate.m_mempool);
+    std::swap(curr_chainstate.m_mempool, prev_chainstate->m_mempool);
     return true;
 }
 
 ChainstateRole Chainstate::GetRole() const
 {
-    if (m_chainman.GetAll().size() <= 1) {
-        return ChainstateRole::NORMAL;
-    }
-    return (this != &m_chainman.ActiveChainstate()) ?
-               ChainstateRole::BACKGROUND :
-               ChainstateRole::ASSUMEDVALID;
-}
-
-const CBlockIndex* ChainstateManager::GetSnapshotBaseBlock() const
-{
-    return m_active_chainstate ? m_active_chainstate->SnapshotBase() : nullptr;
-}
-
-std::optional<int> ChainstateManager::GetSnapshotBaseHeight() const
-{
-    const CBlockIndex* base = this->GetSnapshotBaseBlock();
-    return base ? std::make_optional(base->nHeight) : std::nullopt;
+    return ChainstateRole{.validated = m_assumeutxo == Assumeutxo::VALIDATED, .historical = bool{m_target_blockhash}};
 }
 
 void ChainstateManager::RecalculateBestHeader()
@@ -6401,33 +6320,17 @@ void ChainstateManager::RecalculateBestHeader()
     }
 }
 
-bool ChainstateManager::ValidatedSnapshotCleanup()
+bool ChainstateManager::ValidatedSnapshotCleanup(Chainstate& validated_cs, Chainstate& unvalidated_cs)
 {
     AssertLockHeld(::cs_main);
-    auto get_storage_path = [](auto& chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) -> std::optional<fs::path> {
-        if (!(chainstate && chainstate->HasCoinsViews())) {
-            return {};
-        }
-        return chainstate->CoinsDB().StoragePath();
-    };
-    std::optional<fs::path> ibd_chainstate_path_maybe = get_storage_path(m_ibd_chainstate);
-    std::optional<fs::path> snapshot_chainstate_path_maybe = get_storage_path(m_snapshot_chainstate);
-
-    if (!this->IsSnapshotValidated()) {
+    if (unvalidated_cs.m_assumeutxo != Assumeutxo::VALIDATED) {
         // No need to clean up.
         return false;
     }
-    // If either path doesn't exist, that means at least one of the chainstates
-    // is in-memory, in which case we can't do on-disk cleanup. You'd better be
-    // in a unittest!
-    if (!ibd_chainstate_path_maybe || !snapshot_chainstate_path_maybe) {
-        LogError("[snapshot] snapshot chainstate cleanup cannot happen with "
-                 "in-memory chainstates. You are testing, right?");
-        return false;
-    }
 
-    const auto& snapshot_chainstate_path = *snapshot_chainstate_path_maybe;
-    const auto& ibd_chainstate_path = *ibd_chainstate_path_maybe;
+    const fs::path validated_path{validated_cs.StoragePath()};
+    const fs::path assumed_valid_path{unvalidated_cs.StoragePath()};
+    const fs::path delete_path{validated_path + "_todelete"};
 
     // Since we're going to be moving around the underlying leveldb filesystem content
     // for each chainstate, make sure that the chainstates (and their constituent
@@ -6436,14 +6339,10 @@ bool ChainstateManager::ValidatedSnapshotCleanup()
     // The caller of this method will be responsible for reinitializing chainstates
     // if they want to continue operation.
     this->ResetChainstates();
-
-    // No chainstates should be considered usable.
-    assert(this->GetAll().size() == 0);
+    assert(this->m_chainstates.size() == 0);
 
     LogInfo("[snapshot] deleting background chainstate directory (now unnecessary) (%s)",
-              fs::PathToString(ibd_chainstate_path));
-
-    fs::path tmp_old{ibd_chainstate_path + "_todelete"};
+              fs::PathToString(validated_path));
 
     auto rename_failed_abort = [this](
                                    fs::path p_old,
@@ -6458,59 +6357,52 @@ bool ChainstateManager::ValidatedSnapshotCleanup()
     };
 
     try {
-        fs::rename(ibd_chainstate_path, tmp_old);
+        fs::rename(validated_path, delete_path);
     } catch (const fs::filesystem_error& e) {
-        rename_failed_abort(ibd_chainstate_path, tmp_old, e);
+        rename_failed_abort(validated_path, delete_path, e);
         throw;
     }
 
     LogInfo("[snapshot] moving snapshot chainstate (%s) to "
               "default chainstate directory (%s)",
-              fs::PathToString(snapshot_chainstate_path), fs::PathToString(ibd_chainstate_path));
+              fs::PathToString(assumed_valid_path), fs::PathToString(validated_path));
 
     try {
-        fs::rename(snapshot_chainstate_path, ibd_chainstate_path);
+        fs::rename(assumed_valid_path, validated_path);
     } catch (const fs::filesystem_error& e) {
-        rename_failed_abort(snapshot_chainstate_path, ibd_chainstate_path, e);
+        rename_failed_abort(assumed_valid_path, validated_path, e);
         throw;
     }
 
-    if (!DeleteCoinsDBFromDisk(tmp_old, /*is_snapshot=*/false)) {
+    if (!DeleteCoinsDBFromDisk(delete_path, /*is_snapshot=*/false)) {
         // No need to FatalError because once the unneeded bg chainstate data is
         // moved, it will not interfere with subsequent initialization.
         LogWarning("Deletion of %s failed. Please remove it manually, as the "
                    "directory is now unnecessary.",
-                  fs::PathToString(tmp_old));
+                   fs::PathToString(delete_path));
     } else {
         LogInfo("[snapshot] deleted background chainstate directory (%s)",
-                  fs::PathToString(ibd_chainstate_path));
+                fs::PathToString(validated_path));
     }
     return true;
 }
 
-Chainstate& ChainstateManager::GetChainstateForIndexing()
+std::pair<int, int> Chainstate::GetPruneRange(int last_height_can_prune) const
 {
-    // We can't always return `m_ibd_chainstate` because after background validation
-    // has completed, `m_snapshot_chainstate == m_active_chainstate`, but it can be
-    // indexed.
-    return (this->GetAll().size() > 1) ? *m_ibd_chainstate : *m_active_chainstate;
-}
-
-std::pair<int, int> ChainstateManager::GetPruneRange(const Chainstate& chainstate, int last_height_can_prune)
-{
-    if (chainstate.m_chain.Height() <= 0) {
+    if (m_chain.Height() <= 0) {
         return {0, 0};
     }
     int prune_start{0};
 
-    if (this->GetAll().size() > 1 && m_snapshot_chainstate.get() == &chainstate) {
-        // Leave the blocks in the background IBD chain alone if we're pruning
-        // the snapshot chain.
-        prune_start = *Assert(GetSnapshotBaseHeight()) + 1;
+    if (m_from_snapshot_blockhash && m_assumeutxo != Assumeutxo::VALIDATED) {
+        // Only prune blocks _after_ the snapshot if this is a snapshot chain
+        // that has not been fully validated yet. The earlier blocks need to be
+        // kept to validate the snapshot
+        prune_start = Assert(SnapshotBase())->nHeight + 1;
     }
 
     int max_prune = std::max<int>(
-        0, chainstate.m_chain.Height() - static_cast<int>(MIN_BLOCKS_TO_KEEP));
+        0, m_chain.Height() - static_cast<int>(MIN_BLOCKS_TO_KEEP));
 
     // last block to prune is the lesser of (caller-specified height, MIN_BLOCKS_TO_KEEP from the tip)
     //
@@ -6522,3 +6414,36 @@ std::pair<int, int> ChainstateManager::GetPruneRange(const Chainstate& chainstat
 
     return {prune_start, prune_end};
 }
+
+std::optional<std::pair<const CBlockIndex*, const CBlockIndex*>> ChainstateManager::GetHistoricalBlockRange() const
+{
+    const Chainstate* chainstate{HistoricalChainstate()};
+    if (!chainstate) return {};
+    return std::make_pair(chainstate->m_chain.Tip(), chainstate->TargetBlock());
+}
+
+util::Result<void> ChainstateManager::ActivateBestChains()
+{
+    // We can't hold cs_main during ActivateBestChain even though we're accessing
+    // the chainman unique_ptrs since ABC requires us not to be holding cs_main, so retrieve
+    // the relevant pointers before the ABC call.
+    AssertLockNotHeld(cs_main);
+    std::vector<Chainstate*> chainstates;
+    {
+        LOCK(GetMutex());
+        chainstates.reserve(m_chainstates.size());
+        for (const auto& chainstate : m_chainstates) {
+            if (chainstate && chainstate->m_assumeutxo != Assumeutxo::INVALID && !chainstate->m_target_utxohash) {
+                chainstates.push_back(chainstate.get());
+            }
+        }
+    }
+    for (Chainstate* chainstate : chainstates) {
+        BlockValidationState state;
+        if (!chainstate->ActivateBestChain(state, nullptr)) {
+            LOCK(GetMutex());
+            return util::Error{Untranslated(strprintf("%s Failed to connect best block (%s)", chainstate->ToString(), state.ToString()))};
+        }
+    }
+    return {};
+}
diff --git a/depend/bitcoin/src/validation.h b/depend/bitcoin/src/validation.h
index cd448f3c..e4b1e555 100644
--- a/depend/bitcoin/src/validation.h
+++ b/depend/bitcoin/src/validation.h
@@ -58,6 +58,9 @@ class DisconnectedBlockTransactions;
 struct PrecomputedTransactionData;
 struct LockPoints;
 struct AssumeutxoData;
+namespace kernel {
+struct ChainstateRole;
+} // namespace kernel
 namespace node {
 class SnapshotMetadata;
 } // namespace node
@@ -514,6 +517,16 @@ constexpr int64_t LargeCoinsCacheThreshold(int64_t total_space) noexcept
                     total_space - MAX_BLOCK_COINSDB_USAGE_BYTES);
 }
 
+//! Chainstate assumeutxo validity.
+enum class Assumeutxo {
+    //! Every block in the chain has been validated.
+    VALIDATED,
+    //! Blocks after an assumeutxo snapshot have been validated but the snapshot itself has not been validated.
+    UNVALIDATED,
+    //! The assumeutxo snapshot failed validation.
+    INVALID,
+};
+
 /**
  * Chainstate stores and provides an API to update our local knowledge of the
  * current best chain.
@@ -545,22 +558,12 @@ class Chainstate
     //! Manages the UTXO set, which is a reflection of the contents of `m_chain`.
     std::unique_ptr<CoinsViews> m_coins_views;
 
-    //! This toggle exists for use when doing background validation for UTXO
-    //! snapshots.
-    //!
-    //! In the expected case, it is set once the background validation chain reaches the
-    //! same height as the base of the snapshot and its UTXO set is found to hash to
-    //! the expected assumeutxo value. It signals that we should no longer connect
-    //! blocks to the background chainstate. When set on the background validation
-    //! chainstate, it signifies that we have fully validated the snapshot chainstate.
-    //!
-    //! In the unlikely case that the snapshot chainstate is found to be invalid, this
-    //! is set to true on the snapshot chainstate.
-    bool m_disabled GUARDED_BY(::cs_main) {false};
-
     //! Cached result of LookupBlockIndex(*m_from_snapshot_blockhash)
     mutable const CBlockIndex* m_cached_snapshot_base GUARDED_BY(::cs_main){nullptr};
 
+    //! Cached result of LookupBlockIndex(*m_target_blockhash)
+    mutable const CBlockIndex* m_cached_target_block GUARDED_BY(::cs_main){nullptr};
+
     std::optional<const char*> m_last_script_check_reason_logged GUARDED_BY(::cs_main){};
 
 public:
@@ -579,11 +582,14 @@ class Chainstate
         ChainstateManager& chainman,
         std::optional<uint256> from_snapshot_blockhash = std::nullopt);
 
+    //! Return path to chainstate leveldb directory.
+    fs::path StoragePath() const;
+
     //! Return the current role of the chainstate. See `ChainstateManager`
     //! documentation for a description of the different types of chainstates.
     //!
     //! @sa ChainstateRole
-    ChainstateRole GetRole() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    kernel::ChainstateRole GetRole() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     /**
      * Initialize the CoinsViews UTXO set database management data structures. The in-memory
@@ -594,8 +600,7 @@ class Chainstate
     void InitCoinsDB(
         size_t cache_size_bytes,
         bool in_memory,
-        bool should_wipe,
-        fs::path leveldb_name = "chainstate");
+        bool should_wipe);
 
     //! Initialize the in-memory coins cache (to be done after the health of the on-disk database
     //! is verified).
@@ -613,6 +618,11 @@ class Chainstate
     //! @see CChain, CBlockIndex.
     CChain m_chain;
 
+    //! Assumeutxo state indicating whether all blocks in the chain were
+    //! validated, or if the chainstate is based on an assumeutxo snapshot and
+    //! the snapshot has not been validated.
+    Assumeutxo m_assumeutxo GUARDED_BY(::cs_main);
+
     /**
      * The blockhash which is the base of the snapshot this chainstate was created from.
      *
@@ -620,6 +630,16 @@ class Chainstate
      */
     const std::optional<uint256> m_from_snapshot_blockhash;
 
+    //! Target block for this chainstate. If this is not set, chainstate will
+    //! target the most-work, valid block. If this is set, ChainstateManager
+    //! considers this a "historical" chainstate since it will only contain old
+    //! blocks up to the target block, not newer blocks.
+    std::optional<uint256> m_target_blockhash GUARDED_BY(::cs_main);
+
+    //! Hash of the UTXO set at the target block, computed when the chainstate
+    //! reaches the target block, and null before then.
+    std::optional<AssumeutxoHash> m_target_utxohash GUARDED_BY(::cs_main);
+
     /**
      * The base of the snapshot this chainstate was created from.
      *
@@ -627,6 +647,26 @@ class Chainstate
      */
     const CBlockIndex* SnapshotBase() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
+    //! Return target block which chainstate tip is expected to reach, if this
+    //! is a historic chainstate being used to validate a snapshot, or null if
+    //! chainstate targets the most-work block.
+    const CBlockIndex* TargetBlock() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    //! Set target block for this chainstate. If null, chainstate will target
+    //! the most-work valid block. If non-null chainstate will be a historic
+    //! chainstate and target the specified block.
+    void SetTargetBlock(CBlockIndex* block) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    //! Set target block for this chainstate using just a block hash. Useful
+    //! when the block database has not been loaded yet.
+    void SetTargetBlockHash(uint256 block_hash) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+
+    //! Return true if chainstate reached target block.
+    bool ReachedTarget() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
+    {
+        const CBlockIndex* target_block{TargetBlock()};
+        assert(!target_block || target_block->GetAncestor(m_chain.Height()) == m_chain.Tip());
+        return target_block && target_block == m_chain.Tip();
+    }
+
     /**
      * The set of all CBlockIndex entries that have as much work as our current
      * tip or more, and transaction data needed to be validated (with
@@ -668,9 +708,6 @@ class Chainstate
     //! Destructs all objects related to accessing the UTXO set.
     void ResetCoinsViews() { m_coins_views.reset(); }
 
-    //! Does this chainstate have a UTXO set attached?
-    bool HasCoinsViews() const { return (bool)m_coins_views; }
-
     //! The cache size of the on-disk coins view.
     size_t m_coinsdb_cache_size_bytes{0};
 
@@ -719,9 +756,9 @@ class Chainstate
      * validationinterface callback.
      *
      * Note that if this is called while a snapshot chainstate is active, and if
-     * it is called on a background chainstate whose tip has reached the base block
-     * of the snapshot, its execution will take *MINUTES* while it hashes the
-     * background UTXO set to verify the assumeutxo value the snapshot was activated
+     * it is called on a validated chainstate whose tip has reached the base
+     * block of the snapshot, its execution will take *MINUTES* while it hashes
+     * the UTXO set to verify the assumeutxo value the snapshot was activated
      * with. `cs_main` will be held during this time.
      *
      * @returns true unless a system error occurred
@@ -798,6 +835,11 @@ class Chainstate
         return m_mempool ? &m_mempool->cs : nullptr;
     }
 
+    //! Return the [start, end] (inclusive) of block heights we can prune.
+    //!
+    //! start > end is possible, meaning no blocks can be pruned.
+    std::pair<int, int> GetPruneRange(int last_height_can_prune) const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+
 protected:
     bool ActivateBestChainStep(BlockValidationState& state, CBlockIndex* pindexMostWork, const std::shared_ptr<const CBlock>& pblock, bool& fInvalidFound, ConnectTrace& connectTrace) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool->cs);
     bool ConnectTip(
@@ -855,84 +897,38 @@ enum class SnapshotCompletionResult {
     // base block.
     MISSING_CHAINPARAMS,
 
-    // Failed to generate UTXO statistics (to check UTXO set hash) for the background
-    // chainstate.
+    // Failed to generate UTXO statistics (to check UTXO set hash) for the
+    // validated chainstate.
     STATS_FAILED,
 
-    // The UTXO set hash of the background validation chainstate does not match
-    // the one expected by assumeutxo chainparams.
+    // The UTXO set hash of the validated chainstate does not match the one
+    // expected by assumeutxo chainparams.
     HASH_MISMATCH,
-
-    // The blockhash of the current tip of the background validation chainstate does
-    // not match the one expected by the snapshot chainstate.
-    BASE_BLOCKHASH_MISMATCH,
 };
 
 /**
- * Provides an interface for creating and interacting with one or two
- * chainstates: an IBD chainstate generated by downloading blocks, and
- * an optional snapshot chainstate loaded from a UTXO snapshot. Managed
- * chainstates can be maintained at different heights simultaneously.
- *
- * This class provides abstractions that allow the retrieval of the current
- * most-work chainstate ("Active") as well as chainstates which may be in
- * background use to validate UTXO snapshots.
- *
- * Definitions:
- *
- * *IBD chainstate*: a chainstate whose current state has been "fully"
- *   validated by the initial block download process.
- *
- * *Snapshot chainstate*: a chainstate populated by loading in an
- *    assumeutxo UTXO snapshot.
+ * Interface for managing multiple \ref Chainstate objects, where each
+ * chainstate is associated with chainstate* subdirectory in the data directory
+ * and contains a database of UTXOs existing at a different point in history.
+ * (See \ref Chainstate class for more information.)
  *
- * *Active chainstate*: the chainstate containing the current most-work
- *    chain. Consulted by most parts of the system (net_processing,
- *    wallet) as a reflection of the current chain and UTXO set.
- *    This may either be an IBD chainstate or a snapshot chainstate.
+ * Normally there is exactly one Chainstate, which contains the UTXO set of
+ * chain tip if syncing is completed, or the UTXO set the most recent validated
+ * block if the initial sync is still in progress.
  *
- * *Background IBD chainstate*: an IBD chainstate for which the
- *    IBD process is happening in the background while use of the
- *    active (snapshot) chainstate allows the rest of the system to function.
+ * However, if an assumeutxo snapshot is loaded before syncing is completed,
+ * there will be two chainstates. The original fully validated chainstate will
+ * continue to exist and download new blocks in the background. But the new
+ * snapshot which is loaded will become a second chainstate. The second
+ * chainstate will be used as the chain tip for the wallet and RPCs even though
+ * it is only assumed to be valid. When the initial chainstate catches up to the
+ * snapshot height and confirms that the assumeutxo snapshot is actually valid,
+ * the second chainstate will be marked validated and become the only chainstate
+ * again.
  */
 class ChainstateManager
 {
 private:
-    //! The chainstate used under normal operation (i.e. "regular" IBD) or, if
-    //! a snapshot is in use, for background validation.
-    //!
-    //! Its contents (including on-disk data) will be deleted *upon shutdown*
-    //! after background validation of the snapshot has completed. We do not
-    //! free the chainstate contents immediately after it finishes validation
-    //! to cautiously avoid a case where some other part of the system is still
-    //! using this pointer (e.g. net_processing).
-    //!
-    //! Once this pointer is set to a corresponding chainstate, it will not
-    //! be reset until init.cpp:Shutdown().
-    //!
-    //! It is important for the pointer to not be deleted until shutdown,
-    //! because cs_main is not always held when the pointer is accessed, for
-    //! example when calling ActivateBestChain, so there's no way you could
-    //! prevent code from using the pointer while deleting it.
-    std::unique_ptr<Chainstate> m_ibd_chainstate GUARDED_BY(::cs_main);
-
-    //! A chainstate initialized on the basis of a UTXO snapshot. If this is
-    //! non-null, it is always our active chainstate.
-    //!
-    //! Once this pointer is set to a corresponding chainstate, it will not
-    //! be reset until init.cpp:Shutdown().
-    //!
-    //! It is important for the pointer to not be deleted until shutdown,
-    //! because cs_main is not always held when the pointer is accessed, for
-    //! example when calling ActivateBestChain, so there's no way you could
-    //! prevent code from using the pointer while deleting it.
-    std::unique_ptr<Chainstate> m_snapshot_chainstate GUARDED_BY(::cs_main);
-
-    //! Points to either the ibd or snapshot chainstate; indicates our
-    //! most-work chain.
-    Chainstate* m_active_chainstate GUARDED_BY(::cs_main) {nullptr};
-
-    CBlockIndex* m_best_invalid GUARDED_BY(::cs_main){nullptr};
 
     /** The last header for which a headerTip notification was issued. */
     CBlockIndex* m_last_notified_header GUARDED_BY(GetMutex()){nullptr};
@@ -968,15 +964,6 @@ class ChainstateManager
     /** Most recent headers presync progress update, for rate-limiting. */
     MockableSteadyClock::time_point m_last_presync_update GUARDED_BY(GetMutex()){};
 
-    //! Return true if a chainstate is considered usable.
-    //!
-    //! This is false when a background validation chainstate has completed its
-    //! validation of an assumed-valid chainstate, or when a snapshot
-    //! chainstate has been found to be invalid.
-    bool IsUsable(const Chainstate* const cs) const EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
-        return cs && !cs->m_disabled;
-    }
-
     //! A queue for script verifications that have to be performed by worker threads.
     CCheckQueue<CScriptCheck> m_script_check_queue;
 
@@ -995,6 +982,9 @@ class ChainstateManager
     SteadyClock::duration GUARDED_BY(::cs_main) time_chainstate{};
     SteadyClock::duration GUARDED_BY(::cs_main) time_post_connect{};
 
+protected:
+    CBlockIndex* m_best_invalid GUARDED_BY(::cs_main){nullptr};
+
 public:
     using Options = kernel::ChainstateManagerOpts;
 
@@ -1091,9 +1081,6 @@ class ChainstateManager
     //                                  constructor
     Chainstate& InitializeChainstate(CTxMemPool* mempool) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
-    //! Get all chainstates currently being used.
-    std::vector<Chainstate*> GetAll();
-
     //! Construct and activate a Chainstate on the basis of UTXO snapshot data.
     //!
     //! Steps:
@@ -1104,38 +1091,71 @@ class ChainstateManager
     //!   per assumeutxo chain parameters.
     //! - Wait for our headers chain to include the base block of the snapshot.
     //! - "Fast forward" the tip of the new chainstate to the base of the snapshot.
-    //! - Move the new chainstate to `m_snapshot_chainstate` and make it our
-    //!   ChainstateActive().
+    //! - Construct the new Chainstate and add it to m_chainstates.
     [[nodiscard]] util::Result<CBlockIndex*> ActivateSnapshot(
         AutoFile& coins_file, const node::SnapshotMetadata& metadata, bool in_memory);
 
-    //! Once the background validation chainstate has reached the height which
-    //! is the base of the UTXO snapshot in use, compare its coins to ensure
-    //! they match those expected by the snapshot.
-    //!
-    //! If the coins match (expected), then mark the validation chainstate for
-    //! deletion and continue using the snapshot chainstate as active.
-    //! Otherwise, revert to using the ibd chainstate and shutdown.
-    SnapshotCompletionResult MaybeCompleteSnapshotValidation() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    //! Try to validate an assumeutxo snapshot by using a validated historical
+    //! chainstate targeted at the snapshot block. When the target block is
+    //! reached, the UTXO hash is computed and saved to
+    //! `validated_cs.m_target_utxohash`, and `unvalidated_cs.m_assumeutxo` will
+    //! be updated from UNVALIDATED to either VALIDATED or INVALID depending on
+    //! whether the hash matches. The INVALID case should not happen in practice
+    //! because the software should refuse to load unrecognized snapshots, but
+    //! if it does happen, it is a fatal error.
+    SnapshotCompletionResult MaybeValidateSnapshot(Chainstate& validated_cs, Chainstate& unvalidated_cs) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+
+    //! Return current chainstate targeting the most-work, network tip.
+    Chainstate& CurrentChainstate() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
+    {
+        for (auto& cs : m_chainstates) {
+            if (cs && cs->m_assumeutxo != Assumeutxo::INVALID && !cs->m_target_blockhash) return *cs;
+        }
+        abort();
+    }
+
+    //! Return historical chainstate targeting a specific block, if any.
+    Chainstate* HistoricalChainstate() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
+    {
+        for (auto& cs : m_chainstates) {
+            if (cs && cs->m_assumeutxo != Assumeutxo::INVALID && cs->m_target_blockhash && !cs->m_target_utxohash) return cs.get();
+        }
+        return nullptr;
+    }
 
-    //! Returns nullptr if no snapshot has been loaded.
-    const CBlockIndex* GetSnapshotBaseBlock() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    //! Return fully validated chainstate that should be used for indexing, to
+    //! support indexes that need to index blocks in order and can't start from
+    //! the snapshot block.
+    Chainstate& ValidatedChainstate() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
+    {
+        for (auto* cs : {&CurrentChainstate(), HistoricalChainstate()}) {
+            if (cs && cs->m_assumeutxo == Assumeutxo::VALIDATED) return *cs;
+        }
+        abort();
+    }
+
+    //! Remove a chainstate.
+    std::unique_ptr<Chainstate> RemoveChainstate(Chainstate& chainstate) EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
+    {
+        auto it{std::find_if(m_chainstates.begin(), m_chainstates.end(), [&](auto& cs) { return cs.get() == &chainstate; })};
+        if (it != m_chainstates.end()) {
+            auto ret{std::move(*it)};
+            m_chainstates.erase(it);
+            return ret;
+        }
+        return nullptr;
+    }
 
-    //! The most-work chain.
+    //! Alternatives to CurrentChainstate() used by older code to query latest
+    //! chainstate information without locking cs_main. Newer code should avoid
+    //! querying ChainstateManager and use Chainstate objects directly, or
+    //! should use CurrentChainstate() instead.
+    //! @{
     Chainstate& ActiveChainstate() const;
     CChain& ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex()) { return ActiveChainstate().m_chain; }
     int ActiveHeight() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex()) { return ActiveChain().Height(); }
     CBlockIndex* ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex()) { return ActiveChain().Tip(); }
-
-    //! The state of a background sync (for net processing)
-    bool BackgroundSyncInProgress() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex()) {
-        return IsUsable(m_snapshot_chainstate.get()) && IsUsable(m_ibd_chainstate.get());
-    }
-
-    //! The tip of the background sync chain
-    const CBlockIndex* GetBackgroundSyncTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex()) {
-        return BackgroundSyncInProgress() ? m_ibd_chainstate->m_chain.Tip() : nullptr;
-    }
+    //! @}
 
     node::BlockMap& BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
     {
@@ -1148,18 +1168,6 @@ class ChainstateManager
      */
     mutable VersionBitsCache m_versionbitscache;
 
-    //! @returns true if a snapshot-based chainstate is in use. Also implies
-    //!          that a background validation chainstate is also in use.
-    bool IsSnapshotActive() const;
-
-    std::optional<uint256> SnapshotBlockhash() const;
-
-    //! Is there a snapshot in use and has it been fully validated?
-    bool IsSnapshotValidated() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
-    {
-        return m_snapshot_chainstate && m_ibd_chainstate && m_ibd_chainstate->m_disabled;
-    }
-
     /** Check whether we are doing an initial block download (synchronizing from disk or network) */
     bool IsInitialBlockDownload() const;
 
@@ -1293,18 +1301,18 @@ class ChainstateManager
     void ReportHeadersPresync(const arith_uint256& work, int64_t height, int64_t timestamp);
 
     //! When starting up, search the datadir for a chainstate based on a UTXO
-    //! snapshot that is in the process of being validated.
-    bool DetectSnapshotChainstate() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    //! snapshot that is in the process of being validated and load it if found.
+    //! Return pointer to the Chainstate if it is loaded.
+    Chainstate* LoadAssumeutxoChainstate() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+
+    //! Add new chainstate.
+    Chainstate& AddChainstate(std::unique_ptr<Chainstate> chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     void ResetChainstates() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
-    //! Remove the snapshot-based chainstate and all on-disk artifacts.
+    //! Remove the chainstate and all on-disk artifacts.
     //! Used when reindex{-chainstate} is called during snapshot use.
-    [[nodiscard]] bool DeleteSnapshotChainstate() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
-
-    //! Switch the active chainstate to one based on a UTXO snapshot that was loaded
-    //! previously.
-    Chainstate& ActivateExistingSnapshot(uint256 base_blockhash) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    [[nodiscard]] bool DeleteChainstate(Chainstate& chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     //! If we have validated a snapshot chain during this runtime, copy its
     //! chainstate directory over to the main `chainstate` location, completing
@@ -1315,27 +1323,13 @@ class ChainstateManager
     //! directories are moved or deleted.
     //!
     //! @sa node/chainstate:LoadChainstate()
-    bool ValidatedSnapshotCleanup() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
-
-    //! @returns the chainstate that indexes should consult when ensuring that an
-    //!   index is synced with a chain where we can expect block index entries to have
-    //!   BLOCK_HAVE_DATA beneath the tip.
-    //!
-    //!   In other words, give us the chainstate for which we can reasonably expect
-    //!   that all blocks beneath the tip have been indexed. In practice this means
-    //!   when using an assumed-valid chainstate based upon a snapshot, return only the
-    //!   fully validated chain.
-    Chainstate& GetChainstateForIndexing() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    bool ValidatedSnapshotCleanup(Chainstate& validated_cs, Chainstate& unvalidated_cs) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
-    //! Return the [start, end] (inclusive) of block heights we can prune.
-    //!
-    //! start > end is possible, meaning no blocks can be pruned.
-    std::pair<int, int> GetPruneRange(
-        const Chainstate& chainstate, int last_height_can_prune) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    //! Get range of historical blocks to download.
+    std::optional<std::pair<const CBlockIndex*, const CBlockIndex*>> GetHistoricalBlockRange() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
-    //! Return the height of the base block of the snapshot in use, if one exists, else
-    //! nullopt.
-    std::optional<int> GetSnapshotBaseHeight() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    //! Call ActivateBestChain() on every chainstate.
+    util::Result<void> ActivateBestChains() LOCKS_EXCLUDED(::cs_main);
 
     //! If, due to invalidation / reconsideration of blocks, the previous
     //! best header is no longer valid / guaranteed to be the most-work
@@ -1345,6 +1339,15 @@ class ChainstateManager
     CCheckQueue<CScriptCheck>& GetCheckQueue() { return m_script_check_queue; }
 
     ~ChainstateManager();
+
+    //! List of chainstates. Note: in general, it is not safe to delete
+    //! Chainstate objects once they are added to this list because there is no
+    //! mutex that can be locked to prevent Chainstate pointers from being used
+    //! while they are deleted. (cs_main doesn't work because it is too narrow
+    //! and is released in the middle of Chainstate::ActivateBestChain to let
+    //! notifications be processed. m_chainstate_mutex doesn't work because it
+    //! is not locked at other times when the chainstate is in use.)
+    std::vector<std::unique_ptr<Chainstate>> m_chainstates GUARDED_BY(::cs_main);
 };
 
 /** Deployment* info via ChainstateManager */
diff --git a/depend/bitcoin/src/validationinterface.cpp b/depend/bitcoin/src/validationinterface.cpp
index 313f730e..586d29f4 100644
--- a/depend/bitcoin/src/validationinterface.cpp
+++ b/depend/bitcoin/src/validationinterface.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
@@ -7,9 +7,9 @@
 
 #include <chain.h>
 #include <consensus/validation.h>
-#include <kernel/chain.h>
 #include <kernel/mempool_entry.h>
 #include <kernel/mempool_removal_reason.h>
+#include <kernel/types.h>
 #include <logging.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
@@ -21,6 +21,8 @@
 #include <unordered_map>
 #include <utility>
 
+using kernel::ChainstateRole;
+
 /**
  * ValidationSignalsImpl manages a list of shared_ptr<CValidationInterface> callbacks.
  *
@@ -209,7 +211,8 @@ void ValidationSignals::TransactionRemovedFromMempool(const CTransactionRef& tx,
                           RemovalReasonToString(reason));
 }
 
-void ValidationSignals::BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock> &pblock, const CBlockIndex *pindex) {
+void ValidationSignals::BlockConnected(const ChainstateRole& role, const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
+{
     auto event = [role, pblock, pindex, this] {
         m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.BlockConnected(role, pblock, pindex); });
     };
@@ -238,7 +241,8 @@ void ValidationSignals::BlockDisconnected(const std::shared_ptr<const CBlock>& p
                           pindex->nHeight);
 }
 
-void ValidationSignals::ChainStateFlushed(ChainstateRole role, const CBlockLocator &locator) {
+void ValidationSignals::ChainStateFlushed(const ChainstateRole& role, const CBlockLocator& locator)
+{
     auto event = [role, locator, this] {
         m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.ChainStateFlushed(role, locator); });
     };
diff --git a/depend/bitcoin/src/validationinterface.h b/depend/bitcoin/src/validationinterface.h
index e0a88ad0..4777e8dc 100644
--- a/depend/bitcoin/src/validationinterface.h
+++ b/depend/bitcoin/src/validationinterface.h
@@ -6,7 +6,6 @@
 #ifndef BITCOIN_VALIDATIONINTERFACE_H
 #define BITCOIN_VALIDATIONINTERFACE_H
 
-#include <kernel/chain.h>
 #include <kernel/cs_main.h>
 #include <primitives/transaction.h>
 #include <sync.h>
@@ -17,6 +16,9 @@
 #include <memory>
 #include <vector>
 
+namespace kernel {
+struct ChainstateRole;
+} // namespace kernel
 namespace util {
 class TaskRunnerInterface;
 } // namespace util
@@ -118,7 +120,7 @@ class CValidationInterface {
      *
      * Called on a background thread.
      */
-    virtual void BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock> &block, const CBlockIndex *pindex) {}
+    virtual void BlockConnected(const kernel::ChainstateRole& role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) {}
     /**
      * Notifies listeners of a block being disconnected
      * Provides the block that was disconnected.
@@ -143,7 +145,7 @@ class CValidationInterface {
      *
      * Called on a background thread.
      */
-    virtual void ChainStateFlushed(ChainstateRole role, const CBlockLocator &locator) {}
+    virtual void ChainStateFlushed(const kernel::ChainstateRole& role, const CBlockLocator& locator) {}
     /**
      * Notifies listeners of a block validation result.
      * If the provided BlockValidationState IsValid, the provided block
@@ -221,9 +223,9 @@ class ValidationSignals {
     void TransactionAddedToMempool(const NewMempoolTransactionInfo&, uint64_t mempool_sequence);
     void TransactionRemovedFromMempool(const CTransactionRef&, MemPoolRemovalReason, uint64_t mempool_sequence);
     void MempoolTransactionsRemovedForBlock(const std::vector<RemovedMempoolTransactionInfo>&, unsigned int nBlockHeight);
-    void BlockConnected(ChainstateRole, const std::shared_ptr<const CBlock> &, const CBlockIndex *pindex);
+    void BlockConnected(const kernel::ChainstateRole&, const std::shared_ptr<const CBlock>&, const CBlockIndex* pindex);
     void BlockDisconnected(const std::shared_ptr<const CBlock> &, const CBlockIndex* pindex);
-    void ChainStateFlushed(ChainstateRole, const CBlockLocator &);
+    void ChainStateFlushed(const kernel::ChainstateRole&, const CBlockLocator&);
     void BlockChecked(const std::shared_ptr<const CBlock>&, const BlockValidationState&);
     void NewPoWValidBlock(const CBlockIndex *, const std::shared_ptr<const CBlock>&);
 };
diff --git a/depend/bitcoin/src/versionbits.cpp b/depend/bitcoin/src/versionbits.cpp
index 32edcd7d..e282d21d 100644
--- a/depend/bitcoin/src/versionbits.cpp
+++ b/depend/bitcoin/src/versionbits.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
@@ -48,7 +48,7 @@ ThresholdState AbstractThresholdConditionChecker::GetStateFor(const CBlockIndex*
 
     // Walk backwards in steps of nPeriod to find a pindexPrev whose information is known
     std::vector<const CBlockIndex*> vToCompute;
-    while (cache.count(pindexPrev) == 0) {
+    while (!cache.contains(pindexPrev)) {
         if (pindexPrev == nullptr) {
             // The genesis block is by definition defined.
             cache[pindexPrev] = ThresholdState::DEFINED;
@@ -64,7 +64,7 @@ ThresholdState AbstractThresholdConditionChecker::GetStateFor(const CBlockIndex*
     }
 
     // At this point, cache[pindexPrev] is known
-    assert(cache.count(pindexPrev));
+    assert(cache.contains(pindexPrev));
     ThresholdState state = cache[pindexPrev];
 
     // Now walk forward and compute the state of descendants of pindexPrev
diff --git a/depend/bitcoin/src/versionbits.h b/depend/bitcoin/src/versionbits.h
index abd671b4..59b0cbee 100644
--- a/depend/bitcoin/src/versionbits.h
+++ b/depend/bitcoin/src/versionbits.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/versionbits_impl.h b/depend/bitcoin/src/versionbits_impl.h
index 84f19ebc..bd59bf73 100644
--- a/depend/bitcoin/src/versionbits_impl.h
+++ b/depend/bitcoin/src/versionbits_impl.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/wallet/coincontrol.cpp b/depend/bitcoin/src/wallet/coincontrol.cpp
index 873c5ab3..0717e906 100644
--- a/depend/bitcoin/src/wallet/coincontrol.cpp
+++ b/depend/bitcoin/src/wallet/coincontrol.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 The Bitcoin Core developers
+// 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.
 
@@ -19,7 +19,7 @@ bool CCoinControl::HasSelected() const
 
 bool CCoinControl::IsSelected(const COutPoint& outpoint) const
 {
-    return m_selected.count(outpoint) > 0;
+    return m_selected.contains(outpoint);
 }
 
 bool CCoinControl::IsExternalSelected(const COutPoint& outpoint) const
diff --git a/depend/bitcoin/src/wallet/coincontrol.h b/depend/bitcoin/src/wallet/coincontrol.h
index 98284ce3..ead3307a 100644
--- a/depend/bitcoin/src/wallet/coincontrol.h
+++ b/depend/bitcoin/src/wallet/coincontrol.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/wallet/coinselection.cpp b/depend/bitcoin/src/wallet/coinselection.cpp
index 1302ec99..192e4936 100644
--- a/depend/bitcoin/src/wallet/coinselection.cpp
+++ b/depend/bitcoin/src/wallet/coinselection.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/wallet/coinselection.h b/depend/bitcoin/src/wallet/coinselection.h
index ca9f2698..79fee40d 100644
--- a/depend/bitcoin/src/wallet/coinselection.h
+++ b/depend/bitcoin/src/wallet/coinselection.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/wallet/context.cpp b/depend/bitcoin/src/wallet/context.cpp
index 39c3b54b..402d54aa 100644
--- a/depend/bitcoin/src/wallet/context.cpp
+++ b/depend/bitcoin/src/wallet/context.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/wallet/context.h b/depend/bitcoin/src/wallet/context.h
index 58b9924f..65493a09 100644
--- a/depend/bitcoin/src/wallet/context.h
+++ b/depend/bitcoin/src/wallet/context.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/wallet/crypter.cpp b/depend/bitcoin/src/wallet/crypter.cpp
index ffb1d29e..148a0ad2 100644
--- a/depend/bitcoin/src/wallet/crypter.cpp
+++ b/depend/bitcoin/src/wallet/crypter.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/wallet/crypter.h b/depend/bitcoin/src/wallet/crypter.h
index fa15f02c..0737e561 100644
--- a/depend/bitcoin/src/wallet/crypter.h
+++ b/depend/bitcoin/src/wallet/crypter.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/wallet/dump.h b/depend/bitcoin/src/wallet/dump.h
index 9b44af92..5dfed35f 100644
--- a/depend/bitcoin/src/wallet/dump.h
+++ b/depend/bitcoin/src/wallet/dump.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/wallet/external_signer_scriptpubkeyman.cpp b/depend/bitcoin/src/wallet/external_signer_scriptpubkeyman.cpp
index c2b1b604..f6668625 100644
--- a/depend/bitcoin/src/wallet/external_signer_scriptpubkeyman.cpp
+++ b/depend/bitcoin/src/wallet/external_signer_scriptpubkeyman.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2022 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/wallet/external_signer_scriptpubkeyman.h b/depend/bitcoin/src/wallet/external_signer_scriptpubkeyman.h
index 27c0258e..0ccc243c 100644
--- a/depend/bitcoin/src/wallet/external_signer_scriptpubkeyman.h
+++ b/depend/bitcoin/src/wallet/external_signer_scriptpubkeyman.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 The Bitcoin Core developers
+// Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/src/wallet/feebumper.cpp b/depend/bitcoin/src/wallet/feebumper.cpp
index fc0a68de..e63b9ae1 100644
--- a/depend/bitcoin/src/wallet/feebumper.cpp
+++ b/depend/bitcoin/src/wallet/feebumper.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
@@ -39,7 +39,7 @@ static feebumper::Result PreconditionChecks(const CWallet& wallet, const CWallet
         return feebumper::Result::WALLET_ERROR;
     }
 
-    if (wtx.mapValue.count("replaced_by_txid")) {
+    if (wtx.mapValue.contains("replaced_by_txid")) {
         errors.push_back(Untranslated(strprintf("Cannot bump transaction %s which was already bumped by transaction %s", wtx.GetHash().ToString(), wtx.mapValue.at("replaced_by_txid"))));
         return feebumper::Result::WALLET_ERROR;
     }
diff --git a/depend/bitcoin/src/wallet/feebumper.h b/depend/bitcoin/src/wallet/feebumper.h
index 7b56cb7f..4e0befe4 100644
--- a/depend/bitcoin/src/wallet/feebumper.h
+++ b/depend/bitcoin/src/wallet/feebumper.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2021 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/wallet/init.cpp b/depend/bitcoin/src/wallet/init.cpp
index 79e2c968..e2d47fb3 100644
--- a/depend/bitcoin/src/wallet/init.cpp
+++ b/depend/bitcoin/src/wallet/init.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/wallet/interfaces.cpp b/depend/bitcoin/src/wallet/interfaces.cpp
index 2cda1ba2..535a4af5 100644
--- a/depend/bitcoin/src/wallet/interfaces.cpp
+++ b/depend/bitcoin/src/wallet/interfaces.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
@@ -597,16 +597,15 @@ class WalletLoaderImpl : public WalletLoader
             return util::Error{error};
         }
     }
-    util::Result<std::unique_ptr<Wallet>> restoreWallet(const fs::path& backup_file, const std::string& wallet_name, std::vector<bilingual_str>& warnings) override
+    util::Result<std::unique_ptr<Wallet>> restoreWallet(const fs::path& backup_file, const std::string& wallet_name, std::vector<bilingual_str>& warnings, bool load_after_restore) override
     {
         DatabaseStatus status;
         bilingual_str error;
-        std::unique_ptr<Wallet> wallet{MakeWallet(m_context, RestoreWallet(m_context, backup_file, wallet_name, /*load_on_start=*/true, status, error, warnings))};
-        if (wallet) {
-            return wallet;
-        } else {
+        std::unique_ptr<Wallet> wallet{MakeWallet(m_context, RestoreWallet(m_context, backup_file, wallet_name, /*load_on_start=*/true, status, error, warnings, load_after_restore))};
+        if (!error.empty()) {
             return util::Error{error};
         }
+        return wallet;
     }
     util::Result<WalletMigrationResult> migrateWallet(const std::string& name, const SecureString& passphrase) override
     {
diff --git a/depend/bitcoin/src/wallet/load.cpp b/depend/bitcoin/src/wallet/load.cpp
index f3620644..84ee9cf1 100644
--- a/depend/bitcoin/src/wallet/load.cpp
+++ b/depend/bitcoin/src/wallet/load.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/wallet/load.h b/depend/bitcoin/src/wallet/load.h
index 20859d5c..329c5af7 100644
--- a/depend/bitcoin/src/wallet/load.h
+++ b/depend/bitcoin/src/wallet/load.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/wallet/migrate.cpp b/depend/bitcoin/src/wallet/migrate.cpp
index 798d2356..1f6e4e85 100644
--- a/depend/bitcoin/src/wallet/migrate.cpp
+++ b/depend/bitcoin/src/wallet/migrate.cpp
@@ -747,7 +747,7 @@ bool BerkeleyROBatch::ReadKey(DataStream&& key, DataStream& value)
 bool BerkeleyROBatch::HasKey(DataStream&& key)
 {
     SerializeData key_data{key.begin(), key.end()};
-    return m_database.m_records.count(key_data) > 0;
+    return m_database.m_records.contains(key_data);
 }
 
 BerkeleyROCursor::BerkeleyROCursor(const BerkeleyRODatabase& database, std::span<const std::byte> prefix)
diff --git a/depend/bitcoin/src/wallet/receive.cpp b/depend/bitcoin/src/wallet/receive.cpp
index 13a25b36..7176dff5 100644
--- a/depend/bitcoin/src/wallet/receive.cpp
+++ b/depend/bitcoin/src/wallet/receive.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -227,7 +227,7 @@ bool CachedTxIsTrusted(const CWallet& wallet, const CWalletTx& wtx, std::set<Txi
         // Check that this specific input being spent is trusted
         if (!wallet.IsMine(parentOut)) return false;
         // If we've already trusted this parent, continue
-        if (trusted_parents.count(parent->GetHash())) continue;
+        if (trusted_parents.contains(parent->GetHash())) continue;
         // Recurse to check that the parent is also trusted
         if (!CachedTxIsTrusted(wallet, *parent, trusted_parents)) return false;
         trusted_parents.insert(parent->GetHash());
diff --git a/depend/bitcoin/src/wallet/receive.h b/depend/bitcoin/src/wallet/receive.h
index f6c55a45..2e550494 100644
--- a/depend/bitcoin/src/wallet/receive.h
+++ b/depend/bitcoin/src/wallet/receive.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/wallet/rpc/backup.cpp b/depend/bitcoin/src/wallet/rpc/backup.cpp
index 5cb40304..c2df2f61 100644
--- a/depend/bitcoin/src/wallet/rpc/backup.cpp
+++ b/depend/bitcoin/src/wallet/rpc/backup.cpp
@@ -526,7 +526,7 @@ RPCHelpMan listdescriptors()
         wallet_descriptors.push_back({
             descriptor,
             wallet_descriptor.creation_time,
-            active_spk_mans.count(desc_spk_man) != 0,
+            active_spk_mans.contains(desc_spk_man),
             wallet->IsInternalScriptPubKeyMan(desc_spk_man),
             is_range ? std::optional(std::make_pair(wallet_descriptor.range_start, wallet_descriptor.range_end)) : std::nullopt,
             wallet_descriptor.next_index
diff --git a/depend/bitcoin/src/wallet/rpc/coins.cpp b/depend/bitcoin/src/wallet/rpc/coins.cpp
index 7aeb60f7..bb7fc2e5 100644
--- a/depend/bitcoin/src/wallet/rpc/coins.cpp
+++ b/depend/bitcoin/src/wallet/rpc/coins.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
@@ -67,7 +67,7 @@ static CAmount GetReceived(const CWallet& wallet, const UniValue& params, bool b
         }
 
         for (const CTxOut& txout : wtx.tx->vout) {
-            if (output_scripts.count(txout.scriptPubKey) > 0) {
+            if (output_scripts.contains(txout.scriptPubKey)) {
                 amount += txout.nValue;
             }
         }
@@ -612,7 +612,7 @@ RPCHelpMan listunspent()
         bool fValidAddress = ExtractDestination(scriptPubKey, address);
         bool reused = avoid_reuse && pwallet->IsSpentKey(scriptPubKey);
 
-        if (destinations.size() && (!fValidAddress || !destinations.count(address)))
+        if (destinations.size() && (!fValidAddress || !destinations.contains(address)))
             continue;
 
         UniValue entry(UniValue::VOBJ);
diff --git a/depend/bitcoin/src/wallet/rpc/encrypt.cpp b/depend/bitcoin/src/wallet/rpc/encrypt.cpp
index a5f1cea9..0314090c 100644
--- a/depend/bitcoin/src/wallet/rpc/encrypt.cpp
+++ b/depend/bitcoin/src/wallet/rpc/encrypt.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/wallet/rpc/signmessage.cpp b/depend/bitcoin/src/wallet/rpc/signmessage.cpp
index fb02861e..1929e477 100644
--- a/depend/bitcoin/src/wallet/rpc/signmessage.cpp
+++ b/depend/bitcoin/src/wallet/rpc/signmessage.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
diff --git a/depend/bitcoin/src/wallet/rpc/spend.cpp b/depend/bitcoin/src/wallet/rpc/spend.cpp
index d765dc11..c7208e05 100644
--- a/depend/bitcoin/src/wallet/rpc/spend.cpp
+++ b/depend/bitcoin/src/wallet/rpc/spend.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2011-2022 The Bitcoin Core developers
+// Copyright (c) 2011-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.
 
@@ -1588,7 +1588,7 @@ RPCHelpMan sendall()
                 CTxDestination dest;
                 ExtractDestination(out.scriptPubKey, dest);
                 std::string addr{EncodeDestination(dest)};
-                if (addresses_without_amount.count(addr) > 0) {
+                if (addresses_without_amount.contains(addr)) {
                     out.nValue = per_output_without_amount;
                     if (!gave_remaining_to_first) {
                         out.nValue += remainder % addresses_without_amount.size();
diff --git a/depend/bitcoin/src/wallet/rpc/transactions.cpp b/depend/bitcoin/src/wallet/rpc/transactions.cpp
index 4e9bff19..6fe96458 100644
--- a/depend/bitcoin/src/wallet/rpc/transactions.cpp
+++ b/depend/bitcoin/src/wallet/rpc/transactions.cpp
@@ -418,7 +418,11 @@ RPCHelpMan listtransactions()
     return RPCHelpMan{
         "listtransactions",
         "If a label name is provided, this will return only incoming transactions paying to addresses with the specified label.\n"
-                "\nReturns up to 'count' most recent transactions skipping the first 'from' transactions.\n",
+                "Returns up to 'count' most recent transactions ordered from oldest to newest while skipping the first number of \n"
+                "transactions specified in the 'skip' argument. A transaction can have multiple entries in this RPC response. \n"
+                "For instance, a wallet transaction that pays three addresses — one wallet-owned and two external — will produce \n"
+                "four entries. The payment to the wallet-owned address appears both as a send entry and as a receive entry. \n"
+                "As a result, the RPC response will contain one entry in the receive category and three entries in the send category.\n",
                 {
                     {"label", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "If set, should be a valid label name to return only incoming transactions\n"
                           "with the specified label, or \"*\" to disable filtering and return all transactions."},
@@ -802,7 +806,7 @@ RPCHelpMan abandontransaction()
 
     Txid hash{Txid::FromUint256(ParseHashV(request.params[0], "txid"))};
 
-    if (!pwallet->mapWallet.count(hash)) {
+    if (!pwallet->mapWallet.contains(hash)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid or non-wallet transaction id");
     }
     if (!pwallet->AbandonTransaction(hash)) {
diff --git a/depend/bitcoin/src/wallet/rpc/wallet.cpp b/depend/bitcoin/src/wallet/rpc/wallet.cpp
index 3d45c160..8651b98d 100644
--- a/depend/bitcoin/src/wallet/rpc/wallet.cpp
+++ b/depend/bitcoin/src/wallet/rpc/wallet.cpp
@@ -311,7 +311,7 @@ static RPCHelpMan setwalletflag()
     std::string flag_str = request.params[0].get_str();
     bool value = request.params[1].isNull() || request.params[1].get_bool();
 
-    if (!STRING_TO_WALLET_FLAG.count(flag_str)) {
+    if (!STRING_TO_WALLET_FLAG.contains(flag_str)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Unknown wallet flag: %s", flag_str));
     }
 
@@ -336,7 +336,7 @@ static RPCHelpMan setwalletflag()
         pwallet->UnsetWalletFlag(flag);
     }
 
-    if (flag && value && WALLET_FLAG_CAVEATS.count(flag)) {
+    if (flag && value && WALLET_FLAG_CAVEATS.contains(flag)) {
         res.pushKV("warnings", WALLET_FLAG_CAVEATS.at(flag));
     }
 
@@ -548,10 +548,10 @@ RPCHelpMan simulaterawtransaction()
         // broadcast, we will lose everything in these
         for (const auto& txin : mtx.vin) {
             const auto& outpoint = txin.prevout;
-            if (spent.count(outpoint)) {
+            if (spent.contains(outpoint)) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Transaction(s) are spending the same output more than once");
             }
-            if (new_utxos.count(outpoint)) {
+            if (new_utxos.contains(outpoint)) {
                 changes -= new_utxos.at(outpoint);
                 new_utxos.erase(outpoint);
             } else {
diff --git a/depend/bitcoin/src/wallet/scriptpubkeyman.cpp b/depend/bitcoin/src/wallet/scriptpubkeyman.cpp
index fc27da5d..a6c25484 100644
--- a/depend/bitcoin/src/wallet/scriptpubkeyman.cpp
+++ b/depend/bitcoin/src/wallet/scriptpubkeyman.cpp
@@ -339,7 +339,7 @@ bool LegacyDataSPKM::AddCryptedKeyInner(const CPubKey &vchPubKey, const std::vec
 bool LegacyDataSPKM::HaveWatchOnly(const CScript &dest) const
 {
     LOCK(cs_KeyStore);
-    return setWatchOnly.count(dest) > 0;
+    return setWatchOnly.contains(dest);
 }
 
 bool LegacyDataSPKM::LoadWatchOnly(const CScript &dest)
@@ -385,7 +385,7 @@ bool LegacyDataSPKM::HaveKey(const CKeyID &address) const
     if (!m_storage.HasEncryptionKeys()) {
         return FillableSigningProvider::HaveKey(address);
     }
-    return mapCryptedKeys.count(address) > 0;
+    return mapCryptedKeys.contains(address);
 }
 
 bool LegacyDataSPKM::GetKey(const CKeyID &address, CKey& keyOut) const
@@ -560,7 +560,7 @@ std::optional<MigrationData> LegacyDataSPKM::MigrateToDescriptor()
                 keyid_it++;
                 continue;
             }
-            if (!meta.hd_seed_id.IsNull() && (m_hd_chain.seed_id == meta.hd_seed_id || m_inactive_hd_chains.count(meta.hd_seed_id) > 0)) {
+            if (!meta.hd_seed_id.IsNull() && (m_hd_chain.seed_id == meta.hd_seed_id || m_inactive_hd_chains.contains(meta.hd_seed_id))) {
                 keyid_it = keyids.erase(keyid_it);
                 continue;
             }
@@ -1039,7 +1039,7 @@ bool DescriptorScriptPubKeyMan::TopUpWithDB(WalletBatch& batch, unsigned int siz
         }
         for (const auto& pk_pair : out_keys.pubkeys) {
             const CPubKey& pubkey = pk_pair.second;
-            if (m_map_pubkeys.count(pubkey) != 0) {
+            if (m_map_pubkeys.contains(pubkey)) {
                 // We don't need to give an error here.
                 // It doesn't matter which of many valid indexes the pubkey has, we just need an index where we can derive it and its private key
                 continue;
@@ -1107,8 +1107,8 @@ bool DescriptorScriptPubKeyMan::AddDescriptorKeyWithDB(WalletBatch& batch, const
     assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
 
     // Check if provided key already exists
-    if (m_map_keys.find(pubkey.GetID()) != m_map_keys.end() ||
-        m_map_crypted_keys.find(pubkey.GetID()) != m_map_crypted_keys.end()) {
+    if (m_map_keys.contains(pubkey.GetID()) ||
+        m_map_crypted_keys.contains(pubkey.GetID())) {
         return true;
     }
 
@@ -1441,14 +1441,14 @@ void DescriptorScriptPubKeyMan::SetCache(const DescriptorCache& cache)
         // Add all of the scriptPubKeys to the scriptPubKey set
         new_spks.insert(scripts_temp.begin(), scripts_temp.end());
         for (const CScript& script : scripts_temp) {
-            if (m_map_script_pub_keys.count(script) != 0) {
+            if (m_map_script_pub_keys.contains(script)) {
                 throw std::runtime_error(strprintf("Error: Already loaded script at index %d as being at index %d", i, m_map_script_pub_keys[script]));
             }
             m_map_script_pub_keys[script] = i;
         }
         for (const auto& pk_pair : out_keys.pubkeys) {
             const CPubKey& pubkey = pk_pair.second;
-            if (m_map_pubkeys.count(pubkey) != 0) {
+            if (m_map_pubkeys.contains(pubkey)) {
                 // We don't need to give an error here.
                 // It doesn't matter which of many valid indexes the pubkey has, we just need an index where we can derive it and its private key
                 continue;
diff --git a/depend/bitcoin/src/wallet/spend.cpp b/depend/bitcoin/src/wallet/spend.cpp
index f9997f62..c7c41f5d 100644
--- a/depend/bitcoin/src/wallet/spend.cpp
+++ b/depend/bitcoin/src/wallet/spend.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -219,7 +219,7 @@ void CoinsResult::Erase(const std::unordered_set<COutPoint, SaltedOutpointHasher
     for (auto& [type, vec] : coins) {
         auto remove_it = std::remove_if(vec.begin(), vec.end(), [&](const COutput& coin) {
             // remove it if it's on the set
-            if (coins_to_remove.count(coin.outpoint) == 0) return false;
+            if (!coins_to_remove.contains(coin.outpoint)) return false;
 
             // update cached amounts
             total_amount -= coin.txout.nValue;
@@ -382,7 +382,7 @@ CoinsResult AvailableCoins(const CWallet& wallet,
             // be a 1-block reorg away from the chain where transactions A and C
             // were accepted to another chain where B, B', and C were all
             // accepted.
-            if (nDepth == 0 && wtx.mapValue.count("replaces_txid")) {
+            if (nDepth == 0 && wtx.mapValue.contains("replaces_txid")) {
                 safeTx = false;
             }
 
@@ -394,7 +394,7 @@ CoinsResult AvailableCoins(const CWallet& wallet,
             // intending to replace A', but potentially resulting in a scenario
             // where A, A', and D could all be accepted (instead of just B and
             // D, or just A and A' like the user would want).
-            if (nDepth == 0 && wtx.mapValue.count("replaced_by_txid")) {
+            if (nDepth == 0 && wtx.mapValue.contains("replaced_by_txid")) {
                 safeTx = false;
             }
 
diff --git a/depend/bitcoin/src/wallet/test/coinselection_tests.cpp b/depend/bitcoin/src/wallet/test/coinselection_tests.cpp
index b4608383..05ee6ab4 100644
--- a/depend/bitcoin/src/wallet/test/coinselection_tests.cpp
+++ b/depend/bitcoin/src/wallet/test/coinselection_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2024 The Bitcoin Core developers
+// Copyright (c) 2024-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/wallet/test/coinselector_tests.cpp b/depend/bitcoin/src/wallet/test/coinselector_tests.cpp
index c73663de..5c047bad 100644
--- a/depend/bitcoin/src/wallet/test/coinselector_tests.cpp
+++ b/depend/bitcoin/src/wallet/test/coinselector_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/wallet/test/feebumper_tests.cpp b/depend/bitcoin/src/wallet/test/feebumper_tests.cpp
index 80fd7784..017d2bbe 100644
--- a/depend/bitcoin/src/wallet/test/feebumper_tests.cpp
+++ b/depend/bitcoin/src/wallet/test/feebumper_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/wallet/test/fuzz/coincontrol.cpp b/depend/bitcoin/src/wallet/test/fuzz/coincontrol.cpp
index f1efbc1c..6774a21d 100644
--- a/depend/bitcoin/src/wallet/test/fuzz/coincontrol.cpp
+++ b/depend/bitcoin/src/wallet/test/fuzz/coincontrol.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/wallet/test/fuzz/coinselection.cpp b/depend/bitcoin/src/wallet/test/fuzz/coinselection.cpp
index 8bb18340..e85a49f5 100644
--- a/depend/bitcoin/src/wallet/test/fuzz/coinselection.cpp
+++ b/depend/bitcoin/src/wallet/test/fuzz/coinselection.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/wallet/test/fuzz/crypter.cpp b/depend/bitcoin/src/wallet/test/fuzz/crypter.cpp
index 8c2b570b..f8f59354 100644
--- a/depend/bitcoin/src/wallet/test/fuzz/crypter.cpp
+++ b/depend/bitcoin/src/wallet/test/fuzz/crypter.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/src/wallet/test/fuzz/scriptpubkeyman.cpp b/depend/bitcoin/src/wallet/test/fuzz/scriptpubkeyman.cpp
index 3edf2265..ea1431a7 100644
--- a/depend/bitcoin/src/wallet/test/fuzz/scriptpubkeyman.cpp
+++ b/depend/bitcoin/src/wallet/test/fuzz/scriptpubkeyman.cpp
@@ -125,7 +125,7 @@ FUZZ_TARGET(scriptpubkeyman, .init = initialize_spkm)
             [&] {
                 const CScript script{ConsumeScript(fuzzed_data_provider)};
                 if (spk_manager->IsMine(script)) {
-                    assert(spk_manager->GetScriptPubKeys().count(script));
+                    assert(spk_manager->GetScriptPubKeys().contains(script));
                 }
             },
             [&] {
diff --git a/depend/bitcoin/src/wallet/test/group_outputs_tests.cpp b/depend/bitcoin/src/wallet/test/group_outputs_tests.cpp
index d259f495..4bbf145c 100644
--- a/depend/bitcoin/src/wallet/test/group_outputs_tests.cpp
+++ b/depend/bitcoin/src/wallet/test/group_outputs_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/wallet/test/init_test_fixture.cpp b/depend/bitcoin/src/wallet/test/init_test_fixture.cpp
index a01561df..69353427 100644
--- a/depend/bitcoin/src/wallet/test/init_test_fixture.cpp
+++ b/depend/bitcoin/src/wallet/test/init_test_fixture.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/wallet/test/init_test_fixture.h b/depend/bitcoin/src/wallet/test/init_test_fixture.h
index ac7bb899..b435527a 100644
--- a/depend/bitcoin/src/wallet/test/init_test_fixture.h
+++ b/depend/bitcoin/src/wallet/test/init_test_fixture.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/wallet/test/init_tests.cpp b/depend/bitcoin/src/wallet/test/init_tests.cpp
index 10aeed49..cd1a0f57 100644
--- a/depend/bitcoin/src/wallet/test/init_tests.cpp
+++ b/depend/bitcoin/src/wallet/test/init_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/wallet/test/ismine_tests.cpp b/depend/bitcoin/src/wallet/test/ismine_tests.cpp
index b4cace21..e3f85da7 100644
--- a/depend/bitcoin/src/wallet/test/ismine_tests.cpp
+++ b/depend/bitcoin/src/wallet/test/ismine_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/wallet/test/psbt_wallet_tests.cpp b/depend/bitcoin/src/wallet/test/psbt_wallet_tests.cpp
index f7f7fcdb..91b69b9d 100644
--- a/depend/bitcoin/src/wallet/test/psbt_wallet_tests.cpp
+++ b/depend/bitcoin/src/wallet/test/psbt_wallet_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/wallet/test/scriptpubkeyman_tests.cpp b/depend/bitcoin/src/wallet/test/scriptpubkeyman_tests.cpp
index 90fff119..9c62436d 100644
--- a/depend/bitcoin/src/wallet/test/scriptpubkeyman_tests.cpp
+++ b/depend/bitcoin/src/wallet/test/scriptpubkeyman_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 The Bitcoin Core developers
+// Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/src/wallet/test/spend_tests.cpp b/depend/bitcoin/src/wallet/test/spend_tests.cpp
index 1302fc0b..866ffa48 100644
--- a/depend/bitcoin/src/wallet/test/spend_tests.cpp
+++ b/depend/bitcoin/src/wallet/test/spend_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/wallet/test/util.cpp b/depend/bitcoin/src/wallet/test/util.cpp
index c06c6af5..1e4fd7aa 100644
--- a/depend/bitcoin/src/wallet/test/util.cpp
+++ b/depend/bitcoin/src/wallet/test/util.cpp
@@ -163,7 +163,7 @@ bool MockableBatch::HasKey(DataStream&& key)
         return false;
     }
     SerializeData key_data{key.begin(), key.end()};
-    return m_records.count(key_data) > 0;
+    return m_records.contains(key_data);
 }
 
 bool MockableBatch::ErasePrefix(std::span<const std::byte> prefix)
diff --git a/depend/bitcoin/src/wallet/test/wallet_crypto_tests.cpp b/depend/bitcoin/src/wallet/test/wallet_crypto_tests.cpp
index e01c7a4e..45383c85 100644
--- a/depend/bitcoin/src/wallet/test/wallet_crypto_tests.cpp
+++ b/depend/bitcoin/src/wallet/test/wallet_crypto_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2022 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/wallet/test/wallet_test_fixture.cpp b/depend/bitcoin/src/wallet/test/wallet_test_fixture.cpp
index a502314c..f495eb27 100644
--- a/depend/bitcoin/src/wallet/test/wallet_test_fixture.cpp
+++ b/depend/bitcoin/src/wallet/test/wallet_test_fixture.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/wallet/test/wallet_test_fixture.h b/depend/bitcoin/src/wallet/test/wallet_test_fixture.h
index 4aae02e0..b268463a 100644
--- a/depend/bitcoin/src/wallet/test/wallet_test_fixture.h
+++ b/depend/bitcoin/src/wallet/test/wallet_test_fixture.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/wallet/test/wallet_tests.cpp b/depend/bitcoin/src/wallet/test/wallet_tests.cpp
index a4cbb1e1..85f8dfc3 100644
--- a/depend/bitcoin/src/wallet/test/wallet_tests.cpp
+++ b/depend/bitcoin/src/wallet/test/wallet_tests.cpp
@@ -631,8 +631,8 @@ BOOST_FIXTURE_TEST_CASE(CreateWallet, TestChain100Setup)
     BOOST_CHECK_EQUAL(addtx_count, 3);
     {
         LOCK(wallet->cs_wallet);
-        BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_tx.GetHash()), 1U);
-        BOOST_CHECK_EQUAL(wallet->mapWallet.count(mempool_tx.GetHash()), 1U);
+        BOOST_CHECK(wallet->mapWallet.contains(block_tx.GetHash()));
+        BOOST_CHECK(wallet->mapWallet.contains(mempool_tx.GetHash()));
     }
 
 
@@ -670,8 +670,8 @@ BOOST_FIXTURE_TEST_CASE(CreateWallet, TestChain100Setup)
     BOOST_CHECK_EQUAL(addtx_count, 2 + 2);
     {
         LOCK(wallet->cs_wallet);
-        BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_tx.GetHash()), 1U);
-        BOOST_CHECK_EQUAL(wallet->mapWallet.count(mempool_tx.GetHash()), 1U);
+        BOOST_CHECK(wallet->mapWallet.contains(block_tx.GetHash()));
+        BOOST_CHECK(wallet->mapWallet.contains(mempool_tx.GetHash()));
     }
 
 
@@ -710,13 +710,13 @@ BOOST_FIXTURE_TEST_CASE(RemoveTxs, TestChain100Setup)
 
         LOCK(wallet->cs_wallet);
         BOOST_CHECK(wallet->HasWalletSpend(prev_tx));
-        BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_hash), 1u);
+        BOOST_CHECK(wallet->mapWallet.contains(block_hash));
 
         std::vector<Txid> vHashIn{ block_hash };
         BOOST_CHECK(wallet->RemoveTxs(vHashIn));
 
         BOOST_CHECK(!wallet->HasWalletSpend(prev_tx));
-        BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_hash), 0u);
+        BOOST_CHECK(!wallet->mapWallet.contains(block_hash));
     }
 
     TestUnloadWallet(std::move(wallet));
diff --git a/depend/bitcoin/src/wallet/test/wallet_transaction_tests.cpp b/depend/bitcoin/src/wallet/test/wallet_transaction_tests.cpp
index 9f562486..e4943906 100644
--- a/depend/bitcoin/src/wallet/test/wallet_transaction_tests.cpp
+++ b/depend/bitcoin/src/wallet/test/wallet_transaction_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/wallet/test/walletdb_tests.cpp b/depend/bitcoin/src/wallet/test/walletdb_tests.cpp
index b12dc19a..b3741f09 100644
--- a/depend/bitcoin/src/wallet/test/walletdb_tests.cpp
+++ b/depend/bitcoin/src/wallet/test/walletdb_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2021 The Bitcoin Core developers
+// Copyright (c) 2012-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.
 
diff --git a/depend/bitcoin/src/wallet/test/walletload_tests.cpp b/depend/bitcoin/src/wallet/test/walletload_tests.cpp
index 0c69849d..e5f5ee96 100644
--- a/depend/bitcoin/src/wallet/test/walletload_tests.cpp
+++ b/depend/bitcoin/src/wallet/test/walletload_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/wallet/transaction.cpp b/depend/bitcoin/src/wallet/transaction.cpp
index a611a034..3d82d55f 100644
--- a/depend/bitcoin/src/wallet/transaction.cpp
+++ b/depend/bitcoin/src/wallet/transaction.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/wallet/transaction.h b/depend/bitcoin/src/wallet/transaction.h
index 1dbcdd2d..f979d83b 100644
--- a/depend/bitcoin/src/wallet/transaction.h
+++ b/depend/bitcoin/src/wallet/transaction.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2022 The Bitcoin Core developers
+// Copyright (c) 2021-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/src/wallet/types.h b/depend/bitcoin/src/wallet/types.h
index 10a463c4..97c18d4f 100644
--- a/depend/bitcoin/src/wallet/types.h
+++ b/depend/bitcoin/src/wallet/types.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
diff --git a/depend/bitcoin/src/wallet/wallet.cpp b/depend/bitcoin/src/wallet/wallet.cpp
index 86474a45..4becb340 100644
--- a/depend/bitcoin/src/wallet/wallet.cpp
+++ b/depend/bitcoin/src/wallet/wallet.cpp
@@ -22,8 +22,8 @@
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
 #include <interfaces/wallet.h>
-#include <kernel/chain.h>
 #include <kernel/mempool_removal_reason.h>
+#include <kernel/types.h>
 #include <key.h>
 #include <key_io.h>
 #include <logging.h>
@@ -87,6 +87,7 @@ using common::AmountErrMsg;
 using common::AmountHighWarn;
 using common::PSBTError;
 using interfaces::FoundBlock;
+using kernel::ChainstateRole;
 using util::ReplaceAll;
 using util::ToString;
 
@@ -265,7 +266,7 @@ void WaitForDeleteWallet(std::shared_ptr<CWallet>&& wallet)
     wallet.reset();
     {
         WAIT_LOCK(g_wallet_release_mutex, lock);
-        while (g_unloading_wallet_set.count(name) == 1) {
+        while (g_unloading_wallet_set.contains(name)) {
             g_wallet_release_cv.wait(lock);
         }
     }
@@ -924,7 +925,7 @@ bool CWallet::MarkReplaced(const Txid& originalHash, const Txid& newHash)
     CWalletTx& wtx = (*mi).second;
 
     // Ensure for now that we're not overwriting data
-    assert(wtx.mapValue.count("replaced_by_txid") == 0);
+    assert(!wtx.mapValue.contains("replaced_by_txid"));
 
     wtx.mapValue["replaced_by_txid"] = newHash.ToString();
 
@@ -1160,7 +1161,7 @@ bool CWallet::AddToWalletIfInvolvingMe(const CTransactionRef& ptx, const SyncTxS
             }
         }
 
-        bool fExisted = mapWallet.count(tx.GetHash()) != 0;
+        bool fExisted = mapWallet.contains(tx.GetHash());
         if (fExisted && !fUpdate) return false;
         if (fExisted || IsMine(tx) || IsFromMe(tx))
         {
@@ -1336,7 +1337,7 @@ void CWallet::RecursiveUpdateTxState(WalletBatch* batch, const Txid& tx_hash, co
             for (unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {
                 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(COutPoint(now, i));
                 for (TxSpends::const_iterator iter = range.first; iter != range.second; ++iter) {
-                    if (!done.count(iter->second)) {
+                    if (!done.contains(iter->second)) {
                         todo.insert(iter->second);
                     }
                 }
@@ -1477,9 +1478,9 @@ void CWallet::transactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRe
     }
 }
 
-void CWallet::blockConnected(ChainstateRole role, const interfaces::BlockInfo& block)
+void CWallet::blockConnected(const ChainstateRole& role, const interfaces::BlockInfo& block)
 {
-    if (role == ChainstateRole::BACKGROUND) {
+    if (role.historical) {
         return;
     }
     assert(block.data);
@@ -1525,7 +1526,7 @@ void CWallet::blockDisconnected(const interfaces::BlockInfo& block)
 
         for (const CTxIn& tx_in : ptx->vin) {
             // No other wallet transactions conflicted with this transaction
-            if (mapTxSpends.count(tx_in.prevout) < 1) continue;
+            if (!mapTxSpends.contains(tx_in.prevout)) continue;
 
             std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(tx_in.prevout);
 
@@ -2534,7 +2535,7 @@ void CWallet::MarkDestinationsDirty(const std::set<CTxDestination>& destinations
         if (wtx.m_is_cache_empty) continue;
         for (unsigned int i = 0; i < wtx.tx->vout.size(); i++) {
             CTxDestination dst;
-            if (ExtractDestination(wtx.tx->vout[i].scriptPubKey, dst) && destinations.count(dst)) {
+            if (ExtractDestination(wtx.tx->vout[i].scriptPubKey, dst) && destinations.contains(dst)) {
                 wtx.MarkDirty();
                 break;
             }
@@ -2678,7 +2679,7 @@ bool CWallet::UnlockAllCoins()
 bool CWallet::IsLockedCoin(const COutPoint& output) const
 {
     AssertLockHeld(cs_wallet);
-    return m_locked_coins.count(output) > 0;
+    return m_locked_coins.contains(output);
 }
 
 void CWallet::ListLockedCoins(std::vector<COutPoint>& vOutpts) const
@@ -3397,7 +3398,7 @@ std::set<ScriptPubKeyMan*> CWallet::GetScriptPubKeyMans(const CScript& script) c
 
 ScriptPubKeyMan* CWallet::GetScriptPubKeyMan(const uint256& id) const
 {
-    if (m_spk_managers.count(id) > 0) {
+    if (m_spk_managers.contains(id)) {
         return m_spk_managers.at(id).get();
     }
     return nullptr;
@@ -3682,7 +3683,7 @@ DescriptorScriptPubKeyMan* CWallet::GetDescriptorScriptPubKeyMan(const WalletDes
 std::optional<bool> CWallet::IsInternalScriptPubKeyMan(ScriptPubKeyMan* spk_man) const
 {
     // only active ScriptPubKeyMan can be internal
-    if (!GetActiveScriptPubKeyMans().count(spk_man)) {
+    if (!GetActiveScriptPubKeyMans().contains(spk_man)) {
         return std::nullopt;
     }
 
@@ -3877,7 +3878,7 @@ util::Result<void> CWallet::ApplyMigrationData(WalletBatch& local_wallet_batch,
     if (!data.solvable_descs.empty()) Assume(!data.solvable_wallet->m_cached_spks.empty());
 
     for (auto& desc_spkm : data.desc_spkms) {
-        if (m_spk_managers.count(desc_spkm->GetID()) > 0) {
+        if (m_spk_managers.contains(desc_spkm->GetID())) {
             return util::Error{_("Error: Duplicate descriptors created during migration. Your wallet may be corrupted.")};
         }
         uint256 id = desc_spkm->GetID();
@@ -4025,7 +4026,7 @@ util::Result<void> CWallet::ApplyMigrationData(WalletBatch& local_wallet_batch,
         if (require_transfer && !copied) {
 
             // Skip invalid/non-watched scripts that will not be migrated
-            if (not_migrated_dests.count(dest) > 0) {
+            if (not_migrated_dests.contains(dest)) {
                 dests_to_delete.push_back(dest);
                 continue;
             }
diff --git a/depend/bitcoin/src/wallet/wallet.h b/depend/bitcoin/src/wallet/wallet.h
index 275d4ead..1d463564 100644
--- a/depend/bitcoin/src/wallet/wallet.h
+++ b/depend/bitcoin/src/wallet/wallet.h
@@ -629,7 +629,7 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     CWalletTx* AddToWallet(CTransactionRef tx, const TxState& state, const UpdateWalletTxFn& update_wtx=nullptr, bool rescanning_old_block = false);
     bool LoadToWallet(const Txid& hash, const UpdateWalletTxFn& fill_wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     void transactionAddedToMempool(const CTransactionRef& tx) override;
-    void blockConnected(ChainstateRole role, const interfaces::BlockInfo& block) override;
+    void blockConnected(const kernel::ChainstateRole& role, const interfaces::BlockInfo& block) override;
     void blockDisconnected(const interfaces::BlockInfo& block) override;
     void updatedBlockTip() override;
     int64_t RescanFromTime(int64_t startTime, const WalletRescanReserver& reserver, bool update);
diff --git a/depend/bitcoin/src/wallet/walletdb.cpp b/depend/bitcoin/src/wallet/walletdb.cpp
index 9ca4d2da..617b8282 100644
--- a/depend/bitcoin/src/wallet/walletdb.cpp
+++ b/depend/bitcoin/src/wallet/walletdb.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2022 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
@@ -409,7 +409,7 @@ bool LoadEncryptionKey(CWallet* pwallet, DataStream& ssKey, DataStream& ssValue,
         ssKey >> nID;
         CMasterKey kMasterKey;
         ssValue >> kMasterKey;
-        if(pwallet->mapMasterKeys.count(nID) != 0)
+        if(pwallet->mapMasterKeys.contains(nID))
         {
             strErr = strprintf("Error reading wallet database: duplicate CMasterKey id %u", nID);
             return false;
diff --git a/depend/bitcoin/src/wallet/wallettool.cpp b/depend/bitcoin/src/wallet/wallettool.cpp
index af32986c..6aaf0827 100644
--- a/depend/bitcoin/src/wallet/wallettool.cpp
+++ b/depend/bitcoin/src/wallet/wallettool.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2022 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/wallet/wallettool.h b/depend/bitcoin/src/wallet/wallettool.h
index 9e0fe2b0..3769f99a 100644
--- a/depend/bitcoin/src/wallet/wallettool.h
+++ b/depend/bitcoin/src/wallet/wallettool.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 The Bitcoin Core developers
+// Copyright (c) 2016-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.
 
diff --git a/depend/bitcoin/src/wallet/walletutil.cpp b/depend/bitcoin/src/wallet/walletutil.cpp
index 3ee296a6..93d4b1ac 100644
--- a/depend/bitcoin/src/wallet/walletutil.cpp
+++ b/depend/bitcoin/src/wallet/walletutil.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2022 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/wallet/walletutil.h b/depend/bitcoin/src/wallet/walletutil.h
index e9e66181..bbf27932 100644
--- a/depend/bitcoin/src/wallet/walletutil.h
+++ b/depend/bitcoin/src/wallet/walletutil.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2021 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/walletinitinterface.h b/depend/bitcoin/src/walletinitinterface.h
index ecee2e93..62fd4421 100644
--- a/depend/bitcoin/src/walletinitinterface.h
+++ b/depend/bitcoin/src/walletinitinterface.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2021 The Bitcoin Core developers
+// Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/src/zmq/zmqabstractnotifier.cpp b/depend/bitcoin/src/zmq/zmqabstractnotifier.cpp
index 90aefb00..081a2a2c 100644
--- a/depend/bitcoin/src/zmq/zmqabstractnotifier.cpp
+++ b/depend/bitcoin/src/zmq/zmqabstractnotifier.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2020 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/zmq/zmqabstractnotifier.h b/depend/bitcoin/src/zmq/zmqabstractnotifier.h
index 47132cd5..77d478a1 100644
--- a/depend/bitcoin/src/zmq/zmqabstractnotifier.h
+++ b/depend/bitcoin/src/zmq/zmqabstractnotifier.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/zmq/zmqnotificationinterface.cpp b/depend/bitcoin/src/zmq/zmqnotificationinterface.cpp
index e5b5f9d8..a341c47b 100644
--- a/depend/bitcoin/src/zmq/zmqnotificationinterface.cpp
+++ b/depend/bitcoin/src/zmq/zmqnotificationinterface.cpp
@@ -1,12 +1,12 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <zmq/zmqnotificationinterface.h>
 
 #include <common/args.h>
-#include <kernel/chain.h>
 #include <kernel/mempool_entry.h>
+#include <kernel/types.h>
 #include <logging.h>
 #include <netbase.h>
 #include <primitives/block.h>
@@ -24,6 +24,8 @@
 #include <utility>
 #include <vector>
 
+using kernel::ChainstateRole;
+
 CZMQNotificationInterface::CZMQNotificationInterface() = default;
 
 CZMQNotificationInterface::~CZMQNotificationInterface()
@@ -176,9 +178,9 @@ void CZMQNotificationInterface::TransactionRemovedFromMempool(const CTransaction
     });
 }
 
-void CZMQNotificationInterface::BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected)
+void CZMQNotificationInterface::BlockConnected(const ChainstateRole& role, const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected)
 {
-    if (role == ChainstateRole::BACKGROUND) {
+    if (role.historical) {
         return;
     }
     for (const CTransactionRef& ptx : pblock->vtx) {
diff --git a/depend/bitcoin/src/zmq/zmqnotificationinterface.h b/depend/bitcoin/src/zmq/zmqnotificationinterface.h
index 5dacf3b3..12d805c1 100644
--- a/depend/bitcoin/src/zmq/zmqnotificationinterface.h
+++ b/depend/bitcoin/src/zmq/zmqnotificationinterface.h
@@ -35,7 +35,7 @@ class CZMQNotificationInterface final : public CValidationInterface
     // CValidationInterface
     void TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t mempool_sequence) override;
     void TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t mempool_sequence) override;
-    void BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected) override;
+    void BlockConnected(const kernel::ChainstateRole& role, const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected) override;
     void BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexDisconnected) override;
     void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override;
 
diff --git a/depend/bitcoin/src/zmq/zmqpublishnotifier.cpp b/depend/bitcoin/src/zmq/zmqpublishnotifier.cpp
index 693d70c8..44ef34b1 100644
--- a/depend/bitcoin/src/zmq/zmqpublishnotifier.cpp
+++ b/depend/bitcoin/src/zmq/zmqpublishnotifier.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/zmq/zmqpublishnotifier.h b/depend/bitcoin/src/zmq/zmqpublishnotifier.h
index ed81dc0a..226797e3 100644
--- a/depend/bitcoin/src/zmq/zmqpublishnotifier.h
+++ b/depend/bitcoin/src/zmq/zmqpublishnotifier.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2022 The Bitcoin Core developers
+// Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/src/zmq/zmqrpc.cpp b/depend/bitcoin/src/zmq/zmqrpc.cpp
index 4e479883..948ce2ba 100644
--- a/depend/bitcoin/src/zmq/zmqrpc.cpp
+++ b/depend/bitcoin/src/zmq/zmqrpc.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2022 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/zmq/zmqrpc.h b/depend/bitcoin/src/zmq/zmqrpc.h
index ea5d1908..e5379f89 100644
--- a/depend/bitcoin/src/zmq/zmqrpc.h
+++ b/depend/bitcoin/src/zmq/zmqrpc.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 The Bitcoin Core developers
+// 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.
 
diff --git a/depend/bitcoin/src/zmq/zmqutil.cpp b/depend/bitcoin/src/zmq/zmqutil.cpp
index 842928ed..d3addaad 100644
--- a/depend/bitcoin/src/zmq/zmqutil.cpp
+++ b/depend/bitcoin/src/zmq/zmqutil.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2022 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/src/zmq/zmqutil.h b/depend/bitcoin/src/zmq/zmqutil.h
index bec48c0a..86f594c1 100644
--- a/depend/bitcoin/src/zmq/zmqutil.h
+++ b/depend/bitcoin/src/zmq/zmqutil.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2021 The Bitcoin Core developers
+// Copyright (c) 2014-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.
 
diff --git a/depend/bitcoin/test/config.ini.in b/depend/bitcoin/test/config.ini.in
index f695dec4..affa2508 100644
--- a/depend/bitcoin/test/config.ini.in
+++ b/depend/bitcoin/test/config.ini.in
@@ -1,4 +1,4 @@
-# Copyright (c) 2013-2016 The Bitcoin Core developers
+# Copyright (c) 2013-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.
 
diff --git a/depend/bitcoin/test/functional/create_cache.py b/depend/bitcoin/test/functional/create_cache.py
index c77d5fee..0ac9e7e7 100755
--- a/depend/bitcoin/test/functional/create_cache.py
+++ b/depend/bitcoin/test/functional/create_cache.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2019 The Bitcoin Core developers
+# Copyright (c) 2016-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.
 """Create a blockchain cache.
diff --git a/depend/bitcoin/test/functional/data/invalid_txs.py b/depend/bitcoin/test/functional/data/invalid_txs.py
index 4853f8cc..2a317b82 100644
--- a/depend/bitcoin/test/functional/data/invalid_txs.py
+++ b/depend/bitcoin/test/functional/data/invalid_txs.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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.
 """
diff --git a/depend/bitcoin/test/functional/example_test.py b/depend/bitcoin/test/functional/example_test.py
index 1e11586b..72955bdf 100755
--- a/depend/bitcoin/test/functional/example_test.py
+++ b/depend/bitcoin/test/functional/example_test.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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.
 """An example functional test
diff --git a/depend/bitcoin/test/functional/feature_abortnode.py b/depend/bitcoin/test/functional/feature_abortnode.py
index a5c8aa16..11420b1a 100755
--- a/depend/bitcoin/test/functional/feature_abortnode.py
+++ b/depend/bitcoin/test/functional/feature_abortnode.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2019-2021 The Bitcoin Core developers
+# Copyright (c) 2019-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 bitcoind aborts if can't disconnect a block.
diff --git a/depend/bitcoin/test/functional/feature_addrman.py b/depend/bitcoin/test/functional/feature_addrman.py
index 62f9cee1..a80261ec 100755
--- a/depend/bitcoin/test/functional/feature_addrman.py
+++ b/depend/bitcoin/test/functional/feature_addrman.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021-2022 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test addrman functionality"""
diff --git a/depend/bitcoin/test/functional/feature_anchors.py b/depend/bitcoin/test/functional/feature_anchors.py
index 154461e7..d3d24f46 100755
--- a/depend/bitcoin/test/functional/feature_anchors.py
+++ b/depend/bitcoin/test/functional/feature_anchors.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2021 The Bitcoin Core developers
+# Copyright (c) 2020-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 block-relay-only anchors functionality"""
diff --git a/depend/bitcoin/test/functional/feature_bind_extra.py b/depend/bitcoin/test/functional/feature_bind_extra.py
index 956f29b7..ad4c4b13 100755
--- a/depend/bitcoin/test/functional/feature_bind_extra.py
+++ b/depend/bitcoin/test/functional/feature_bind_extra.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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.
 """
diff --git a/depend/bitcoin/test/functional/feature_bind_port_discover.py b/depend/bitcoin/test/functional/feature_bind_port_discover.py
index 46bf384c..338dbd02 100755
--- a/depend/bitcoin/test/functional/feature_bind_port_discover.py
+++ b/depend/bitcoin/test/functional/feature_bind_port_discover.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2021 The Bitcoin Core developers
+# Copyright (c) 2020-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.
 """
diff --git a/depend/bitcoin/test/functional/feature_bind_port_externalip.py b/depend/bitcoin/test/functional/feature_bind_port_externalip.py
index 8e2ac024..0e7764db 100755
--- a/depend/bitcoin/test/functional/feature_bind_port_externalip.py
+++ b/depend/bitcoin/test/functional/feature_bind_port_externalip.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2021 The Bitcoin Core developers
+# Copyright (c) 2020-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.
 """
diff --git a/depend/bitcoin/test/functional/feature_bip68_sequence.py b/depend/bitcoin/test/functional/feature_bip68_sequence.py
index 2f54183f..f037c818 100755
--- a/depend/bitcoin/test/functional/feature_bip68_sequence.py
+++ b/depend/bitcoin/test/functional/feature_bip68_sequence.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 BIP68 implementation."""
diff --git a/depend/bitcoin/test/functional/feature_block.py b/depend/bitcoin/test/functional/feature_block.py
index 60e6117c..47b80674 100755
--- a/depend/bitcoin/test/functional/feature_block.py
+++ b/depend/bitcoin/test/functional/feature_block.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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 block processing."""
diff --git a/depend/bitcoin/test/functional/feature_blocksdir.py b/depend/bitcoin/test/functional/feature_blocksdir.py
index 4a436328..379c2bec 100755
--- a/depend/bitcoin/test/functional/feature_blocksdir.py
+++ b/depend/bitcoin/test/functional/feature_blocksdir.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2021 The Bitcoin Core developers
+# 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.
 """Test the blocksdir option.
diff --git a/depend/bitcoin/test/functional/feature_blocksxor.py b/depend/bitcoin/test/functional/feature_blocksxor.py
index ab5b0071..596b189e 100755
--- a/depend/bitcoin/test/functional/feature_blocksxor.py
+++ b/depend/bitcoin/test/functional/feature_blocksxor.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2024 The Bitcoin Core developers
+# Copyright (c) 2024-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test support for XORed block data and undo files (`-blocksxor` option)."""
diff --git a/depend/bitcoin/test/functional/feature_cltv.py b/depend/bitcoin/test/functional/feature_cltv.py
index 2a958e9d..0cc2f458 100755
--- a/depend/bitcoin/test/functional/feature_cltv.py
+++ b/depend/bitcoin/test/functional/feature_cltv.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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 BIP65 (CHECKLOCKTIMEVERIFY).
diff --git a/depend/bitcoin/test/functional/feature_coinstatsindex.py b/depend/bitcoin/test/functional/feature_coinstatsindex.py
index 6405be41..05efb525 100755
--- a/depend/bitcoin/test/functional/feature_coinstatsindex.py
+++ b/depend/bitcoin/test/functional/feature_coinstatsindex.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2022 The Bitcoin Core developers
+# Copyright (c) 2020-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 coinstatsindex across nodes.
diff --git a/depend/bitcoin/test/functional/feature_coinstatsindex_compatibility.py b/depend/bitcoin/test/functional/feature_coinstatsindex_compatibility.py
index 357700a7..5031494f 100755
--- a/depend/bitcoin/test/functional/feature_coinstatsindex_compatibility.py
+++ b/depend/bitcoin/test/functional/feature_coinstatsindex_compatibility.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2025 The Bitcoin Core developers
+# Copyright (c) 2025-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test coinstatsindex across node versions.
diff --git a/depend/bitcoin/test/functional/feature_csv_activation.py b/depend/bitcoin/test/functional/feature_csv_activation.py
index bef870be..0850bc50 100755
--- a/depend/bitcoin/test/functional/feature_csv_activation.py
+++ b/depend/bitcoin/test/functional/feature_csv_activation.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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 CSV soft fork activation.
diff --git a/depend/bitcoin/test/functional/feature_dbcrash.py b/depend/bitcoin/test/functional/feature_dbcrash.py
index 0c2059d1..2eb7bd07 100755
--- a/depend/bitcoin/test/functional/feature_dbcrash.py
+++ b/depend/bitcoin/test/functional/feature_dbcrash.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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 recovery from a crash during chainstate writing.
diff --git a/depend/bitcoin/test/functional/feature_dersig.py b/depend/bitcoin/test/functional/feature_dersig.py
index de6d1c09..01529647 100755
--- a/depend/bitcoin/test/functional/feature_dersig.py
+++ b/depend/bitcoin/test/functional/feature_dersig.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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 BIP66 (DER SIG).
diff --git a/depend/bitcoin/test/functional/feature_dirsymlinks.py b/depend/bitcoin/test/functional/feature_dirsymlinks.py
index 9fed99cb..e6a9918e 100755
--- a/depend/bitcoin/test/functional/feature_dirsymlinks.py
+++ b/depend/bitcoin/test/functional/feature_dirsymlinks.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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 successful startup with symlinked directories.
diff --git a/depend/bitcoin/test/functional/feature_discover.py b/depend/bitcoin/test/functional/feature_discover.py
index 9eaaea36..10a9f3ea 100755
--- a/depend/bitcoin/test/functional/feature_discover.py
+++ b/depend/bitcoin/test/functional/feature_discover.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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 -discover command."""
diff --git a/depend/bitcoin/test/functional/feature_fastprune.py b/depend/bitcoin/test/functional/feature_fastprune.py
index ca6877b9..1eaf7679 100755
--- a/depend/bitcoin/test/functional/feature_fastprune.py
+++ b/depend/bitcoin/test/functional/feature_fastprune.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2023 The Bitcoin Core developers
+# Copyright (c) 2023-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test fastprune mode."""
diff --git a/depend/bitcoin/test/functional/feature_fee_estimation.py b/depend/bitcoin/test/functional/feature_fee_estimation.py
index 3815c7ab..ca45945e 100755
--- a/depend/bitcoin/test/functional/feature_fee_estimation.py
+++ b/depend/bitcoin/test/functional/feature_fee_estimation.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 fee estimation code."""
diff --git a/depend/bitcoin/test/functional/feature_filelock.py b/depend/bitcoin/test/functional/feature_filelock.py
index 90dd4848..0887cac2 100755
--- a/depend/bitcoin/test/functional/feature_filelock.py
+++ b/depend/bitcoin/test/functional/feature_filelock.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2022 The Bitcoin Core developers
+# 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.
 """Check that it's not possible to start a second bitcoind instance using the same datadir or wallet."""
diff --git a/depend/bitcoin/test/functional/feature_framework_miniwallet.py b/depend/bitcoin/test/functional/feature_framework_miniwallet.py
index c6931e2a..2fd9eaf3 100755
--- a/depend/bitcoin/test/functional/feature_framework_miniwallet.py
+++ b/depend/bitcoin/test/functional/feature_framework_miniwallet.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2024 The Bitcoin Core developers
+# Copyright (c) 2024-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test MiniWallet."""
diff --git a/depend/bitcoin/test/functional/feature_framework_startup_failures.py b/depend/bitcoin/test/functional/feature_framework_startup_failures.py
index 43dbeae7..ee031e11 100755
--- a/depend/bitcoin/test/functional/feature_framework_startup_failures.py
+++ b/depend/bitcoin/test/functional/feature_framework_startup_failures.py
@@ -36,22 +36,24 @@ def setup_network(self):
     # Launches a child test process that runs this same file, but instantiates
     # a child test. Verifies that it raises only the expected exception, once.
     def _verify_startup_failure(self, test, internal_args, expected_exception):
+        name = test.__name__
+        def format_child_output(output):
+            return f"\n<{name} OUTPUT BEGIN>\n{output.strip()}\n<{name} OUTPUT END>\n"
+
         # Inherit sys.argv from parent, only overriding tmpdir to a subdirectory
         # so children don't fail due to colliding with the parent dir.
         assert self.options.tmpdir, "Framework should always set tmpdir."
         subdir = md5(expected_exception.encode('utf-8')).hexdigest()[:8]
-        args = [sys.executable] + sys.argv + [f"--tmpdir={self.options.tmpdir}/{subdir}", f"--internal_test={test.__name__}"] + internal_args
+        args = [sys.executable] + sys.argv + [f"--tmpdir={self.options.tmpdir}/{subdir}", f"--internal_test={name}"] + internal_args
 
         try:
             output = subprocess.run(args, timeout=60 * self.options.timeout_factor,
                                     stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True).stdout
         except subprocess.TimeoutExpired as e:
-            print("Unexpected child process timeout!\n"
-                  "WARNING: Timeouts like this halt execution of TestNode logic, "
-                  "meaning dangling bitcoind processes are to be expected.\n"
-                  f"<CHILD OUTPUT BEGIN>\n{e.output}\n<CHILD OUTPUT END>",
-                  file=sys.stderr)
-            raise
+            sys.exit("Unexpected child process timeout!\n"
+                     "WARNING: Timeouts like this halt execution of TestNode logic, "
+                     "meaning dangling bitcoind processes are to be expected.\n" +
+                     (format_child_output(e.output.decode("utf-8")) if e.output else "<EMPTY OUTPUT>"))
 
         errors = []
         if (n := output.count("Traceback")) != 1:
@@ -61,13 +63,17 @@ def _verify_startup_failure(self, test, internal_args, expected_exception):
         if (n := output.count("Test failed. Test logging available at")) != 1:
             errors.append(f"Found {n}/1 test failure output messages.")
 
-        assert not errors, f"Child test didn't contain (only) expected errors:\n{linesep.join(errors)}\n<CHILD OUTPUT BEGIN>\n{output}\n<CHILD OUTPUT END>\n"
+        assert not errors, (f"Child test did NOT contain (only) expected errors:\n{linesep.join(errors)}\n" +
+                            format_child_output(output))
+
+        self.log.debug("Child test did contain (only) expected errors:\n" +
+                       format_child_output(output))
 
     def run_test(self):
         self.log.info("Verifying _verify_startup_failure() functionality (self-check).")
         assert_raises_message(
             AssertionError,
-            ( "Child test didn't contain (only) expected errors:\n"
+            ( "Child test did NOT contain (only) expected errors:\n"
              f"Found 0/1 tracebacks - expecting exactly one with no knock-on exceptions.{linesep}"
              f"Found 0/1 occurrences of the specific exception: NonExistentError{linesep}"
               "Found 0/1 test failure output messages."),
@@ -76,7 +82,7 @@ def run_test(self):
             "NonExistentError",
         )
 
-        self.log.info("Parent process is measuring node startup duration in order to obtain a reasonable timeout value for later test...")
+        self.log.info("Parent process is measuring node startup duration in order to obtain a reasonable timeout value for later tests...")
         node_start_time = time.time()
         self.nodes[0].start()
         self.nodes[0].wait_for_rpc_connection()
@@ -90,6 +96,12 @@ def run_test(self):
             r"AssertionError: \[node 0\] Unable to connect to bitcoind after \d+s \(ignored errors: {[^}]*'OSError \w+'?: \d+[^}]*}, latest: '[\w ]+'/\w+\([^)]+\)\)"
         )
 
+        self.log.info("Verifying timeout while waiting for init errors that do not occur results in only one exception.")
+        self._verify_startup_failure(
+            TestMissingInitErrorTimeout, [f"--internal_node_start_duration={node_start_duration}"],
+            r"AssertionError: \[node 0\] bitcoind should have exited within \d+s with an error \(cmd:"
+        )
+
         self.log.info("Verifying startup failure due to invalid arg results in only one exception.")
         self._verify_startup_failure(
             TestInitErrorStartupFailure, [],
@@ -107,20 +119,41 @@ def add_options(self, parser):
         # Just here to silence unrecognized argument error, we actually read the value in the if-main at the bottom.
         parser.add_argument("--internal_test", dest="internal_never_read", help="ONLY TO BE USED WHEN TEST RELAUNCHES ITSELF")
 
-class TestWrongRpcPortStartupFailure(InternalTestMixin, BitcoinTestFramework):
+class InternalDurationTestMixin(InternalTestMixin):
     def add_options(self, parser):
+        # Receives the previously measured duration for node startup + RPC connection establishment.
         parser.add_argument("--internal_node_start_duration", dest="node_start_duration", help="ONLY TO BE USED WHEN TEST RELAUNCHES ITSELF", type=float)
         InternalTestMixin.add_options(self, parser)
 
+    def get_reasonable_rpc_timeout(self):
+        # 2 * the measured test startup duration should be enough.
+        # Divide by timeout_factor to counter multiplication in BitcoinTestFramework.
+        return max(3, 2 * self.options.node_start_duration) / self.options.timeout_factor
+
+class TestWrongRpcPortStartupFailure(InternalDurationTestMixin, BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         # Override RPC listen port to something TestNode isn't expecting so that
         # we are unable to establish an RPC connection.
         self.extra_args = [[f"-rpcport={rpc_port(2)}"]]
         # Override the timeout to avoid waiting unnecessarily long to realize
-        # nothing is on that port. Divide by timeout_factor to counter
-        # multiplication in base, 2 * node_start_duration should be enough.
-        self.rpc_timeout = max(3, 2 * self.options.node_start_duration) / self.options.timeout_factor
+        # nothing is on that port.
+        self.rpc_timeout = self.get_reasonable_rpc_timeout()
+
+    def run_test(self):
+        assert False, "Should have failed earlier during startup."
+
+class TestMissingInitErrorTimeout(InternalDurationTestMixin, BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+        # Override the timeout to avoid waiting unnecessarily long for an init
+        # error which never occurs.
+        self.rpc_timeout = self.get_reasonable_rpc_timeout()
+
+    def setup_network(self):
+        self.add_nodes(self.num_nodes, self.extra_args)
+        self.nodes[0].assert_start_raises_init_error()
+        assert False, "assert_start_raises_init_error() should raise an exception due to timeout since we don't expect an init error."
 
     def run_test(self):
         assert False, "Should have failed earlier during startup."
diff --git a/depend/bitcoin/test/functional/feature_framework_unit_tests.py b/depend/bitcoin/test/functional/feature_framework_unit_tests.py
index 4ee2143a..2a796f5b 100755
--- a/depend/bitcoin/test/functional/feature_framework_unit_tests.py
+++ b/depend/bitcoin/test/functional/feature_framework_unit_tests.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2024 The Bitcoin Core developers
+# Copyright (c) 2017-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.
 """Framework unit tests
diff --git a/depend/bitcoin/test/functional/feature_help.py b/depend/bitcoin/test/functional/feature_help.py
index 6d8a742d..e973c71f 100755
--- a/depend/bitcoin/test/functional/feature_help.py
+++ b/depend/bitcoin/test/functional/feature_help.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2021 The Bitcoin Core developers
+# 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.
 """Verify that starting bitcoin with -h works as expected."""
diff --git a/depend/bitcoin/test/functional/feature_init.py b/depend/bitcoin/test/functional/feature_init.py
index 0fa99470..f3572013 100755
--- a/depend/bitcoin/test/functional/feature_init.py
+++ b/depend/bitcoin/test/functional/feature_init.py
@@ -10,7 +10,6 @@
 import shutil
 import signal
 import subprocess
-import time
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.test_node import (
@@ -272,7 +271,8 @@ def break_wait_test(self):
             # returns early it will return the current block height.
             self.log.debug(f"Calling waitforblockheight with {self.rpc_timeout} sec RPC timeout")
             fut = ex.submit(node.waitforblockheight, height=current_height+1, timeout=self.rpc_timeout*1000*2)
-            time.sleep(1)
+
+            self.wait_until(lambda: any(c["method"] == "waitforblockheight" for c in node.cli.getrpcinfo()["active_commands"]))
 
             self.log.debug(f"Sending break signal to pid {node.process.pid}")
             if platform.system() == 'Windows':
diff --git a/depend/bitcoin/test/functional/feature_logging.py b/depend/bitcoin/test/functional/feature_logging.py
index bc868d19..b04cd48c 100755
--- a/depend/bitcoin/test/functional/feature_logging.py
+++ b/depend/bitcoin/test/functional/feature_logging.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2021 The Bitcoin Core developers
+# Copyright (c) 2017-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 debug logging."""
diff --git a/depend/bitcoin/test/functional/feature_maxtipage.py b/depend/bitcoin/test/functional/feature_maxtipage.py
index 4ce9bb94..6319d7fb 100755
--- a/depend/bitcoin/test/functional/feature_maxtipage.py
+++ b/depend/bitcoin/test/functional/feature_maxtipage.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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 logic for setting -maxtipage on command line.
diff --git a/depend/bitcoin/test/functional/feature_maxuploadtarget.py b/depend/bitcoin/test/functional/feature_maxuploadtarget.py
index 6c4366c0..1b0f28df 100755
--- a/depend/bitcoin/test/functional/feature_maxuploadtarget.py
+++ b/depend/bitcoin/test/functional/feature_maxuploadtarget.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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 behavior of -maxuploadtarget.
diff --git a/depend/bitcoin/test/functional/feature_minchainwork.py b/depend/bitcoin/test/functional/feature_minchainwork.py
index 5c225266..4523acef 100755
--- a/depend/bitcoin/test/functional/feature_minchainwork.py
+++ b/depend/bitcoin/test/functional/feature_minchainwork.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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 logic for setting nMinimumChainWork on command line.
diff --git a/depend/bitcoin/test/functional/feature_nulldummy.py b/depend/bitcoin/test/functional/feature_nulldummy.py
index 95760e6a..8925ddaf 100755
--- a/depend/bitcoin/test/functional/feature_nulldummy.py
+++ b/depend/bitcoin/test/functional/feature_nulldummy.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2022 The Bitcoin Core developers
+# Copyright (c) 2016-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 NULLDUMMY softfork.
diff --git a/depend/bitcoin/test/functional/feature_posix_fs_permissions.py b/depend/bitcoin/test/functional/feature_posix_fs_permissions.py
index 28b18038..e1884694 100755
--- a/depend/bitcoin/test/functional/feature_posix_fs_permissions.py
+++ b/depend/bitcoin/test/functional/feature_posix_fs_permissions.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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 file system permissions for POSIX platforms.
diff --git a/depend/bitcoin/test/functional/feature_presegwit_node_upgrade.py b/depend/bitcoin/test/functional/feature_presegwit_node_upgrade.py
index 8c1bd900..759a9296 100755
--- a/depend/bitcoin/test/functional/feature_presegwit_node_upgrade.py
+++ b/depend/bitcoin/test/functional/feature_presegwit_node_upgrade.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2021 The Bitcoin Core developers
+# Copyright (c) 2017-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 a pre-segwit node upgrading to segwit consensus"""
diff --git a/depend/bitcoin/test/functional/feature_proxy.py b/depend/bitcoin/test/functional/feature_proxy.py
index aec81fa7..e95d5ed4 100755
--- a/depend/bitcoin/test/functional/feature_proxy.py
+++ b/depend/bitcoin/test/functional/feature_proxy.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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 bitcoind with different proxy configuration.
diff --git a/depend/bitcoin/test/functional/feature_pruning.py b/depend/bitcoin/test/functional/feature_pruning.py
index 76c79fe0..2c601b6a 100755
--- a/depend/bitcoin/test/functional/feature_pruning.py
+++ b/depend/bitcoin/test/functional/feature_pruning.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 the pruning code.
diff --git a/depend/bitcoin/test/functional/feature_rbf.py b/depend/bitcoin/test/functional/feature_rbf.py
index 4b2c89f3..a2c8cb60 100755
--- a/depend/bitcoin/test/functional/feature_rbf.py
+++ b/depend/bitcoin/test/functional/feature_rbf.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 the RBF code."""
diff --git a/depend/bitcoin/test/functional/feature_reindex.py b/depend/bitcoin/test/functional/feature_reindex.py
index 1ebfe82d..1e6c1490 100755
--- a/depend/bitcoin/test/functional/feature_reindex.py
+++ b/depend/bitcoin/test/functional/feature_reindex.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2021 The Bitcoin Core developers
+# Copyright (c) 2014-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 running bitcoind with -reindex and -reindex-chainstate options.
diff --git a/depend/bitcoin/test/functional/feature_segwit.py b/depend/bitcoin/test/functional/feature_segwit.py
index 80266aa2..dc5dde9c 100755
--- a/depend/bitcoin/test/functional/feature_segwit.py
+++ b/depend/bitcoin/test/functional/feature_segwit.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2022 The Bitcoin Core developers
+# Copyright (c) 2016-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 the SegWit changeover logic."""
diff --git a/depend/bitcoin/test/functional/feature_settings.py b/depend/bitcoin/test/functional/feature_settings.py
index 0ec69f75..9a4138b9 100755
--- a/depend/bitcoin/test/functional/feature_settings.py
+++ b/depend/bitcoin/test/functional/feature_settings.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2021 The Bitcoin Core developers
+# Copyright (c) 2017-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 various command line arguments and configuration file parameters."""
diff --git a/depend/bitcoin/test/functional/feature_shutdown.py b/depend/bitcoin/test/functional/feature_shutdown.py
index a7277be3..3b4c35cb 100755
--- a/depend/bitcoin/test/functional/feature_shutdown.py
+++ b/depend/bitcoin/test/functional/feature_shutdown.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2020 The Bitcoin Core developers
+# 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.
 """Test bitcoind shutdown."""
diff --git a/depend/bitcoin/test/functional/feature_signet.py b/depend/bitcoin/test/functional/feature_signet.py
index 02e37f0f..b8219e97 100755
--- a/depend/bitcoin/test/functional/feature_signet.py
+++ b/depend/bitcoin/test/functional/feature_signet.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2019-2022 The Bitcoin Core developers
+# Copyright (c) 2019-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 basic signet functionality"""
diff --git a/depend/bitcoin/test/functional/feature_uacomment.py b/depend/bitcoin/test/functional/feature_uacomment.py
index fc372f54..12fcd129 100755
--- a/depend/bitcoin/test/functional/feature_uacomment.py
+++ b/depend/bitcoin/test/functional/feature_uacomment.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2019 The Bitcoin Core developers
+# Copyright (c) 2017-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 the -uacomment option."""
diff --git a/depend/bitcoin/test/functional/feature_unsupported_utxo_db.py b/depend/bitcoin/test/functional/feature_unsupported_utxo_db.py
index 694a8e06..a71ae223 100755
--- a/depend/bitcoin/test/functional/feature_unsupported_utxo_db.py
+++ b/depend/bitcoin/test/functional/feature_unsupported_utxo_db.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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 that unsupported utxo db causes an init error.
diff --git a/depend/bitcoin/test/functional/feature_utxo_set_hash.py b/depend/bitcoin/test/functional/feature_utxo_set_hash.py
index 1b49a7d8..733b1fea 100755
--- a/depend/bitcoin/test/functional/feature_utxo_set_hash.py
+++ b/depend/bitcoin/test/functional/feature_utxo_set_hash.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2022 The Bitcoin Core developers
+# Copyright (c) 2020-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 UTXO set hash value calculation in gettxoutsetinfo."""
diff --git a/depend/bitcoin/test/functional/interface_bitcoin_cli.py b/depend/bitcoin/test/functional/interface_bitcoin_cli.py
index 1d917749..8b7c8616 100755
--- a/depend/bitcoin/test/functional/interface_bitcoin_cli.py
+++ b/depend/bitcoin/test/functional/interface_bitcoin_cli.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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 bitcoin-cli"""
diff --git a/depend/bitcoin/test/functional/interface_http.py b/depend/bitcoin/test/functional/interface_http.py
index a10132e2..60e2b8ca 100755
--- a/depend/bitcoin/test/functional/interface_http.py
+++ b/depend/bitcoin/test/functional/interface_http.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2021 The Bitcoin Core developers
+# Copyright (c) 2014-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 the RPC HTTP basics."""
diff --git a/depend/bitcoin/test/functional/interface_ipc.py b/depend/bitcoin/test/functional/interface_ipc.py
index 75d340d5..7c8f51a8 100755
--- a/depend/bitcoin/test/functional/interface_ipc.py
+++ b/depend/bitcoin/test/functional/interface_ipc.py
@@ -4,6 +4,8 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the IPC (multiprocess) interface."""
 import asyncio
+import inspect
+from contextlib import asynccontextmanager, AsyncExitStack
 from io import BytesIO
 from pathlib import Path
 import shutil
@@ -21,6 +23,44 @@
 except ImportError:
     pass
 
+@asynccontextmanager
+async def destroying(obj, ctx):
+    """Call obj.destroy(ctx) at end of with: block. Similar to contextlib.closing."""
+    try:
+        yield obj
+    finally:
+        await obj.destroy(ctx)
+
+async def create_block_template(mining, stack, ctx, opts):
+    """Call mining.createNewBlock() and return template, then call template.destroy() when stack exits."""
+    return await stack.enter_async_context(destroying((await mining.createNewBlock(opts)).result, ctx))
+
+async def wait_next_template(template, stack, ctx, opts):
+    """Call template.waitNext() and return template, then call template.destroy() when stack exits."""
+    return await stack.enter_async_context(destroying((await template.waitNext(ctx, opts)).result, ctx))
+
+async def wait_and_do(wait_fn, do_fn):
+    """Call wait_fn, then sleep, then call do_fn in a parallel task. Wait for
+    both tasks to complete."""
+    wait_started = asyncio.Event()
+    result = None
+
+    async def wait():
+        nonlocal result
+        wait_started.set()
+        result = await wait_fn
+
+    async def do():
+        await wait_started.wait()
+        await asyncio.sleep(0.1)
+        # Let do_fn be either a callable or an awaitable object
+        if inspect.isawaitable(do_fn):
+            await do_fn
+        else:
+            do_fn()
+
+    await asyncio.gather(wait(), do())
+    return result
 
 class IPCInterfaceTest(BitcoinTestFramework):
 
@@ -77,13 +117,13 @@ async def make_capnp_init_ctx(self):
         return ctx, init
 
     async def parse_and_deserialize_block(self, block_template, ctx):
-        block_data = BytesIO((await block_template.result.getBlock(ctx)).result)
+        block_data = BytesIO((await block_template.getBlock(ctx)).result)
         block = CBlock()
         block.deserialize(block_data)
         return block
 
     async def parse_and_deserialize_coinbase_tx(self, block_template, ctx):
-        coinbase_data = BytesIO((await block_template.result.getCoinbaseTx(ctx)).result)
+        coinbase_data = BytesIO((await block_template.getCoinbaseTx(ctx)).result)
         tx = CTransaction()
         tx.deserialize(coinbase_data)
         return tx
@@ -112,148 +152,142 @@ def run_mining_test(self):
         async def async_routine():
             ctx, init = await self.make_capnp_init_ctx()
             self.log.debug("Create Mining proxy object")
-            mining = init.makeMining(ctx)
+            mining = init.makeMining(ctx).result
             self.log.debug("Test simple inspectors")
-            assert (await mining.result.isTestChain(ctx))
-            assert (await mining.result.isInitialBlockDownload(ctx))
-            blockref = await mining.result.getTip(ctx)
+            assert (await mining.isTestChain(ctx)).result
+            assert not (await mining.isInitialBlockDownload(ctx)).result
+            blockref = await mining.getTip(ctx)
             assert blockref.hasResult
             assert_equal(len(blockref.result.hash), block_hash_size)
             current_block_height = self.nodes[0].getchaintips()[0]["height"]
             assert blockref.result.height == current_block_height
             self.log.debug("Mine a block")
-            wait = mining.result.waitTipChanged(ctx, blockref.result.hash, )
-            self.generate(self.nodes[0], 1)
-            newblockref = await wait
-            assert_equal(len(newblockref.result.hash), block_hash_size)
-            assert_equal(newblockref.result.height, current_block_height + 1)
+            newblockref = (await wait_and_do(
+                mining.waitTipChanged(ctx, blockref.result.hash, timeout),
+                lambda: self.generate(self.nodes[0], 1))).result
+            assert_equal(len(newblockref.hash), block_hash_size)
+            assert_equal(newblockref.height, current_block_height + 1)
             self.log.debug("Wait for timeout")
-            wait = mining.result.waitTipChanged(ctx, newblockref.result.hash, timeout)
-            oldblockref = await wait
-            assert_equal(len(newblockref.result.hash), block_hash_size)
-            assert_equal(oldblockref.result.hash, newblockref.result.hash)
-            assert_equal(oldblockref.result.height, newblockref.result.height)
-
-            self.log.debug("Create a template")
-            opts = self.capnp_modules['mining'].BlockCreateOptions()
-            opts.useMempool = True
-            opts.blockReservedWeight = 4000
-            opts.coinbaseOutputMaxAdditionalSigops = 0
-            template = mining.result.createNewBlock(opts)
-            self.log.debug("Test some inspectors of Template")
-            header = await template.result.getBlockHeader(ctx)
-            assert_equal(len(header.result), block_header_size)
-            block = await self.parse_and_deserialize_block(template, ctx)
-            assert_equal(ser_uint256(block.hashPrevBlock), newblockref.result.hash)
-            assert len(block.vtx) >= 1
-            txfees = await template.result.getTxFees(ctx)
-            assert_equal(len(txfees.result), 0)
-            txsigops = await template.result.getTxSigops(ctx)
-            assert_equal(len(txsigops.result), 0)
-            coinbase_data = BytesIO((await template.result.getCoinbaseTx(ctx)).result)
-            coinbase = CTransaction()
-            coinbase.deserialize(coinbase_data)
-            assert_equal(coinbase.vin[0].prevout.hash, 0)
-            self.log.debug("Wait for a new template")
-            waitoptions = self.capnp_modules['mining'].BlockWaitOptions()
-            waitoptions.timeout = timeout
-            waitoptions.feeThreshold = 1
-            waitnext = template.result.waitNext(ctx, waitoptions)
-            self.generate(self.nodes[0], 1)
-            template2 = await waitnext
-            block2 = await self.parse_and_deserialize_block(template2, ctx)
-            assert_equal(len(block2.vtx), 1)
-            self.log.debug("Wait for another, but time out")
-            template3 = await template2.result.waitNext(ctx, waitoptions)
-            assert_equal(template3.to_dict(), {})
-            self.log.debug("Wait for another, get one after increase in fees in the mempool")
-            waitnext = template2.result.waitNext(ctx, waitoptions)
-            miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0])
-            template4 = await waitnext
-            block3 = await self.parse_and_deserialize_block(template4, ctx)
-            assert_equal(len(block3.vtx), 2)
-            self.log.debug("Wait again, this should return the same template, since the fee threshold is zero")
-            waitoptions.feeThreshold = 0
-            template5 = await template4.result.waitNext(ctx, waitoptions)
-            block4 = await self.parse_and_deserialize_block(template5, ctx)
-            assert_equal(len(block4.vtx), 2)
-            waitoptions.feeThreshold = 1
-            self.log.debug("Wait for another, get one after increase in fees in the mempool")
-            waitnext = template5.result.waitNext(ctx, waitoptions)
-            miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0])
-            template6 = await waitnext
-            block4 = await self.parse_and_deserialize_block(template6, ctx)
-            assert_equal(len(block4.vtx), 3)
-            self.log.debug("Wait for another, but time out, since the fee threshold is set now")
-            template7 = await template6.result.waitNext(ctx, waitoptions)
-            assert_equal(template7.to_dict(), {})
-
-            self.log.debug("interruptWait should abort the current wait")
-            wait_started = asyncio.Event()
-            async def wait_for_block():
-                new_waitoptions = self.capnp_modules['mining'].BlockWaitOptions()
-                new_waitoptions.timeout = waitoptions.timeout * 60 # 1 minute wait
-                new_waitoptions.feeThreshold = 1
-                wait_started.set()
-                return await template6.result.waitNext(ctx, new_waitoptions)
-
-            async def interrupt_wait():
-                await wait_started.wait() # Wait for confirmation wait started
-                await asyncio.sleep(0.1)  # Minimal buffer
-                template6.result.interruptWait()
-                miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0])
-
-            wait_task = asyncio.create_task(wait_for_block())
-            interrupt_task = asyncio.create_task(interrupt_wait())
-
-            result = await wait_task
-            await interrupt_task
-            assert_equal(result.to_dict(), {})
+            oldblockref = (await mining.waitTipChanged(ctx, newblockref.hash, timeout)).result
+            assert_equal(len(newblockref.hash), block_hash_size)
+            assert_equal(oldblockref.hash, newblockref.hash)
+            assert_equal(oldblockref.height, newblockref.height)
+
+            async with AsyncExitStack() as stack:
+                self.log.debug("Create a template")
+                opts = self.capnp_modules['mining'].BlockCreateOptions()
+                opts.useMempool = True
+                opts.blockReservedWeight = 4000
+                opts.coinbaseOutputMaxAdditionalSigops = 0
+                template = await create_block_template(mining, stack, ctx, opts)
+
+                self.log.debug("Test some inspectors of Template")
+                header = (await template.getBlockHeader(ctx)).result
+                assert_equal(len(header), block_header_size)
+                block = await self.parse_and_deserialize_block(template, ctx)
+                assert_equal(ser_uint256(block.hashPrevBlock), newblockref.hash)
+                assert len(block.vtx) >= 1
+                txfees = await template.getTxFees(ctx)
+                assert_equal(len(txfees.result), 0)
+                txsigops = await template.getTxSigops(ctx)
+                assert_equal(len(txsigops.result), 0)
+                coinbase_data = BytesIO((await template.getCoinbaseTx(ctx)).result)
+                coinbase = CTransaction()
+                coinbase.deserialize(coinbase_data)
+                assert_equal(coinbase.vin[0].prevout.hash, 0)
+
+                self.log.debug("Wait for a new template")
+                waitoptions = self.capnp_modules['mining'].BlockWaitOptions()
+                waitoptions.timeout = timeout
+                waitoptions.feeThreshold = 1
+                template2 = await wait_and_do(
+                    wait_next_template(template, stack, ctx, waitoptions),
+                    lambda: self.generate(self.nodes[0], 1))
+                block2 = await self.parse_and_deserialize_block(template2, ctx)
+                assert_equal(len(block2.vtx), 1)
+
+                self.log.debug("Wait for another, but time out")
+                template3 = await template2.waitNext(ctx, waitoptions)
+                assert_equal(template3._has("result"), False)
+
+                self.log.debug("Wait for another, get one after increase in fees in the mempool")
+                template4 = await wait_and_do(
+                    wait_next_template(template2, stack, ctx, waitoptions),
+                    lambda: miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0]))
+                block3 = await self.parse_and_deserialize_block(template4, ctx)
+                assert_equal(len(block3.vtx), 2)
+
+                self.log.debug("Wait again, this should return the same template, since the fee threshold is zero")
+                waitoptions.feeThreshold = 0
+                template5 = await wait_next_template(template4, stack, ctx, waitoptions)
+                block4 = await self.parse_and_deserialize_block(template5, ctx)
+                assert_equal(len(block4.vtx), 2)
+                waitoptions.feeThreshold = 1
+
+                self.log.debug("Wait for another, get one after increase in fees in the mempool")
+                template6 = await wait_and_do(
+                    wait_next_template(template5, stack, ctx, waitoptions),
+                    lambda: miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0]))
+                block4 = await self.parse_and_deserialize_block(template6, ctx)
+                assert_equal(len(block4.vtx), 3)
+
+                self.log.debug("Wait for another, but time out, since the fee threshold is set now")
+                template7 = await template6.waitNext(ctx, waitoptions)
+                assert_equal(template7._has("result"), False)
+
+                self.log.debug("interruptWait should abort the current wait")
+                async def wait_for_block():
+                    new_waitoptions = self.capnp_modules['mining'].BlockWaitOptions()
+                    new_waitoptions.timeout = waitoptions.timeout * 60 # 1 minute wait
+                    new_waitoptions.feeThreshold = 1
+                    template7 = await template6.waitNext(ctx, new_waitoptions)
+                    assert_equal(template7._has("result"), False)
+                await wait_and_do(wait_for_block(), template6.interruptWait())
 
             current_block_height = self.nodes[0].getchaintips()[0]["height"]
             check_opts = self.capnp_modules['mining'].BlockCheckOptions()
-            template = await mining.result.createNewBlock(opts)
-            block = await self.parse_and_deserialize_block(template, ctx)
-            coinbase = await self.parse_and_deserialize_coinbase_tx(template, ctx)
-            balance = miniwallet.get_balance()
-            coinbase.vout[0].scriptPubKey = miniwallet.get_output_script()
-            coinbase.vout[0].nValue = COIN
-            block.vtx[0] = coinbase
-            block.hashMerkleRoot = block.calc_merkle_root()
-            original_version = block.nVersion
-            self.log.debug("Submit a block with a bad version")
-            block.nVersion = 0
-            block.solve()
-            res = await mining.result.checkBlock(block.serialize(), check_opts)
-            assert_equal(res.result, False)
-            assert_equal(res.reason, "bad-version(0x00000000)")
-            res = await template.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())
-            assert_equal(res.result, False)
-            self.log.debug("Submit a valid block")
-            block.nVersion = original_version
-            block.solve()
-
-            self.log.debug("First call checkBlock()")
-            res = await mining.result.checkBlock(block.serialize(), check_opts)
-            assert_equal(res.result, True)
-
-            # The remote template block will be mutated, capture the original:
-            remote_block_before = await self.parse_and_deserialize_block(template, ctx)
-
-            self.log.debug("Submitted coinbase must include witness")
-            assert_not_equal(coinbase.serialize_without_witness().hex(), coinbase.serialize().hex())
-            res = await template.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize_without_witness())
-            assert_equal(res.result, False)
-
-            self.log.debug("Even a rejected submitBlock() mutates the template's block")
-            # Can be used by clients to download and inspect the (rejected)
-            # reconstructed block.
-            remote_block_after = await self.parse_and_deserialize_block(template, ctx)
-            assert_not_equal(remote_block_before.serialize().hex(), remote_block_after.serialize().hex())
-
-            self.log.debug("Submit again, with the witness")
-            res = await template.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())
-            assert_equal(res.result, True)
+            async with destroying((await mining.createNewBlock(opts)).result, ctx) as template:
+                block = await self.parse_and_deserialize_block(template, ctx)
+                coinbase = await self.parse_and_deserialize_coinbase_tx(template, ctx)
+                balance = miniwallet.get_balance()
+                coinbase.vout[0].scriptPubKey = miniwallet.get_output_script()
+                coinbase.vout[0].nValue = COIN
+                block.vtx[0] = coinbase
+                block.hashMerkleRoot = block.calc_merkle_root()
+                original_version = block.nVersion
+                self.log.debug("Submit a block with a bad version")
+                block.nVersion = 0
+                block.solve()
+                check = await mining.checkBlock(block.serialize(), check_opts)
+                assert_equal(check.result, False)
+                assert_equal(check.reason, "bad-version(0x00000000)")
+                submitted = (await template.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())).result
+                assert_equal(submitted, False)
+                self.log.debug("Submit a valid block")
+                block.nVersion = original_version
+                block.solve()
+
+                self.log.debug("First call checkBlock()")
+                block_valid = (await mining.checkBlock(block.serialize(), check_opts)).result
+                assert_equal(block_valid, True)
+
+                # The remote template block will be mutated, capture the original:
+                remote_block_before = await self.parse_and_deserialize_block(template, ctx)
+
+                self.log.debug("Submitted coinbase must include witness")
+                assert_not_equal(coinbase.serialize_without_witness().hex(), coinbase.serialize().hex())
+                submitted = (await template.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize_without_witness())).result
+                assert_equal(submitted, False)
+
+                self.log.debug("Even a rejected submitBlock() mutates the template's block")
+                # Can be used by clients to download and inspect the (rejected)
+                # reconstructed block.
+                remote_block_after = await self.parse_and_deserialize_block(template, ctx)
+                assert_not_equal(remote_block_before.serialize().hex(), remote_block_after.serialize().hex())
+
+                self.log.debug("Submit again, with the witness")
+                submitted = (await template.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())).result
+                assert_equal(submitted, True)
 
             self.log.debug("Block should propagate")
             # Check that the IPC node actually updates its own chain
@@ -266,18 +300,10 @@ async def interrupt_wait():
             miniwallet.rescan_utxos()
             assert_equal(miniwallet.get_balance(), balance + 1)
             self.log.debug("Check block should fail now, since it is a duplicate")
-            res = await mining.result.checkBlock(block.serialize(), check_opts)
-            assert_equal(res.result, False)
-            assert_equal(res.reason, "inconclusive-not-best-prevblk")
-
-            self.log.debug("Destroy template objects")
-            template.result.destroy(ctx)
-            template2.result.destroy(ctx)
-            template3.result.destroy(ctx)
-            template4.result.destroy(ctx)
-            template5.result.destroy(ctx)
-            template6.result.destroy(ctx)
-            template7.result.destroy(ctx)
+            check = await mining.checkBlock(block.serialize(), check_opts)
+            assert_equal(check.result, False)
+            assert_equal(check.reason, "inconclusive-not-best-prevblk")
+
         asyncio.run(capnp.run(async_routine()))
 
     def run_test(self):
diff --git a/depend/bitcoin/test/functional/interface_rest.py b/depend/bitcoin/test/functional/interface_rest.py
index be5bb78b..2009752c 100755
--- a/depend/bitcoin/test/functional/interface_rest.py
+++ b/depend/bitcoin/test/functional/interface_rest.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 the REST API."""
@@ -84,7 +84,7 @@ def test_rest_request(
             conn.request('POST', rest_uri, body)
         resp = conn.getresponse()
 
-        assert resp.status == status, f"Expected: {status}, Got: {resp.status} - Response: {str(resp.read())}"
+        assert resp.status == status, f"Expected: {status}, Got: {resp.status} ({resp.reason}) - Response: {str(resp.read())}"
 
         if ret_type == RetType.OBJ:
             return resp
@@ -485,12 +485,15 @@ def get_block_part(status: int = 200, **kwargs):
 
             get_block_part(status=400, query_params={"offset": 0, "size": 0})
             get_block_part(status=400, query_params={"offset": len(block_bin), "size": 0})
-            get_block_part(status=400, query_params={"offset": len(block_bin) + 1, "size": 1})
             get_block_part(status=400, query_params={"offset": len(block_bin), "size": 1})
             get_block_part(status=400, query_params={"offset": len(block_bin) + 1, "size": 1})
             get_block_part(status=400, query_params={"offset": 0, "size": len(block_bin) + 1})
 
-        self.test_rest_request(f"/blockpart/{blockhash}", status=400, req_type=ReqType.JSON, ret_type=RetType.OBJ)
+        res = self.test_rest_request(f"/blockpart/{blockhash}", status=400, req_type=ReqType.BIN, ret_type=RetType.OBJ)
+        assert res.read().decode().startswith("Block part offset missing or invalid")
+
+        res = self.test_rest_request(f"/blockpart/{blockhash}", query_params={"offset":0, "size":1}, status=400, req_type=ReqType.JSON, ret_type=RetType.OBJ)
+        assert res.read().decode().startswith("JSON output is not supported for this request type")
 
         self.log.info("Missing block data should cause REST API to fail")
 
diff --git a/depend/bitcoin/test/functional/interface_rpc.py b/depend/bitcoin/test/functional/interface_rpc.py
index 9074f0a2..46dbd2f8 100755
--- a/depend/bitcoin/test/functional/interface_rpc.py
+++ b/depend/bitcoin/test/functional/interface_rpc.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2022 The Bitcoin Core developers
+# 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.
 """Tests some generic aspects of the RPC interface."""
diff --git a/depend/bitcoin/test/functional/interface_zmq.py b/depend/bitcoin/test/functional/interface_zmq.py
index 11cd8e63..67170076 100755
--- a/depend/bitcoin/test/functional/interface_zmq.py
+++ b/depend/bitcoin/test/functional/interface_zmq.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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 the ZMQ notification interface."""
diff --git a/depend/bitcoin/test/functional/mempool_accept.py b/depend/bitcoin/test/functional/mempool_accept.py
index 7dbd7ba1..5893b1cc 100755
--- a/depend/bitcoin/test/functional/mempool_accept.py
+++ b/depend/bitcoin/test/functional/mempool_accept.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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 mempool acceptance of raw transactions."""
diff --git a/depend/bitcoin/test/functional/mempool_accept_wtxid.py b/depend/bitcoin/test/functional/mempool_accept_wtxid.py
index fdb88cd4..60fa580f 100755
--- a/depend/bitcoin/test/functional/mempool_accept_wtxid.py
+++ b/depend/bitcoin/test/functional/mempool_accept_wtxid.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """
diff --git a/depend/bitcoin/test/functional/mempool_cluster.py b/depend/bitcoin/test/functional/mempool_cluster.py
index c8d09c21..921f7441 100755
--- a/depend/bitcoin/test/functional/mempool_cluster.py
+++ b/depend/bitcoin/test/functional/mempool_cluster.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2024 The Bitcoin Core developers
+# Copyright (c) 2024-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test cluster mempool accessors and limits"""
diff --git a/depend/bitcoin/test/functional/mempool_compatibility.py b/depend/bitcoin/test/functional/mempool_compatibility.py
index 51b0cd63..4f824b9f 100755
--- a/depend/bitcoin/test/functional/mempool_compatibility.py
+++ b/depend/bitcoin/test/functional/mempool_compatibility.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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 that mempool.dat is both backward and forward compatible between versions
diff --git a/depend/bitcoin/test/functional/mempool_datacarrier.py b/depend/bitcoin/test/functional/mempool_datacarrier.py
index ca113fcb..8e17d4a3 100755
--- a/depend/bitcoin/test/functional/mempool_datacarrier.py
+++ b/depend/bitcoin/test/functional/mempool_datacarrier.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2022 The Bitcoin Core developers
+# Copyright (c) 2020-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 datacarrier functionality"""
diff --git a/depend/bitcoin/test/functional/mempool_dust.py b/depend/bitcoin/test/functional/mempool_dust.py
index 937e77fb..957cfccc 100755
--- a/depend/bitcoin/test/functional/mempool_dust.py
+++ b/depend/bitcoin/test/functional/mempool_dust.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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 dust limit mempool policy (`-dustrelayfee` parameter)"""
diff --git a/depend/bitcoin/test/functional/mempool_ephemeral_dust.py b/depend/bitcoin/test/functional/mempool_ephemeral_dust.py
index 0616ae8f..7d45fcb8 100755
--- a/depend/bitcoin/test/functional/mempool_ephemeral_dust.py
+++ b/depend/bitcoin/test/functional/mempool_ephemeral_dust.py
@@ -216,18 +216,16 @@ def test_nonzero_dust(self):
         self.connect_nodes(0, 1)
         assert_mempool_contents(self, self.nodes[0], expected=[])
 
-    # N.B. If individual minrelay requirement is dropped, this test can be dropped
     def test_non_truc(self):
-        self.log.info("Test that v2 dust-having transaction is rejected even if spent, because of min relay requirement")
+        self.log.info("Test that v2 dust-having transaction is also accepted if spent")
 
         assert_equal(self.nodes[0].getrawmempool(), [])
         dusty_tx, sweep_tx = self.create_ephemeral_dust_package(tx_version=2)
 
         res = self.nodes[0].submitpackage([dusty_tx["hex"], sweep_tx["hex"]])
-        assert_equal(res["package_msg"], "transaction failed")
-        assert_equal(res["tx-results"][dusty_tx["wtxid"]]["error"], "min relay fee not met, 0 < 15")
-
-        assert_equal(self.nodes[0].getrawmempool(), [])
+        assert_equal(res["package_msg"], "success")
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"], sweep_tx["tx"]])
+        self.generate(self.nodes[0], 1)
 
     def test_unspent_ephemeral(self):
         self.log.info("Test that spending from a tx with ephemeral outputs is only allowed if dust is spent as well")
diff --git a/depend/bitcoin/test/functional/mempool_expiry.py b/depend/bitcoin/test/functional/mempool_expiry.py
index 2bd88f98..f33c5331 100755
--- a/depend/bitcoin/test/functional/mempool_expiry.py
+++ b/depend/bitcoin/test/functional/mempool_expiry.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2022 The Bitcoin Core developers
+# Copyright (c) 2020-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.
 """Tests that a mempool transaction expires after a given timeout and that its
diff --git a/depend/bitcoin/test/functional/mempool_limit.py b/depend/bitcoin/test/functional/mempool_limit.py
index 8b9fd381..597d02f9 100755
--- a/depend/bitcoin/test/functional/mempool_limit.py
+++ b/depend/bitcoin/test/functional/mempool_limit.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 mempool limiting together/eviction with the wallet."""
diff --git a/depend/bitcoin/test/functional/mempool_package_limits.py b/depend/bitcoin/test/functional/mempool_package_limits.py
index 3f267779..8c0ae358 100755
--- a/depend/bitcoin/test/functional/mempool_package_limits.py
+++ b/depend/bitcoin/test/functional/mempool_package_limits.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021-2022 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test logic for limiting mempool and package ancestors/descendants."""
diff --git a/depend/bitcoin/test/functional/mempool_package_rbf.py b/depend/bitcoin/test/functional/mempool_package_rbf.py
index c54534f6..bc361db6 100755
--- a/depend/bitcoin/test/functional/mempool_package_rbf.py
+++ b/depend/bitcoin/test/functional/mempool_package_rbf.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/test/functional/mempool_packages.py b/depend/bitcoin/test/functional/mempool_packages.py
index 4a20d576..ca6675d3 100755
--- a/depend/bitcoin/test/functional/mempool_packages.py
+++ b/depend/bitcoin/test/functional/mempool_packages.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 descendant package tracking code."""
@@ -239,8 +239,9 @@ def run_test(self):
         self.generate(self.nodes[0], 1)
         self.trigger_reorg(fork_blocks, self.nodes[0])
 
-        # Check if the txs are returned to the mempool
-        assert_equal(self.nodes[0].getrawmempool(), mempool0)
+        # Check if the txs are returned to the mempool (though the transaction ordering may
+        # change as it is non-deterministic).
+        assert_equal(set(self.nodes[0].getrawmempool()), set(mempool0))
 
         # Clean-up the mempool
         self.generate(self.nodes[0], 1)
diff --git a/depend/bitcoin/test/functional/mempool_persist.py b/depend/bitcoin/test/functional/mempool_persist.py
index ceb69cf1..ce3981a3 100755
--- a/depend/bitcoin/test/functional/mempool_persist.py
+++ b/depend/bitcoin/test/functional/mempool_persist.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 mempool persistence.
diff --git a/depend/bitcoin/test/functional/mempool_reorg.py b/depend/bitcoin/test/functional/mempool_reorg.py
index 1a697bd5..556cf4cf 100755
--- a/depend/bitcoin/test/functional/mempool_reorg.py
+++ b/depend/bitcoin/test/functional/mempool_reorg.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 mempool re-org scenarios.
diff --git a/depend/bitcoin/test/functional/mempool_resurrect.py b/depend/bitcoin/test/functional/mempool_resurrect.py
index 51890507..b43ed408 100755
--- a/depend/bitcoin/test/functional/mempool_resurrect.py
+++ b/depend/bitcoin/test/functional/mempool_resurrect.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2021 The Bitcoin Core developers
+# Copyright (c) 2014-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 resurrection of mined transactions when the blockchain is re-organized."""
diff --git a/depend/bitcoin/test/functional/mempool_sigoplimit.py b/depend/bitcoin/test/functional/mempool_sigoplimit.py
index 3b2d7373..932e045a 100755
--- a/depend/bitcoin/test/functional/mempool_sigoplimit.py
+++ b/depend/bitcoin/test/functional/mempool_sigoplimit.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2023 The Bitcoin Core developers
+# Copyright (c) 2023-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test sigop limit mempool policy (`-bytespersigop` parameter)"""
diff --git a/depend/bitcoin/test/functional/mempool_spend_coinbase.py b/depend/bitcoin/test/functional/mempool_spend_coinbase.py
index 64ab33d3..b09041c7 100755
--- a/depend/bitcoin/test/functional/mempool_spend_coinbase.py
+++ b/depend/bitcoin/test/functional/mempool_spend_coinbase.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 spending coinbase transactions.
diff --git a/depend/bitcoin/test/functional/mempool_truc.py b/depend/bitcoin/test/functional/mempool_truc.py
index 3f55e481..2586308e 100755
--- a/depend/bitcoin/test/functional/mempool_truc.py
+++ b/depend/bitcoin/test/functional/mempool_truc.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2024 The Bitcoin Core developers
+# Copyright (c) 2024-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 from decimal import Decimal
@@ -612,7 +612,7 @@ def test_reorg_sibling_eviction_1p2c(self):
     @cleanup(extra_args=None)
     def test_minrelay_in_package_combos(self):
         node = self.nodes[0]
-        self.log.info("Test that only TRUC transactions can be under minrelaytxfee for various settings...")
+        self.log.info("Test that all transaction versions can be under minrelaytxfee for various settings...")
 
         for minrelay_setting in (0, 5, 10, 100, 500, 1000, 5000, 333333, 2500000):
             self.log.info(f"-> Test -minrelaytxfee={minrelay_setting}sat/kvB...")
@@ -649,14 +649,8 @@ def test_minrelay_in_package_combos(self):
             assert_equal(result_truc["package_msg"], "success")
 
             result_non_truc = node.submitpackage([tx_v2_0fee_parent["hex"], tx_v2_child["hex"]], maxfeerate=0)
-            if minrelayfeerate > 0:
-                assert_equal(result_non_truc["package_msg"], "transaction failed")
-                min_fee_parent = int(get_fee(tx_v2_0fee_parent["tx"].get_vsize(), minrelayfeerate) * COIN)
-                assert_equal(result_non_truc["tx-results"][tx_v2_0fee_parent["wtxid"]]["error"], f"min relay fee not met, 0 < {min_fee_parent}")
-                self.check_mempool([tx_v3_0fee_parent["txid"], tx_v3_child["txid"]])
-            else:
-                assert_equal(result_non_truc["package_msg"], "success")
-                self.check_mempool([tx_v2_0fee_parent["txid"], tx_v2_child["txid"], tx_v3_0fee_parent["txid"], tx_v3_child["txid"]])
+            assert_equal(result_non_truc["package_msg"], "success")
+            self.check_mempool([tx_v2_0fee_parent["txid"], tx_v2_child["txid"], tx_v3_0fee_parent["txid"], tx_v3_child["txid"]])
 
 
     def run_test(self):
diff --git a/depend/bitcoin/test/functional/mempool_unbroadcast.py b/depend/bitcoin/test/functional/mempool_unbroadcast.py
index 522ea939..953c55c5 100755
--- a/depend/bitcoin/test/functional/mempool_unbroadcast.py
+++ b/depend/bitcoin/test/functional/mempool_unbroadcast.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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 that the mempool ensures transaction delivery by periodically sending
diff --git a/depend/bitcoin/test/functional/mining_basic.py b/depend/bitcoin/test/functional/mining_basic.py
index 7e71761a..750dd42c 100755
--- a/depend/bitcoin/test/functional/mining_basic.py
+++ b/depend/bitcoin/test/functional/mining_basic.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 mining RPCs
diff --git a/depend/bitcoin/test/functional/mining_getblocktemplate_longpoll.py b/depend/bitcoin/test/functional/mining_getblocktemplate_longpoll.py
index 2d15151e..42111696 100755
--- a/depend/bitcoin/test/functional/mining_getblocktemplate_longpoll.py
+++ b/depend/bitcoin/test/functional/mining_getblocktemplate_longpoll.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2021 The Bitcoin Core developers
+# Copyright (c) 2014-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 longpolling with getblocktemplate."""
diff --git a/depend/bitcoin/test/functional/mining_prioritisetransaction.py b/depend/bitcoin/test/functional/mining_prioritisetransaction.py
index c3b56e8d..44ce8a2b 100755
--- a/depend/bitcoin/test/functional/mining_prioritisetransaction.py
+++ b/depend/bitcoin/test/functional/mining_prioritisetransaction.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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 the prioritisetransaction mining RPC."""
diff --git a/depend/bitcoin/test/functional/mining_template_verification.py b/depend/bitcoin/test/functional/mining_template_verification.py
index de0833c5..2087aff4 100755
--- a/depend/bitcoin/test/functional/mining_template_verification.py
+++ b/depend/bitcoin/test/functional/mining_template_verification.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2024-Present The Bitcoin Core developers
+# Copyright (c) 2024-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test getblocktemplate RPC in proposal mode
diff --git a/depend/bitcoin/test/functional/mocks/multi_signers.py b/depend/bitcoin/test/functional/mocks/multi_signers.py
index 88f93e23..96c28820 100755
--- a/depend/bitcoin/test/functional/mocks/multi_signers.py
+++ b/depend/bitcoin/test/functional/mocks/multi_signers.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/test/functional/p2p_addr_relay.py b/depend/bitcoin/test/functional/p2p_addr_relay.py
index 71af7f1e..f89ac701 100755
--- a/depend/bitcoin/test/functional/p2p_addr_relay.py
+++ b/depend/bitcoin/test/functional/p2p_addr_relay.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2021 The Bitcoin Core developers
+# Copyright (c) 2020-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.
 """
diff --git a/depend/bitcoin/test/functional/p2p_addr_selfannouncement.py b/depend/bitcoin/test/functional/p2p_addr_selfannouncement.py
new file mode 100755
index 00000000..1fb91e0a
--- /dev/null
+++ b/depend/bitcoin/test/functional/p2p_addr_selfannouncement.py
@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025-present The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""
+Test that a node sends a self-announcement with its external IP to
+in- and outbound peers after connection open and again sometime later.
+"""
+
+import time
+
+from test_framework.messages import (
+    CAddress,
+    from_hex,
+    msg_headers,
+    CBlockHeader,
+)
+from test_framework.p2p import P2PInterface
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal, assert_greater_than
+
+IP_TO_ANNOUNCE = "42.42.42.42"
+ONE_DAY = 60 * 60 * 24
+
+
+class SelfAnnouncementReceiver(P2PInterface):
+    self_announcements_received = 0
+    addresses_received = 0
+    addr_messages_received = 0
+
+    expected = None
+    addrv2_test = False
+
+    def __init__(self, *, expected, addrv2):
+        super().__init__(support_addrv2=addrv2)
+        self.expected = expected
+        self.addrv2_test = addrv2
+
+    def handle_addr_message(self, message):
+        self.addr_messages_received += 1
+        for addr in message.addrs:
+            self.addresses_received += 1
+            if addr == self.expected:
+                self.self_announcements_received += 1
+
+    def on_addrv2(self, message):
+        assert (self.addrv2_test)
+        self.handle_addr_message(message)
+
+    def on_addr(self, message):
+        assert (not self.addrv2_test)
+        self.handle_addr_message(message)
+
+
+class AddrSelfAnnouncementTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.extra_args = [[f"-externalip={IP_TO_ANNOUNCE}"]]
+
+    def run_test(self):
+        # populate addrman to have some addresses for a GETADDR response
+        for i in range(50):
+            a = f"{1 + i}.{i}.1.1"
+            self.nodes[0].addpeeraddress(a, 8333)
+
+        self.self_announcement_test(outbound=False, addrv2=False)
+        self.self_announcement_test(outbound=False, addrv2=True)
+        self.self_announcement_test(outbound=True, addrv2=False)
+        self.self_announcement_test(outbound=True, addrv2=True)
+
+    def inbound_connection_open_assertions(self, addr_receiver):
+        # We expect one self-announcement and multiple other addresses in
+        # response to a GETADDR in a single addr / addrv2 message.
+        assert_equal(addr_receiver.self_announcements_received, 1)
+        assert_equal(addr_receiver.addr_messages_received, 1)
+        assert_greater_than(addr_receiver.addresses_received, 1)
+
+    def outbound_connection_open_assertions(self, addr_receiver):
+        # We expect only the self-announcement.
+        assert_equal(addr_receiver.self_announcements_received, 1)
+        assert_equal(addr_receiver.addr_messages_received, 1)
+        assert_equal(addr_receiver.addresses_received, 1)
+
+    def self_announcement_test(self, *, outbound, addrv2):
+        connection_type = "outbound" if outbound else "inbound"
+        addr_version = "addrv2" if addrv2 else "addrv1"
+        self.log.info(f"Test that the node does an address self-announcement to {connection_type} connections ({addr_version})")
+
+        # We only self-announce after initial block download is done
+        assert (not self.nodes[0].getblockchaininfo()["initialblockdownload"])
+
+        netinfo = self.nodes[0].getnetworkinfo()
+        port = netinfo["localaddresses"][0]["port"]
+        self.nodes[0].setmocktime(int(time.time()))
+
+        expected = CAddress()
+        expected.nServices = int(netinfo["localservices"], 16)
+        expected.ip = IP_TO_ANNOUNCE
+        expected.port = port
+        expected.time = self.nodes[0].mocktime
+
+        with self.nodes[0].assert_debug_log([f'Advertising address {IP_TO_ANNOUNCE}:{port}']):
+            if outbound:
+                self.log.info(f"Check that we get an initial self-announcement on an outbound connection from the node ({connection_type}, {addr_version})")
+                addr_receiver = self.nodes[0].add_outbound_p2p_connection(SelfAnnouncementReceiver(expected=expected, addrv2=addrv2), p2p_idx=0, connection_type="outbound-full-relay")
+            else:
+                self.log.info(f"Check that we get an initial self-announcement when connecting to a node and sending a GETADDR ({connection_type}, {addr_version})")
+                addr_receiver = self.nodes[0].add_p2p_connection(SelfAnnouncementReceiver(expected=expected, addrv2=addrv2))
+            addr_receiver.sync_with_ping()
+
+        if outbound:
+            self.outbound_connection_open_assertions(addr_receiver)
+        else:
+            self.inbound_connection_open_assertions(addr_receiver)
+
+        if outbound:
+            # to avoid the node evicting the outbound peer, protect it by announcing the most recent header to it
+            tip_header = from_hex(CBlockHeader(), self.nodes[0].getblockheader(self.nodes[0].getbestblockhash(), False))
+            addr_receiver.send_and_ping(msg_headers([tip_header]))
+
+        self.log.info(f"Check that we get more self-announcements sometime later ({connection_type}, {addr_version})")
+        for _ in range(5):
+            last_self_announcements_received = addr_receiver.self_announcements_received
+            last_addr_messages_received = addr_receiver.addr_messages_received
+            last_addresses_received = addr_receiver.addresses_received
+            with self.nodes[0].assert_debug_log([f'Advertising address {IP_TO_ANNOUNCE}:{port}']):
+                # m_next_local_addr_send and AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL:
+                # self-announcements are sent on an exponential distribution with mean interval of 24h.
+                # Setting the mocktime 20d forward gives a probability of (1 - e^-(480/24)) that
+                # the event will occur (i.e. this fails once in ~500 million repeats).
+                self.nodes[0].bumpmocktime(20 * ONE_DAY)
+                addr_receiver.expected.time = self.nodes[0].mocktime
+                addr_receiver.sync_with_ping()
+
+            assert_equal(addr_receiver.self_announcements_received, last_self_announcements_received + 1)
+            assert_equal(addr_receiver.addr_messages_received, last_addr_messages_received + 1)
+            assert_equal(addr_receiver.addresses_received, last_addresses_received + 1)
+
+        self.nodes[0].disconnect_p2ps()
+
+if __name__ == '__main__':
+    AddrSelfAnnouncementTest(__file__).main()
diff --git a/depend/bitcoin/test/functional/p2p_addrfetch.py b/depend/bitcoin/test/functional/p2p_addrfetch.py
index 1243f951..49c131f1 100755
--- a/depend/bitcoin/test/functional/p2p_addrfetch.py
+++ b/depend/bitcoin/test/functional/p2p_addrfetch.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """
diff --git a/depend/bitcoin/test/functional/p2p_addrv2_relay.py b/depend/bitcoin/test/functional/p2p_addrv2_relay.py
index 3a14d892..b5fb6229 100755
--- a/depend/bitcoin/test/functional/p2p_addrv2_relay.py
+++ b/depend/bitcoin/test/functional/p2p_addrv2_relay.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2021 The Bitcoin Core developers
+# Copyright (c) 2020-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.
 """
diff --git a/depend/bitcoin/test/functional/p2p_block_sync.py b/depend/bitcoin/test/functional/p2p_block_sync.py
index 51bbac17..ae2ea538 100755
--- a/depend/bitcoin/test/functional/p2p_block_sync.py
+++ b/depend/bitcoin/test/functional/p2p_block_sync.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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 block download
diff --git a/depend/bitcoin/test/functional/p2p_blockfilters.py b/depend/bitcoin/test/functional/p2p_blockfilters.py
index afe5e5d7..32a3db7b 100755
--- a/depend/bitcoin/test/functional/p2p_blockfilters.py
+++ b/depend/bitcoin/test/functional/p2p_blockfilters.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2019-2022 The Bitcoin Core developers
+# Copyright (c) 2019-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.
 """Tests NODE_COMPACT_FILTERS (BIP 157/158).
diff --git a/depend/bitcoin/test/functional/p2p_blocksonly.py b/depend/bitcoin/test/functional/p2p_blocksonly.py
index fca8e326..6a251e69 100755
--- a/depend/bitcoin/test/functional/p2p_blocksonly.py
+++ b/depend/bitcoin/test/functional/p2p_blocksonly.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2019-2022 The Bitcoin Core developers
+# Copyright (c) 2019-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 p2p blocksonly mode & block-relay-only connections."""
diff --git a/depend/bitcoin/test/functional/p2p_compactblocks.py b/depend/bitcoin/test/functional/p2p_compactblocks.py
index a2a3ffe2..81ab3f74 100755
--- a/depend/bitcoin/test/functional/p2p_compactblocks.py
+++ b/depend/bitcoin/test/functional/p2p_compactblocks.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2022 The Bitcoin Core developers
+# Copyright (c) 2016-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 compact blocks (BIP 152)."""
diff --git a/depend/bitcoin/test/functional/p2p_compactblocks_blocksonly.py b/depend/bitcoin/test/functional/p2p_compactblocks_blocksonly.py
index 2979d000..befc283f 100755
--- a/depend/bitcoin/test/functional/p2p_compactblocks_blocksonly.py
+++ b/depend/bitcoin/test/functional/p2p_compactblocks_blocksonly.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021-2021 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test that a node in blocksonly mode does not request compact blocks."""
diff --git a/depend/bitcoin/test/functional/p2p_compactblocks_hb.py b/depend/bitcoin/test/functional/p2p_compactblocks_hb.py
index e4f58e9c..cc330c87 100755
--- a/depend/bitcoin/test/functional/p2p_compactblocks_hb.py
+++ b/depend/bitcoin/test/functional/p2p_compactblocks_hb.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test compact blocks HB selection logic."""
diff --git a/depend/bitcoin/test/functional/p2p_dns_seeds.py b/depend/bitcoin/test/functional/p2p_dns_seeds.py
index 89a29c0e..06db3349 100755
--- a/depend/bitcoin/test/functional/p2p_dns_seeds.py
+++ b/depend/bitcoin/test/functional/p2p_dns_seeds.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test ThreadDNSAddressSeed logic for querying DNS seeds."""
diff --git a/depend/bitcoin/test/functional/p2p_eviction.py b/depend/bitcoin/test/functional/p2p_eviction.py
index 9809faa6..c26e46e7 100755
--- a/depend/bitcoin/test/functional/p2p_eviction.py
+++ b/depend/bitcoin/test/functional/p2p_eviction.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2019-2021 The Bitcoin Core developers
+# Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/test/functional/p2p_feefilter.py b/depend/bitcoin/test/functional/p2p_feefilter.py
index 6b441184..927ef878 100755
--- a/depend/bitcoin/test/functional/p2p_feefilter.py
+++ b/depend/bitcoin/test/functional/p2p_feefilter.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2021 The Bitcoin Core developers
+# Copyright (c) 2016-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 processing of feefilter messages."""
diff --git a/depend/bitcoin/test/functional/p2p_filter.py b/depend/bitcoin/test/functional/p2p_filter.py
index e3612f98..a3fd045b 100755
--- a/depend/bitcoin/test/functional/p2p_filter.py
+++ b/depend/bitcoin/test/functional/p2p_filter.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2021 The Bitcoin Core developers
+# Copyright (c) 2020-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.
 """
diff --git a/depend/bitcoin/test/functional/p2p_fingerprint.py b/depend/bitcoin/test/functional/p2p_fingerprint.py
index 738b10c0..0d97a161 100755
--- a/depend/bitcoin/test/functional/p2p_fingerprint.py
+++ b/depend/bitcoin/test/functional/p2p_fingerprint.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2021 The Bitcoin Core developers
+# Copyright (c) 2017-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 various fingerprinting protections.
diff --git a/depend/bitcoin/test/functional/p2p_getaddr_caching.py b/depend/bitcoin/test/functional/p2p_getaddr_caching.py
index b12a7912..63d34035 100755
--- a/depend/bitcoin/test/functional/p2p_getaddr_caching.py
+++ b/depend/bitcoin/test/functional/p2p_getaddr_caching.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2022 The Bitcoin Core developers
+# Copyright (c) 2020-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 addr response caching"""
diff --git a/depend/bitcoin/test/functional/p2p_getdata.py b/depend/bitcoin/test/functional/p2p_getdata.py
index 96e43560..7a816ae6 100755
--- a/depend/bitcoin/test/functional/p2p_getdata.py
+++ b/depend/bitcoin/test/functional/p2p_getdata.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020 The Bitcoin Core developers
+# Copyright (c) 2020-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 GETDATA processing behavior"""
diff --git a/depend/bitcoin/test/functional/p2p_handshake.py b/depend/bitcoin/test/functional/p2p_handshake.py
index f509ece4..96db741f 100755
--- a/depend/bitcoin/test/functional/p2p_handshake.py
+++ b/depend/bitcoin/test/functional/p2p_handshake.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2024 The Bitcoin Core developers
+# Copyright (c) 2024-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """
diff --git a/depend/bitcoin/test/functional/p2p_i2p_sessions.py b/depend/bitcoin/test/functional/p2p_i2p_sessions.py
index 67474f6c..eb229fb9 100755
--- a/depend/bitcoin/test/functional/p2p_i2p_sessions.py
+++ b/depend/bitcoin/test/functional/p2p_i2p_sessions.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022-2022 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 """
@@ -23,12 +23,12 @@ def run_test(self):
 
         self.log.info("Ensure we create a persistent session when -i2pacceptincoming=1")
         node0 = self.nodes[0]
-        with node0.assert_debug_log(expected_msgs=["Creating persistent SAM session"]):
+        with node0.assert_debug_log(expected_msgs=["Creating persistent I2P SAM session"]):
             node0.addnode(node=addr, command="onetry")
 
         self.log.info("Ensure we create a transient session when -i2pacceptincoming=0")
         node1 = self.nodes[1]
-        with node1.assert_debug_log(expected_msgs=["Creating transient SAM session"]):
+        with node1.assert_debug_log(expected_msgs=["Creating transient I2P SAM session"]):
             node1.addnode(node=addr, command="onetry")
 
 
diff --git a/depend/bitcoin/test/functional/p2p_ibd_stalling.py b/depend/bitcoin/test/functional/p2p_ibd_stalling.py
index c09b2e50..5d80ba90 100755
--- a/depend/bitcoin/test/functional/p2p_ibd_stalling.py
+++ b/depend/bitcoin/test/functional/p2p_ibd_stalling.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022- The Bitcoin Core developers
+# Copyright (c) 2022-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.
 """
diff --git a/depend/bitcoin/test/functional/p2p_ibd_txrelay.py b/depend/bitcoin/test/functional/p2p_ibd_txrelay.py
index 0cd0ac05..423c2a07 100755
--- a/depend/bitcoin/test/functional/p2p_ibd_txrelay.py
+++ b/depend/bitcoin/test/functional/p2p_ibd_txrelay.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2021 The Bitcoin Core developers
+# Copyright (c) 2020-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 transaction relay behavior during IBD:
diff --git a/depend/bitcoin/test/functional/p2p_invalid_block.py b/depend/bitcoin/test/functional/p2p_invalid_block.py
index 88bdbe22..5e2cbb63 100755
--- a/depend/bitcoin/test/functional/p2p_invalid_block.py
+++ b/depend/bitcoin/test/functional/p2p_invalid_block.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2021 The Bitcoin Core developers
+# Copyright (c) 2015-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 responses to invalid blocks.
diff --git a/depend/bitcoin/test/functional/p2p_invalid_locator.py b/depend/bitcoin/test/functional/p2p_invalid_locator.py
index d36f4c6a..a0972fad 100755
--- a/depend/bitcoin/test/functional/p2p_invalid_locator.py
+++ b/depend/bitcoin/test/functional/p2p_invalid_locator.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2021 The Bitcoin Core developers
+# Copyright (c) 2015-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 responses to invalid locators.
diff --git a/depend/bitcoin/test/functional/p2p_invalid_messages.py b/depend/bitcoin/test/functional/p2p_invalid_messages.py
index e629a599..ec0859f5 100755
--- a/depend/bitcoin/test/functional/p2p_invalid_messages.py
+++ b/depend/bitcoin/test/functional/p2p_invalid_messages.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2021 The Bitcoin Core developers
+# Copyright (c) 2015-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 responses to invalid network messages."""
diff --git a/depend/bitcoin/test/functional/p2p_invalid_tx.py b/depend/bitcoin/test/functional/p2p_invalid_tx.py
index 0d4c4ffb..8510a95c 100755
--- a/depend/bitcoin/test/functional/p2p_invalid_tx.py
+++ b/depend/bitcoin/test/functional/p2p_invalid_tx.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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 responses to invalid transactions.
diff --git a/depend/bitcoin/test/functional/p2p_leak.py b/depend/bitcoin/test/functional/p2p_leak.py
index 4b74c55a..ec7b9dc2 100755
--- a/depend/bitcoin/test/functional/p2p_leak.py
+++ b/depend/bitcoin/test/functional/p2p_leak.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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 message sending before handshake completion.
diff --git a/depend/bitcoin/test/functional/p2p_leak_tx.py b/depend/bitcoin/test/functional/p2p_leak_tx.py
index c347f597..04b63e0f 100755
--- a/depend/bitcoin/test/functional/p2p_leak_tx.py
+++ b/depend/bitcoin/test/functional/p2p_leak_tx.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2021 The Bitcoin Core developers
+# Copyright (c) 2017-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 transaction upload"""
diff --git a/depend/bitcoin/test/functional/p2p_message_capture.py b/depend/bitcoin/test/functional/p2p_message_capture.py
index 4c82adc5..11a5c2fe 100755
--- a/depend/bitcoin/test/functional/p2p_message_capture.py
+++ b/depend/bitcoin/test/functional/p2p_message_capture.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2022 The Bitcoin Core developers
+# Copyright (c) 2020-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 per-peer message capture capability.
diff --git a/depend/bitcoin/test/functional/p2p_nobloomfilter_messages.py b/depend/bitcoin/test/functional/p2p_nobloomfilter_messages.py
index 835230fa..2d5d7add 100755
--- a/depend/bitcoin/test/functional/p2p_nobloomfilter_messages.py
+++ b/depend/bitcoin/test/functional/p2p_nobloomfilter_messages.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2020 The Bitcoin Core developers
+# Copyright (c) 2015-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 invalid p2p messages for nodes with bloom filters disabled.
diff --git a/depend/bitcoin/test/functional/p2p_node_network_limited.py b/depend/bitcoin/test/functional/p2p_node_network_limited.py
index 73f52b0e..8140823f 100755
--- a/depend/bitcoin/test/functional/p2p_node_network_limited.py
+++ b/depend/bitcoin/test/functional/p2p_node_network_limited.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2021 The Bitcoin Core developers
+# Copyright (c) 2017-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.
 """Tests NODE_NETWORK_LIMITED.
diff --git a/depend/bitcoin/test/functional/p2p_orphan_handling.py b/depend/bitcoin/test/functional/p2p_orphan_handling.py
index b71af822..4cd59f8f 100755
--- a/depend/bitcoin/test/functional/p2p_orphan_handling.py
+++ b/depend/bitcoin/test/functional/p2p_orphan_handling.py
@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
-# Copyright (c) 2023 The Bitcoin Core developers
+# Copyright (c) 2023-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 import time
 
+from test_framework.blocktools import MAX_STANDARD_TX_WEIGHT
 from test_framework.mempool_util import (
     create_large_orphan,
     tx_in_orphanage,
@@ -188,15 +189,15 @@ def test_orphan_rejected_parents_exceptions(self):
         peer2 = node.add_p2p_connection(PeerTxRelayer())
 
         self.log.info("Test orphan handling when a nonsegwit parent is known to be invalid")
-        parent_low_fee_nonsegwit = self.wallet_nonsegwit.create_self_transfer(fee_rate=0)
-        assert_equal(parent_low_fee_nonsegwit["txid"], parent_low_fee_nonsegwit["tx"].wtxid_hex)
+        parent_overly_large_nonsegwit = self.wallet_nonsegwit.create_self_transfer(target_vsize=int(MAX_STANDARD_TX_WEIGHT / 4) + 1)
+        assert_equal(parent_overly_large_nonsegwit["txid"], parent_overly_large_nonsegwit["tx"].wtxid_hex)
         parent_other = self.wallet_nonsegwit.create_self_transfer()
         child_nonsegwit = self.wallet_nonsegwit.create_self_transfer_multi(
-            utxos_to_spend=[parent_other["new_utxo"], parent_low_fee_nonsegwit["new_utxo"]])
+            utxos_to_spend=[parent_other["new_utxo"], parent_overly_large_nonsegwit["new_utxo"]])
 
-        # Relay the parent. It should be rejected because it pays 0 fees.
-        self.relay_transaction(peer1, parent_low_fee_nonsegwit["tx"])
-        assert parent_low_fee_nonsegwit["txid"] not in node.getrawmempool()
+        # Relay the parent. It should be rejected (and not reconsiderable) because it violated size limitations.
+        self.relay_transaction(peer1, parent_overly_large_nonsegwit["tx"])
+        assert parent_overly_large_nonsegwit["txid"] not in node.getrawmempool()
 
         # Relay the child. It should not be accepted because it has missing inputs.
         # Its parent should not be requested because its hash (txid == wtxid) has been added to the rejection filter.
@@ -208,7 +209,7 @@ def test_orphan_rejected_parents_exceptions(self):
         self.nodes[0].bumpmocktime(GETDATA_TX_INTERVAL)
         peer1.assert_never_requested(int(parent_other["txid"], 16))
         peer2.assert_never_requested(int(parent_other["txid"], 16))
-        peer2.assert_never_requested(int(parent_low_fee_nonsegwit["txid"], 16))
+        peer2.assert_never_requested(int(parent_overly_large_nonsegwit["txid"], 16))
 
         self.log.info("Test orphan handling when a segwit parent was invalid but may be retried with another witness")
         parent_low_fee = self.wallet.create_self_transfer(fee_rate=0)
@@ -391,23 +392,23 @@ def test_orphan_inherit_rejection(self):
         peer3 = node.add_p2p_connection(PeerTxRelayer(wtxidrelay=False))
 
         self.log.info("Test that an orphan with rejected parents, along with any descendants, cannot be retried with an alternate witness")
-        parent_low_fee_nonsegwit = self.wallet_nonsegwit.create_self_transfer(fee_rate=0)
-        assert_equal(parent_low_fee_nonsegwit["txid"], parent_low_fee_nonsegwit["tx"].wtxid_hex)
-        child = self.wallet.create_self_transfer(utxo_to_spend=parent_low_fee_nonsegwit["new_utxo"])
+        parent_overly_large_nonsegwit = self.wallet_nonsegwit.create_self_transfer(target_vsize=int(MAX_STANDARD_TX_WEIGHT / 4) + 1)
+        assert_equal(parent_overly_large_nonsegwit["txid"], parent_overly_large_nonsegwit["tx"].wtxid_hex)
+        child = self.wallet.create_self_transfer(utxo_to_spend=parent_overly_large_nonsegwit["new_utxo"])
         grandchild = self.wallet.create_self_transfer(utxo_to_spend=child["new_utxo"])
         assert_not_equal(child["txid"], child["tx"].wtxid_hex)
         assert_not_equal(grandchild["txid"], grandchild["tx"].wtxid_hex)
 
         # Relay the parent. It should be rejected because it pays 0 fees.
-        self.relay_transaction(peer1, parent_low_fee_nonsegwit["tx"])
-        assert parent_low_fee_nonsegwit["txid"] not in node.getrawmempool()
+        self.relay_transaction(peer1, parent_overly_large_nonsegwit["tx"])
+        assert parent_overly_large_nonsegwit["txid"] not in node.getrawmempool()
 
         # Relay the child. It should be rejected for having missing parents, and this rejection is
         # cached by txid and wtxid.
         self.relay_transaction(peer1, child["tx"])
         assert_equal(0, len(node.getrawmempool()))
         assert not tx_in_orphanage(node, child["tx"])
-        peer1.assert_never_requested(parent_low_fee_nonsegwit["txid"])
+        peer1.assert_never_requested(parent_overly_large_nonsegwit["txid"])
 
         # Grandchild should also not be kept in orphanage because its parent has been rejected.
         self.relay_transaction(peer2, grandchild["tx"])
diff --git a/depend/bitcoin/test/functional/p2p_outbound_eviction.py b/depend/bitcoin/test/functional/p2p_outbound_eviction.py
index 42168a75..d5ad7945 100755
--- a/depend/bitcoin/test/functional/p2p_outbound_eviction.py
+++ b/depend/bitcoin/test/functional/p2p_outbound_eviction.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2019-2021 The Bitcoin Core developers
+# Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/test/functional/p2p_permissions.py b/depend/bitcoin/test/functional/p2p_permissions.py
index 543cd319..f2652f30 100755
--- a/depend/bitcoin/test/functional/p2p_permissions.py
+++ b/depend/bitcoin/test/functional/p2p_permissions.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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 p2p permission message.
diff --git a/depend/bitcoin/test/functional/p2p_ping.py b/depend/bitcoin/test/functional/p2p_ping.py
index 8f341fe5..7fb3add9 100755
--- a/depend/bitcoin/test/functional/p2p_ping.py
+++ b/depend/bitcoin/test/functional/p2p_ping.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2022 The Bitcoin Core developers
+# Copyright (c) 2020-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 ping message
diff --git a/depend/bitcoin/test/functional/p2p_seednode.py b/depend/bitcoin/test/functional/p2p_seednode.py
index ceefe1aa..4a527905 100755
--- a/depend/bitcoin/test/functional/p2p_seednode.py
+++ b/depend/bitcoin/test/functional/p2p_seednode.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2019-2021 The Bitcoin Core developers
+# Copyright (c) 2019-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.
 
diff --git a/depend/bitcoin/test/functional/p2p_segwit.py b/depend/bitcoin/test/functional/p2p_segwit.py
index 1a7fe418..88b2bcbb 100755
--- a/depend/bitcoin/test/functional/p2p_segwit.py
+++ b/depend/bitcoin/test/functional/p2p_segwit.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2022 The Bitcoin Core developers
+# Copyright (c) 2016-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 segwit transactions and blocks on P2P network."""
diff --git a/depend/bitcoin/test/functional/p2p_sendheaders.py b/depend/bitcoin/test/functional/p2p_sendheaders.py
index 1070a403..337e9804 100755
--- a/depend/bitcoin/test/functional/p2p_sendheaders.py
+++ b/depend/bitcoin/test/functional/p2p_sendheaders.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2021 The Bitcoin Core developers
+# Copyright (c) 2014-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 behavior of headers messages to announce blocks.
diff --git a/depend/bitcoin/test/functional/p2p_sendtxrcncl.py b/depend/bitcoin/test/functional/p2p_sendtxrcncl.py
index 12070c4c..2addc330 100755
--- a/depend/bitcoin/test/functional/p2p_sendtxrcncl.py
+++ b/depend/bitcoin/test/functional/p2p_sendtxrcncl.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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 SENDTXRCNCL message
diff --git a/depend/bitcoin/test/functional/p2p_timeouts.py b/depend/bitcoin/test/functional/p2p_timeouts.py
index 73a6a866..b165b122 100755
--- a/depend/bitcoin/test/functional/p2p_timeouts.py
+++ b/depend/bitcoin/test/functional/p2p_timeouts.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2022 The Bitcoin Core developers
+# Copyright (c) 2016-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 various net timeouts.
diff --git a/depend/bitcoin/test/functional/p2p_tx_download.py b/depend/bitcoin/test/functional/p2p_tx_download.py
index 3da781de..f1a42f5a 100755
--- a/depend/bitcoin/test/functional/p2p_tx_download.py
+++ b/depend/bitcoin/test/functional/p2p_tx_download.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2019-2021 The Bitcoin Core developers
+# Copyright (c) 2019-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.
 """
diff --git a/depend/bitcoin/test/functional/p2p_tx_privacy.py b/depend/bitcoin/test/functional/p2p_tx_privacy.py
index 7b56c580..16d9394b 100755
--- a/depend/bitcoin/test/functional/p2p_tx_privacy.py
+++ b/depend/bitcoin/test/functional/p2p_tx_privacy.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 """
diff --git a/depend/bitcoin/test/functional/p2p_unrequested_blocks.py b/depend/bitcoin/test/functional/p2p_unrequested_blocks.py
index b165b809..6ce1cd1e 100755
--- a/depend/bitcoin/test/functional/p2p_unrequested_blocks.py
+++ b/depend/bitcoin/test/functional/p2p_unrequested_blocks.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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 processing of unrequested blocks.
diff --git a/depend/bitcoin/test/functional/p2p_v2_encrypted.py b/depend/bitcoin/test/functional/p2p_v2_encrypted.py
index 36e2f316..68936903 100755
--- a/depend/bitcoin/test/functional/p2p_v2_encrypted.py
+++ b/depend/bitcoin/test/functional/p2p_v2_encrypted.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 """
diff --git a/depend/bitcoin/test/functional/p2p_v2_misbehaving.py b/depend/bitcoin/test/functional/p2p_v2_misbehaving.py
index ee589010..f7793c13 100755
--- a/depend/bitcoin/test/functional/p2p_v2_misbehaving.py
+++ b/depend/bitcoin/test/functional/p2p_v2_misbehaving.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 
@@ -161,8 +161,8 @@ def test_v2disconnection(self):
         node0 = self.nodes[0]
         expected_debug_message = [
             [],  # EARLY_KEY_RESPONSE
-            ["V2 transport error: missing garbage terminator, peer=1"],  # EXCESS_GARBAGE
-            ["V2 handshake timeout, disconnecting peer=3"],  # WRONG_GARBAGE_TERMINATOR
+            ["V2 transport error: missing garbage terminator"],  # EXCESS_GARBAGE
+            ["V2 handshake timeout, disconnecting peer"],  # WRONG_GARBAGE_TERMINATOR
             ["V2 transport error: packet decryption failure"],  # WRONG_GARBAGE
             ["V2 transport error: packet decryption failure"],  # SEND_NO_AAD
             [],  # SEND_NON_EMPTY_VERSION_PACKET
diff --git a/depend/bitcoin/test/functional/rpc_bind.py b/depend/bitcoin/test/functional/rpc_bind.py
index e5de0ef0..3c6e3e4b 100755
--- a/depend/bitcoin/test/functional/rpc_bind.py
+++ b/depend/bitcoin/test/functional/rpc_bind.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2019 The Bitcoin Core developers
+# Copyright (c) 2014-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 running bitcoind with the -rpcbind and -rpcallowip options."""
diff --git a/depend/bitcoin/test/functional/rpc_deprecated.py b/depend/bitcoin/test/functional/rpc_deprecated.py
index 6b0ef709..acc3a05f 100755
--- a/depend/bitcoin/test/functional/rpc_deprecated.py
+++ b/depend/bitcoin/test/functional/rpc_deprecated.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2025 The Bitcoin Core developers
+# Copyright (c) 2017-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 deprecation of RPC calls."""
diff --git a/depend/bitcoin/test/functional/rpc_deriveaddresses.py b/depend/bitcoin/test/functional/rpc_deriveaddresses.py
index 32fdfa35..f704223f 100755
--- a/depend/bitcoin/test/functional/rpc_deriveaddresses.py
+++ b/depend/bitcoin/test/functional/rpc_deriveaddresses.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2022 The Bitcoin Core developers
+# 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.
 """Test the deriveaddresses rpc call."""
diff --git a/depend/bitcoin/test/functional/rpc_dumptxoutset.py b/depend/bitcoin/test/functional/rpc_dumptxoutset.py
index ba1cca49..5edcddf0 100755
--- a/depend/bitcoin/test/functional/rpc_dumptxoutset.py
+++ b/depend/bitcoin/test/functional/rpc_dumptxoutset.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2019-2022 The Bitcoin Core developers
+# Copyright (c) 2019-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 the generation of UTXO snapshots using `dumptxoutset`.
diff --git a/depend/bitcoin/test/functional/rpc_estimatefee.py b/depend/bitcoin/test/functional/rpc_estimatefee.py
index 9346a000..6c44b1af 100755
--- a/depend/bitcoin/test/functional/rpc_estimatefee.py
+++ b/depend/bitcoin/test/functional/rpc_estimatefee.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2022 The Bitcoin Core developers
+# 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.
 """Test the estimatefee RPCs.
diff --git a/depend/bitcoin/test/functional/rpc_getblockfilter.py b/depend/bitcoin/test/functional/rpc_getblockfilter.py
index 245bcec8..db72acd6 100755
--- a/depend/bitcoin/test/functional/rpc_getblockfilter.py
+++ b/depend/bitcoin/test/functional/rpc_getblockfilter.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2021 The Bitcoin Core developers
+# 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.
 """Test the getblockfilter RPC."""
diff --git a/depend/bitcoin/test/functional/rpc_getblockfrompeer.py b/depend/bitcoin/test/functional/rpc_getblockfrompeer.py
index a417ffcb..841cde02 100755
--- a/depend/bitcoin/test/functional/rpc_getblockfrompeer.py
+++ b/depend/bitcoin/test/functional/rpc_getblockfrompeer.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2022 The Bitcoin Core developers
+# Copyright (c) 2020-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 the getblockfrompeer RPC."""
diff --git a/depend/bitcoin/test/functional/rpc_getchaintips.py b/depend/bitcoin/test/functional/rpc_getchaintips.py
index 7bf8e4d8..1a284118 100755
--- a/depend/bitcoin/test/functional/rpc_getchaintips.py
+++ b/depend/bitcoin/test/functional/rpc_getchaintips.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2021 The Bitcoin Core developers
+# Copyright (c) 2014-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 the getchaintips RPC.
diff --git a/depend/bitcoin/test/functional/rpc_getdescriptorinfo.py b/depend/bitcoin/test/functional/rpc_getdescriptorinfo.py
index 56a8faaf..b86d8ff8 100755
--- a/depend/bitcoin/test/functional/rpc_getdescriptorinfo.py
+++ b/depend/bitcoin/test/functional/rpc_getdescriptorinfo.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2019-2022 The Bitcoin Core developers
+# Copyright (c) 2019-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 getdescriptorinfo RPC.
diff --git a/depend/bitcoin/test/functional/rpc_invalidateblock.py b/depend/bitcoin/test/functional/rpc_invalidateblock.py
index 78073bd4..dc55e7fd 100755
--- a/depend/bitcoin/test/functional/rpc_invalidateblock.py
+++ b/depend/bitcoin/test/functional/rpc_invalidateblock.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 the invalidateblock RPC."""
diff --git a/depend/bitcoin/test/functional/rpc_mempool_info.py b/depend/bitcoin/test/functional/rpc_mempool_info.py
index 231d93a7..b611b2e3 100755
--- a/depend/bitcoin/test/functional/rpc_mempool_info.py
+++ b/depend/bitcoin/test/functional/rpc_mempool_info.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 RPCs that retrieve information from the mempool."""
diff --git a/depend/bitcoin/test/functional/rpc_misc.py b/depend/bitcoin/test/functional/rpc_misc.py
index 139384b6..5ff02c56 100755
--- a/depend/bitcoin/test/functional/rpc_misc.py
+++ b/depend/bitcoin/test/functional/rpc_misc.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2019-2022 The Bitcoin Core developers
+# Copyright (c) 2019-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 RPC misc output."""
diff --git a/depend/bitcoin/test/functional/rpc_named_arguments.py b/depend/bitcoin/test/functional/rpc_named_arguments.py
index 0385c332..ce1bbda4 100755
--- a/depend/bitcoin/test/functional/rpc_named_arguments.py
+++ b/depend/bitcoin/test/functional/rpc_named_arguments.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2020 The Bitcoin Core developers
+# Copyright (c) 2016-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 using named arguments for RPCs."""
diff --git a/depend/bitcoin/test/functional/rpc_orphans.py b/depend/bitcoin/test/functional/rpc_orphans.py
index 20e9b1ce..6addb58f 100755
--- a/depend/bitcoin/test/functional/rpc_orphans.py
+++ b/depend/bitcoin/test/functional/rpc_orphans.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2024 The Bitcoin Core developers
+# Copyright (c) 2014-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.
 """Tests for orphan related RPCs."""
diff --git a/depend/bitcoin/test/functional/rpc_packages.py b/depend/bitcoin/test/functional/rpc_packages.py
index 2249fe49..12e08621 100755
--- a/depend/bitcoin/test/functional/rpc_packages.py
+++ b/depend/bitcoin/test/functional/rpc_packages.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021-2022 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """RPCs that handle raw transaction packages."""
diff --git a/depend/bitcoin/test/functional/rpc_preciousblock.py b/depend/bitcoin/test/functional/rpc_preciousblock.py
index 78809871..29d72608 100755
--- a/depend/bitcoin/test/functional/rpc_preciousblock.py
+++ b/depend/bitcoin/test/functional/rpc_preciousblock.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2021 The Bitcoin Core developers
+# Copyright (c) 2015-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 the preciousblock RPC."""
diff --git a/depend/bitcoin/test/functional/rpc_rawtransaction.py b/depend/bitcoin/test/functional/rpc_rawtransaction.py
index d2610a1d..78e12139 100755
--- a/depend/bitcoin/test/functional/rpc_rawtransaction.py
+++ b/depend/bitcoin/test/functional/rpc_rawtransaction.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 the rawtransaction RPCs.
diff --git a/depend/bitcoin/test/functional/rpc_scanblocks.py b/depend/bitcoin/test/functional/rpc_scanblocks.py
index d05ba09b..0b13741e 100755
--- a/depend/bitcoin/test/functional/rpc_scanblocks.py
+++ b/depend/bitcoin/test/functional/rpc_scanblocks.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021-2022 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the scanblocks RPC call."""
diff --git a/depend/bitcoin/test/functional/rpc_scantxoutset.py b/depend/bitcoin/test/functional/rpc_scantxoutset.py
index a7b560ef..d59bd31a 100755
--- a/depend/bitcoin/test/functional/rpc_scantxoutset.py
+++ b/depend/bitcoin/test/functional/rpc_scantxoutset.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2022 The Bitcoin Core developers
+# 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.
 """Test the scantxoutset rpc call."""
diff --git a/depend/bitcoin/test/functional/rpc_setban.py b/depend/bitcoin/test/functional/rpc_setban.py
index c4e5ebcc..4a0a3787 100755
--- a/depend/bitcoin/test/functional/rpc_setban.py
+++ b/depend/bitcoin/test/functional/rpc_setban.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2021 The Bitcoin Core developers
+# Copyright (c) 2015-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 the setban rpc call."""
diff --git a/depend/bitcoin/test/functional/rpc_signmessagewithprivkey.py b/depend/bitcoin/test/functional/rpc_signmessagewithprivkey.py
index 8e866987..44872d33 100755
--- a/depend/bitcoin/test/functional/rpc_signmessagewithprivkey.py
+++ b/depend/bitcoin/test/functional/rpc_signmessagewithprivkey.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2022 The Bitcoin Core developers
+# Copyright (c) 2016-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 RPC commands for signing messages with private key."""
diff --git a/depend/bitcoin/test/functional/rpc_signrawtransactionwithkey.py b/depend/bitcoin/test/functional/rpc_signrawtransactionwithkey.py
index b359a08f..f423366c 100755
--- a/depend/bitcoin/test/functional/rpc_signrawtransactionwithkey.py
+++ b/depend/bitcoin/test/functional/rpc_signrawtransactionwithkey.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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 transaction signing using the signrawtransactionwithkey RPC."""
diff --git a/depend/bitcoin/test/functional/rpc_txoutproof.py b/depend/bitcoin/test/functional/rpc_txoutproof.py
index d430f47f..055942a8 100755
--- a/depend/bitcoin/test/functional/rpc_txoutproof.py
+++ b/depend/bitcoin/test/functional/rpc_txoutproof.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2021 The Bitcoin Core developers
+# Copyright (c) 2014-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 gettxoutproof and verifytxoutproof RPCs."""
diff --git a/depend/bitcoin/test/functional/rpc_uptime.py b/depend/bitcoin/test/functional/rpc_uptime.py
index fdf45995..74880417 100755
--- a/depend/bitcoin/test/functional/rpc_uptime.py
+++ b/depend/bitcoin/test/functional/rpc_uptime.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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 the RPC call related to the uptime command.
diff --git a/depend/bitcoin/test/functional/rpc_validateaddress.py b/depend/bitcoin/test/functional/rpc_validateaddress.py
index bf094a7d..cb4f6f8d 100755
--- a/depend/bitcoin/test/functional/rpc_validateaddress.py
+++ b/depend/bitcoin/test/functional/rpc_validateaddress.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2023 The Bitcoin Core developers
+# Copyright (c) 2023-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test validateaddress for main chain"""
diff --git a/depend/bitcoin/test/functional/test_framework/address.py b/depend/bitcoin/test/functional/test_framework/address.py
index 2c754e35..2af5cf51 100644
--- a/depend/bitcoin/test/functional/test_framework/address.py
+++ b/depend/bitcoin/test/functional/test_framework/address.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2022 The Bitcoin Core developers
+# Copyright (c) 2016-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.
 """Encode and decode Bitcoin addresses.
diff --git a/depend/bitcoin/test/functional/test_framework/blockfilter.py b/depend/bitcoin/test/functional/test_framework/blockfilter.py
index a16aa3d3..d02f0212 100644
--- a/depend/bitcoin/test/functional/test_framework/blockfilter.py
+++ b/depend/bitcoin/test/functional/test_framework/blockfilter.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 """Helper routines relevant for compact block filters (BIP158).
diff --git a/depend/bitcoin/test/functional/test_framework/crypto/bip324_cipher.py b/depend/bitcoin/test/functional/test_framework/crypto/bip324_cipher.py
index c9f0fa01..d0e94ac5 100644
--- a/depend/bitcoin/test/functional/test_framework/crypto/bip324_cipher.py
+++ b/depend/bitcoin/test/functional/test_framework/crypto/bip324_cipher.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/test/functional/test_framework/crypto/chacha20.py b/depend/bitcoin/test/functional/test_framework/crypto/chacha20.py
index 19b6698d..00197b99 100644
--- a/depend/bitcoin/test/functional/test_framework/crypto/chacha20.py
+++ b/depend/bitcoin/test/functional/test_framework/crypto/chacha20.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/test/functional/test_framework/crypto/hkdf.py b/depend/bitcoin/test/functional/test_framework/crypto/hkdf.py
index 7e895873..86c551ef 100644
--- a/depend/bitcoin/test/functional/test_framework/crypto/hkdf.py
+++ b/depend/bitcoin/test/functional/test_framework/crypto/hkdf.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2023 The Bitcoin Core developers
+# Copyright (c) 2023-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/test/functional/test_framework/crypto/poly1305.py b/depend/bitcoin/test/functional/test_framework/crypto/poly1305.py
index 967b9025..866a55b0 100644
--- a/depend/bitcoin/test/functional/test_framework/crypto/poly1305.py
+++ b/depend/bitcoin/test/functional/test_framework/crypto/poly1305.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/test/functional/test_framework/crypto/secp256k1.py b/depend/bitcoin/test/functional/test_framework/crypto/secp256k1.py
index 9d85d557..479d046f 100644
--- a/depend/bitcoin/test/functional/test_framework/crypto/secp256k1.py
+++ b/depend/bitcoin/test/functional/test_framework/crypto/secp256k1.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2022-2023 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/test/functional/test_framework/crypto/siphash.py b/depend/bitcoin/test/functional/test_framework/crypto/siphash.py
index bd13b2c9..f89a7ce9 100644
--- a/depend/bitcoin/test/functional/test_framework/crypto/siphash.py
+++ b/depend/bitcoin/test/functional/test_framework/crypto/siphash.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2022 The Bitcoin Core developers
+# Copyright (c) 2016-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.
 """SipHash-2-4 implementation.
diff --git a/depend/bitcoin/test/functional/test_framework/mempool_util.py b/depend/bitcoin/test/functional/test_framework/mempool_util.py
index 89e25583..2ee1f03d 100644
--- a/depend/bitcoin/test/functional/test_framework/mempool_util.py
+++ b/depend/bitcoin/test/functional/test_framework/mempool_util.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2024 The Bitcoin Core developers
+# Copyright (c) 2024-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Helpful routines for mempool testing."""
diff --git a/depend/bitcoin/test/functional/test_framework/messages.py b/depend/bitcoin/test/functional/test_framework/messages.py
index 17062723..f6dfc461 100755
--- a/depend/bitcoin/test/functional/test_framework/messages.py
+++ b/depend/bitcoin/test/functional/test_framework/messages.py
@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # Copyright (c) 2010 ArtForz -- public domain half-a-node
 # Copyright (c) 2012 Jeff Garzik
-# Copyright (c) 2010-2022 The Bitcoin Core developers
+# Copyright (c) 2010-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.
 """Bitcoin test framework primitive and message structures
diff --git a/depend/bitcoin/test/functional/test_framework/psbt.py b/depend/bitcoin/test/functional/test_framework/psbt.py
index 4fe688ec..8c552e42 100644
--- a/depend/bitcoin/test/functional/test_framework/psbt.py
+++ b/depend/bitcoin/test/functional/test_framework/psbt.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/test/functional/test_framework/script.py b/depend/bitcoin/test/functional/test_framework/script.py
index 369bd2d7..5b42096d 100644
--- a/depend/bitcoin/test/functional/test_framework/script.py
+++ b/depend/bitcoin/test/functional/test_framework/script.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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.
 """Functionality to build scripts, as well as signature hash functions.
diff --git a/depend/bitcoin/test/functional/test_framework/script_util.py b/depend/bitcoin/test/functional/test_framework/script_util.py
index 3b9d1957..50a185ee 100755
--- a/depend/bitcoin/test/functional/test_framework/script_util.py
+++ b/depend/bitcoin/test/functional/test_framework/script_util.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2019-2022 The Bitcoin Core developers
+# Copyright (c) 2019-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.
 """Useful Script constants and utils."""
diff --git a/depend/bitcoin/test/functional/test_framework/socks5.py b/depend/bitcoin/test/functional/test_framework/socks5.py
index 0cd16a3f..3fd4d5c8 100644
--- a/depend/bitcoin/test/functional/test_framework/socks5.py
+++ b/depend/bitcoin/test/functional/test_framework/socks5.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2019 The Bitcoin Core developers
+# Copyright (c) 2015-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.
 """Dummy Socks5 server for testing."""
diff --git a/depend/bitcoin/test/functional/test_framework/test_node.py b/depend/bitcoin/test/functional/test_framework/test_node.py
index b3f3d2d3..77d48fe5 100755
--- a/depend/bitcoin/test/functional/test_framework/test_node.py
+++ b/depend/bitcoin/test/functional/test_framework/test_node.py
@@ -363,10 +363,15 @@ def suppress_error(category: str, e: Exception):
                 latest_error = suppress_error(f"JSONRPCException {e.error['code']}", e)
             except OSError as e:
                 error_num = e.errno
-                # Work around issue where socket timeouts don't have errno set.
-                # https://github.com/python/cpython/issues/109601
-                if error_num is None and isinstance(e, TimeoutError):
-                    error_num = errno.ETIMEDOUT
+                if error_num is None:
+                    # Work around issue where socket timeouts don't have errno set.
+                    # https://github.com/python/cpython/issues/109601
+                    if isinstance(e, TimeoutError):
+                        error_num = errno.ETIMEDOUT
+                    # http.client.RemoteDisconnected inherits from this type and
+                    # doesn't specify errno.
+                    elif isinstance(e, ConnectionResetError):
+                        error_num = errno.ECONNRESET
 
                 # Suppress similarly to the above JSONRPCException errors.
                 if error_num not in [
@@ -712,11 +717,12 @@ def assert_start_raises_init_error(self, extra_args=None, expected_msg=None, mat
         extra_args: extra arguments to pass through to bitcoind
         expected_msg: regex that stderr should match when bitcoind fails
 
-        Will throw if bitcoind starts without an error.
-        Will throw if an expected_msg is provided and it does not match bitcoind's stdout."""
+        Will raise if bitcoind starts without an error.
+        Will raise if an expected_msg is provided and it does not match bitcoind's stdout."""
         assert not self.running
         with tempfile.NamedTemporaryFile(dir=self.stderr_dir, delete=False) as log_stderr, \
              tempfile.NamedTemporaryFile(dir=self.stdout_dir, delete=False) as log_stdout:
+            assert_msg = None
             try:
                 self.start(extra_args, stdout=log_stdout, stderr=log_stderr, *args, **kwargs)
                 ret = self.process.wait(timeout=self.rpc_timeout)
@@ -740,7 +746,7 @@ def assert_start_raises_init_error(self, extra_args=None, expected_msg=None, mat
                         if expected_msg != stderr:
                             self._raise_assertion_error(
                                 'Expected message "{}" does not fully match stderr:\n"{}"'.format(expected_msg, stderr))
-            except subprocess.TimeoutExpired:
+            except subprocess.TimeoutExpired as e:
                 self.process.kill()
                 self.running = False
                 self.process = None
@@ -749,6 +755,10 @@ def assert_start_raises_init_error(self, extra_args=None, expected_msg=None, mat
                     assert_msg += "with an error"
                 else:
                     assert_msg += "with expected error " + expected_msg
+                assert_msg += f" (cmd: {e.cmd})"
+
+            # Raise assertion outside of except-block above in order for it not to be treated as a knock-on exception.
+            if assert_msg:
                 self._raise_assertion_error(assert_msg)
 
     def add_p2p_connection(self, p2p_conn, *, wait_for_verack=True, send_version=True, supports_v2_p2p=None, wait_for_v2_handshake=True, expect_success=True, **kwargs):
diff --git a/depend/bitcoin/test/functional/test_framework/test_shell.py b/depend/bitcoin/test/functional/test_framework/test_shell.py
index 9820a222..b02f0272 100644
--- a/depend/bitcoin/test/functional/test_framework/test_shell.py
+++ b/depend/bitcoin/test/functional/test_framework/test_shell.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2019-2022 The Bitcoin Core developers
+# Copyright (c) 2019-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.
 import pathlib
diff --git a/depend/bitcoin/test/functional/test_framework/v2_p2p.py b/depend/bitcoin/test/functional/test_framework/v2_p2p.py
index 87600c36..5315aaf8 100644
--- a/depend/bitcoin/test/functional/test_framework/v2_p2p.py
+++ b/depend/bitcoin/test/functional/test_framework/v2_p2p.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 """Class for v2 P2P protocol (see BIP 324)"""
diff --git a/depend/bitcoin/test/functional/test_framework/wallet.py b/depend/bitcoin/test/functional/test_framework/wallet.py
index a47ccab0..fc8b639b 100644
--- a/depend/bitcoin/test/functional/test_framework/wallet.py
+++ b/depend/bitcoin/test/functional/test_framework/wallet.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2022 The Bitcoin Core developers
+# Copyright (c) 2020-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.
 """A limited-functionality wallet, which may replace a real wallet in tests"""
diff --git a/depend/bitcoin/test/functional/test_framework/wallet_util.py b/depend/bitcoin/test/functional/test_framework/wallet_util.py
index 2a327e17..12251530 100755
--- a/depend/bitcoin/test/functional/test_framework/wallet_util.py
+++ b/depend/bitcoin/test/functional/test_framework/wallet_util.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2021 The Bitcoin Core developers
+# 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.
 """Useful util functions for testing the wallet"""
diff --git a/depend/bitcoin/test/functional/test_runner.py b/depend/bitcoin/test/functional/test_runner.py
index d63dbade..7701f949 100755
--- a/depend/bitcoin/test/functional/test_runner.py
+++ b/depend/bitcoin/test/functional/test_runner.py
@@ -276,6 +276,7 @@
     'p2p_initial_headers_sync.py',
     'feature_nulldummy.py',
     'mempool_accept.py',
+    'p2p_addr_selfannouncement.py',
     'mempool_expiry.py',
     'wallet_importdescriptors.py',
     'wallet_crosschain.py',
diff --git a/depend/bitcoin/test/functional/wallet_abandonconflict.py b/depend/bitcoin/test/functional/wallet_abandonconflict.py
index f5650b87..f4d289e4 100755
--- a/depend/bitcoin/test/functional/wallet_abandonconflict.py
+++ b/depend/bitcoin/test/functional/wallet_abandonconflict.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 the abandontransaction RPC.
diff --git a/depend/bitcoin/test/functional/wallet_address_types.py b/depend/bitcoin/test/functional/wallet_address_types.py
index 7f6cf73d..4c6e6ad7 100755
--- a/depend/bitcoin/test/functional/wallet_address_types.py
+++ b/depend/bitcoin/test/functional/wallet_address_types.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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 that the wallet can send and receive using all combinations of address types.
diff --git a/depend/bitcoin/test/functional/wallet_avoid_mixing_output_types.py b/depend/bitcoin/test/functional/wallet_avoid_mixing_output_types.py
index 8428efbf..0d062989 100755
--- a/depend/bitcoin/test/functional/wallet_avoid_mixing_output_types.py
+++ b/depend/bitcoin/test/functional/wallet_avoid_mixing_output_types.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or https://www.opensource.org/licenses/mit-license.php.
 """Test output type mixing during coin selection
diff --git a/depend/bitcoin/test/functional/wallet_avoidreuse.py b/depend/bitcoin/test/functional/wallet_avoidreuse.py
index 44fa16ff..80d67683 100755
--- a/depend/bitcoin/test/functional/wallet_avoidreuse.py
+++ b/depend/bitcoin/test/functional/wallet_avoidreuse.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2022 The Bitcoin Core developers
+# 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.
 """Test the avoid_reuse and setwalletflag features."""
diff --git a/depend/bitcoin/test/functional/wallet_balance.py b/depend/bitcoin/test/functional/wallet_balance.py
index a76cc223..b2d0be78 100755
--- a/depend/bitcoin/test/functional/wallet_balance.py
+++ b/depend/bitcoin/test/functional/wallet_balance.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2022 The Bitcoin Core developers
+# 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.
 """Test the wallet balance RPC methods."""
diff --git a/depend/bitcoin/test/functional/wallet_basic.py b/depend/bitcoin/test/functional/wallet_basic.py
index dabc1b3c..6039e308 100755
--- a/depend/bitcoin/test/functional/wallet_basic.py
+++ b/depend/bitcoin/test/functional/wallet_basic.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 the wallet."""
diff --git a/depend/bitcoin/test/functional/wallet_blank.py b/depend/bitcoin/test/functional/wallet_blank.py
index 10e5238e..4c3604e2 100755
--- a/depend/bitcoin/test/functional/wallet_blank.py
+++ b/depend/bitcoin/test/functional/wallet_blank.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/test/functional/wallet_bumpfee.py b/depend/bitcoin/test/functional/wallet_bumpfee.py
index d3972bef..044ddc96 100755
--- a/depend/bitcoin/test/functional/wallet_bumpfee.py
+++ b/depend/bitcoin/test/functional/wallet_bumpfee.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2022 The Bitcoin Core developers
+# Copyright (c) 2016-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 the bumpfee RPC.
diff --git a/depend/bitcoin/test/functional/wallet_change_address.py b/depend/bitcoin/test/functional/wallet_change_address.py
index 1545a46d..533a6921 100755
--- a/depend/bitcoin/test/functional/wallet_change_address.py
+++ b/depend/bitcoin/test/functional/wallet_change_address.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2023 The Bitcoin Core developers
+# Copyright (c) 2023-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test wallet change address selection"""
diff --git a/depend/bitcoin/test/functional/wallet_coinbase_category.py b/depend/bitcoin/test/functional/wallet_coinbase_category.py
index bc28e593..3f477be9 100755
--- a/depend/bitcoin/test/functional/wallet_coinbase_category.py
+++ b/depend/bitcoin/test/functional/wallet_coinbase_category.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 coinbase transactions return the correct categories.
diff --git a/depend/bitcoin/test/functional/wallet_conflicts.py b/depend/bitcoin/test/functional/wallet_conflicts.py
index b16a2f83..30f06726 100755
--- a/depend/bitcoin/test/functional/wallet_conflicts.py
+++ b/depend/bitcoin/test/functional/wallet_conflicts.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2023 The Bitcoin Core developers
+# Copyright (c) 2023-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff --git a/depend/bitcoin/test/functional/wallet_create_tx.py b/depend/bitcoin/test/functional/wallet_create_tx.py
index a3205b56..03bc6046 100755
--- a/depend/bitcoin/test/functional/wallet_create_tx.py
+++ b/depend/bitcoin/test/functional/wallet_create_tx.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2022 The Bitcoin Core developers
+# 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.
 
diff --git a/depend/bitcoin/test/functional/wallet_createwallet.py b/depend/bitcoin/test/functional/wallet_createwallet.py
index cf0d8b4e..9dd085bc 100755
--- a/depend/bitcoin/test/functional/wallet_createwallet.py
+++ b/depend/bitcoin/test/functional/wallet_createwallet.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2022 The Bitcoin Core developers
+# 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.
 """Test createwallet arguments.
diff --git a/depend/bitcoin/test/functional/wallet_createwalletdescriptor.py b/depend/bitcoin/test/functional/wallet_createwalletdescriptor.py
index dfebae4e..b1d41132 100755
--- a/depend/bitcoin/test/functional/wallet_createwalletdescriptor.py
+++ b/depend/bitcoin/test/functional/wallet_createwalletdescriptor.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2023 The Bitcoin Core developers
+# Copyright (c) 2023-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test wallet createwalletdescriptor RPC."""
diff --git a/depend/bitcoin/test/functional/wallet_crosschain.py b/depend/bitcoin/test/functional/wallet_crosschain.py
index b6105e5c..e991b208 100755
--- a/depend/bitcoin/test/functional/wallet_crosschain.py
+++ b/depend/bitcoin/test/functional/wallet_crosschain.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2022 The Bitcoin Core developers
+# Copyright (c) 2020-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.
 
diff --git a/depend/bitcoin/test/functional/wallet_descriptor.py b/depend/bitcoin/test/functional/wallet_descriptor.py
index 4ab79b79..39b80bf7 100755
--- a/depend/bitcoin/test/functional/wallet_descriptor.py
+++ b/depend/bitcoin/test/functional/wallet_descriptor.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2019-2022 The Bitcoin Core developers
+# Copyright (c) 2019-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 descriptor wallet function."""
diff --git a/depend/bitcoin/test/functional/wallet_disable.py b/depend/bitcoin/test/functional/wallet_disable.py
index da6e5d40..dbcccd47 100755
--- a/depend/bitcoin/test/functional/wallet_disable.py
+++ b/depend/bitcoin/test/functional/wallet_disable.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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 a node with the -disablewallet option.
diff --git a/depend/bitcoin/test/functional/wallet_fallbackfee.py b/depend/bitcoin/test/functional/wallet_fallbackfee.py
index 798f5230..e6930627 100755
--- a/depend/bitcoin/test/functional/wallet_fallbackfee.py
+++ b/depend/bitcoin/test/functional/wallet_fallbackfee.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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 wallet replace-by-fee capabilities in conjunction with the fallbackfee."""
diff --git a/depend/bitcoin/test/functional/wallet_fast_rescan.py b/depend/bitcoin/test/functional/wallet_fast_rescan.py
index 1bb6949c..3bd4c8f0 100755
--- a/depend/bitcoin/test/functional/wallet_fast_rescan.py
+++ b/depend/bitcoin/test/functional/wallet_fast_rescan.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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 that fast rescan using block filters for descriptor wallets detects
diff --git a/depend/bitcoin/test/functional/wallet_fundrawtransaction.py b/depend/bitcoin/test/functional/wallet_fundrawtransaction.py
index c6fd83bd..3577a2f4 100755
--- a/depend/bitcoin/test/functional/wallet_fundrawtransaction.py
+++ b/depend/bitcoin/test/functional/wallet_fundrawtransaction.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 the fundrawtransaction RPC."""
diff --git a/depend/bitcoin/test/functional/wallet_gethdkeys.py b/depend/bitcoin/test/functional/wallet_gethdkeys.py
index 11ff5bdd..93256279 100755
--- a/depend/bitcoin/test/functional/wallet_gethdkeys.py
+++ b/depend/bitcoin/test/functional/wallet_gethdkeys.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2023 The Bitcoin Core developers
+# Copyright (c) 2023-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test wallet gethdkeys RPC."""
diff --git a/depend/bitcoin/test/functional/wallet_groups.py b/depend/bitcoin/test/functional/wallet_groups.py
index 7c9b7507..0bc8838a 100755
--- a/depend/bitcoin/test/functional/wallet_groups.py
+++ b/depend/bitcoin/test/functional/wallet_groups.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2022 The Bitcoin Core developers
+# 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.
 """Test wallet group functionality."""
diff --git a/depend/bitcoin/test/functional/wallet_hd.py b/depend/bitcoin/test/functional/wallet_hd.py
index 0beed9c0..62ad88d2 100755
--- a/depend/bitcoin/test/functional/wallet_hd.py
+++ b/depend/bitcoin/test/functional/wallet_hd.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2022 The Bitcoin Core developers
+# Copyright (c) 2016-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 Hierarchical Deterministic wallet function."""
diff --git a/depend/bitcoin/test/functional/wallet_importdescriptors.py b/depend/bitcoin/test/functional/wallet_importdescriptors.py
index f14c99c6..16cf9d3b 100755
--- a/depend/bitcoin/test/functional/wallet_importdescriptors.py
+++ b/depend/bitcoin/test/functional/wallet_importdescriptors.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2019-2022 The Bitcoin Core developers
+# Copyright (c) 2019-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 the importdescriptors RPC.
diff --git a/depend/bitcoin/test/functional/wallet_importprunedfunds.py b/depend/bitcoin/test/functional/wallet_importprunedfunds.py
index d45be4aa..72896052 100755
--- a/depend/bitcoin/test/functional/wallet_importprunedfunds.py
+++ b/depend/bitcoin/test/functional/wallet_importprunedfunds.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 the importprunedfunds and removeprunedfunds RPCs."""
diff --git a/depend/bitcoin/test/functional/wallet_keypool.py b/depend/bitcoin/test/functional/wallet_keypool.py
index 03fed4df..a935b854 100755
--- a/depend/bitcoin/test/functional/wallet_keypool.py
+++ b/depend/bitcoin/test/functional/wallet_keypool.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 the wallet keypool and interaction with wallet encryption/locking."""
diff --git a/depend/bitcoin/test/functional/wallet_keypool_topup.py b/depend/bitcoin/test/functional/wallet_keypool_topup.py
index 9f7d960c..aae6985f 100755
--- a/depend/bitcoin/test/functional/wallet_keypool_topup.py
+++ b/depend/bitcoin/test/functional/wallet_keypool_topup.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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 HD Wallet keypool restore function.
diff --git a/depend/bitcoin/test/functional/wallet_labels.py b/depend/bitcoin/test/functional/wallet_labels.py
index 4a752486..79ca23a1 100755
--- a/depend/bitcoin/test/functional/wallet_labels.py
+++ b/depend/bitcoin/test/functional/wallet_labels.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2022 The Bitcoin Core developers
+# Copyright (c) 2016-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 label RPCs.
diff --git a/depend/bitcoin/test/functional/wallet_listdescriptors.py b/depend/bitcoin/test/functional/wallet_listdescriptors.py
index aaa5daac..107f2e59 100755
--- a/depend/bitcoin/test/functional/wallet_listdescriptors.py
+++ b/depend/bitcoin/test/functional/wallet_listdescriptors.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 the listdescriptors RPC."""
diff --git a/depend/bitcoin/test/functional/wallet_listreceivedby.py b/depend/bitcoin/test/functional/wallet_listreceivedby.py
index 91dc1a95..2fb2f442 100755
--- a/depend/bitcoin/test/functional/wallet_listreceivedby.py
+++ b/depend/bitcoin/test/functional/wallet_listreceivedby.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 the listreceivedbyaddress, listreceivedbylabel, getreceivedybaddress, and getreceivedbylabel RPCs."""
diff --git a/depend/bitcoin/test/functional/wallet_listsinceblock.py b/depend/bitcoin/test/functional/wallet_listsinceblock.py
index d734cfd5..2b7ec635 100755
--- a/depend/bitcoin/test/functional/wallet_listsinceblock.py
+++ b/depend/bitcoin/test/functional/wallet_listsinceblock.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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 the listsinceblock RPC."""
diff --git a/depend/bitcoin/test/functional/wallet_miniscript.py b/depend/bitcoin/test/functional/wallet_miniscript.py
index 606ddb3b..a086cf02 100755
--- a/depend/bitcoin/test/functional/wallet_miniscript.py
+++ b/depend/bitcoin/test/functional/wallet_miniscript.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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 Miniscript descriptors integration in the wallet."""
diff --git a/depend/bitcoin/test/functional/wallet_miniscript_decaying_multisig_descriptor_psbt.py b/depend/bitcoin/test/functional/wallet_miniscript_decaying_multisig_descriptor_psbt.py
index 1661ff93..92cf9c8e 100755
--- a/depend/bitcoin/test/functional/wallet_miniscript_decaying_multisig_descriptor_psbt.py
+++ b/depend/bitcoin/test/functional/wallet_miniscript_decaying_multisig_descriptor_psbt.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2024 The Bitcoin Core developers
+# Copyright (c) 2024-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test a miniscript multisig that starts as 4-of-4 and "decays" to 3-of-4, 2-of-4, and finally 1-of-4 at each future halvening block height.
diff --git a/depend/bitcoin/test/functional/wallet_multisig_descriptor_psbt.py b/depend/bitcoin/test/functional/wallet_multisig_descriptor_psbt.py
index 21bb3a3b..7b8c8df2 100755
--- a/depend/bitcoin/test/functional/wallet_multisig_descriptor_psbt.py
+++ b/depend/bitcoin/test/functional/wallet_multisig_descriptor_psbt.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021-2022 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test a basic M-of-N multisig setup between multiple people using descriptor wallets and PSBTs, as well as a signing flow.
diff --git a/depend/bitcoin/test/functional/wallet_musig.py b/depend/bitcoin/test/functional/wallet_musig.py
index 277ca927..97966e6a 100755
--- a/depend/bitcoin/test/functional/wallet_musig.py
+++ b/depend/bitcoin/test/functional/wallet_musig.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2024 The Bitcoin Core developers
+# Copyright (c) 2024-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -21,39 +21,26 @@
 PLACEHOLDER_RE = re.compile(r"\$\d")
 
 class WalletMuSigTest(BitcoinTestFramework):
-    WALLET_NUM = 0
+    wallet_num = 0
     def set_test_params(self):
         self.num_nodes = 1
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
-    def do_test(self, comment, pattern, sighash_type=None, scriptpath=False, nosign_wallets=None, only_one_musig_wallet=False):
-        self.log.info(f"Testing {comment}")
-        has_internal = MULTIPATH_TWO_RE.search(pattern) is not None
-
+    # Create wallets and extract keys
+    def create_wallets_and_keys_from_pattern(self, pat):
         wallets = []
         keys = []
 
-        pat = pattern.replace("$H", H_POINT)
-
-        # Figure out how many wallets are needed and create them
-        expected_pubnonces = 0
-        expected_partial_sigs = 0
         for musig in MUSIG_RE.findall(pat):
-            musig_partial_sigs = 0
             for placeholder in PLACEHOLDER_RE.findall(musig):
                 wallet_index = int(placeholder[1:])
-                if nosign_wallets is None or wallet_index not in nosign_wallets:
-                    expected_pubnonces += 1
-                else:
-                    musig_partial_sigs = None
-                if musig_partial_sigs is not None:
-                    musig_partial_sigs += 1
                 if wallet_index < len(wallets):
                     continue
-                wallet_name = f"musig_{self.WALLET_NUM}"
-                self.WALLET_NUM += 1
+
+                wallet_name = f"musig_{self.wallet_num}"
+                self.wallet_num += 1
                 self.nodes[0].createwallet(wallet_name)
                 wallet = self.nodes[0].get_wallet_rpc(wallet_name)
                 wallets.append(wallet)
@@ -74,32 +61,137 @@ def do_test(self, comment, pattern, sighash_type=None, scriptpath=False, nosign_
                     privkey += ORIGIN_PATH_RE.search(pubkey).group(1)
                     break
                 keys.append((privkey, pubkey))
-            if musig_partial_sigs is not None:
-                expected_partial_sigs += musig_partial_sigs
 
-        # Construct and import each wallet's musig descriptor that
-        # contains the private key from that wallet and pubkeys of the others
+        return wallets, keys
+
+    # Construct and import each wallet's musig descriptor that
+    # contains the private key from that wallet and pubkeys of the others
+    def construct_and_import_musig_descriptor_in_wallets(self, pat, wallets, keys, only_one_musig_wallet=False):
         for i, wallet in enumerate(wallets):
             if only_one_musig_wallet and i > 0:
                 continue
             desc = pat
-            import_descs = []
             for j, (priv, pub) in enumerate(keys):
                 if j == i:
                     desc = desc.replace(f"${i}", priv)
                 else:
                     desc = desc.replace(f"${j}", pub)
 
-            import_descs.append({
+            import_descs = [{
                 "desc": descsum_create(desc),
                 "active": True,
                 "timestamp": "now",
-            })
+            }]
 
             res = wallet.importdescriptors(import_descs)
             for r in res:
                 assert_equal(r["success"], True)
 
+    def setup_musig_scenario(self, pat):
+        wallets, keys = self.create_wallets_and_keys_from_pattern(pat)
+        self.construct_and_import_musig_descriptor_in_wallets(pat, wallets, keys, only_one_musig_wallet=False)
+
+        # Fund address
+        addr = wallets[0].getnewaddress(address_type="bech32m")
+        for wallet in wallets[1:]:
+            assert_equal(addr, wallet.getnewaddress(address_type="bech32m"))
+
+        self.def_wallet.sendtoaddress(addr, 10)
+        self.generate(self.nodes[0], 1)
+
+        # Create PSBT
+        utxo = wallets[0].listunspent()[0]
+        psbt = wallets[0].walletcreatefundedpsbt(
+            outputs=[{self.def_wallet.getnewaddress(): 5}],
+            inputs=[utxo],
+            change_type="bech32m",
+            changePosition=1
+        )["psbt"]
+
+        return wallets, psbt
+
+    def test_failure_case_1(self, comment, pat):
+        self.log.info(f"Testing {comment}")
+        wallets, psbt = self.setup_musig_scenario(pat)
+
+        # Only 2 out of 3 participants provide nonces
+        nonce_psbts = []
+        for i in range(2):
+            proc = wallets[i].walletprocesspsbt(psbt=psbt)
+            nonce_psbts.append(proc["psbt"])
+
+        comb_nonce_psbt = self.nodes[0].combinepsbt(nonce_psbts)
+
+        # Attempt to create partial sigs. This should not complete due to the
+        # missing nonce.
+        for wallet in wallets[:2]:
+            proc = wallet.walletprocesspsbt(psbt=comb_nonce_psbt)
+            assert_equal(proc["complete"], False)
+            # No partial sigs are created
+            dec = self.nodes[0].decodepsbt(proc["psbt"])
+            # There are still only two nonces
+            assert_equal(len(dec["inputs"][0].get("musig2_pubnonces", [])), 2)
+
+    def test_failure_case_2(self, comment, pat):
+        self.log.info(f"Testing {comment}")
+        wallets, psbt = self.setup_musig_scenario(pat)
+        nonce_psbts = [w.walletprocesspsbt(psbt=psbt)["psbt"] for w in wallets]
+        comb_nonce_psbt = self.nodes[0].combinepsbt(nonce_psbts)
+
+        # Only 2 out of 3 provide partial sigs
+        psig_psbts = []
+        for i in range(2):
+            proc = wallets[i].walletprocesspsbt(psbt=comb_nonce_psbt)
+            psig_psbts.append(proc["psbt"])
+
+        comb_psig_psbt = self.nodes[0].combinepsbt(psig_psbts)
+
+        # Finalization fails due to missing partial sig
+        finalized = self.nodes[0].finalizepsbt(comb_psig_psbt)
+        assert_equal(finalized["complete"], False)
+
+        # Still only two partial sigs in combined PSBT
+        dec = self.nodes[0].decodepsbt(comb_psig_psbt)
+        assert_equal(len(dec["inputs"][0]["musig2_partial_sigs"]), 2)
+
+    def test_failure_case_3(self, comment, pat):
+        self.log.info(f"Testing {comment}")
+        wallets, psbt = self.setup_musig_scenario(pat)
+        nonce_psbts = [w.walletprocesspsbt(psbt=psbt)["psbt"] for w in wallets]
+        comb_nonce_psbt = self.nodes[0].combinepsbt(nonce_psbts)
+
+        finalized = self.nodes[0].finalizepsbt(comb_nonce_psbt)
+        assert_equal(finalized["complete"], False)
+
+        dec = self.nodes[0].decodepsbt(comb_nonce_psbt)
+        assert "musig2_pubnonces" in dec["inputs"][0]
+        assert "musig2_partial_sigs" not in dec["inputs"][0]
+
+    def test_success_case(self, comment, pattern, sighash_type=None, scriptpath=False, nosign_wallets=None, only_one_musig_wallet=False):
+        self.log.info(f"Testing {comment}")
+        has_internal = MULTIPATH_TWO_RE.search(pattern) is not None
+
+        pat = pattern.replace("$H", H_POINT)
+        wallets, keys = self.create_wallets_and_keys_from_pattern(pat)
+        self.construct_and_import_musig_descriptor_in_wallets(pat, wallets, keys, only_one_musig_wallet)
+
+        expected_pubnonces = 0
+        expected_partial_sigs = 0
+        for musig in MUSIG_RE.findall(pat):
+            musig_partial_sigs = 0
+            for placeholder in PLACEHOLDER_RE.findall(musig):
+                wallet_index = int(placeholder[1:])
+                if nosign_wallets is None or wallet_index not in nosign_wallets:
+                    expected_pubnonces += 1
+                else:
+                    musig_partial_sigs = None
+                if musig_partial_sigs is not None:
+                    musig_partial_sigs += 1
+                if wallet_index < len(wallets):
+                    continue
+            if musig_partial_sigs is not None:
+                expected_partial_sigs += musig_partial_sigs
+
         # Check that the wallets agree on the same musig address
         addr = None
         change_addr = None
@@ -221,22 +313,25 @@ def do_test(self, comment, pattern, sighash_type=None, scriptpath=False, nosign_
     def run_test(self):
         self.def_wallet = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
 
-        self.do_test("rawtr(musig(keys/*))", "rawtr(musig($0/<0;1>/*,$1/<1;2>/*,$2/<2;3>/*))")
-        self.do_test("rawtr(musig(keys/*)) with ALL|ANYONECANPAY", "rawtr(musig($0/<0;1>/*,$1/<1;2>/*,$2/<2;3>/*))", "ALL|ANYONECANPAY")
-        self.do_test("tr(musig(keys/*)) no multipath", "tr(musig($0/0/*,$1/1/*,$2/2/*))")
-        self.do_test("tr(musig(keys/*)) 2 index multipath", "tr(musig($0/<0;1>/*,$1/<1;2>/*,$2/<2;3>/*))")
-        self.do_test("tr(musig(keys/*)) 3 index multipath", "tr(musig($0/<0;1;2>/*,$1/<1;2;3>/*,$2/<2;3;4>/*))")
-        self.do_test("rawtr(musig/*)", "rawtr(musig($0,$1,$2)/<0;1>/*)")
-        self.do_test("tr(musig/*)", "tr(musig($0,$1,$2)/<0;1>/*)")
-        self.do_test("rawtr(musig(keys/*)) without all wallets importing", "rawtr(musig($0/<0;1>/*,$1/<0;1>/*,$2/<0;1>/*))", only_one_musig_wallet=True)
-        self.do_test("tr(musig(keys/*)) without all wallets importing", "tr(musig($0/<0;1>/*,$1/<0;1>/*,$2/<0;1>/*))", only_one_musig_wallet=True)
-        self.do_test("tr(H, pk(musig(keys/*)))", "tr($H,pk(musig($0/<0;1>/*,$1/<1;2>/*,$2/<2;3>/*)))", scriptpath=True)
-        self.do_test("tr(H,pk(musig/*))", "tr($H,pk(musig($0,$1,$2)/<0;1>/*))", scriptpath=True)
-        self.do_test("tr(H,{pk(musig/*), pk(musig/*)})", "tr($H,{pk(musig($0,$1,$2)/<0;1>/*),pk(musig($3,$4,$5)/0/*)})", scriptpath=True)
-        self.do_test("tr(H,{pk(musig/*), pk(same keys different musig/*)})", "tr($H,{pk(musig($0,$1,$2)/<0;1>/*),pk(musig($1,$2)/0/*)})", scriptpath=True)
-        self.do_test("tr(musig/*,{pk(partial keys diff musig-1/*),pk(partial keys diff musig-2/*)})}", "tr(musig($0,$1,$2)/<3;4>/*,{pk(musig($0,$1)/<5;6>/*),pk(musig($1,$2)/7/*)})")
-        self.do_test("tr(musig/*,{pk(partial keys diff musig-1/*),pk(partial keys diff musig-2/*)})} script-path", "tr(musig($0,$1,$2)/<3;4>/*,{pk(musig($0,$1)/<5;6>/*),pk(musig($1,$2)/7/*)})", scriptpath=True, nosign_wallets=[0])
+        self.test_success_case("rawtr(musig(keys/*))", "rawtr(musig($0/<0;1>/*,$1/<1;2>/*,$2/<2;3>/*))")
+        self.test_success_case("rawtr(musig(keys/*)) with ALL|ANYONECANPAY", "rawtr(musig($0/<0;1>/*,$1/<1;2>/*,$2/<2;3>/*))", "ALL|ANYONECANPAY")
+        self.test_success_case("tr(musig(keys/*)) no multipath", "tr(musig($0/0/*,$1/1/*,$2/2/*))")
+        self.test_success_case("tr(musig(keys/*)) 2 index multipath", "tr(musig($0/<0;1>/*,$1/<1;2>/*,$2/<2;3>/*))")
+        self.test_success_case("tr(musig(keys/*)) 3 index multipath", "tr(musig($0/<0;1;2>/*,$1/<1;2;3>/*,$2/<2;3;4>/*))")
+        self.test_success_case("rawtr(musig/*)", "rawtr(musig($0,$1,$2)/<0;1>/*)")
+        self.test_success_case("tr(musig/*)", "tr(musig($0,$1,$2)/<0;1>/*)")
+        self.test_success_case("rawtr(musig(keys/*)) without all wallets importing", "rawtr(musig($0/<0;1>/*,$1/<0;1>/*,$2/<0;1>/*))", only_one_musig_wallet=True)
+        self.test_success_case("tr(musig(keys/*)) without all wallets importing", "tr(musig($0/<0;1>/*,$1/<0;1>/*,$2/<0;1>/*))", only_one_musig_wallet=True)
+        self.test_success_case("tr(H, pk(musig(keys/*)))", "tr($H,pk(musig($0/<0;1>/*,$1/<1;2>/*,$2/<2;3>/*)))", scriptpath=True)
+        self.test_success_case("tr(H,pk(musig/*))", "tr($H,pk(musig($0,$1,$2)/<0;1>/*))", scriptpath=True)
+        self.test_success_case("tr(H,{pk(musig/*), pk(musig/*)})", "tr($H,{pk(musig($0,$1,$2)/<0;1>/*),pk(musig($3,$4,$5)/0/*)})", scriptpath=True)
+        self.test_success_case("tr(H,{pk(musig/*), pk(same keys different musig/*)})", "tr($H,{pk(musig($0,$1,$2)/<0;1>/*),pk(musig($1,$2)/0/*)})", scriptpath=True)
+        self.test_success_case("tr(musig/*,{pk(partial keys diff musig-1/*),pk(partial keys diff musig-2/*)})}", "tr(musig($0,$1,$2)/<3;4>/*,{pk(musig($0,$1)/<5;6>/*),pk(musig($1,$2)/7/*)})")
+        self.test_success_case("tr(musig/*,{pk(partial keys diff musig-1/*),pk(partial keys diff musig-2/*)})} script-path", "tr(musig($0,$1,$2)/<3;4>/*,{pk(musig($0,$1)/<5;6>/*),pk(musig($1,$2)/7/*)})", scriptpath=True, nosign_wallets=[0])
 
+        self.test_failure_case_1("missing participant nonce", "tr(musig($0/<0;1>/*,$1/<1;2>/*,$2/<2;3>/*))")
+        self.test_failure_case_2("insufficient partial signatures", "rawtr(musig($0/<0;1>/*,$1/<1;2>/*,$2/<2;3>/*))")
+        self.test_failure_case_3("finalize without partial sigs", "rawtr(musig($0/<0;1>/*,$1/<1;2>/*))")
 
 if __name__ == '__main__':
     WalletMuSigTest(__file__).main()
diff --git a/depend/bitcoin/test/functional/wallet_orphanedreward.py b/depend/bitcoin/test/functional/wallet_orphanedreward.py
index f13b5a8c..2ab50f79 100755
--- a/depend/bitcoin/test/functional/wallet_orphanedreward.py
+++ b/depend/bitcoin/test/functional/wallet_orphanedreward.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2022 The Bitcoin Core developers
+# Copyright (c) 2020-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 orphaned block rewards in the wallet."""
diff --git a/depend/bitcoin/test/functional/wallet_rescan_unconfirmed.py b/depend/bitcoin/test/functional/wallet_rescan_unconfirmed.py
index e41a7689..c4ab5452 100755
--- a/depend/bitcoin/test/functional/wallet_rescan_unconfirmed.py
+++ b/depend/bitcoin/test/functional/wallet_rescan_unconfirmed.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2024 The Bitcoin Core developers
+# Copyright (c) 2024-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test that descriptor wallets rescan mempool transactions properly when importing."""
diff --git a/depend/bitcoin/test/functional/wallet_resendwallettransactions.py b/depend/bitcoin/test/functional/wallet_resendwallettransactions.py
index 6ebc9d58..0b749f69 100755
--- a/depend/bitcoin/test/functional/wallet_resendwallettransactions.py
+++ b/depend/bitcoin/test/functional/wallet_resendwallettransactions.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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 that the wallet resends transactions periodically."""
diff --git a/depend/bitcoin/test/functional/wallet_send.py b/depend/bitcoin/test/functional/wallet_send.py
index fef2088e..bbc2b990 100755
--- a/depend/bitcoin/test/functional/wallet_send.py
+++ b/depend/bitcoin/test/functional/wallet_send.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020-2022 The Bitcoin Core developers
+# Copyright (c) 2020-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 the send RPC command."""
diff --git a/depend/bitcoin/test/functional/wallet_sendall.py b/depend/bitcoin/test/functional/wallet_sendall.py
index 51fe4a07..1977a1e2 100755
--- a/depend/bitcoin/test/functional/wallet_sendall.py
+++ b/depend/bitcoin/test/functional/wallet_sendall.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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 the sendall RPC command."""
diff --git a/depend/bitcoin/test/functional/wallet_sendmany.py b/depend/bitcoin/test/functional/wallet_sendmany.py
index 8c2f9b0f..d1531272 100755
--- a/depend/bitcoin/test/functional/wallet_sendmany.py
+++ b/depend/bitcoin/test/functional/wallet_sendmany.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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 the sendmany RPC command."""
diff --git a/depend/bitcoin/test/functional/wallet_signmessagewithaddress.py b/depend/bitcoin/test/functional/wallet_signmessagewithaddress.py
index a81119a6..2c6e17b6 100755
--- a/depend/bitcoin/test/functional/wallet_signmessagewithaddress.py
+++ b/depend/bitcoin/test/functional/wallet_signmessagewithaddress.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2022 The Bitcoin Core developers
+# Copyright (c) 2016-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 Wallet commands for signing and verifying messages."""
diff --git a/depend/bitcoin/test/functional/wallet_signrawtransactionwithwallet.py b/depend/bitcoin/test/functional/wallet_signrawtransactionwithwallet.py
index fb843234..2dec5068 100755
--- a/depend/bitcoin/test/functional/wallet_signrawtransactionwithwallet.py
+++ b/depend/bitcoin/test/functional/wallet_signrawtransactionwithwallet.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2022 The Bitcoin Core developers
+# Copyright (c) 2015-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 transaction signing using the signrawtransactionwithwallet RPC."""
diff --git a/depend/bitcoin/test/functional/wallet_simulaterawtx.py b/depend/bitcoin/test/functional/wallet_simulaterawtx.py
index 4ee66306..d7941e82 100755
--- a/depend/bitcoin/test/functional/wallet_simulaterawtx.py
+++ b/depend/bitcoin/test/functional/wallet_simulaterawtx.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021-2022 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test simulaterawtransaction.
diff --git a/depend/bitcoin/test/functional/wallet_spend_unconfirmed.py b/depend/bitcoin/test/functional/wallet_spend_unconfirmed.py
index e673056c..2dbecf65 100755
--- a/depend/bitcoin/test/functional/wallet_spend_unconfirmed.py
+++ b/depend/bitcoin/test/functional/wallet_spend_unconfirmed.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/test/functional/wallet_startup.py b/depend/bitcoin/test/functional/wallet_startup.py
index ade33e41..17958b75 100755
--- a/depend/bitcoin/test/functional/wallet_startup.py
+++ b/depend/bitcoin/test/functional/wallet_startup.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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 wallet load on startup.
diff --git a/depend/bitcoin/test/functional/wallet_taproot.py b/depend/bitcoin/test/functional/wallet_taproot.py
index 35d2d791..7bd5d9a5 100755
--- a/depend/bitcoin/test/functional/wallet_taproot.py
+++ b/depend/bitcoin/test/functional/wallet_taproot.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2021-2022 The Bitcoin Core developers
+# Copyright (c) 2021-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test generation and spending of P2TR addresses."""
diff --git a/depend/bitcoin/test/functional/wallet_timelock.py b/depend/bitcoin/test/functional/wallet_timelock.py
index 0326c291..8b5e6460 100755
--- a/depend/bitcoin/test/functional/wallet_timelock.py
+++ b/depend/bitcoin/test/functional/wallet_timelock.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2022 The Bitcoin Core developers
+# Copyright (c) 2022-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.
 
diff --git a/depend/bitcoin/test/functional/wallet_transactiontime_rescan.py b/depend/bitcoin/test/functional/wallet_transactiontime_rescan.py
index 3155a86b..6ebd2f23 100755
--- a/depend/bitcoin/test/functional/wallet_transactiontime_rescan.py
+++ b/depend/bitcoin/test/functional/wallet_transactiontime_rescan.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2018-2022 The Bitcoin Core developers
+# 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.
 """Test transaction time during old block rescanning
diff --git a/depend/bitcoin/test/functional/wallet_txn_clone.py b/depend/bitcoin/test/functional/wallet_txn_clone.py
index 7dc392b0..befd66ff 100755
--- a/depend/bitcoin/test/functional/wallet_txn_clone.py
+++ b/depend/bitcoin/test/functional/wallet_txn_clone.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 the wallet accounts properly when there are cloned transactions with malleated scriptsigs."""
diff --git a/depend/bitcoin/test/functional/wallet_txn_doublespend.py b/depend/bitcoin/test/functional/wallet_txn_doublespend.py
index eb8f046e..4b61fa89 100755
--- a/depend/bitcoin/test/functional/wallet_txn_doublespend.py
+++ b/depend/bitcoin/test/functional/wallet_txn_doublespend.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
+# Copyright (c) 2014-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 the wallet accounts properly when there is a double-spend conflict."""
diff --git a/depend/bitcoin/test/functional/wallet_v3_txs.py b/depend/bitcoin/test/functional/wallet_v3_txs.py
index a037c1bc..6b3b40d5 100755
--- a/depend/bitcoin/test/functional/wallet_v3_txs.py
+++ b/depend/bitcoin/test/functional/wallet_v3_txs.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2025 The Bitcoin Core developers
+# Copyright (c) 2025-present The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test how the wallet deals with TRUC transactions"""
diff --git a/depend/bitcoin/test/lint/README.md b/depend/bitcoin/test/lint/README.md
index 1858a2c0..e28eda1f 100644
--- a/depend/bitcoin/test/lint/README.md
+++ b/depend/bitcoin/test/lint/README.md
@@ -50,7 +50,6 @@ or `--help`:
 | [`lint-python.py`](/test/lint/lint-python.py) | [pyzmq](https://github.com/zeromq/pyzmq)
 | [`lint-python-dead-code.py`](/test/lint/lint-python-dead-code.py) | [vulture](https://github.com/jendrikseipp/vulture)
 | [`lint-shell.py`](/test/lint/lint-shell.py) | [ShellCheck](https://github.com/koalaman/shellcheck)
-| [`lint-spelling.py`](/test/lint/lint-spelling.py) | [codespell](https://github.com/codespell-project/codespell)
 | `py_lint` | [ruff](https://github.com/astral-sh/ruff)
 | markdown link check | [mlc](https://github.com/becheran/mlc)
 
diff --git a/depend/bitcoin/test/lint/commit-script-check.sh b/depend/bitcoin/test/lint/commit-script-check.sh
index 52ae95fb..af7a0d2f 100755
--- a/depend/bitcoin/test/lint/commit-script-check.sh
+++ b/depend/bitcoin/test/lint/commit-script-check.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# Copyright (c) 2017-2022 The Bitcoin Core developers
+# Copyright (c) 2017-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.
 
diff --git a/depend/bitcoin/test/lint/git-subtree-check.sh b/depend/bitcoin/test/lint/git-subtree-check.sh
index 83816bb2..1eb83401 100755
--- a/depend/bitcoin/test/lint/git-subtree-check.sh
+++ b/depend/bitcoin/test/lint/git-subtree-check.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# Copyright (c) 2015-2021 The Bitcoin Core developers
+# Copyright (c) 2015-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.
 
diff --git a/depend/bitcoin/test/lint/lint-circular-dependencies.py b/depend/bitcoin/test/lint/lint-circular-dependencies.py
index 9554e560..8114b6dd 100755
--- a/depend/bitcoin/test/lint/lint-circular-dependencies.py
+++ b/depend/bitcoin/test/lint/lint-circular-dependencies.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 #
-# Copyright (c) 2020-2022 The Bitcoin Core developers
+# Copyright (c) 2020-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.
 #
diff --git a/depend/bitcoin/test/lint/lint-shell.py b/depend/bitcoin/test/lint/lint-shell.py
index 7fb78894..23830e94 100755
--- a/depend/bitcoin/test/lint/lint-shell.py
+++ b/depend/bitcoin/test/lint/lint-shell.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 #
-# Copyright (c) 2018-2022 The Bitcoin Core developers
+# 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.
 
diff --git a/depend/bitcoin/test/lint/lint-spelling.py b/depend/bitcoin/test/lint/lint-spelling.py
deleted file mode 100755
index cd34162c..00000000
--- a/depend/bitcoin/test/lint/lint-spelling.py
+++ /dev/null
@@ -1,43 +0,0 @@
-#!/usr/bin/env python3
-#
-# Copyright (c) 2022-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.
-
-"""
-Warn in case of spelling errors.
-Note: Will exit successfully regardless of spelling errors.
-"""
-
-from subprocess import check_output, STDOUT, CalledProcessError
-
-from lint_ignore_dirs import SHARED_EXCLUDED_SUBTREES
-
-IGNORE_WORDS_FILE = 'test/lint/spelling.ignore-words.txt'
-FILES_ARGS = ['git', 'ls-files', '--', ":(exclude)contrib/seeds/*.txt", ":(exclude)depends/", ":(exclude)doc/release-notes/", ":(exclude)src/qt/locale/", ":(exclude)src/qt/*.qrc", ":(exclude)contrib/guix/patches"]
-FILES_ARGS += [f":(exclude){dir}" for dir in SHARED_EXCLUDED_SUBTREES]
-
-
-def check_codespell_install():
-    try:
-        check_output(["codespell", "--version"])
-    except FileNotFoundError:
-        print("Skipping spell check linting since codespell is not installed.")
-        exit(0)
-
-
-def main():
-    check_codespell_install()
-
-    files = check_output(FILES_ARGS, text=True).splitlines()
-    codespell_args = ['codespell', '--check-filenames', '--disable-colors', '--quiet-level=7', '--ignore-words={}'.format(IGNORE_WORDS_FILE)] + files
-
-    try:
-        check_output(codespell_args, stderr=STDOUT, text=True)
-    except CalledProcessError as e:
-        print(e.output, end="")
-        print('^ Warning: codespell identified likely spelling errors. Any false positives? Add them to the list of ignored words in {}'.format(IGNORE_WORDS_FILE))
-
-
-if __name__ == "__main__":
-    main()
diff --git a/depend/bitcoin/test/lint/spelling.ignore-words.txt b/depend/bitcoin/test/lint/spelling.ignore-words.txt
deleted file mode 100644
index fe08eabe..00000000
--- a/depend/bitcoin/test/lint/spelling.ignore-words.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-afile
-amountIn
-anc
-blockin
-bu
-cachable
-clen
-debbugs
-deques
-fo
-hashIn
-hights
-incomin
-invokable
-lief
-mor
-nd
-nin
-ot
-outIn
-requestor
-ser
-siz
-stap
-unparseable
-unser
-useable
-viewIn
-wit
\ No newline at end of file
diff --git a/kernel/chainstate_manager.go b/kernel/chainstate_manager.go
index 78cf86d9..0d89a0e5 100644
--- a/kernel/chainstate_manager.go
+++ b/kernel/chainstate_manager.go
@@ -172,18 +172,10 @@ func (cm *ChainstateManager) ImportBlocks(blockFilePaths []string) error {
 	cLens := make([]C.size_t, len(blockFilePaths))
 	for i, path := range blockFilePaths {
 		cPaths[i] = C.CString(path)
+		defer C.free(unsafe.Pointer(cPaths[i]))
 		cLens[i] = C.size_t(len(path))
 	}
 
-	// Clean up C strings
-	defer func() {
-		for i := range cPaths {
-			if cPaths[i] != nil {
-				C.free(unsafe.Pointer(cPaths[i]))
-			}
-		}
-	}()
-
 	var cPathsPtr **C.char
 	var cLensPtr *C.size_t
 	if len(cPaths) > 0 {
diff --git a/kernel/errors.go b/kernel/errors.go
index dc257860..1298faa3 100644
--- a/kernel/errors.go
+++ b/kernel/errors.go
@@ -8,7 +8,6 @@ var (
 	ErrVerifyScriptVerifyTxInputIndex            = &ScriptVerifyError{"Transaction input index out of range"}
 	ErrVerifyScriptVerifyInvalidFlags            = &ScriptVerifyError{"Invalid script verification flags"}
 	ErrVerifyScriptVerifyInvalidFlagsCombination = &ScriptVerifyError{"Invalid combination of script verification flags"}
-	ErrVerifyScriptVerifySpentOutputsMismatch    = &ScriptVerifyError{"Spent outputs count mismatch"}
 	ErrVerifyScriptVerifySpentOutputsRequired    = &ScriptVerifyError{"Spent outputs required for verification"}
 )
 
diff --git a/kernel/precomputed_transaction_data.go b/kernel/precomputed_transaction_data.go
new file mode 100644
index 00000000..ff6fb10b
--- /dev/null
+++ b/kernel/precomputed_transaction_data.go
@@ -0,0 +1,69 @@
+package kernel
+
+/*
+#include "bitcoinkernel.h"
+*/
+import "C"
+import (
+	"unsafe"
+)
+
+type precomputedTransactionDataCFuncs struct{}
+
+func (precomputedTransactionDataCFuncs) destroy(ptr unsafe.Pointer) {
+	C.btck_precomputed_transaction_data_destroy((*C.btck_PrecomputedTransactionData)(ptr))
+}
+
+func (precomputedTransactionDataCFuncs) copy(ptr unsafe.Pointer) unsafe.Pointer {
+	return unsafe.Pointer(C.btck_precomputed_transaction_data_copy((*C.btck_PrecomputedTransactionData)(ptr)))
+}
+
+type PrecomputedTransactionData struct {
+	*handle
+}
+
+func newPrecomputedTransactionData(ptr *C.btck_PrecomputedTransactionData, fromOwned bool) *PrecomputedTransactionData {
+	h := newHandle(unsafe.Pointer(ptr), precomputedTransactionDataCFuncs{}, fromOwned)
+	return &PrecomputedTransactionData{handle: h}
+}
+
+// NewPrecomputedTransactionData creates precomputed transaction data for script verification.
+//
+// Precomputed data is reusable when verifying multiple inputs of the same transaction.
+// This avoids recomputing transaction hashes for each input.
+//
+// Required when verifying a taproot input.
+//
+// The underlying C implementation copies the spent outputs data, so the spentOutputs slice
+// and its elements can be safely freed after this function returns.
+//
+// Parameters:
+//   - txTo: The transaction to precompute data for
+//   - spentOutputs: Outputs spent by the transaction. May be nil for non-taproot verification.
+//
+// Returns an error if the precomputation fails.
+func NewPrecomputedTransactionData(txTo *Transaction, spentOutputs []*TransactionOutput) (*PrecomputedTransactionData, error) {
+	var cSpentOutputsPtr **C.btck_TransactionOutput
+	if len(spentOutputs) > 0 {
+		cSpentOutputs := make([]*C.btck_TransactionOutput, len(spentOutputs))
+		for i, output := range spentOutputs {
+			cSpentOutputs[i] = (*C.btck_TransactionOutput)(output.handle.ptr)
+		}
+		cSpentOutputsPtr = (**C.btck_TransactionOutput)(unsafe.Pointer(&cSpentOutputs[0]))
+	}
+
+	ptr := C.btck_precomputed_transaction_data_create(
+		(*C.btck_Transaction)(txTo.handle.ptr),
+		cSpentOutputsPtr,
+		C.size_t(len(spentOutputs)),
+	)
+	if ptr == nil {
+		return nil, &InternalError{"Failed to create precomputed transaction data"}
+	}
+	return newPrecomputedTransactionData(ptr, true), nil
+}
+
+// Copy creates a copy of the precomputed transaction data.
+func (p *PrecomputedTransactionData) Copy() *PrecomputedTransactionData {
+	return newPrecomputedTransactionData((*C.btck_PrecomputedTransactionData)(p.ptr), false)
+}
diff --git a/kernel/script_pubkey.go b/kernel/script_pubkey.go
index c77b3549..6c22e87e 100644
--- a/kernel/script_pubkey.go
+++ b/kernel/script_pubkey.go
@@ -75,13 +75,13 @@ func (s *scriptPubkeyApi) Bytes() ([]byte, error) {
 
 // Verify verifies if the input at inputIndex of txTo spends the script pubkey
 // under the constraints specified by flags. If the witness flag is set in flags,
-// the amount parameter is used. If the taproot flag is set, spentOutputs is used
-// to validate taproot transactions.
+// the amount parameter is used. If the taproot flag is set, precomputedTxData must
+// contain the spent outputs.
 //
 // Parameters:
 //   - amount: Amount of the script pubkey's associated output. May be zero if the witness flag is not set.
 //   - txTo: Transaction spending the script pubkey.
-//   - spentOutputs: Outputs spent by the transaction. May be nil if the taproot flag is not set.
+//   - precomputedTxData: Precomputed transaction data. May be nil if the taproot flag is not set.
 //   - inputIndex: Index of the input in txTo spending the script pubkey.
 //   - flags: ScriptFlags controlling validation constraints.
 //
@@ -89,28 +89,20 @@ func (s *scriptPubkeyApi) Bytes() ([]byte, error) {
 //   - bool: true if the script is valid, false if invalid (only meaningful when error is nil)
 //   - error: non-nil if verification could not be performed due to malformed input;
 //     nil if verification completed successfully (check bool for validity result)
-func (s *scriptPubkeyApi) Verify(amount int64, txTo *Transaction, spentOutputs []*TransactionOutput, inputIndex uint, flags ScriptFlags) (bool, error) {
+func (s *scriptPubkeyApi) Verify(amount int64, txTo *Transaction, precomputedTxData *PrecomputedTransactionData, inputIndex uint, flags ScriptFlags) (bool, error) {
 	inputCount := txTo.CountInputs()
 	if inputIndex >= uint(inputCount) {
 		return false, ErrVerifyScriptVerifyTxInputIndex
 	}
 
-	if len(spentOutputs) > 0 && uint64(len(spentOutputs)) != inputCount {
-		return false, ErrVerifyScriptVerifySpentOutputsMismatch
-	}
-
 	allFlags := ScriptFlagsVerifyAll
 	if (flags & ^ScriptFlags(allFlags)) != 0 {
 		return false, ErrVerifyScriptVerifyInvalidFlags
 	}
 
-	var cSpentOutputsPtr **C.btck_TransactionOutput
-	if len(spentOutputs) > 0 {
-		cSpentOutputs := make([]*C.btck_TransactionOutput, len(spentOutputs))
-		for i, output := range spentOutputs {
-			cSpentOutputs[i] = (*C.btck_TransactionOutput)(output.handle.ptr)
-		}
-		cSpentOutputsPtr = (**C.btck_TransactionOutput)(unsafe.Pointer(&cSpentOutputs[0]))
+	var cPrecomputedTxData *C.btck_PrecomputedTransactionData
+	if precomputedTxData != nil {
+		cPrecomputedTxData = (*C.btck_PrecomputedTransactionData)(precomputedTxData.ptr)
 	}
 
 	var cStatus C.btck_ScriptVerifyStatus
@@ -118,8 +110,7 @@ func (s *scriptPubkeyApi) Verify(amount int64, txTo *Transaction, spentOutputs [
 		s.ptr,
 		C.int64_t(amount),
 		(*C.btck_Transaction)(txTo.handle.ptr),
-		cSpentOutputsPtr,
-		C.size_t(len(spentOutputs)),
+		cPrecomputedTxData,
 		C.uint(inputIndex),
 		C.btck_ScriptVerificationFlags(flags),
 		&cStatus,
diff --git a/kernel/script_pubkey_test.go b/kernel/script_pubkey_test.go
index 2e1e5376..95a9e511 100644
--- a/kernel/script_pubkey_test.go
+++ b/kernel/script_pubkey_test.go
@@ -3,6 +3,7 @@ package kernel
 import (
 	"encoding/hex"
 	"errors"
+	"fmt"
 	"testing"
 )
 
@@ -118,7 +119,12 @@ func TestValidScripts(t *testing.T) {
 		amount          int64
 		txToHex         string
 		inputIndex      uint
-		description     string
+		spentOutputs    []struct {
+			scriptHex string
+			amount    int64
+		}
+		flags       ScriptFlags
+		description string
 	}{
 		{
 			name:            "old_style_transaction",
@@ -126,6 +132,7 @@ func TestValidScripts(t *testing.T) {
 			amount:          0,
 			txToHex:         "02000000013f7cebd65c27431a90bba7f796914fe8cc2ddfc3f2cbd6f7e5f2fc854534da95000000006b483045022100de1ac3bcdfb0332207c4a91f3832bd2c2915840165f876ab47c5f8996b971c3602201c6c053d750fadde599e6f5c4e1963df0f01fc0d97815e8157e3d59fe09ca30d012103699b464d1d8bc9e47d4fb1cdaa89a1c5783d68363c4dbc4b524ed3d857148617feffffff02836d3c01000000001976a914fc25d6d5c94003bf5b0c7b640a248e2c637fcfb088ac7ada8202000000001976a914fbed3d9b11183209a57999d54d59f67c019e756c88ac6acb0700",
 			inputIndex:      0,
+			flags:           ScriptFlagsVerifyAll &^ ScriptFlagsVerifyTaproot,
 			description:     "a random old-style transaction from the blockchain",
 		},
 		{
@@ -134,6 +141,7 @@ func TestValidScripts(t *testing.T) {
 			amount:          1900000,
 			txToHex:         "01000000000101d9fd94d0ff0026d307c994d0003180a5f248146efb6371d040c5973f5f66d9df0400000017160014b31b31a6cb654cfab3c50567bcf124f48a0beaecffffffff012cbd1c000000000017a914233b74bf0823fa58bbbd26dfc3bb4ae715547167870247304402206f60569cac136c114a58aedd80f6fa1c51b49093e7af883e605c212bdafcd8d202200e91a55f408a021ad2631bc29a67bd6915b2d7e9ef0265627eabd7f7234455f6012103e7e802f50344303c76d12c089c8724c1b230e3b745693bbe16aad536293d15e300000000",
 			inputIndex:      0,
+			flags:           ScriptFlagsVerifyAll &^ ScriptFlagsVerifyTaproot,
 			description:     "a random segwit transaction from the blockchain using P2SH",
 		},
 		{
@@ -142,13 +150,32 @@ func TestValidScripts(t *testing.T) {
 			amount:          18393430,
 			txToHex:         "010000000001011f97548fbbe7a0db7588a66e18d803d0089315aa7d4cc28360b6ec50ef36718a0100000000ffffffff02df1776000000000017a9146c002a686959067f4866b8fb493ad7970290ab728757d29f0000000000220020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d04004730440220565d170eed95ff95027a69b313758450ba84a01224e1f7f130dda46e94d13f8602207bdd20e307f062594022f12ed5017bbf4a055a06aea91c10110a0e3bb23117fc014730440220647d2dc5b15f60bc37dc42618a370b2a1490293f9e5c8464f53ec4fe1dfe067302203598773895b4b16d37485cbe21b337f4e4b650739880098c592553add7dd4355016952210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae00000000",
 			inputIndex:      0,
+			flags:           ScriptFlagsVerifyAll &^ ScriptFlagsVerifyTaproot,
 			description:     "a random segwit transaction from the blockchain using native segwit",
 		},
+		{
+			name:            "taproot_single_input",
+			scriptPubkeyHex: "5120339ce7e165e67d93adb3fef88a6d4beed33f01fa876f05a225242b82a631abc0",
+			amount:          88480,
+			txToHex:         "01000000000101d1f1c1f8cdf6759167b90f52c9ad358a369f95284e841d7a2536cef31c0549580100000000fdffffff020000000000000000316a2f49206c696b65205363686e6f7272207369677320616e6420492063616e6e6f74206c69652e204062697462756734329e06010000000000225120a37c3903c8d0db6512e2b40b0dffa05e5a3ab73603ce8c9c4b7771e5412328f90140a60c383f71bac0ec919b1d7dbc3eb72dd56e7aa99583615564f9f99b8ae4e837b758773a5b2e4c51348854c8389f008e05029db7f464a5ff2e01d5e6e626174affd30a00",
+			inputIndex:      0,
+			spentOutputs: []struct {
+				scriptHex string
+				amount    int64
+			}{
+				{
+					scriptHex: "5120339ce7e165e67d93adb3fef88a6d4beed33f01fa876f05a225242b82a631abc0",
+					amount:    88480,
+				},
+			},
+			flags:       ScriptFlagsVerifyAll,
+			description: "Single-input Taproot transaction",
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			valid, err := testVerifyScript(t, tt.scriptPubkeyHex, tt.amount, tt.txToHex, tt.inputIndex)
+			valid, err := testVerifyScript(t, tt.scriptPubkeyHex, tt.amount, tt.txToHex, tt.inputIndex, tt.flags, tt.spentOutputs)
 			if err != nil {
 				t.Errorf("testVerifyScript() error = %v", err)
 			} else if !valid {
@@ -158,6 +185,81 @@ func TestValidScripts(t *testing.T) {
 	}
 }
 
+func TestValidTaprootMultiInput(t *testing.T) {
+	txToHex := "02000000000102c0f01ead18750892c84b1d4f595149ad38f16847df1fbf490e235b3b78c1f98a0100000000ffffffff456764a19c2682bf5b1567119f06a421849ad1664cf42b5ef95b69d6e2159e9d0000000000ffffffff022202000000000000225120b6c0c2a8ee25a2ae0322ab7f1a06f01746f81f6b90d179c3c2a51a356e6188f1d70e020000000000225120b7da80f57e36930b0515eb09293e25858d13e6b91fee6184943f5a584cb4248e0141933fdc49eb1af1f08ed1e9cf5559259309a8acd25ff1e6999b6955124438aef4fceaa4e6a5f85286631e24837329563595bc3cf4b31e1c687442abb01c4206818101401c9620faf1e8c84187762ad14d04ae3857f59a2f03f1dcbb99290e16dfc572a63b4ea435780a5787af59beb5742fd71cda8a95381517a1ff14b4c67996c4bf8100000000"
+
+	txToBytes, err := hex.DecodeString(txToHex)
+	if err != nil {
+		t.Fatalf("Failed to decode transaction hex: %v", err)
+	}
+
+	txTo, err := NewTransaction(txToBytes)
+	if err != nil {
+		t.Fatalf("Failed to create transaction: %v", err)
+	}
+	defer txTo.Destroy()
+
+	spentOutputs := []struct {
+		scriptHex string
+		amount    int64
+	}{
+		{scriptHex: "5120b7da80f57e36930b0515eb09293e25858d13e6b91fee6184943f5a584cb4248e", amount: 546},
+		{scriptHex: "5120ab78e077d062e7b8acd7063668b4db5355a1b5d5fd2a46a8e98e62e5e63fab77", amount: 135125},
+	}
+
+	outputs := make([]*TransactionOutput, len(spentOutputs))
+	for i, spent := range spentOutputs {
+		spentScriptBytes, err := hex.DecodeString(spent.scriptHex)
+		if err != nil {
+			t.Fatalf("Failed to decode spent script hex: %v", err)
+		}
+		spentScript := NewScriptPubkey(spentScriptBytes)
+		defer spentScript.Destroy()
+
+		outputs[i] = NewTransactionOutput(spentScript, spent.amount)
+		defer outputs[i].Destroy()
+	}
+
+	precomputed, err := NewPrecomputedTransactionData(txTo, outputs)
+	if err != nil {
+		t.Fatalf("Failed to create precomputed transaction data: %v", err)
+	}
+	defer precomputed.Destroy()
+
+	inputs := []struct {
+		scriptPubkeyHex string
+		amount          int64
+	}{
+		{
+			scriptPubkeyHex: "5120b7da80f57e36930b0515eb09293e25858d13e6b91fee6184943f5a584cb4248e",
+			amount:          546,
+		},
+		{
+			scriptPubkeyHex: "5120ab78e077d062e7b8acd7063668b4db5355a1b5d5fd2a46a8e98e62e5e63fab77",
+			amount:          135125,
+		},
+	}
+
+	for i, input := range inputs {
+		t.Run(fmt.Sprintf("input_%d", i), func(t *testing.T) {
+			scriptPubkeyBytes, err := hex.DecodeString(input.scriptPubkeyHex)
+			if err != nil {
+				t.Fatalf("Failed to decode script pubkey hex: %v", err)
+			}
+
+			scriptPubkey := NewScriptPubkey(scriptPubkeyBytes)
+			defer scriptPubkey.Destroy()
+
+			valid, err := scriptPubkey.Verify(input.amount, txTo, precomputed, uint(i), ScriptFlagsVerifyAll)
+			if err != nil {
+				t.Errorf("Verify() error = %v", err)
+			} else if !valid {
+				t.Errorf("Verify() expected valid script, got invalid")
+			}
+		})
+	}
+}
+
 func TestInvalidScripts(t *testing.T) {
 	tests := []struct {
 		name            string
@@ -165,7 +267,12 @@ func TestInvalidScripts(t *testing.T) {
 		amount          int64
 		txToHex         string
 		inputIndex      uint
-		description     string
+		spentOutputs    []struct {
+			scriptHex string
+			amount    int64
+		}
+		flags       ScriptFlags
+		description string
 	}{
 		{
 			name:            "old_style_wrong_signature",
@@ -173,6 +280,7 @@ func TestInvalidScripts(t *testing.T) {
 			amount:          0,
 			txToHex:         "02000000013f7cebd65c27431a90bba7f796914fe8cc2ddfc3f2cbd6f7e5f2fc854534da95000000006b483045022100de1ac3bcdfb0332207c4a91f3832bd2c2915840165f876ab47c5f8996b971c3602201c6c053d750fadde599e6f5c4e1963df0f01fc0d97815e8157e3d59fe09ca30d012103699b464d1d8bc9e47d4fb1cdaa89a1c5783d68363c4dbc4b524ed3d857148617feffffff02836d3c01000000001976a914fc25d6d5c94003bf5b0c7b640a248e2c637fcfb088ac7ada8202000000001976a914fbed3d9b11183209a57999d54d59f67c019e756c88ac6acb0700",
 			inputIndex:      0,
+			flags:           ScriptFlagsVerifyAll & ^ScriptFlagsVerifyTaproot,
 			description:     "a random old-style transaction from the blockchain - WITH WRONG SIGNATURE for the address",
 		},
 		{
@@ -181,6 +289,7 @@ func TestInvalidScripts(t *testing.T) {
 			amount:          900000, // Wrong amount, should be 1900000
 			txToHex:         "01000000000101d9fd94d0ff0026d307c994d0003180a5f248146efb6371d040c5973f5f66d9df0400000017160014b31b31a6cb654cfab3c50567bcf124f48a0beaecffffffff012cbd1c000000000017a914233b74bf0823fa58bbbd26dfc3bb4ae715547167870247304402206f60569cac136c114a58aedd80f6fa1c51b49093e7af883e605c212bdafcd8d202200e91a55f408a021ad2631bc29a67bd6915b2d7e9ef0265627eabd7f7234455f6012103e7e802f50344303c76d12c089c8724c1b230e3b745693bbe16aad536293d15e300000000",
 			inputIndex:      0,
+			flags:           ScriptFlagsVerifyAll & ^ScriptFlagsVerifyTaproot,
 			description:     "a random segwit transaction from the blockchain using P2SH - WITH WRONG AMOUNT",
 		},
 		{
@@ -189,6 +298,7 @@ func TestInvalidScripts(t *testing.T) {
 			amount:          18393430,
 			txToHex:         "010000000001011f97548fbbe7a0db7588a66e18d803d0089315aa7d4cc28360b6ec50ef36718a0100000000ffffffff02df1776000000000017a9146c002a686959067f4866b8fb493ad7970290ab728757d29f0000000000220020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d04004730440220565d170eed95ff95027a69b313758450ba84a01224e1f7f130dda46e94d13f8602207bdd20e307f062594022f12ed5017bbf4a055a06aea91c10110a0e3bb23117fc014730440220647d2dc5b15f60bc37dc42618a370b2a1490293f9e5c8464f53ec4fe1dfe067302203598773895b4b16d37485cbe21b337f4e4b650739880098c592553add7dd4355016952210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae00000000",
 			inputIndex:      0,
+			flags:           ScriptFlagsVerifyAll & ^ScriptFlagsVerifyTaproot,
 			description:     "a random segwit transaction from the blockchain using native segwit - WITH WRONG SEGWIT",
 		},
 		{
@@ -199,13 +309,32 @@ func TestInvalidScripts(t *testing.T) {
 			// used to trigger verification paths.
 			txToHex:     "01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff00ffffffff0100000000000000000000000000",
 			inputIndex:  0,
+			flags:       ScriptFlagsVerifyAll & ^ScriptFlagsVerifyTaproot,
 			description: "empty scriptPubkey should fail verification",
 		},
+		{
+			name:            "taproot_wrong_spent_output_amount",
+			scriptPubkeyHex: "5120339ce7e165e67d93adb3fef88a6d4beed33f01fa876f05a225242b82a631abc0",
+			amount:          88480,
+			txToHex:         "01000000000101d1f1c1f8cdf6759167b90f52c9ad358a369f95284e841d7a2536cef31c0549580100000000fdffffff020000000000000000316a2f49206c696b65205363686e6f7272207369677320616e6420492063616e6e6f74206c69652e204062697462756734329e06010000000000225120a37c3903c8d0db6512e2b40b0dffa05e5a3ab73603ce8c9c4b7771e5412328f90140a60c383f71bac0ec919b1d7dbc3eb72dd56e7aa99583615564f9f99b8ae4e837b758773a5b2e4c51348854c8389f008e05029db7f464a5ff2e01d5e6e626174affd30a00",
+			inputIndex:      0,
+			spentOutputs: []struct {
+				scriptHex string
+				amount    int64
+			}{
+				{
+					scriptHex: "5120339ce7e165e67d93adb3fef88a6d4beed33f01fa876f05a225242b82a631abc0",
+					amount:    100000, // Wrong amount, should be 88480
+				},
+			},
+			flags:       ScriptFlagsVerifyAll,
+			description: "Taproot transaction with incorrect spent output amount in precomputed data",
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			valid, err := testVerifyScript(t, tt.scriptPubkeyHex, tt.amount, tt.txToHex, tt.inputIndex)
+			valid, err := testVerifyScript(t, tt.scriptPubkeyHex, tt.amount, tt.txToHex, tt.inputIndex, tt.flags, tt.spentOutputs)
 			if err != nil {
 				t.Errorf("testVerifyScript() unexpected error = %v", err)
 			} else if valid {
@@ -239,35 +368,50 @@ func TestScriptVerifyErrors(t *testing.T) {
 	}
 	defer tx.Destroy()
 
+	// Create a precomputed txdata without spent outputs for the spent_outputs_required test
+	emptyPrecomputedTxData, err := NewPrecomputedTransactionData(tx, nil)
+	if err != nil {
+		t.Fatalf("Failed to create empty precomputed transaction data: %v", err)
+	}
+	defer emptyPrecomputedTxData.Destroy()
+
 	tests := []struct {
-		name          string
-		inputIndex    uint
-		flags         ScriptFlags
-		spentOutputs  []*TransactionOutput
-		expectedError error
-		description   string
+		name              string
+		inputIndex        uint
+		flags             ScriptFlags
+		precomputedTxData *PrecomputedTransactionData
+		expectedError     error
+		description       string
 	}{
 		{
-			name:          "invalid_input_index",
-			inputIndex:    999,
-			flags:         ScriptFlagsVerifyAll,
-			spentOutputs:  nil,
-			expectedError: ErrVerifyScriptVerifyTxInputIndex,
-			description:   "input index out of bounds should return error",
+			name:              "invalid_input_index",
+			inputIndex:        999,
+			flags:             ScriptFlagsVerifyAll,
+			precomputedTxData: nil,
+			expectedError:     ErrVerifyScriptVerifyTxInputIndex,
+			description:       "input index out of bounds should return error",
 		},
 		{
-			name:          "invalid_flags",
-			inputIndex:    0,
-			flags:         ScriptFlags(0xFFFFFFFF), // Invalid flags
-			spentOutputs:  nil,
-			expectedError: ErrVerifyScriptVerifyInvalidFlags,
-			description:   "invalid flags should return error",
+			name:              "invalid_flags",
+			inputIndex:        0,
+			flags:             0xFFFFFFFF, // Invalid flags
+			precomputedTxData: nil,
+			expectedError:     ErrVerifyScriptVerifyInvalidFlags,
+			description:       "invalid flags should return error",
+		},
+		{
+			name:              "spent_outputs_required",
+			inputIndex:        0,
+			flags:             ScriptFlagsVerifyAll,
+			precomputedTxData: emptyPrecomputedTxData,
+			expectedError:     ErrVerifyScriptVerifySpentOutputsRequired,
+			description:       "taproot verification with empty spent outputs should return error",
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			valid, err := scriptPubkey.Verify(0, tx, tt.spentOutputs, tt.inputIndex, tt.flags)
+			valid, err := scriptPubkey.Verify(0, tx, tt.precomputedTxData, tt.inputIndex, tt.flags)
 			if err == nil {
 				t.Errorf("Expected error %v, got nil (valid=%v)", tt.expectedError, valid)
 				return
@@ -279,8 +423,19 @@ func TestScriptVerifyErrors(t *testing.T) {
 	}
 }
 
-// testVerifyScript is a helper function that creates the necessary objects and calls VerifyScript
-func testVerifyScript(t *testing.T, scriptPubkeyHex string, amount int64, txToHex string, inputIndex uint) (bool, error) {
+// testVerifyScript is a helper function that creates necessary objects and calls VerifyScript
+func testVerifyScript(
+	t *testing.T,
+	scriptPubkeyHex string,
+	amount int64,
+	txToHex string,
+	inputIndex uint,
+	flags ScriptFlags,
+	spentOutputs []struct {
+		scriptHex string
+		amount    int64
+	},
+) (bool, error) {
 	scriptPubkeyBytes, err := hex.DecodeString(scriptPubkeyHex)
 	if err != nil {
 		t.Fatalf("Failed to decode script pubkey hex: %v", err)
@@ -300,6 +455,29 @@ func testVerifyScript(t *testing.T, scriptPubkeyHex string, amount int64, txToHe
 	}
 	defer txTo.Destroy()
 
-	flags := ScriptFlags(ScriptFlagsVerifyAll &^ ScriptFlagsVerifyTaproot)
-	return scriptPubkey.Verify(amount, txTo, nil, inputIndex, flags)
+	// Create spent outputs if provided
+	var outputs []*TransactionOutput
+	if len(spentOutputs) > 0 {
+		outputs = make([]*TransactionOutput, len(spentOutputs))
+		for i, spent := range spentOutputs {
+			spentScriptBytes, err := hex.DecodeString(spent.scriptHex)
+			if err != nil {
+				t.Fatalf("Failed to decode spent script hex: %v", err)
+			}
+			spentScript := NewScriptPubkey(spentScriptBytes)
+			defer spentScript.Destroy()
+
+			outputs[i] = NewTransactionOutput(spentScript, spent.amount)
+			defer outputs[i].Destroy()
+		}
+	}
+
+	// Always create precomputed data (outputs can be nil)
+	precomputed, err := NewPrecomputedTransactionData(txTo, outputs)
+	if err != nil {
+		t.Fatalf("Failed to create precomputed transaction data: %v", err)
+	}
+	defer precomputed.Destroy()
+
+	return scriptPubkey.Verify(amount, txTo, precomputed, inputIndex, flags)
 }