diff --git a/libbitcoinkernel-sys/bitcoin/.github/workflows/ci.yml b/libbitcoinkernel-sys/bitcoin/.github/workflows/ci.yml
index 3801c187..d4336462 100644
--- a/libbitcoinkernel-sys/bitcoin/.github/workflows/ci.yml
+++ b/libbitcoinkernel-sys/bitcoin/.github/workflows/ci.yml
@@ -510,7 +510,7 @@ jobs:
             timeout-minutes: 240
             file-env: './ci/test/00_setup_env_native_fuzz_with_valgrind.sh'
 
-          - name: 'previous releases, depends DEBUG'
+          - name: 'previous releases'
             cirrus-runner: 'ghcr.io/cirruslabs/ubuntu-runner-amd64:24.04-md'
             fallback-runner: 'ubuntu-24.04'
             timeout-minutes: 120
diff --git a/libbitcoinkernel-sys/bitcoin/CMakeLists.txt b/libbitcoinkernel-sys/bitcoin/CMakeLists.txt
index 3749cf7c..2d21f6e1 100644
--- a/libbitcoinkernel-sys/bitcoin/CMakeLists.txt
+++ b/libbitcoinkernel-sys/bitcoin/CMakeLists.txt
@@ -463,6 +463,8 @@ else()
   try_append_cxx_flags("-Wself-assign" TARGET warn_interface SKIP_LINK)
   try_append_cxx_flags("-Wbidi-chars=any" TARGET warn_interface SKIP_LINK)
   try_append_cxx_flags("-Wundef" TARGET warn_interface SKIP_LINK)
+  try_append_cxx_flags("-Wleading-whitespace=spaces" TARGET warn_interface SKIP_LINK)
+  try_append_cxx_flags("-Wtrailing-whitespace=any" TARGET warn_interface SKIP_LINK)
 
   # Some compilers (gcc) ignore unknown -Wno-* options, but warn about all
   # unknown options if any other warning is produced. Test the -Wfoo case, and
@@ -493,8 +495,8 @@ try_append_cxx_flags("-fmacro-prefix-map=A=B" TARGET core_interface SKIP_LINK
   IF_CHECK_PASSED "-fmacro-prefix-map=${PROJECT_SOURCE_DIR}/src=."
 )
 
-# Currently all versions of gcc are subject to a class of bugs, see the
-# gccbug_90348 test case (only reproduces on GCC 11 and earlier) and
+# GCC versions 13.2 (and earlier) are subject to a class of bugs, see
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90348 and the meta bug
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111843. To work around that, set
 # -fstack-reuse=none for all gcc builds. (Only gcc understands this flag).
 try_append_cxx_flags("-fstack-reuse=none" TARGET core_interface)
diff --git a/libbitcoinkernel-sys/bitcoin/ci/lint/01_install.sh b/libbitcoinkernel-sys/bitcoin/ci/lint/01_install.sh
index 0d8cca98..fc422675 100755
--- a/libbitcoinkernel-sys/bitcoin/ci/lint/01_install.sh
+++ b/libbitcoinkernel-sys/bitcoin/ci/lint/01_install.sh
@@ -18,7 +18,8 @@ ${CI_RETRY_EXE} apt-get update
 # - curl/xz-utils (to install shellcheck)
 # - git (used in many lint scripts)
 # - gpg (used by verify-commits)
-${CI_RETRY_EXE} apt-get install -y cargo curl xz-utils git gpg
+# - moreutils (used by scripted-diff)
+${CI_RETRY_EXE} apt-get install -y cargo curl xz-utils git gpg moreutils
 
 PYTHON_PATH="/python_build"
 if [ ! -d "${PYTHON_PATH}/bin" ]; then
diff --git a/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_arm.sh b/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_arm.sh
index d5b2bb4b..12ec71b8 100755
--- a/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_arm.sh
+++ b/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_arm.sh
@@ -19,10 +19,7 @@ export GOAL="install"
 export CI_LIMIT_STACK_SIZE=1
 # -Wno-psabi is to disable ABI warnings: "note: parameter passing for argument of type ... changed in GCC 7.1"
 # This could be removed once the ABI change warning does not show up by default
-#
-# -Wno-error=dangling-reference helps to work around a GCC 13.1 false-positive,
-# fixed in later versions.
 export BITCOIN_CONFIG=" \
   -DREDUCE_EXPORTS=ON \
-  -DCMAKE_CXX_FLAGS='-Wno-psabi -Wno-error=dangling-reference -Wno-error=maybe-uninitialized' \
+  -DCMAKE_CXX_FLAGS='-Wno-psabi -Wno-error=maybe-uninitialized' \
 "
diff --git a/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_native_previous_releases.sh b/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_native_previous_releases.sh
index d9f8d3bf..a44a51c3 100755
--- a/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_native_previous_releases.sh
+++ b/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_native_previous_releases.sh
@@ -8,15 +8,16 @@ export LC_ALL=C.UTF-8
 
 export CONTAINER_NAME=ci_native_previous_releases
 export CI_IMAGE_NAME_TAG="mirror.gcr.io/ubuntu:22.04"
-# Use minimum supported python3.10 and gcc-11, see doc/dependencies.md
-export PACKAGES="gcc-11 g++-11 python3-zmq"
-export DEP_OPTS="CC=gcc-11 CXX=g++-11"
+# Use minimum supported python3.10 and gcc-12, see doc/dependencies.md
+export PACKAGES="gcc-12 g++-12 python3-zmq"
+export DEP_OPTS="CC=gcc-12 CXX=g++-12"
 export TEST_RUNNER_EXTRA="--previous-releases --coverage --extended --exclude feature_dbcrash"  # Run extended tests so that coverage does not fail, but exclude the very slow dbcrash
 export GOAL="install"
 export CI_LIMIT_STACK_SIZE=1
 export DOWNLOAD_PREVIOUS_RELEASES="true"
 export BITCOIN_CONFIG="\
- -DWITH_ZMQ=ON -DBUILD_GUI=ON -DREDUCE_EXPORTS=ON \
+ --preset=dev-mode \
+ -DREDUCE_EXPORTS=ON \
  -DCMAKE_BUILD_TYPE=Debug \
  -DCMAKE_C_FLAGS='-funsigned-char' \
  -DCMAKE_C_FLAGS_DEBUG='-g2 -O2' \
diff --git a/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_win64.sh b/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_win64.sh
index 06134457..110db1a8 100755
--- a/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_win64.sh
+++ b/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_win64.sh
@@ -13,8 +13,6 @@ export PACKAGES="g++-mingw-w64-x86-64-posix nsis"
 export RUN_UNIT_TESTS=false
 export RUN_FUNCTIONAL_TESTS=false
 export GOAL="deploy"
-# -Wno-error=dangling-reference helps to work around a GCC 13.1 false-positive,
-# fixed in later versions.
 export BITCOIN_CONFIG="-DREDUCE_EXPORTS=ON -DBUILD_GUI_TESTS=OFF -DBUILD_KERNEL_LIB=ON -DBUILD_KERNEL_TEST=ON \
-  -DCMAKE_CXX_FLAGS='-Wno-error=dangling-reference -Wno-error=maybe-uninitialized' \
+  -DCMAKE_CXX_FLAGS='-Wno-error=maybe-uninitialized' \
 "
diff --git a/libbitcoinkernel-sys/bitcoin/contrib/guix/libexec/build.sh b/libbitcoinkernel-sys/bitcoin/contrib/guix/libexec/build.sh
index 16e12d56..09cc058e 100755
--- a/libbitcoinkernel-sys/bitcoin/contrib/guix/libexec/build.sh
+++ b/libbitcoinkernel-sys/bitcoin/contrib/guix/libexec/build.sh
@@ -225,10 +225,15 @@ esac
 
 # LDFLAGS
 case "$HOST" in
-    *linux*)  HOST_LDFLAGS="-Wl,--as-needed -Wl,--dynamic-linker=$glibc_dynamic_linker -static-libstdc++ -Wl,-O2" ;;
+    *linux*)  HOST_LDFLAGS="-Wl,--as-needed -Wl,--dynamic-linker=$glibc_dynamic_linker -Wl,-O2" ;;
     *mingw*)  HOST_LDFLAGS="-Wl,--no-insert-timestamp" ;;
 esac
 
+# EXE FLAGS
+case "$HOST" in
+    *linux*)  CMAKE_EXE_LINKER_FLAGS="-DCMAKE_EXE_LINKER_FLAGS=${HOST_LDFLAGS} -static-libstdc++ -static-libgcc" ;;
+esac
+
 mkdir -p "$DISTSRC"
 (
     cd "$DISTSRC"
@@ -243,7 +248,8 @@ mkdir -p "$DISTSRC"
           --toolchain "${BASEPREFIX}/${HOST}/toolchain.cmake" \
           -DWITH_CCACHE=OFF \
           -Werror=dev \
-          ${CONFIGFLAGS}
+          ${CONFIGFLAGS} \
+          "${CMAKE_EXE_LINKER_FLAGS}"
 
     # Build Bitcoin Core
     cmake --build build -j "$JOBS" ${V:+--verbose}
diff --git a/libbitcoinkernel-sys/bitcoin/contrib/guix/manifest.scm b/libbitcoinkernel-sys/bitcoin/contrib/guix/manifest.scm
index 3670fcec..011ba0de 100644
--- a/libbitcoinkernel-sys/bitcoin/contrib/guix/manifest.scm
+++ b/libbitcoinkernel-sys/bitcoin/contrib/guix/manifest.scm
@@ -99,10 +99,10 @@ chain for " target " development."))
 
 (define* (make-bitcoin-cross-toolchain target
                                        #:key
-                                       (base-gcc-for-libc linux-base-gcc)
+                                       (base-gcc-for-libc (gcc-libgcc-patches linux-base-gcc))
                                        (base-kernel-headers base-linux-kernel-headers)
                                        (base-libc glibc-2.31)
-                                       (base-gcc linux-base-gcc))
+                                       (base-gcc (gcc-libgcc-patches linux-base-gcc)))
   "Convenience wrapper around MAKE-CROSS-TOOLCHAIN with default values
 desirable for building Bitcoin Core release binaries."
   (make-cross-toolchain target
@@ -111,7 +111,7 @@ desirable for building Bitcoin Core release binaries."
                         base-libc
                         base-gcc))
 
-(define (gcc-mingw-patches gcc)
+(define (gcc-libgcc-patches gcc)
   (package-with-extra-patches gcc
     (search-our-patches "gcc-remap-guix-store.patch")))
 
@@ -128,10 +128,10 @@ desirable for building Bitcoin Core release binaries."
   (let* ((xbinutils (binutils-mingw-patches (cross-binutils target)))
          (machine (substring target 0 (string-index target #\-)))
          (pthreads-xlibc (winpthreads-patches (make-mingw-w64 machine
-                                         #:xgcc (cross-gcc target #:xgcc (gcc-mingw-patches base-gcc))
+                                         #:xgcc (cross-gcc target #:xgcc (gcc-libgcc-patches base-gcc))
                                          #:with-winpthreads? #t)))
          (pthreads-xgcc (cross-gcc target
-                                    #:xgcc (gcc-mingw-patches mingw-w64-base-gcc)
+                                    #:xgcc (gcc-libgcc-patches mingw-w64-base-gcc)
                                     #:xbinutils xbinutils
                                     #:libc pthreads-xlibc)))
     ;; Define a meta-package that propagates the resulting XBINUTILS, XLIBC, and
diff --git a/libbitcoinkernel-sys/bitcoin/contrib/guix/patches/gcc-remap-guix-store.patch b/libbitcoinkernel-sys/bitcoin/contrib/guix/patches/gcc-remap-guix-store.patch
index a8b41d48..4144bcd8 100644
--- a/libbitcoinkernel-sys/bitcoin/contrib/guix/patches/gcc-remap-guix-store.patch
+++ b/libbitcoinkernel-sys/bitcoin/contrib/guix/patches/gcc-remap-guix-store.patch
@@ -1,4 +1,4 @@
-Without ffile-prefix-map, the debug symbols will contain paths for the
+Without -ffile-prefix-map, the debug symbols will contain paths for the
 guix store which will include the hashes of each package. However, the
 hash for the same package will differ when on different architectures.
 In order to be reproducible regardless of the architecture used to build
@@ -6,7 +6,7 @@ the package, map all guix store prefixes to something fixed, e.g. /usr.
 
 --- a/libgcc/Makefile.in
 +++ b/libgcc/Makefile.in
-@@ -854,7 +854,7 @@ endif
+@@ -857,7 +857,7 @@ endif
  # libgcc_eh.a, only LIB2ADDEH matters.  If we do, only LIB2ADDEHSTATIC and
  # LIB2ADDEHSHARED matter.  (Usually all three are identical.)
  
@@ -15,6 +15,15 @@ the package, map all guix store prefixes to something fixed, e.g. /usr.
  
  ifeq ($(enable_shared),yes)
  
+@@ -880,7 +880,7 @@ endif
+ # Build LIBUNWIND. Use -fno-exceptions so that the unwind library does
+ # not generate calls to __gcc_personality_v0.
+ 
+-c_flags := -fno-exceptions
++c_flags := -fno-exceptions $(shell find /gnu/store -maxdepth 1 -mindepth 1 -type d -exec echo -n " -ffile-prefix-map={}=/usr" \;)
+ 
+ libunwind-objects += $(addsuffix $(objext),$(basename $(notdir $(LIBUNWIND))))
+ 
 -- 
 2.37.0
 
diff --git a/libbitcoinkernel-sys/bitcoin/contrib/guix/symbol-check.py b/libbitcoinkernel-sys/bitcoin/contrib/guix/symbol-check.py
index 464b33cf..249c53a2 100755
--- a/libbitcoinkernel-sys/bitcoin/contrib/guix/symbol-check.py
+++ b/libbitcoinkernel-sys/bitcoin/contrib/guix/symbol-check.py
@@ -16,23 +16,18 @@
 
 # Debian 11 (Bullseye) EOL: 2026. https://wiki.debian.org/LTS
 #
-# - libgcc version 10.2.1 (https://packages.debian.org/bullseye/libgcc-s1)
 # - libc version 2.31 (https://packages.debian.org/source/bullseye/glibc)
 #
 # Ubuntu 20.04 (Focal) EOL: 2030. https://wiki.ubuntu.com/ReleaseTeam
 #
-# - libgcc version 10.5.0 (https://packages.ubuntu.com/focal/libgcc1)
 # - libc version 2.31 (https://packages.ubuntu.com/focal/libc6)
 #
 # CentOS Stream 9 EOL: 2027. https://www.centos.org/cl-vs-cs/#end-of-life
 #
-# - libgcc version 12.2.1 (https://mirror.stream.centos.org/9-stream/AppStream/x86_64/os/Packages/)
 # - libc version 2.34 (https://mirror.stream.centos.org/9-stream/AppStream/x86_64/os/Packages/)
 #
-# See https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html for more info.
 
 MAX_VERSIONS = {
-'GCC':       (7,0,0),
 'GLIBC': {
     lief.ELF.ARCH.X86_64: (2,31),
     lief.ELF.ARCH.ARM:    (2,31),
@@ -40,7 +35,6 @@
     lief.ELF.ARCH.PPC64:  (2,31),
     lief.ELF.ARCH.RISCV:  (2,31),
 },
-'LIBATOMIC': (1,0),
 'V':         (0,5,0),  # xkb (bitcoin-qt only)
 }
 
@@ -93,11 +87,9 @@
 # Allowed NEEDED libraries
 ELF_ALLOWED_LIBRARIES = {
 # bitcoind and bitcoin-qt
-'libgcc_s.so.1', # GCC base support
 'libc.so.6', # C library
 'libpthread.so.0', # threading
 'libm.so.6', # math library
-'libatomic.so.1',
 'ld-linux-x86-64.so.2', # 64-bit dynamic linker
 'ld-linux.so.2', # 32-bit dynamic linker
 'ld-linux-aarch64.so.1', # 64-bit ARM dynamic linker
diff --git a/libbitcoinkernel-sys/bitcoin/depends/packages/qt.mk b/libbitcoinkernel-sys/bitcoin/depends/packages/qt.mk
index 9ac4088e..ad958b7b 100644
--- a/libbitcoinkernel-sys/bitcoin/depends/packages/qt.mk
+++ b/libbitcoinkernel-sys/bitcoin/depends/packages/qt.mk
@@ -12,7 +12,6 @@ $(package)_freebsd_dependencies := $($(package)_linux_dependencies)
 $(package)_patches_path := $(qt_details_patches_path)
 $(package)_patches := dont_hardcode_pwd.patch
 $(package)_patches += qtbase-moc-ignore-gcc-macro.patch
-$(package)_patches += qtbase_avoid_native_float16.patch
 $(package)_patches += qtbase_avoid_qmain.patch
 $(package)_patches += qtbase_platformsupport.patch
 $(package)_patches += qtbase_plugins_cocoa.patch
@@ -257,7 +256,6 @@ endif
 define $(package)_preprocess_cmds
   patch -p1 -i $($(package)_patch_dir)/dont_hardcode_pwd.patch && \
   patch -p1 -i $($(package)_patch_dir)/qtbase-moc-ignore-gcc-macro.patch && \
-  patch -p1 -i $($(package)_patch_dir)/qtbase_avoid_native_float16.patch && \
   patch -p1 -i $($(package)_patch_dir)/qtbase_avoid_qmain.patch && \
   patch -p1 -i $($(package)_patch_dir)/qtbase_platformsupport.patch && \
   patch -p1 -i $($(package)_patch_dir)/qtbase_plugins_cocoa.patch && \
diff --git a/libbitcoinkernel-sys/bitcoin/depends/patches/qt/qtbase_avoid_native_float16.patch b/libbitcoinkernel-sys/bitcoin/depends/patches/qt/qtbase_avoid_native_float16.patch
deleted file mode 100644
index ec03d140..00000000
--- a/libbitcoinkernel-sys/bitcoin/depends/patches/qt/qtbase_avoid_native_float16.patch
+++ /dev/null
@@ -1,37 +0,0 @@
-Avoid using native float16 types in Qt's qfloat16
-
-Using native float16 types may introduce compatibility issues
-in release binaries for Linux platforms.
-
-See: https://gcc.gnu.org/git/?p=gcc.git;a=commit;h=e42d2d2a20f2bb59928bc895ec9f46503a1b5c73
-
-This patch can be dropped once the minimum required libgcc version
-is updated to 12.x or newer.
-
-
---- a/qtbase/src/corelib/global/qtypes.h
-+++ b/qtbase/src/corelib/global/qtypes.h
-@@ -258,23 +258,8 @@ using qsizetype = QIntegerForSizeof<std::size_t>::Signed;
- 
- // Define a native float16 type
- namespace QtPrivate {
--#if defined(__STDCPP_FLOAT16_T__)
--#  define QFLOAT16_IS_NATIVE        1
--using NativeFloat16Type = std::float16_t;
--#elif defined(Q_CC_CLANG) && defined(__FLT16_MAX__) && 0
--// disabled due to https://github.com/llvm/llvm-project/issues/56963
--#  define QFLOAT16_IS_NATIVE        1
--using NativeFloat16Type = decltype(__FLT16_MAX__);
--#elif defined(Q_CC_GNU_ONLY) && defined(__FLT16_MAX__) && defined(__ARM_FP16_FORMAT_IEEE)
--#  define QFLOAT16_IS_NATIVE        1
--using NativeFloat16Type = __fp16;
--#elif defined(Q_CC_GNU_ONLY) && defined(__FLT16_MAX__) && defined(__SSE2__)
--#  define QFLOAT16_IS_NATIVE        1
--using NativeFloat16Type = _Float16;
--#else
- #  define QFLOAT16_IS_NATIVE        0
- using NativeFloat16Type = void;
--#endif
- } // QtPrivate
- 
- #endif // __cplusplus
diff --git a/libbitcoinkernel-sys/bitcoin/doc/build-unix.md b/libbitcoinkernel-sys/bitcoin/doc/build-unix.md
index d9bbb350..e499aa9b 100644
--- a/libbitcoinkernel-sys/bitcoin/doc/build-unix.md
+++ b/libbitcoinkernel-sys/bitcoin/doc/build-unix.md
@@ -46,10 +46,14 @@ Finally, clang (often less resource hungry) can be used instead of gcc, which is
 
 #### Dependency Build Instructions
 
-Build requirements:
+Build requirements for the latest Debian "stable" release, or the latest Ubuntu LTS release:
 
     sudo apt-get install build-essential cmake pkgconf python3
 
+For Debian "oldstable", or earlier Ubuntu LTS releases, you may need to pick a
+later compiler version, according to the [dependencies](/doc/dependencies.md)
+documentation.
+
 Now, you can either build from self-compiled [depends](#dependencies) or install the required dependencies:
 
     sudo apt-get install libevent-dev libboost-dev
diff --git a/libbitcoinkernel-sys/bitcoin/doc/dependencies.md b/libbitcoinkernel-sys/bitcoin/doc/dependencies.md
index 77391f74..3ff306f8 100644
--- a/libbitcoinkernel-sys/bitcoin/doc/dependencies.md
+++ b/libbitcoinkernel-sys/bitcoin/doc/dependencies.md
@@ -11,7 +11,7 @@ Bitcoin Core requires one of the following compilers.
 | Dependency | Minimum required |
 | --- | --- |
 | [Clang](https://clang.llvm.org) | [17.0](https://github.com/bitcoin/bitcoin/pull/33555) |
-| [GCC](https://gcc.gnu.org) | [11.1](https://github.com/bitcoin/bitcoin/pull/29091) |
+| [GCC](https://gcc.gnu.org) | [12.1](https://github.com/bitcoin/bitcoin/pull/33842) |
 
 ## Required
 
diff --git a/libbitcoinkernel-sys/bitcoin/doc/release-notes-33842.md b/libbitcoinkernel-sys/bitcoin/doc/release-notes-33842.md
new file mode 100644
index 00000000..ad15f50b
--- /dev/null
+++ b/libbitcoinkernel-sys/bitcoin/doc/release-notes-33842.md
@@ -0,0 +1,4 @@
+Build System
+------------
+
+- The minimum supported GCC compiler version has been raised to 12.1 (#33842).
diff --git a/libbitcoinkernel-sys/bitcoin/src/bench/connectblock.cpp b/libbitcoinkernel-sys/bitcoin/src/bench/connectblock.cpp
index 3746ea29..9ea50601 100644
--- a/libbitcoinkernel-sys/bitcoin/src/bench/connectblock.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/bench/connectblock.cpp
@@ -9,6 +9,7 @@
 #include <script/interpreter.h>
 #include <sync.h>
 #include <test/util/setup_common.h>
+#include <undo.h>
 #include <validation.h>
 
 #include <cassert>
@@ -100,7 +101,9 @@ void BenchmarkConnectBlock(benchmark::Bench& bench, std::vector<CKey>& keys, std
         auto* pindex{chainman->m_blockman.AddToBlockIndex(test_block, chainman->m_best_header)}; // Doing this here doesn't impact the benchmark
         CCoinsViewCache viewNew{&chainstate.CoinsTip()};
 
-        assert(chainstate.ConnectBlock(test_block, test_block_state, pindex, viewNew));
+        CBlockUndo blockundo;
+        assert(chainstate.SpendBlock(test_block, pindex, viewNew, test_block_state, blockundo));
+        assert(chainstate.ConnectBlock(test_block, blockundo, test_block_state, pindex));
     });
 }
 
diff --git a/libbitcoinkernel-sys/bitcoin/src/bitcoin-chainstate.cpp b/libbitcoinkernel-sys/bitcoin/src/bitcoin-chainstate.cpp
index 310ca95c..786cd575 100644
--- a/libbitcoinkernel-sys/bitcoin/src/bitcoin-chainstate.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/bitcoin-chainstate.cpp
@@ -44,7 +44,7 @@ class TestValidationInterface : public ValidationInterface
 
     std::optional<std::string> m_expected_valid_block = std::nullopt;
 
-    void BlockChecked(const Block block, const BlockValidationState state) override
+    void BlockChecked(const Block block, const BlockValidationStateView state) override
     {
         auto mode{state.GetValidationMode()};
         switch (mode) {
diff --git a/libbitcoinkernel-sys/bitcoin/src/coins.cpp b/libbitcoinkernel-sys/bitcoin/src/coins.cpp
index 090d36dd..06ef3c8a 100644
--- a/libbitcoinkernel-sys/bitcoin/src/coins.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/coins.cpp
@@ -163,6 +163,29 @@ const Coin& CCoinsViewCache::AccessCoin(const COutPoint &outpoint) const {
     }
 }
 
+std::vector<std::reference_wrapper<const Coin>> CCoinsViewCache::AccessCoins(const CTransaction& tx) const
+{
+    std::vector<std::reference_wrapper<const Coin>> coins;
+    coins.reserve(tx.vin.size());
+    for (const CTxIn& input : tx.vin) {
+        coins.emplace_back(AccessCoin(input.prevout));
+    }
+    return coins;
+}
+
+std::vector<CTxOut> CCoinsViewCache::GetUnspentOutputs(const CTransaction& tx) const
+{
+    std::vector<CTxOut> spent_outputs;
+    spent_outputs.reserve(tx.vin.size());
+    for (const auto& txin : tx.vin) {
+        const COutPoint& prevout = txin.prevout;
+        const Coin& coin = AccessCoin(prevout);
+        assert(!coin.IsSpent());
+        spent_outputs.emplace_back(coin.out);
+    }
+    return spent_outputs;
+}
+
 bool CCoinsViewCache::HaveCoin(const COutPoint &outpoint) const {
     CCoinsMap::const_iterator it = FetchCoin(outpoint);
     return (it != cacheCoins.end() && !it->second.coin.IsSpent());
diff --git a/libbitcoinkernel-sys/bitcoin/src/coins.h b/libbitcoinkernel-sys/bitcoin/src/coins.h
index 2fcc764a..d2dae327 100644
--- a/libbitcoinkernel-sys/bitcoin/src/coins.h
+++ b/libbitcoinkernel-sys/bitcoin/src/coins.h
@@ -413,6 +413,22 @@ class CCoinsViewCache : public CCoinsViewBacked
      */
     const Coin& AccessCoin(const COutPoint &output) const;
 
+    /**
+     * Return a vector of references to Coins in the cache, or coinEmpty if
+     * the Coin is not found.
+     *
+     * Generally, this should only be held for a short scope. The coins should
+     * generally not be held through any other calls to this cache.
+     */
+    std::vector<std::reference_wrapper<const Coin>> AccessCoins(const CTransaction& tx) const;
+
+    /**
+     * Return a vector of unspent outputs of coins in the cache that are spent
+     * by the provided transaction. The coins they belong to must be unspent in
+     * the cache.
+     */
+    std::vector<CTxOut> GetUnspentOutputs(const CTransaction& tx) const;
+
     /**
      * Add a coin. Set possible_overwrite to true if an unspent version may
      * already exist in the cache.
diff --git a/libbitcoinkernel-sys/bitcoin/src/consensus/tx_verify.cpp b/libbitcoinkernel-sys/bitcoin/src/consensus/tx_verify.cpp
index c38b9643..397583bc 100644
--- a/libbitcoinkernel-sys/bitcoin/src/consensus/tx_verify.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/consensus/tx_verify.cpp
@@ -14,6 +14,8 @@
 #include <util/check.h>
 #include <util/moneystr.h>
 
+#include <span>
+
 bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime)
 {
     if (tx.nLockTime == 0)
@@ -123,24 +125,33 @@ unsigned int GetLegacySigOpCount(const CTransaction& tx)
     return nSigOps;
 }
 
-unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& inputs)
+template <Consensus::CoinRef T>
+unsigned int GetP2SHSigOpCount(const CTransaction& tx, const std::span<T> coins)
 {
     if (tx.IsCoinBase())
         return 0;
 
     unsigned int nSigOps = 0;
-    for (unsigned int i = 0; i < tx.vin.size(); i++)
-    {
-        const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
+    Assert(coins.size() == tx.vin.size());
+    auto input_it = tx.vin.begin();
+    for (auto it = coins.begin(); it != coins.end(); ++it, ++input_it) {
+        const Coin& coin = *it;
         assert(!coin.IsSpent());
         const CTxOut &prevout = coin.out;
         if (prevout.scriptPubKey.IsPayToScriptHash())
-            nSigOps += prevout.scriptPubKey.GetSigOpCount(tx.vin[i].scriptSig);
+            nSigOps += prevout.scriptPubKey.GetSigOpCount(input_it->scriptSig);
     }
     return nSigOps;
 }
 
-int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& inputs, script_verify_flags flags)
+template unsigned int GetP2SHSigOpCount<const Coin>(
+    const CTransaction& tx, const std::span<const Coin>);
+
+template unsigned int GetP2SHSigOpCount<std::reference_wrapper<const Coin>>(
+    const CTransaction& tx, const std::span<std::reference_wrapper<const Coin>>);
+
+template <Consensus::CoinRef T>
+int64_t GetTransactionSigOpCost(const CTransaction& tx, const std::span<T> coins, script_verify_flags flags)
 {
     int64_t nSigOps = GetLegacySigOpCount(tx) * WITNESS_SCALE_FACTOR;
 
@@ -148,37 +159,39 @@ int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& i
         return nSigOps;
 
     if (flags & SCRIPT_VERIFY_P2SH) {
-        nSigOps += GetP2SHSigOpCount(tx, inputs) * WITNESS_SCALE_FACTOR;
+        nSigOps += GetP2SHSigOpCount(tx, coins) * WITNESS_SCALE_FACTOR;
     }
 
-    for (unsigned int i = 0; i < tx.vin.size(); i++)
-    {
-        const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
+    Assert(coins.size() == tx.vin.size());
+    auto input_it = tx.vin.begin();
+    for (auto it = coins.begin(); it != coins.end(); ++it, ++input_it) {
+        const Coin& coin = *it;
         assert(!coin.IsSpent());
         const CTxOut &prevout = coin.out;
-        nSigOps += CountWitnessSigOps(tx.vin[i].scriptSig, prevout.scriptPubKey, tx.vin[i].scriptWitness, flags);
+        nSigOps += CountWitnessSigOps(input_it->scriptSig, prevout.scriptPubKey, input_it->scriptWitness, flags);
     }
     return nSigOps;
 }
+template int64_t GetTransactionSigOpCost<const Coin>(
+    const CTransaction& tx, std::span<const Coin> coins, script_verify_flags flags);
 
-bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee)
-{
-    // are the actual inputs available?
-    if (!inputs.HaveInputs(tx)) {
-        return state.Invalid(TxValidationResult::TX_MISSING_INPUTS, "bad-txns-inputs-missingorspent",
-                         strprintf("%s: inputs missing/spent", __func__));
-    }
+template int64_t GetTransactionSigOpCost<std::reference_wrapper<const Coin>>(
+    const CTransaction& tx, const std::span<std::reference_wrapper<const Coin>> coins, script_verify_flags flags);
 
+template <Consensus::CoinRef T>
+bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, const std::span<T> coins, int nSpendHeight, CAmount& txfee)
+{
     CAmount nValueIn = 0;
-    for (unsigned int i = 0; i < tx.vin.size(); ++i) {
-        const COutPoint &prevout = tx.vin[i].prevout;
-        const Coin& coin = inputs.AccessCoin(prevout);
+    Assert(coins.size() == tx.vin.size());
+    auto input_it = tx.vin.begin();
+    for (auto it = coins.begin(); it != coins.end(); ++it, ++input_it) {
+        const Coin& coin = *it;
         assert(!coin.IsSpent());
 
         // If prev is coinbase, check that it's matured
         if (coin.IsCoinBase() && nSpendHeight - coin.nHeight < COINBASE_MATURITY) {
             return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "bad-txns-premature-spend-of-coinbase",
-                strprintf("tried to spend coinbase at depth %d", nSpendHeight - coin.nHeight));
+                strprintf("tried to spend coinbase at depth %d", static_cast<int>(nSpendHeight - coin.nHeight)));
         }
 
         // Check for negative or overflow input values
@@ -203,3 +216,9 @@ bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state,
     txfee = txfee_aux;
     return true;
 }
+
+template bool Consensus::CheckTxInputs<const Coin>(
+    const CTransaction& tx, TxValidationState& state, const std::span<const Coin> coins, int nSpendHeight, CAmount& txfee);
+
+template bool Consensus::CheckTxInputs<std::reference_wrapper<const Coin>>(
+    const CTransaction& tx, TxValidationState& state, const std::span<std::reference_wrapper<const Coin>> coins, int nSpendHeight, CAmount& txfee);
diff --git a/libbitcoinkernel-sys/bitcoin/src/consensus/tx_verify.h b/libbitcoinkernel-sys/bitcoin/src/consensus/tx_verify.h
index ed44d435..8087550d 100644
--- a/libbitcoinkernel-sys/bitcoin/src/consensus/tx_verify.h
+++ b/libbitcoinkernel-sys/bitcoin/src/consensus/tx_verify.h
@@ -5,10 +5,13 @@
 #ifndef BITCOIN_CONSENSUS_TX_VERIFY_H
 #define BITCOIN_CONSENSUS_TX_VERIFY_H
 
+#include <coins.h>
 #include <consensus/amount.h>
 #include <script/verify_flags.h>
 
+#include <concepts>
 #include <cstdint>
+#include <span>
 #include <vector>
 
 class CBlockIndex;
@@ -19,13 +22,19 @@ class TxValidationState;
 /** Transaction validation functions */
 
 namespace Consensus {
+
+template <typename T>
+concept CoinRef = std::convertible_to<T, const Coin&>;
+
 /**
- * Check whether all inputs of this transaction are valid (no double spends and amounts)
+ * Check whether all inputs of this transaction are valid (amounts and maturity)
  * This does not modify the UTXO set. This does not check scripts and sigs.
+ * @param[in] coins Sorted span of Coins containing previous transaction outputs tx is spending
  * @param[out] txfee Set to the transaction fee if successful.
  * Preconditions: tx.IsCoinBase() is false.
  */
-[[nodiscard]] bool CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee);
+template <Consensus::CoinRef T>
+[[nodiscard]] bool CheckTxInputs(const CTransaction& tx, TxValidationState& state, const std::span<T> coins, int nSpendHeight, CAmount& txfee);
 } // namespace Consensus
 
 /** Auxiliary functions for transaction validation (ideally should not be exposed) */
@@ -40,20 +49,22 @@ unsigned int GetLegacySigOpCount(const CTransaction& tx);
 /**
  * Count ECDSA signature operations in pay-to-script-hash inputs.
  *
- * @param[in] mapInputs Map of previous transactions that have outputs we're spending
+ * @param[in] coins Sorted span of Coins containing previous transaction outputs we're spending
  * @return maximum number of sigops required to validate this transaction's inputs
  * @see CTransaction::FetchInputs
  */
-unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& mapInputs);
+template <Consensus::CoinRef T>
+unsigned int GetP2SHSigOpCount(const CTransaction& tx, const std::span<T> coins);
 
 /**
  * Compute total signature operation cost of a transaction.
- * @param[in] tx     Transaction for which we are computing the cost
- * @param[in] inputs Map of previous transactions that have outputs we're spending
+ * @param[in] tx    Transaction for which we are computing the cost
+ * @param[in] coins Sorted span of Coins containing previous transaction outputs we're spending
  * @param[in] flags Script verification flags
  * @return Total signature operation cost of tx
  */
-int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& inputs, script_verify_flags flags);
+template <Consensus::CoinRef T>
+int64_t GetTransactionSigOpCost(const CTransaction& tx, const std::span<T> coins, script_verify_flags flags);
 
 /**
  * Check if transaction is final and can be included in a block with the
diff --git a/libbitcoinkernel-sys/bitcoin/src/crypto/sha256_sse4.cpp b/libbitcoinkernel-sys/bitcoin/src/crypto/sha256_sse4.cpp
index 3de30f74..2d37d124 100644
--- a/libbitcoinkernel-sys/bitcoin/src/crypto/sha256_sse4.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/crypto/sha256_sse4.cpp
@@ -969,27 +969,27 @@ void Transform(uint32_t* s, const unsigned char* chunk, size_t blocks)
 
 /*
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; Copyright (c) 2012, Intel Corporation 
-; 
-; All rights reserved. 
-; 
+; Copyright (c) 2012, Intel Corporation
+;
+; All rights reserved.
+;
 ; Redistribution and use in source and binary forms, with or without
 ; modification, are permitted provided that the following conditions are
-; met: 
-; 
+; met:
+;
 ; * Redistributions of source code must retain the above copyright
-;   notice, this list of conditions and the following disclaimer.  
-; 
+;   notice, this list of conditions and the following disclaimer.
+;
 ; * Redistributions in binary form must reproduce the above copyright
 ;   notice, this list of conditions and the following disclaimer in the
 ;   documentation and/or other materials provided with the
-;   distribution. 
-; 
+;   distribution.
+;
 ; * Neither the name of the Intel Corporation nor the names of its
 ;   contributors may be used to endorse or promote products derived from
-;   this software without specific prior written permission. 
-; 
-; 
+;   this software without specific prior written permission.
+;
+;
 ; THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION "AS IS" AND ANY
 ; EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 ; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
@@ -1020,15 +1020,15 @@ void Transform(uint32_t* s, const unsigned char* chunk, size_t blocks)
 ; This code schedules 1 blocks at a time, with 4 lanes per block
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-%define	MOVDQ movdqu ;; assume buffers not aligned 
+%define MOVDQ movdqu ;; assume buffers not aligned
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Define Macros
 
 ; addm [mem], reg
 ; Add reg to mem using reg-mem add and store
 %macro addm 2
-    add	%2, %1
-    mov	%1, %2
+    add %2, %1
+    mov %1, %2
 %endm
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1054,31 +1054,31 @@ void Transform(uint32_t* s, const unsigned char* chunk, size_t blocks)
 %define XTMP4 xmm8
 %define XFER  xmm9
 
-%define SHUF_00BA	xmm10 ; shuffle xBxA -> 00BA
-%define SHUF_DC00	xmm11 ; shuffle xDxC -> DC00
-%define BYTE_FLIP_MASK	xmm12
-    
+%define SHUF_00BA   xmm10 ; shuffle xBxA -> 00BA
+%define SHUF_DC00   xmm11 ; shuffle xDxC -> DC00
+%define BYTE_FLIP_MASK  xmm12
+
 %ifdef LINUX
-%define NUM_BLKS rdx	; 3rd arg
-%define CTX	rsi	; 2nd arg
-%define INP	rdi	; 1st arg
-
-%define SRND	rdi	; clobbers INP
-%define c	ecx
-%define d 	r8d
-%define e 	edx
+%define NUM_BLKS rdx    ; 3rd arg
+%define CTX rsi ; 2nd arg
+%define INP rdi ; 1st arg
+
+%define SRND    rdi ; clobbers INP
+%define c   ecx
+%define d   r8d
+%define e   edx
 %else
-%define NUM_BLKS r8	; 3rd arg
-%define CTX	rdx 	; 2nd arg
-%define INP	rcx 	; 1st arg
-
-%define SRND	rcx	; clobbers INP
-%define c 	edi 
-%define d	esi 
-%define e 	r8d
-    
+%define NUM_BLKS r8 ; 3rd arg
+%define CTX rdx     ; 2nd arg
+%define INP rcx     ; 1st arg
+
+%define SRND    rcx ; clobbers INP
+%define c   edi
+%define d   esi
+%define e   r8d
+
 %endif
-%define TBL	rbp
+%define TBL rbp
 %define a eax
 %define b ebx
 
@@ -1092,22 +1092,22 @@ void Transform(uint32_t* s, const unsigned char* chunk, size_t blocks)
 
 
 
-_INP_END_SIZE	equ 8
-_INP_SIZE	equ 8
-_XFER_SIZE	equ 8
+_INP_END_SIZE   equ 8
+_INP_SIZE   equ 8
+_XFER_SIZE  equ 8
 %ifdef LINUX
-_XMM_SAVE_SIZE	equ 0
+_XMM_SAVE_SIZE  equ 0
 %else
-_XMM_SAVE_SIZE	equ 7*16
+_XMM_SAVE_SIZE  equ 7*16
 %endif
 ; STACK_SIZE plus pushes must be an odd multiple of 8
-_ALIGN_SIZE	equ 8
+_ALIGN_SIZE equ 8
 
-_INP_END	equ 0
-_INP		equ _INP_END  + _INP_END_SIZE
-_XFER		equ _INP      + _INP_SIZE
-_XMM_SAVE	equ _XFER     + _XFER_SIZE + _ALIGN_SIZE
-STACK_SIZE	equ _XMM_SAVE + _XMM_SAVE_SIZE
+_INP_END    equ 0
+_INP        equ _INP_END  + _INP_END_SIZE
+_XFER       equ _INP      + _INP_SIZE
+_XMM_SAVE   equ _XFER     + _XFER_SIZE + _ALIGN_SIZE
+STACK_SIZE  equ _XMM_SAVE + _XMM_SAVE_SIZE
 
 ; rotate_Xs
 ; Rotate values of symbols X0...X3
@@ -1134,168 +1134,168 @@ STACK_SIZE	equ _XMM_SAVE + _XMM_SAVE_SIZE
 %endm
 
 %macro FOUR_ROUNDS_AND_SCHED 0
-	;; compute s0 four at a time and s1 two at a time
-	;; compute W[-16] + W[-7] 4 at a time
-	movdqa	XTMP0, X3
-    mov	y0, e		; y0 = e
-    ror	y0, (25-11)	; y0 = e >> (25-11)
-    mov	y1, a		; y1 = a
-	palignr	XTMP0, X2, 4	; XTMP0 = W[-7]
-    ror	y1, (22-13)	; y1 = a >> (22-13)
-    xor	y0, e		; y0 = e ^ (e >> (25-11))
-    mov	y2, f		; y2 = f
-    ror	y0, (11-6)	; y0 = (e >> (11-6)) ^ (e >> (25-6))
-	movdqa	XTMP1, X1
-    xor	y1, a		; y1 = a ^ (a >> (22-13)
-    xor	y2, g		; y2 = f^g
-	paddd	XTMP0, X0	; XTMP0 = W[-7] + W[-16]
-    xor	y0, e		; y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
-    and	y2, e		; y2 = (f^g)&e
-    ror	y1, (13-2)	; y1 = (a >> (13-2)) ^ (a >> (22-2))
-	;; compute s0
-	palignr	XTMP1, X0, 4	; XTMP1 = W[-15]
-    xor	y1, a		; y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
-    ror	y0, 6		; y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
-    xor	y2, g		; y2 = CH = ((f^g)&e)^g
-	movdqa	XTMP2, XTMP1	; XTMP2 = W[-15]
-    ror	y1, 2		; y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
-    add	y2, y0		; y2 = S1 + CH
-    add	y2, [rsp + _XFER + 0*4]	; y2 = k + w + S1 + CH
-	movdqa	XTMP3, XTMP1	; XTMP3 = W[-15]
-    mov	y0, a		; y0 = a
-    add	h, y2		; h = h + S1 + CH + k + w
-    mov	y2, a		; y2 = a
-	pslld	XTMP1, (32-7)
-    or	y0, c		; y0 = a|c
-    add	d, h		; d = d + h + S1 + CH + k + w
-    and	y2, c		; y2 = a&c
-	psrld	XTMP2, 7
-    and	y0, b		; y0 = (a|c)&b
-    add	h, y1		; h = h + S1 + CH + k + w + S0
-	por	XTMP1, XTMP2	; XTMP1 = W[-15] ror 7
-    or	y0, y2		; y0 = MAJ = (a|c)&b)|(a&c)
-    add	h, y0		; h = h + S1 + CH + k + w + S0 + MAJ
+    ;; compute s0 four at a time and s1 two at a time
+    ;; compute W[-16] + W[-7] 4 at a time
+    movdqa  XTMP0, X3
+    mov y0, e       ; y0 = e
+    ror y0, (25-11) ; y0 = e >> (25-11)
+    mov y1, a       ; y1 = a
+    palignr XTMP0, X2, 4    ; XTMP0 = W[-7]
+    ror y1, (22-13) ; y1 = a >> (22-13)
+    xor y0, e       ; y0 = e ^ (e >> (25-11))
+    mov y2, f       ; y2 = f
+    ror y0, (11-6)  ; y0 = (e >> (11-6)) ^ (e >> (25-6))
+    movdqa  XTMP1, X1
+    xor y1, a       ; y1 = a ^ (a >> (22-13)
+    xor y2, g       ; y2 = f^g
+    paddd   XTMP0, X0   ; XTMP0 = W[-7] + W[-16]
+    xor y0, e       ; y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+    and y2, e       ; y2 = (f^g)&e
+    ror y1, (13-2)  ; y1 = (a >> (13-2)) ^ (a >> (22-2))
+    ;; compute s0
+    palignr XTMP1, X0, 4    ; XTMP1 = W[-15]
+    xor y1, a       ; y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+    ror y0, 6       ; y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+    xor y2, g       ; y2 = CH = ((f^g)&e)^g
+    movdqa  XTMP2, XTMP1    ; XTMP2 = W[-15]
+    ror y1, 2       ; y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+    add y2, y0      ; y2 = S1 + CH
+    add y2, [rsp + _XFER + 0*4] ; y2 = k + w + S1 + CH
+    movdqa  XTMP3, XTMP1    ; XTMP3 = W[-15]
+    mov y0, a       ; y0 = a
+    add h, y2       ; h = h + S1 + CH + k + w
+    mov y2, a       ; y2 = a
+    pslld   XTMP1, (32-7)
+    or  y0, c       ; y0 = a|c
+    add d, h        ; d = d + h + S1 + CH + k + w
+    and y2, c       ; y2 = a&c
+    psrld   XTMP2, 7
+    and y0, b       ; y0 = (a|c)&b
+    add h, y1       ; h = h + S1 + CH + k + w + S0
+    por XTMP1, XTMP2    ; XTMP1 = W[-15] ror 7
+    or  y0, y2      ; y0 = MAJ = (a|c)&b)|(a&c)
+    add h, y0       ; h = h + S1 + CH + k + w + S0 + MAJ
 
 ROTATE_ARGS
-	movdqa	XTMP2, XTMP3	; XTMP2 = W[-15]
-    mov	y0, e		; y0 = e
-    mov	y1, a		; y1 = a
-	movdqa	XTMP4, XTMP3	; XTMP4 = W[-15]
-    ror	y0, (25-11)	; y0 = e >> (25-11)
-    xor	y0, e		; y0 = e ^ (e >> (25-11))
-    mov	y2, f		; y2 = f
-    ror	y1, (22-13)	; y1 = a >> (22-13)
-	pslld	XTMP3, (32-18)
-    xor	y1, a		; y1 = a ^ (a >> (22-13)
-    ror	y0, (11-6)	; y0 = (e >> (11-6)) ^ (e >> (25-6))
-    xor	y2, g		; y2 = f^g
-	psrld	XTMP2, 18
-    ror	y1, (13-2)	; y1 = (a >> (13-2)) ^ (a >> (22-2))
-    xor	y0, e		; y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
-    and	y2, e		; y2 = (f^g)&e
-    ror	y0, 6		; y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
-	pxor	XTMP1, XTMP3
-    xor	y1, a		; y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
-    xor	y2, g		; y2 = CH = ((f^g)&e)^g
-	psrld	XTMP4, 3	; XTMP4 = W[-15] >> 3
-    add	y2, y0		; y2 = S1 + CH
-    add	y2, [rsp + _XFER + 1*4]	; y2 = k + w + S1 + CH
-    ror	y1, 2		; y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
-	pxor	XTMP1, XTMP2	; XTMP1 = W[-15] ror 7 ^ W[-15] ror 18
-    mov	y0, a		; y0 = a
-    add	h, y2		; h = h + S1 + CH + k + w
-    mov	y2, a		; y2 = a
-	pxor	XTMP1, XTMP4	; XTMP1 = s0
-    or	y0, c		; y0 = a|c
-    add	d, h		; d = d + h + S1 + CH + k + w
-    and	y2, c		; y2 = a&c
-	;; compute low s1
-	pshufd	XTMP2, X3, 11111010b	; XTMP2 = W[-2] {BBAA}
-    and	y0, b		; y0 = (a|c)&b
-    add	h, y1		; h = h + S1 + CH + k + w + S0
-	paddd	XTMP0, XTMP1	; XTMP0 = W[-16] + W[-7] + s0
-    or	y0, y2		; y0 = MAJ = (a|c)&b)|(a&c)
-    add	h, y0		; h = h + S1 + CH + k + w + S0 + MAJ
+    movdqa  XTMP2, XTMP3    ; XTMP2 = W[-15]
+    mov y0, e       ; y0 = e
+    mov y1, a       ; y1 = a
+    movdqa  XTMP4, XTMP3    ; XTMP4 = W[-15]
+    ror y0, (25-11) ; y0 = e >> (25-11)
+    xor y0, e       ; y0 = e ^ (e >> (25-11))
+    mov y2, f       ; y2 = f
+    ror y1, (22-13) ; y1 = a >> (22-13)
+    pslld   XTMP3, (32-18)
+    xor y1, a       ; y1 = a ^ (a >> (22-13)
+    ror y0, (11-6)  ; y0 = (e >> (11-6)) ^ (e >> (25-6))
+    xor y2, g       ; y2 = f^g
+    psrld   XTMP2, 18
+    ror y1, (13-2)  ; y1 = (a >> (13-2)) ^ (a >> (22-2))
+    xor y0, e       ; y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+    and y2, e       ; y2 = (f^g)&e
+    ror y0, 6       ; y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+    pxor    XTMP1, XTMP3
+    xor y1, a       ; y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+    xor y2, g       ; y2 = CH = ((f^g)&e)^g
+    psrld   XTMP4, 3    ; XTMP4 = W[-15] >> 3
+    add y2, y0      ; y2 = S1 + CH
+    add y2, [rsp + _XFER + 1*4] ; y2 = k + w + S1 + CH
+    ror y1, 2       ; y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+    pxor    XTMP1, XTMP2    ; XTMP1 = W[-15] ror 7 ^ W[-15] ror 18
+    mov y0, a       ; y0 = a
+    add h, y2       ; h = h + S1 + CH + k + w
+    mov y2, a       ; y2 = a
+    pxor    XTMP1, XTMP4    ; XTMP1 = s0
+    or  y0, c       ; y0 = a|c
+    add d, h        ; d = d + h + S1 + CH + k + w
+    and y2, c       ; y2 = a&c
+    ;; compute low s1
+    pshufd  XTMP2, X3, 11111010b    ; XTMP2 = W[-2] {BBAA}
+    and y0, b       ; y0 = (a|c)&b
+    add h, y1       ; h = h + S1 + CH + k + w + S0
+    paddd   XTMP0, XTMP1    ; XTMP0 = W[-16] + W[-7] + s0
+    or  y0, y2      ; y0 = MAJ = (a|c)&b)|(a&c)
+    add h, y0       ; h = h + S1 + CH + k + w + S0 + MAJ
 
 ROTATE_ARGS
-	movdqa	XTMP3, XTMP2	; XTMP3 = W[-2] {BBAA}
-    mov	y0, e		; y0 = e
-    mov	y1, a		; y1 = a
-    ror	y0, (25-11)	; y0 = e >> (25-11)
-	movdqa	XTMP4, XTMP2	; XTMP4 = W[-2] {BBAA}
-    xor	y0, e		; y0 = e ^ (e >> (25-11))
-    ror	y1, (22-13)	; y1 = a >> (22-13)
-    mov	y2, f		; y2 = f
-    xor	y1, a		; y1 = a ^ (a >> (22-13)
-    ror	y0, (11-6)	; y0 = (e >> (11-6)) ^ (e >> (25-6))
-	psrlq	XTMP2, 17	; XTMP2 = W[-2] ror 17 {xBxA}
-    xor	y2, g		; y2 = f^g
-	psrlq	XTMP3, 19	; XTMP3 = W[-2] ror 19 {xBxA}
-    xor	y0, e		; y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
-    and	y2, e		; y2 = (f^g)&e
-	psrld	XTMP4, 10	; XTMP4 = W[-2] >> 10 {BBAA}
-    ror	y1, (13-2)	; y1 = (a >> (13-2)) ^ (a >> (22-2))
-    xor	y1, a		; y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
-    xor	y2, g		; y2 = CH = ((f^g)&e)^g
-    ror	y0, 6		; y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
-	pxor	XTMP2, XTMP3
-    add	y2, y0		; y2 = S1 + CH
-    ror	y1, 2		; y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
-    add	y2, [rsp + _XFER + 2*4]	; y2 = k + w + S1 + CH
-	pxor	XTMP4, XTMP2	; XTMP4 = s1 {xBxA}
-    mov	y0, a		; y0 = a
-    add	h, y2		; h = h + S1 + CH + k + w
-    mov	y2, a		; y2 = a
-	pshufb	XTMP4, SHUF_00BA	; XTMP4 = s1 {00BA}
-    or	y0, c		; y0 = a|c
-    add	d, h		; d = d + h + S1 + CH + k + w
-    and	y2, c		; y2 = a&c
-	paddd	XTMP0, XTMP4	; XTMP0 = {..., ..., W[1], W[0]}
-    and	y0, b		; y0 = (a|c)&b
-    add	h, y1		; h = h + S1 + CH + k + w + S0
-	;; compute high s1
-	pshufd	XTMP2, XTMP0, 01010000b	; XTMP2 = W[-2] {DDCC}
-    or	y0, y2		; y0 = MAJ = (a|c)&b)|(a&c)
-    add	h, y0		; h = h + S1 + CH + k + w + S0 + MAJ
+    movdqa  XTMP3, XTMP2    ; XTMP3 = W[-2] {BBAA}
+    mov y0, e       ; y0 = e
+    mov y1, a       ; y1 = a
+    ror y0, (25-11) ; y0 = e >> (25-11)
+    movdqa  XTMP4, XTMP2    ; XTMP4 = W[-2] {BBAA}
+    xor y0, e       ; y0 = e ^ (e >> (25-11))
+    ror y1, (22-13) ; y1 = a >> (22-13)
+    mov y2, f       ; y2 = f
+    xor y1, a       ; y1 = a ^ (a >> (22-13)
+    ror y0, (11-6)  ; y0 = (e >> (11-6)) ^ (e >> (25-6))
+    psrlq   XTMP2, 17   ; XTMP2 = W[-2] ror 17 {xBxA}
+    xor y2, g       ; y2 = f^g
+    psrlq   XTMP3, 19   ; XTMP3 = W[-2] ror 19 {xBxA}
+    xor y0, e       ; y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+    and y2, e       ; y2 = (f^g)&e
+    psrld   XTMP4, 10   ; XTMP4 = W[-2] >> 10 {BBAA}
+    ror y1, (13-2)  ; y1 = (a >> (13-2)) ^ (a >> (22-2))
+    xor y1, a       ; y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+    xor y2, g       ; y2 = CH = ((f^g)&e)^g
+    ror y0, 6       ; y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+    pxor    XTMP2, XTMP3
+    add y2, y0      ; y2 = S1 + CH
+    ror y1, 2       ; y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+    add y2, [rsp + _XFER + 2*4] ; y2 = k + w + S1 + CH
+    pxor    XTMP4, XTMP2    ; XTMP4 = s1 {xBxA}
+    mov y0, a       ; y0 = a
+    add h, y2       ; h = h + S1 + CH + k + w
+    mov y2, a       ; y2 = a
+    pshufb  XTMP4, SHUF_00BA    ; XTMP4 = s1 {00BA}
+    or  y0, c       ; y0 = a|c
+    add d, h        ; d = d + h + S1 + CH + k + w
+    and y2, c       ; y2 = a&c
+    paddd   XTMP0, XTMP4    ; XTMP0 = {..., ..., W[1], W[0]}
+    and y0, b       ; y0 = (a|c)&b
+    add h, y1       ; h = h + S1 + CH + k + w + S0
+    ;; compute high s1
+    pshufd  XTMP2, XTMP0, 01010000b ; XTMP2 = W[-2] {DDCC}
+    or  y0, y2      ; y0 = MAJ = (a|c)&b)|(a&c)
+    add h, y0       ; h = h + S1 + CH + k + w + S0 + MAJ
 
 ROTATE_ARGS
-	movdqa	XTMP3, XTMP2	; XTMP3 = W[-2] {DDCC}
-    mov	y0, e		; y0 = e
-    ror	y0, (25-11)	; y0 = e >> (25-11)
-    mov	y1, a		; y1 = a
-	movdqa	X0,    XTMP2	; X0    = W[-2] {DDCC}
-    ror	y1, (22-13)	; y1 = a >> (22-13)
-    xor	y0, e		; y0 = e ^ (e >> (25-11))
-    mov	y2, f		; y2 = f
-    ror	y0, (11-6)	; y0 = (e >> (11-6)) ^ (e >> (25-6))
-	psrlq	XTMP2, 17	; XTMP2 = W[-2] ror 17 {xDxC}
-    xor	y1, a		; y1 = a ^ (a >> (22-13)
-    xor	y2, g		; y2 = f^g
-	psrlq	XTMP3, 19	; XTMP3 = W[-2] ror 19 {xDxC}
-    xor	y0, e		; y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
-    and	y2, e		; y2 = (f^g)&e
-    ror	y1, (13-2)	; y1 = (a >> (13-2)) ^ (a >> (22-2))
-	psrld	X0,    10	; X0 = W[-2] >> 10 {DDCC}
-    xor	y1, a		; y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
-    ror	y0, 6		; y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
-    xor	y2, g		; y2 = CH = ((f^g)&e)^g
-	pxor	XTMP2, XTMP3
-    ror	y1, 2		; y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
-    add	y2, y0		; y2 = S1 + CH
-    add	y2, [rsp + _XFER + 3*4]	; y2 = k + w + S1 + CH
-	pxor	X0, XTMP2	; X0 = s1 {xDxC}
-    mov	y0, a		; y0 = a
-    add	h, y2		; h = h + S1 + CH + k + w
-    mov	y2, a		; y2 = a
-	pshufb	X0, SHUF_DC00	; X0 = s1 {DC00}
-    or	y0, c		; y0 = a|c
-    add	d, h		; d = d + h + S1 + CH + k + w
-    and	y2, c		; y2 = a&c
-	paddd	X0, XTMP0	; X0 = {W[3], W[2], W[1], W[0]}
-    and	y0, b		; y0 = (a|c)&b
-    add	h, y1		; h = h + S1 + CH + k + w + S0
-    or	y0, y2		; y0 = MAJ = (a|c)&b)|(a&c)
-    add	h, y0		; h = h + S1 + CH + k + w + S0 + MAJ
+    movdqa  XTMP3, XTMP2    ; XTMP3 = W[-2] {DDCC}
+    mov y0, e       ; y0 = e
+    ror y0, (25-11) ; y0 = e >> (25-11)
+    mov y1, a       ; y1 = a
+    movdqa  X0,    XTMP2    ; X0    = W[-2] {DDCC}
+    ror y1, (22-13) ; y1 = a >> (22-13)
+    xor y0, e       ; y0 = e ^ (e >> (25-11))
+    mov y2, f       ; y2 = f
+    ror y0, (11-6)  ; y0 = (e >> (11-6)) ^ (e >> (25-6))
+    psrlq   XTMP2, 17   ; XTMP2 = W[-2] ror 17 {xDxC}
+    xor y1, a       ; y1 = a ^ (a >> (22-13)
+    xor y2, g       ; y2 = f^g
+    psrlq   XTMP3, 19   ; XTMP3 = W[-2] ror 19 {xDxC}
+    xor y0, e       ; y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+    and y2, e       ; y2 = (f^g)&e
+    ror y1, (13-2)  ; y1 = (a >> (13-2)) ^ (a >> (22-2))
+    psrld   X0,    10   ; X0 = W[-2] >> 10 {DDCC}
+    xor y1, a       ; y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+    ror y0, 6       ; y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+    xor y2, g       ; y2 = CH = ((f^g)&e)^g
+    pxor    XTMP2, XTMP3
+    ror y1, 2       ; y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+    add y2, y0      ; y2 = S1 + CH
+    add y2, [rsp + _XFER + 3*4] ; y2 = k + w + S1 + CH
+    pxor    X0, XTMP2   ; X0 = s1 {xDxC}
+    mov y0, a       ; y0 = a
+    add h, y2       ; h = h + S1 + CH + k + w
+    mov y2, a       ; y2 = a
+    pshufb  X0, SHUF_DC00   ; X0 = s1 {DC00}
+    or  y0, c       ; y0 = a|c
+    add d, h        ; d = d + h + S1 + CH + k + w
+    and y2, c       ; y2 = a&c
+    paddd   X0, XTMP0   ; X0 = {W[3], W[2], W[1], W[0]}
+    and y0, b       ; y0 = (a|c)&b
+    add h, y1       ; h = h + S1 + CH + k + w + S0
+    or  y0, y2      ; y0 = MAJ = (a|c)&b)|(a&c)
+    add h, y0       ; h = h + S1 + CH + k + w + S0 + MAJ
 
 ROTATE_ARGS
 rotate_Xs
@@ -1303,34 +1303,34 @@ rotate_Xs
 
 ;; input is [rsp + _XFER + %1 * 4]
 %macro DO_ROUND 1
-    mov	y0, e		; y0 = e
-    ror	y0, (25-11)	; y0 = e >> (25-11)
-    mov	y1, a		; y1 = a
-    xor	y0, e		; y0 = e ^ (e >> (25-11))
-    ror	y1, (22-13)	; y1 = a >> (22-13)
-    mov	y2, f		; y2 = f
-    xor	y1, a		; y1 = a ^ (a >> (22-13)
-    ror	y0, (11-6)	; y0 = (e >> (11-6)) ^ (e >> (25-6))
-    xor	y2, g		; y2 = f^g
-    xor	y0, e		; y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
-    ror	y1, (13-2)	; y1 = (a >> (13-2)) ^ (a >> (22-2))
-    and	y2, e		; y2 = (f^g)&e
-    xor	y1, a		; y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
-    ror	y0, 6		; y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
-    xor	y2, g		; y2 = CH = ((f^g)&e)^g
-    add	y2, y0		; y2 = S1 + CH
-    ror	y1, 2		; y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
-    add	y2, [rsp + _XFER + %1 * 4]	; y2 = k + w + S1 + CH
-    mov	y0, a		; y0 = a
-    add	h, y2		; h = h + S1 + CH + k + w
-    mov	y2, a		; y2 = a
-    or	y0, c		; y0 = a|c
-    add	d, h		; d = d + h + S1 + CH + k + w
-    and	y2, c		; y2 = a&c
-    and	y0, b		; y0 = (a|c)&b
-    add	h, y1		; h = h + S1 + CH + k + w + S0
-    or	y0, y2		; y0 = MAJ = (a|c)&b)|(a&c)
-    add	h, y0		; h = h + S1 + CH + k + w + S0 + MAJ
+    mov y0, e       ; y0 = e
+    ror y0, (25-11) ; y0 = e >> (25-11)
+    mov y1, a       ; y1 = a
+    xor y0, e       ; y0 = e ^ (e >> (25-11))
+    ror y1, (22-13) ; y1 = a >> (22-13)
+    mov y2, f       ; y2 = f
+    xor y1, a       ; y1 = a ^ (a >> (22-13)
+    ror y0, (11-6)  ; y0 = (e >> (11-6)) ^ (e >> (25-6))
+    xor y2, g       ; y2 = f^g
+    xor y0, e       ; y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
+    ror y1, (13-2)  ; y1 = (a >> (13-2)) ^ (a >> (22-2))
+    and y2, e       ; y2 = (f^g)&e
+    xor y1, a       ; y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
+    ror y0, 6       ; y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
+    xor y2, g       ; y2 = CH = ((f^g)&e)^g
+    add y2, y0      ; y2 = S1 + CH
+    ror y1, 2       ; y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
+    add y2, [rsp + _XFER + %1 * 4]  ; y2 = k + w + S1 + CH
+    mov y0, a       ; y0 = a
+    add h, y2       ; h = h + S1 + CH + k + w
+    mov y2, a       ; y2 = a
+    or  y0, c       ; y0 = a|c
+    add d, h        ; d = d + h + S1 + CH + k + w
+    and y2, c       ; y2 = a&c
+    and y0, b       ; y0 = (a|c)&b
+    add h, y1       ; h = h + S1 + CH + k + w + S0
+    or  y0, y2      ; y0 = MAJ = (a|c)&b)|(a&c)
+    add h, y0       ; h = h + S1 + CH + k + w + S0 + MAJ
     ROTATE_ARGS
 %endm
 
@@ -1344,166 +1344,166 @@ section .text
 global sha256_sse4
 align 32
 sha256_sse4:
-    push	rbx
+    push    rbx
 %ifndef LINUX
-    push	rsi
-    push	rdi
+    push    rsi
+    push    rdi
 %endif
-    push	rbp
-    push	r13
-    push	r14
-    push	r15
+    push    rbp
+    push    r13
+    push    r14
+    push    r15
 
-    sub	rsp,STACK_SIZE
+    sub rsp,STACK_SIZE
 %ifndef LINUX
-    movdqa	[rsp + _XMM_SAVE + 0*16],xmm6	
-    movdqa	[rsp + _XMM_SAVE + 1*16],xmm7
-    movdqa	[rsp + _XMM_SAVE + 2*16],xmm8	
-    movdqa	[rsp + _XMM_SAVE + 3*16],xmm9	
-    movdqa	[rsp + _XMM_SAVE + 4*16],xmm10
-    movdqa	[rsp + _XMM_SAVE + 5*16],xmm11
-    movdqa	[rsp + _XMM_SAVE + 6*16],xmm12
+    movdqa  [rsp + _XMM_SAVE + 0*16],xmm6
+    movdqa  [rsp + _XMM_SAVE + 1*16],xmm7
+    movdqa  [rsp + _XMM_SAVE + 2*16],xmm8
+    movdqa  [rsp + _XMM_SAVE + 3*16],xmm9
+    movdqa  [rsp + _XMM_SAVE + 4*16],xmm10
+    movdqa  [rsp + _XMM_SAVE + 5*16],xmm11
+    movdqa  [rsp + _XMM_SAVE + 6*16],xmm12
 %endif
 
-    shl	NUM_BLKS, 6	; convert to bytes
-    jz	done_hash
-    add	NUM_BLKS, INP	; pointer to end of data
-    mov	[rsp + _INP_END], NUM_BLKS
+    shl NUM_BLKS, 6 ; convert to bytes
+    jz  done_hash
+    add NUM_BLKS, INP   ; pointer to end of data
+    mov [rsp + _INP_END], NUM_BLKS
 
     ;; load initial digest
-    mov	a,[4*0 + CTX]
-    mov	b,[4*1 + CTX]
-    mov	c,[4*2 + CTX]
-    mov	d,[4*3 + CTX]
-    mov	e,[4*4 + CTX]
-    mov	f,[4*5 + CTX]
-    mov	g,[4*6 + CTX]
-    mov	h,[4*7 + CTX]
-
-    movdqa	BYTE_FLIP_MASK, [PSHUFFLE_BYTE_FLIP_MASK wrt rip]
-    movdqa	SHUF_00BA, [_SHUF_00BA wrt rip]
-    movdqa	SHUF_DC00, [_SHUF_DC00 wrt rip]
+    mov a,[4*0 + CTX]
+    mov b,[4*1 + CTX]
+    mov c,[4*2 + CTX]
+    mov d,[4*3 + CTX]
+    mov e,[4*4 + CTX]
+    mov f,[4*5 + CTX]
+    mov g,[4*6 + CTX]
+    mov h,[4*7 + CTX]
+
+    movdqa  BYTE_FLIP_MASK, [PSHUFFLE_BYTE_FLIP_MASK wrt rip]
+    movdqa  SHUF_00BA, [_SHUF_00BA wrt rip]
+    movdqa  SHUF_DC00, [_SHUF_DC00 wrt rip]
 
 loop0:
-    lea	TBL,[K256 wrt rip]
+    lea TBL,[K256 wrt rip]
 
     ;; byte swap first 16 dwords
-    COPY_XMM_AND_BSWAP	X0, [INP + 0*16], BYTE_FLIP_MASK
-    COPY_XMM_AND_BSWAP	X1, [INP + 1*16], BYTE_FLIP_MASK
-    COPY_XMM_AND_BSWAP	X2, [INP + 2*16], BYTE_FLIP_MASK
-    COPY_XMM_AND_BSWAP	X3, [INP + 3*16], BYTE_FLIP_MASK
-    
-    mov	[rsp + _INP], INP
+    COPY_XMM_AND_BSWAP  X0, [INP + 0*16], BYTE_FLIP_MASK
+    COPY_XMM_AND_BSWAP  X1, [INP + 1*16], BYTE_FLIP_MASK
+    COPY_XMM_AND_BSWAP  X2, [INP + 2*16], BYTE_FLIP_MASK
+    COPY_XMM_AND_BSWAP  X3, [INP + 3*16], BYTE_FLIP_MASK
+
+    mov [rsp + _INP], INP
 
     ;; schedule 48 input dwords, by doing 3 rounds of 16 each
-    mov	SRND, 3
+    mov SRND, 3
 align 16
 loop1:
-    movdqa	XFER, [TBL + 0*16]
-    paddd	XFER, X0
-    movdqa	[rsp + _XFER], XFER
+    movdqa  XFER, [TBL + 0*16]
+    paddd   XFER, X0
+    movdqa  [rsp + _XFER], XFER
     FOUR_ROUNDS_AND_SCHED
 
-    movdqa	XFER, [TBL + 1*16]
-    paddd	XFER, X0
-    movdqa	[rsp + _XFER], XFER
+    movdqa  XFER, [TBL + 1*16]
+    paddd   XFER, X0
+    movdqa  [rsp + _XFER], XFER
     FOUR_ROUNDS_AND_SCHED
 
-    movdqa	XFER, [TBL + 2*16]
-    paddd	XFER, X0
-    movdqa	[rsp + _XFER], XFER
+    movdqa  XFER, [TBL + 2*16]
+    paddd   XFER, X0
+    movdqa  [rsp + _XFER], XFER
     FOUR_ROUNDS_AND_SCHED
 
-    movdqa	XFER, [TBL + 3*16]
-    paddd	XFER, X0
-    movdqa	[rsp + _XFER], XFER
-    add	TBL, 4*16
+    movdqa  XFER, [TBL + 3*16]
+    paddd   XFER, X0
+    movdqa  [rsp + _XFER], XFER
+    add TBL, 4*16
     FOUR_ROUNDS_AND_SCHED
 
-    sub	SRND, 1
-    jne	loop1
+    sub SRND, 1
+    jne loop1
 
-    mov	SRND, 2
+    mov SRND, 2
 loop2:
-    paddd	X0, [TBL + 0*16]
-    movdqa	[rsp + _XFER], X0
-    DO_ROUND	0
-    DO_ROUND	1
-    DO_ROUND	2
-    DO_ROUND	3
-    paddd	X1, [TBL + 1*16]
-    movdqa	[rsp + _XFER], X1
-    add	TBL, 2*16
-    DO_ROUND	0
-    DO_ROUND	1
-    DO_ROUND	2
-    DO_ROUND	3
-
-    movdqa	X0, X2
-    movdqa	X1, X3
-
-    sub	SRND, 1
-    jne	loop2
-
-    addm	[4*0 + CTX],a
-    addm	[4*1 + CTX],b
-    addm	[4*2 + CTX],c
-    addm	[4*3 + CTX],d
-    addm	[4*4 + CTX],e
-    addm	[4*5 + CTX],f
-    addm	[4*6 + CTX],g
-    addm	[4*7 + CTX],h
-
-    mov	INP, [rsp + _INP]
-    add	INP, 64
-    cmp	INP, [rsp + _INP_END]
-    jne	loop0
+    paddd   X0, [TBL + 0*16]
+    movdqa  [rsp + _XFER], X0
+    DO_ROUND    0
+    DO_ROUND    1
+    DO_ROUND    2
+    DO_ROUND    3
+    paddd   X1, [TBL + 1*16]
+    movdqa  [rsp + _XFER], X1
+    add TBL, 2*16
+    DO_ROUND    0
+    DO_ROUND    1
+    DO_ROUND    2
+    DO_ROUND    3
+
+    movdqa  X0, X2
+    movdqa  X1, X3
+
+    sub SRND, 1
+    jne loop2
+
+    addm    [4*0 + CTX],a
+    addm    [4*1 + CTX],b
+    addm    [4*2 + CTX],c
+    addm    [4*3 + CTX],d
+    addm    [4*4 + CTX],e
+    addm    [4*5 + CTX],f
+    addm    [4*6 + CTX],g
+    addm    [4*7 + CTX],h
+
+    mov INP, [rsp + _INP]
+    add INP, 64
+    cmp INP, [rsp + _INP_END]
+    jne loop0
 
 done_hash:
 %ifndef LINUX
-    movdqa	xmm6,[rsp + _XMM_SAVE + 0*16]
-    movdqa	xmm7,[rsp + _XMM_SAVE + 1*16]
-    movdqa	xmm8,[rsp + _XMM_SAVE + 2*16]
-    movdqa	xmm9,[rsp + _XMM_SAVE + 3*16]
-    movdqa	xmm10,[rsp + _XMM_SAVE + 4*16]
-    movdqa	xmm11,[rsp + _XMM_SAVE + 5*16]
-    movdqa	xmm12,[rsp + _XMM_SAVE + 6*16]
+    movdqa  xmm6,[rsp + _XMM_SAVE + 0*16]
+    movdqa  xmm7,[rsp + _XMM_SAVE + 1*16]
+    movdqa  xmm8,[rsp + _XMM_SAVE + 2*16]
+    movdqa  xmm9,[rsp + _XMM_SAVE + 3*16]
+    movdqa  xmm10,[rsp + _XMM_SAVE + 4*16]
+    movdqa  xmm11,[rsp + _XMM_SAVE + 5*16]
+    movdqa  xmm12,[rsp + _XMM_SAVE + 6*16]
 %endif
 
-    add	rsp, STACK_SIZE
+    add rsp, STACK_SIZE
 
-    pop	r15
-    pop	r14
-    pop	r13
-    pop	rbp
+    pop r15
+    pop r14
+    pop r13
+    pop rbp
 %ifndef LINUX
-    pop	rdi
-    pop	rsi
+    pop rdi
+    pop rsi
 %endif
-    pop	rbx
+    pop rbx
+
+    ret
 
-    ret	
-    
 
 section .data
 align 64
 K256:
-    dd	0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5
-    dd	0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5
-    dd	0xd807aa98,0x12835b01,0x243185be,0x550c7dc3
-    dd	0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174
-    dd	0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc
-    dd	0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da
-    dd	0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7
-    dd	0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967
-    dd	0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13
-    dd	0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85
-    dd	0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3
-    dd	0xd192e819,0xd6990624,0xf40e3585,0x106aa070
-    dd	0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5
-    dd	0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3
-    dd	0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208
-    dd	0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
+    dd  0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5
+    dd  0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5
+    dd  0xd807aa98,0x12835b01,0x243185be,0x550c7dc3
+    dd  0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174
+    dd  0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc
+    dd  0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da
+    dd  0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7
+    dd  0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967
+    dd  0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13
+    dd  0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85
+    dd  0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3
+    dd  0xd192e819,0xd6990624,0xf40e3585,0x106aa070
+    dd  0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5
+    dd  0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3
+    dd  0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208
+    dd  0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
 
 PSHUFFLE_BYTE_FLIP_MASK: ddq 0x0c0d0e0f08090a0b0405060700010203
 
diff --git a/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel.cpp b/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel.cpp
index 240255bb..0030f49a 100644
--- a/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel.cpp
@@ -494,6 +494,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_BlockHeader : Handle<btck_BlockHeader, CBlockHeader> {};
 
 btck_Transaction* btck_transaction_create(const void* raw_transaction, size_t raw_transaction_len)
 {
@@ -854,6 +855,21 @@ const btck_BlockTreeEntry* btck_block_tree_entry_get_previous(const btck_BlockTr
     return btck_BlockTreeEntry::ref(btck_BlockTreeEntry::get(entry).pprev);
 }
 
+btck_BlockValidationState* btck_block_validation_state_create()
+{
+    return btck_BlockValidationState::create(BlockValidationState{});
+}
+
+btck_BlockValidationState* btck_block_validation_state_copy(const btck_BlockValidationState* state)
+{
+    return btck_BlockValidationState::copy(state);
+}
+
+void btck_block_validation_state_destroy(btck_BlockValidationState* state)
+{
+    delete state;
+}
+
 btck_ValidationMode btck_block_validation_state_get_validation_mode(const btck_BlockValidationState* block_validation_state_)
 {
     auto& block_validation_state = btck_BlockValidationState::get(block_validation_state_);
@@ -998,6 +1014,12 @@ const btck_BlockTreeEntry* btck_chainstate_manager_get_block_tree_entry_by_hash(
     return btck_BlockTreeEntry::ref(block_index);
 }
 
+const btck_BlockTreeEntry* btck_chainstate_manager_get_best_entry(const btck_ChainstateManager* chainstate_manager)
+{
+    auto& chainman = *btck_ChainstateManager::get(chainstate_manager).m_chainman;
+    return btck_BlockTreeEntry::ref(WITH_LOCK(chainman.GetMutex(), return chainman.m_best_header));
+}
+
 void btck_chainstate_manager_destroy(btck_ChainstateManager* chainman)
 {
     {
@@ -1063,6 +1085,11 @@ const btck_Transaction* btck_block_get_transaction_at(const btck_Block* block, s
     return btck_Transaction::ref(&btck_Block::get(block)->vtx[index]);
 }
 
+btck_BlockHeader* btck_block_get_header(const btck_Block* block)
+{
+    return btck_BlockHeader::create(btck_Block::get(block)->GetBlockHeader());
+}
+
 int btck_block_to_bytes(const btck_Block* block, btck_WriteBytes writer, void* user_data)
 {
     try {
@@ -1094,6 +1121,11 @@ btck_Block* btck_block_read(const btck_ChainstateManager* chainman, const btck_B
     return btck_Block::create(block);
 }
 
+btck_BlockHeader* btck_block_tree_entry_get_block_header(const btck_BlockTreeEntry* entry)
+{
+    return btck_BlockHeader::create(btck_BlockTreeEntry::get(entry).GetBlockHeader());
+}
+
 int32_t btck_block_tree_entry_get_height(const btck_BlockTreeEntry* entry)
 {
     return btck_BlockTreeEntry::get(entry).nHeight;
@@ -1143,6 +1175,19 @@ btck_BlockSpentOutputs* btck_block_spent_outputs_read(const btck_ChainstateManag
     return btck_BlockSpentOutputs::create(block_undo);
 }
 
+btck_BlockSpentOutputs* btck_block_spent_outputs_create(void* context, btck_coin_getter coin_getter, btck_coins_count count_getter, size_t num_txs)
+{
+    auto block_undo{std::make_shared<CBlockUndo>()};
+    block_undo->vtxundo.reserve(num_txs);
+    for (uint64_t i{0}; i < num_txs; ++i) {
+        block_undo->vtxundo.emplace_back();
+        for (uint64_t j{0}; j < count_getter(context, i); ++j) {
+            block_undo->vtxundo[i].vprevout.emplace_back(btck_Coin::get(coin_getter(context, i, j)));
+        }
+    }
+    return btck_BlockSpentOutputs::create(block_undo);
+}
+
 btck_BlockSpentOutputs* btck_block_spent_outputs_copy(const btck_BlockSpentOutputs* block_spent_outputs)
 {
     return btck_BlockSpentOutputs::copy(block_spent_outputs);
@@ -1187,6 +1232,11 @@ const btck_Coin* btck_transaction_spent_outputs_get_coin_at(const btck_Transacti
     return btck_Coin::ref(coin);
 }
 
+btck_Coin* btck_coin_create(const btck_TransactionOutput* output, int height, int is_coinbase)
+{
+    return btck_Coin::create(btck_TransactionOutput::get(output), height, is_coinbase == 1);
+}
+
 btck_Coin* btck_coin_copy(const btck_Coin* coin)
 {
     return btck_Coin::copy(coin);
@@ -1225,6 +1275,35 @@ int btck_chainstate_manager_process_block(
     return result ? 0 : -1;
 }
 
+int btck_chainstate_manager_process_block_header(
+    btck_ChainstateManager* chainstate_manager,
+    const btck_BlockHeader* header,
+    btck_BlockValidationState* state)
+{
+    auto& chainman = btck_ChainstateManager::get(chainstate_manager).m_chainman;
+    auto result = chainman->ProcessNewBlockHeaders({&btck_BlockHeader::get(header), 1}, true, btck_BlockValidationState::get(state), nullptr);
+    return result ? 0 : -1;
+}
+
+int btck_chainstate_manager_validate_block(
+    btck_ChainstateManager* chainstate_manager,
+    const btck_Block* block,
+    const btck_BlockSpentOutputs* block_spent_outputs,
+    btck_BlockValidationState* state)
+{
+    auto& chainman = *btck_ChainstateManager::get(chainstate_manager).m_chainman;
+    LOCK(cs_main);
+
+    btck_BlockValidationState::get(state) = chainman.ValidateBlock(*btck_Block::get(block), *btck_BlockSpentOutputs::get(block_spent_outputs));
+
+    return btck_BlockValidationState::get(state).IsValid() ? 0 : -1;
+}
+
+int btck_transaction_is_coinbase(const btck_Transaction* tx)
+{
+    return btck_Transaction::get(tx)->IsCoinBase() ? 1 : 0;
+}
+
 const btck_Chain* btck_chainstate_manager_get_active_chain(const btck_ChainstateManager* chainman)
 {
     return btck_Chain::ref(&WITH_LOCK(btck_ChainstateManager::get(chainman).m_chainman->GetMutex(), return btck_ChainstateManager::get(chainman).m_chainman->ActiveChain()));
@@ -1247,3 +1326,33 @@ int btck_chain_contains(const btck_Chain* chain, const btck_BlockTreeEntry* entr
     LOCK(::cs_main);
     return btck_Chain::get(chain).Contains(&btck_BlockTreeEntry::get(entry)) ? 1 : 0;
 }
+
+btck_BlockHeader* btck_block_header_create(const void* raw_block_header, size_t raw_block_header_length)
+{
+    auto header{std::make_unique<CBlockHeader>()};
+    DataStream stream{std::span{reinterpret_cast<const std::byte*>(raw_block_header), raw_block_header_length}};
+
+    try {
+        stream >> *header;
+    } catch (...) {
+        LogDebug(BCLog::KERNEL, "Block header decode failed.");
+        return nullptr;
+    }
+
+    return btck_BlockHeader::ref(header.release());
+}
+
+btck_BlockHash* btck_block_header_get_hash(const btck_BlockHeader* block_header)
+{
+    return btck_BlockHash::create(btck_BlockHeader::get(block_header).GetHash());
+}
+
+btck_BlockHeader* btck_block_header_copy(const btck_BlockHeader* block_header)
+{
+    return btck_BlockHeader::copy(block_header);
+}
+
+void btck_block_header_destroy(btck_BlockHeader* header)
+{
+    delete header;
+}
diff --git a/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel.h b/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel.h
index 4c94b59f..f8600338 100644
--- a/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel.h
+++ b/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel.h
@@ -271,8 +271,18 @@ typedef struct btck_TransactionInput btck_TransactionInput;
  */
 typedef struct btck_TransactionOutPoint btck_TransactionOutPoint;
 
+/**
+ * Opaque data structure for holding a transaction id.
+ *
+ * This is a type-safe identifier for a transaction.
+ */
 typedef struct btck_Txid btck_Txid;
 
+/**
+ * Opaque data structure for holding a block header.
+ */
+typedef struct btck_BlockHeader btck_BlockHeader;
+
 /** Current sync state passed to tip changed callbacks. */
 typedef uint8_t btck_SynchronizationState;
 #define btck_SynchronizationState_INIT_REINDEX ((btck_SynchronizationState)(0))
@@ -553,6 +563,15 @@ BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_count
 BITCOINKERNEL_API const btck_Txid* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_get_txid(
     const btck_Transaction* transaction) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Check if this is a coinbase transaction.
+ *
+ * @param[in] transaction Non-null.
+ * @return                1 if it is coinbase, 0 if it is not.
+ */
+BITCOINKERNEL_API int btck_transaction_is_coinbase(
+        const btck_Transaction* transaction) BITCOINKERNEL_ARG_NONNULL(1);
+
 /**
  * Destroy the transaction.
  */
@@ -904,6 +923,16 @@ BITCOINKERNEL_API void btck_context_destroy(btck_Context* context);
 BITCOINKERNEL_API const btck_BlockTreeEntry* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_tree_entry_get_previous(
     const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Return the block header associated with this entry. The returned
+ * header is not owned and depends on the lifetime of the block.
+ *
+ * @param[in] block_tree_entry Non-null.
+ * @return                     The block header.
+ */
+BITCOINKERNEL_API btck_BlockHeader* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_tree_entry_get_block_header(
+    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1);
+
 /**
  * @brief Return the height of a certain block tree entry.
  *
@@ -1017,6 +1046,46 @@ BITCOINKERNEL_API void btck_chainstate_manager_options_destroy(btck_ChainstateMa
 BITCOINKERNEL_API btck_ChainstateManager* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_create(
     const btck_ChainstateManagerOptions* chainstate_manager_options) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Get the block tree entry whose associated block header has the most
+ * known cumulative proof of work.
+ *
+ * @param[in] chainstate_manager Non-null.
+ * @return                       The block tree entry.
+ */
+BITCOINKERNEL_API const btck_BlockTreeEntry* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_get_best_entry(
+    const btck_ChainstateManager* chainstate_manager) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Process and validate the passed in block header.
+ *
+ * @param[in] chainstate_manager       Non-null.
+ * @param[in] header                   Non-null.
+ * @param[out] block_validation_state  The result of the header validation.
+ * @return                             0 if processing the header was successful.
+ */
+BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_process_block_header(
+    btck_ChainstateManager* chainstate_manager,
+    const btck_BlockHeader* header,
+    btck_BlockValidationState* block_validation_state) BITCOINKERNEL_ARG_NONNULL(1, 2, 3);
+
+/**
+ * @brief Validated the pass in block. Requires its block header to already
+ * have been processed. Will terminate if the block header has not been
+ * processed before calling this function.
+ *
+ * @param[in] chainstate_manager      Non-null.
+ * @param[in] block                   Non-null.
+ * @param[in] block_spent_outputs     Non-null.
+ * @param[out] block_validation_state The result of the block validation.
+ * @return                            0 if validating the block was successful.
+ */
+BITCOINKERNEL_API int btck_chainstate_manager_validate_block(
+    btck_ChainstateManager* chainstate_manager,
+    const btck_Block* block,
+    const btck_BlockSpentOutputs* block_spent_outputs,
+    btck_BlockValidationState* block_validation_state) BITCOINKERNEL_ARG_NONNULL(1, 2, 3, 4);
+
 /**
  * @brief Triggers the start of a reindex if the wipe options were previously
  * set for the chainstate manager. Can also import an array of existing block
@@ -1148,6 +1217,15 @@ BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_count_trans
 BITCOINKERNEL_API const btck_Transaction* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_get_transaction_at(
     const btck_Block* block, size_t transaction_index) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Get the header of the block.
+ *
+ * @param[in] block Non-null.
+ * @return          The block header.
+ */
+BITCOINKERNEL_API btck_BlockHeader* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_get_header(
+    const btck_Block* block) BITCOINKERNEL_ARG_NONNULL(1);
+
 /**
  * @brief Calculate and return the hash of a block.
  *
@@ -1184,6 +1262,11 @@ BITCOINKERNEL_API void btck_block_destroy(btck_Block* block);
  */
 ///@{
 
+/**
+ * Create a new block validation state.
+ */
+BITCOINKERNEL_API btck_BlockValidationState* btck_block_validation_state_create();
+
 /**
  * Returns the validation mode from an opaque block validation state pointer.
  */
@@ -1196,6 +1279,20 @@ BITCOINKERNEL_API btck_ValidationMode btck_block_validation_state_get_validation
 BITCOINKERNEL_API btck_BlockValidationResult btck_block_validation_state_get_block_validation_result(
     const btck_BlockValidationState* block_validation_state) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Copies the block validation state.
+ *
+ * @param[in] block_validation_state Non-null.
+ * @return                           The copied block validation state.
+ */
+BITCOINKERNEL_API btck_BlockValidationState* btck_block_validation_state_copy(
+    const btck_BlockValidationState* block_validation_state) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Destroy the block validation state.
+ */
+BITCOINKERNEL_API void btck_block_validation_state_destroy(btck_BlockValidationState* state);
+
 ///@}
 
 /** @name Chain
@@ -1256,6 +1353,32 @@ BITCOINKERNEL_API btck_BlockSpentOutputs* BITCOINKERNEL_WARN_UNUSED_RESULT btck_
     const btck_ChainstateManager* chainstate_manager,
     const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1, 2);
 
+/**
+ * Callback type for getting a single coin to construct a block spent
+ * outputs. tx_index index indicates the position of a transaction within a
+ * block, coin_index indicates the position of an input within a block.
+*/
+typedef const btck_Coin* (*btck_coin_getter)(void* context, size_t tx_index, size_t coin_index);
+
+/**
+ * Callback type for getting the number of inputs (and thus number of coins
+ * consumed of a transacstion)
+ */
+typedef size_t (*btck_coins_count)(void* context, size_t block_index);
+
+/**
+ * @brief Create a block spent outputs from some coins.
+ *
+ * @param[in] context      Nullable. A user-defined data pointer that is passed through the callbacks.
+ * @param[in] coin_getter  Non-null. A callback for retrieving a coin.
+ * @param[in] count_getter Non-null. A callback for getting the expected number of coins per transaction.
+ * @param[in] num_txs      Non-null. The number of transactions in the block.
+ */
+BITCOINKERNEL_API btck_BlockSpentOutputs* BITCOINKERNEL_WARN_UNUSED_RESULT
+btck_block_spent_outputs_create(void* context, btck_coin_getter coin_getter,
+        btck_coins_count count_getter, size_t num_txs)
+    BITCOINKERNEL_ARG_NONNULL(1);
+
 /**
  * @brief Copy a block's spent outputs.
  *
@@ -1458,6 +1581,17 @@ BITCOINKERNEL_API void btck_txid_destroy(btck_Txid* txid);
  */
 ///@{
 
+/**
+ * @brief Create a coin.
+ *
+ * @param[in] output      Non-null.
+ * @param[in] height      The height the coin was confirmed in.
+ * @param[in] is_coinbase Set to 1 if the coin is from a coinbase output, set to 0 otherwise.
+ * @return                The coin.
+ */
+BITCOINKERNEL_API btck_Coin* BITCOINKERNEL_WARN_UNUSED_RESULT btck_coin_create(
+    const btck_TransactionOutput* output, int height, int is_coinbase) BITCOINKERNEL_ARG_NONNULL(1);
+
 /**
  * @brief Copy a coin.
  *
@@ -1549,6 +1683,42 @@ BITCOINKERNEL_API void btck_block_hash_destroy(btck_BlockHash* block_hash);
 
 ///@}
 
+/** @name BlockHeader
+ * Functions for working with block headers.
+ */
+///@{
+
+/**
+ * @brief Create a block header from its raw data.
+ */
+BITCOINKERNEL_API btck_BlockHeader* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_header_create(
+    const void* raw_block_header, size_t raw_block_header_len) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Copy a block header.
+ *
+ * @param[in] block_header Non-null.
+ * @return                 The copied block header.
+ */
+BITCOINKERNEL_API btck_BlockHeader* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_header_copy(
+    const btck_BlockHeader* block_header) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Get the block hash.
+ *
+ * @param[in] block_header Non-null.
+ * @return                 The block hash.
+ */
+BITCOINKERNEL_API btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_header_get_hash(
+    const btck_BlockHeader* block_header) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Destroy the block header.
+ */
+BITCOINKERNEL_API void btck_block_header_destroy(btck_BlockHeader* header);
+
+///@}
+
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
diff --git a/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel_wrapper.h b/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel_wrapper.h
index b847dde5..6d84d6bb 100644
--- a/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel_wrapper.h
+++ b/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel_wrapper.h
@@ -580,6 +580,11 @@ class TransactionApi
         return btck_transaction_count_outputs(impl());
     }
 
+    bool IsCoinbase() const
+    {
+        return btck_transaction_is_coinbase(impl()) != 0;
+    }
+
     size_t CountInputs() const
     {
         return btck_transaction_count_inputs(impl());
@@ -702,6 +707,44 @@ class BlockHash : public Handle<btck_BlockHash, btck_block_hash_copy, btck_block
         : Handle{view} {}
 };
 
+template <typename Derived>
+class BlockHeaderApi
+{
+private:
+    auto impl() const
+    {
+        return static_cast<const Derived*>(this)->get();
+    }
+
+    friend Derived;
+    BlockHeaderApi() = default;
+
+public:
+    BlockHash Hash() const
+    {
+        return BlockHash{btck_block_header_get_hash(impl())};
+    }
+};
+
+class BlockHeaderView : public View<btck_BlockHeader>, public BlockHeaderApi<BlockHeaderView>
+{
+public:
+    explicit BlockHeaderView(const btck_BlockHeader* ptr) : View{ptr} {}
+};
+
+class BlockHeader : public Handle<btck_BlockHeader, btck_block_header_copy, btck_block_header_destroy>, public BlockHeaderApi<BlockHeader>
+{
+public:
+    explicit BlockHeader(std::span<const std::byte> raw_block_header)
+        : Handle{btck_block_header_create(raw_block_header.data(), raw_block_header.size())} {}
+
+    BlockHeader(const BlockHeaderView& view)
+        : Handle{view} {}
+
+    BlockHeader(btck_BlockHeader* ptr)
+        : Handle{ptr} {}
+};
+
 class Block : public Handle<btck_Block, btck_block_copy, btck_block_destroy>
 {
 public:
@@ -722,6 +765,11 @@ class Block : public Handle<btck_Block, btck_block_copy, btck_block_destroy>
         return TransactionView{btck_block_get_transaction_at(get(), index)};
     }
 
+    BlockHeader GetHeader() const
+    {
+        return BlockHeader{btck_block_get_header(get())};
+    }
+
     MAKE_RANGE_METHOD(Transactions, Block, &Block::CountTransactions, &Block::GetTransaction, *this)
 
     BlockHash GetHash() const
@@ -802,6 +850,11 @@ class BlockTreeEntry : public View<btck_BlockTreeEntry>
     {
         return BlockHashView{btck_block_tree_entry_get_block_hash(get())};
     }
+
+    BlockHeader GetHeader() const
+    {
+        return BlockHeader{btck_block_tree_entry_get_block_header(get())};
+    }
 };
 
 class KernelNotifications
@@ -824,28 +877,41 @@ class KernelNotifications
     virtual void FatalErrorHandler(std::string_view error) {}
 };
 
-class BlockValidationState
+template <typename Derived>
+class BlockValidationStateApi
 {
 private:
-    const btck_BlockValidationState* m_state;
+    auto impl() const
+    {
+        return static_cast<const Derived*>(this)->get();
+    }
+    friend Derived;
+    BlockValidationStateApi() = default;
 
 public:
-    BlockValidationState(const btck_BlockValidationState* state) : m_state{state} {}
+   ValidationMode GetValidationMode() const
+   {
+       return static_cast<ValidationMode>(btck_block_validation_state_get_validation_mode(impl()));
+   }
+
+   BlockValidationResult GetBlockValidationResult() const
+   {
+       return static_cast<BlockValidationResult>(btck_block_validation_state_get_block_validation_result(impl()));
+   }
+};
 
-    BlockValidationState(const BlockValidationState&) = delete;
-    BlockValidationState& operator=(const BlockValidationState&) = delete;
-    BlockValidationState(BlockValidationState&&) = delete;
-    BlockValidationState& operator=(BlockValidationState&&) = delete;
+class BlockValidationStateView : public View<btck_BlockValidationState>, public BlockValidationStateApi<BlockValidationStateView>
+{
+public:
+    explicit BlockValidationStateView(const btck_BlockValidationState* ptr) : View{ptr} {}
+};
 
-    ValidationMode GetValidationMode() const
-    {
-        return static_cast<ValidationMode>(btck_block_validation_state_get_validation_mode(m_state));
-    }
+class BlockValidationState : public Handle<btck_BlockValidationState, btck_block_validation_state_copy, btck_block_validation_state_destroy>, public BlockValidationStateApi<BlockValidationState>
+{
+public:
+    explicit BlockValidationState() : Handle{btck_block_validation_state_create()} {}
 
-    BlockValidationResult GetBlockValidationResult() const
-    {
-        return static_cast<BlockValidationResult>(btck_block_validation_state_get_block_validation_result(m_state));
-    }
+    BlockValidationState(const BlockValidationStateView& view) : Handle{view} {}
 };
 
 class ValidationInterface
@@ -853,7 +919,7 @@ class ValidationInterface
 public:
     virtual ~ValidationInterface() = default;
 
-    virtual void BlockChecked(Block block, const BlockValidationState state) {}
+    virtual void BlockChecked(Block block, const BlockValidationStateView state) {}
 
     virtual void PowValidBlock(BlockTreeEntry entry, Block block) {}
 
@@ -911,7 +977,7 @@ class ContextOptions : public UniqueHandle<btck_ContextOptions, btck_context_opt
             btck_ValidationInterfaceCallbacks{
                 .user_data = heap_vi.release(),
                 .user_data_destroy = +[](void* user_data) { delete static_cast<user_type>(user_data); },
-                .block_checked = +[](void* user_data, btck_Block* block, const btck_BlockValidationState* state) { (*static_cast<user_type>(user_data))->BlockChecked(Block{block}, BlockValidationState{state}); },
+                .block_checked = +[](void* user_data, btck_Block* block, const btck_BlockValidationState* state) { (*static_cast<user_type>(user_data))->BlockChecked(Block{block}, BlockValidationStateView{state}); },
                 .pow_valid_block = +[](void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry) { (*static_cast<user_type>(user_data))->PowValidBlock(BlockTreeEntry{entry}, Block{block}); },
                 .block_connected = +[](void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry) { (*static_cast<user_type>(user_data))->BlockConnected(Block{block}, BlockTreeEntry{entry}); },
                 .block_disconnected = +[](void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry) { (*static_cast<user_type>(user_data))->BlockDisconnected(Block{block}, BlockTreeEntry{entry}); },
@@ -1025,6 +1091,8 @@ class CoinView : public View<btck_Coin>, public CoinApi<CoinView>
 class Coin : public Handle<btck_Coin, btck_coin_copy, btck_coin_destroy>, public CoinApi<Coin>
 {
 public:
+    Coin(const TransactionOutput& output, int height, bool is_coinbase) : Handle{btck_coin_create(output.get(), height, is_coinbase)} {}
+
     Coin(btck_Coin* coin) : Handle{coin} {}
 
     Coin(const CoinView& view) : Handle{view} {}
@@ -1073,7 +1141,31 @@ class TransactionSpentOutputs : public Handle<btck_TransactionSpentOutputs, btck
 
 class BlockSpentOutputs : public Handle<btck_BlockSpentOutputs, btck_block_spent_outputs_copy, btck_block_spent_outputs_destroy>
 {
+    struct CallbackContext {
+        const std::vector<std::vector<Coin>>& coins;
+    };
+
+    static const btck_Coin* coin_getter_impl(void* context, size_t tx_index, size_t coin_index) {
+        auto* ctx = static_cast<CallbackContext*>(context);
+        return ctx->coins[tx_index][coin_index].get();
+    }
+
+    static size_t count_getter_impl(void* context, size_t tx_index) {
+        auto* ctx = static_cast<CallbackContext*>(context);
+        return ctx->coins[tx_index].size();
+    }
+
 public:
+    BlockSpentOutputs(const std::vector<std::vector<Coin>>& coins) : Handle{[coins]() {
+        CallbackContext ctx{coins};
+        return btck_block_spent_outputs_create(
+            &ctx,
+            coin_getter_impl,
+            count_getter_impl,
+            coins.size()
+        );
+    }()} {}
+
     BlockSpentOutputs(btck_BlockSpentOutputs* block_spent_outputs)
         : Handle{block_spent_outputs}
     {
@@ -1122,6 +1214,16 @@ class ChainMan : UniqueHandle<btck_ChainstateManager, btck_chainstate_manager_de
         return res == 0;
     }
 
+    bool ProcessBlockHeader(const BlockHeader& header, BlockValidationState& state)
+    {
+        return btck_chainstate_manager_process_block_header(get(), header.get(), state.get()) == 0;
+    }
+
+    bool ValidateBlock(const Block& block, const BlockSpentOutputs& block_spent_outputs, BlockValidationState& state)
+    {
+        return btck_chainstate_manager_validate_block(get(), block.get(), block_spent_outputs.get(), state.get()) == 0;
+    }
+
     ChainView GetChain() const
     {
         return ChainView{btck_chainstate_manager_get_active_chain(get())};
@@ -1134,6 +1236,11 @@ class ChainMan : UniqueHandle<btck_ChainstateManager, btck_chainstate_manager_de
         return entry;
     }
 
+    BlockTreeEntry GetBestEntry() const
+    {
+        return btck_chainstate_manager_get_best_entry(get());
+    }
+
     std::optional<Block> ReadBlock(const BlockTreeEntry& entry) const
     {
         auto block{btck_block_read(get(), entry.get())};
diff --git a/libbitcoinkernel-sys/bitcoin/src/node/psbt.cpp b/libbitcoinkernel-sys/bitcoin/src/node/psbt.cpp
index 3933202e..881ffd12 100644
--- a/libbitcoinkernel-sys/bitcoin/src/node/psbt.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/node/psbt.cpp
@@ -137,7 +137,8 @@ PSBTAnalysis AnalyzePSBT(PartiallySignedTransaction psbtx)
 
         if (success) {
             CTransaction ctx = CTransaction(mtx);
-            size_t size(GetVirtualTransactionSize(ctx, GetTransactionSigOpCost(ctx, view, STANDARD_SCRIPT_VERIFY_FLAGS), ::nBytesPerSigOp));
+            auto coins{view.AccessCoins(ctx)};
+            size_t size(GetVirtualTransactionSize(ctx, GetTransactionSigOpCost(ctx, std::span{coins}, STANDARD_SCRIPT_VERIFY_FLAGS), ::nBytesPerSigOp));
             result.estimated_vsize = size;
             // Estimate fee rate
             CFeeRate feerate(fee, size);
diff --git a/libbitcoinkernel-sys/bitcoin/src/qt/CMakeLists.txt b/libbitcoinkernel-sys/bitcoin/src/qt/CMakeLists.txt
index c23a7ec6..58fa08b5 100644
--- a/libbitcoinkernel-sys/bitcoin/src/qt/CMakeLists.txt
+++ b/libbitcoinkernel-sys/bitcoin/src/qt/CMakeLists.txt
@@ -50,11 +50,19 @@ endfunction()
 
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTOMOC_MOC_OPTIONS "-p${CMAKE_CURRENT_SOURCE_DIR}")
-set(CMAKE_AUTORCC ON)
 set(CMAKE_AUTOUIC ON)
 set(CMAKE_AUTOUIC_SEARCH_PATHS forms)
 
+set(CMAKE_AUTORCC OFF)
 configure_file(bitcoin_locale.qrc bitcoin_locale.qrc USE_SOURCE_PERMISSIONS COPYONLY)
+qt6_add_resources(BITCOIN_QRC bitcoin.qrc)
+qt6_add_resources(BITCOIN_LOCALE_QRC ${CMAKE_CURRENT_BINARY_DIR}/bitcoin_locale.qrc)
+# See: https://bugreports.qt.io/browse/QTBUG-141858.
+get_target_property(warn_flags warn_interface INTERFACE_COMPILE_OPTIONS)
+if("-Wtrailing-whitespace=any" IN_LIST warn_flags)
+  set_source_files_properties(${BITCOIN_QRC} ${BITCOIN_LOCALE_QRC} PROPERTIES COMPILE_OPTIONS -Wno-trailing-whitespace)
+endif()
+unset(warn_flags)
 
 # The bitcoinqt sources have to include headers in
 # order to parse them to collect translatable strings.
@@ -119,8 +127,8 @@ add_library(bitcoinqt STATIC EXCLUDE_FROM_ALL
   utilitydialog.h
   $<$<PLATFORM_ID:Windows>:winshutdownmonitor.cpp>
   $<$<PLATFORM_ID:Windows>:winshutdownmonitor.h>
-  bitcoin.qrc
-  ${CMAKE_CURRENT_BINARY_DIR}/bitcoin_locale.qrc
+  ${BITCOIN_QRC}
+  ${BITCOIN_LOCALE_QRC}
 )
 target_compile_definitions(bitcoinqt
   PUBLIC
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/CMakeLists.txt b/libbitcoinkernel-sys/bitcoin/src/test/CMakeLists.txt
index a67cd241..9528004e 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/CMakeLists.txt
+++ b/libbitcoinkernel-sys/bitcoin/src/test/CMakeLists.txt
@@ -34,7 +34,6 @@ add_executable(test_bitcoin
   coinscachepair_tests.cpp
   coinstatsindex_tests.cpp
   common_url_tests.cpp
-  compilerbug_tests.cpp
   compress_tests.cpp
   crypto_tests.cpp
   cuckoocache_tests.cpp
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/blockmanager_tests.cpp b/libbitcoinkernel-sys/bitcoin/src/test/blockmanager_tests.cpp
index f06665d3..e6d5f153 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/blockmanager_tests.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/blockmanager_tests.cpp
@@ -60,16 +60,16 @@ BOOST_AUTO_TEST_CASE(blockmanager_find_block_pos)
 BOOST_FIXTURE_TEST_CASE(blockmanager_scan_unlink_already_pruned_files, TestChain100Setup)
 {
     // Cap last block file size, and mine new block in a new block file.
-    const auto& chainman = Assert(m_node.chainman);
-    auto& blockman = chainman->m_blockman;
-    const CBlockIndex* old_tip{WITH_LOCK(chainman->GetMutex(), return chainman->ActiveChain().Tip())};
-    WITH_LOCK(chainman->GetMutex(), blockman.GetBlockFileInfo(old_tip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE);
+    auto& chainman{*Assert(m_node.chainman)};
+    auto& blockman{chainman.m_blockman};
+    const CBlockIndex* old_tip{WITH_LOCK(chainman.GetMutex(), return chainman.ActiveChain().Tip())};
+    WITH_LOCK(chainman.GetMutex(), blockman.GetBlockFileInfo(old_tip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE);
     CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
 
     // Prune the older block file, but don't unlink it
     int file_number;
     {
-        LOCK(chainman->GetMutex());
+        LOCK(chainman.GetMutex());
         file_number = old_tip->GetBlockPos().nFile;
         blockman.PruneOneBlockFile(file_number);
     }
@@ -78,22 +78,22 @@ BOOST_FIXTURE_TEST_CASE(blockmanager_scan_unlink_already_pruned_files, TestChain
 
     // Check that the file is not unlinked after ScanAndUnlinkAlreadyPrunedFiles
     // if m_have_pruned is not yet set
-    WITH_LOCK(chainman->GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles());
+    WITH_LOCK(chainman.GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles());
     BOOST_CHECK(!blockman.OpenBlockFile(pos, true).IsNull());
 
     // Check that the file is unlinked after ScanAndUnlinkAlreadyPrunedFiles
     // once m_have_pruned is set
     blockman.m_have_pruned = true;
-    WITH_LOCK(chainman->GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles());
+    WITH_LOCK(chainman.GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles());
     BOOST_CHECK(blockman.OpenBlockFile(pos, true).IsNull());
 
     // Check that calling with already pruned files doesn't cause an error
-    WITH_LOCK(chainman->GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles());
+    WITH_LOCK(chainman.GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles());
 
     // Check that the new tip file has not been removed
-    const CBlockIndex* new_tip{WITH_LOCK(chainman->GetMutex(), return chainman->ActiveChain().Tip())};
+    const CBlockIndex* new_tip{WITH_LOCK(chainman.GetMutex(), return chainman.ActiveChain().Tip())};
     BOOST_CHECK_NE(old_tip, new_tip);
-    const int new_file_number{WITH_LOCK(chainman->GetMutex(), return new_tip->GetBlockPos().nFile)};
+    const int new_file_number{WITH_LOCK(chainman.GetMutex(), return new_tip->GetBlockPos().nFile)};
     const FlatFilePos new_pos(new_file_number, 0);
     BOOST_CHECK(!blockman.OpenBlockFile(new_pos, true).IsNull());
 }
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/coinstatsindex_tests.cpp b/libbitcoinkernel-sys/bitcoin/src/test/coinstatsindex_tests.cpp
index 7d54f0fd..9ace758e 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/coinstatsindex_tests.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/coinstatsindex_tests.cpp
@@ -8,6 +8,7 @@
 #include <kernel/coinstats.h>
 #include <test/util/setup_common.h>
 #include <test/util/validation.h>
+#include <undo.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
@@ -96,7 +97,9 @@ BOOST_FIXTURE_TEST_CASE(coinstatsindex_unclean_shutdown, TestChain100Setup)
             BOOST_CHECK(CheckBlock(block, state, params.GetConsensus()));
             BOOST_CHECK(m_node.chainman->AcceptBlock(new_block, state, &new_block_index, true, nullptr, nullptr, true));
             CCoinsViewCache view(&chainstate.CoinsTip());
-            BOOST_CHECK(chainstate.ConnectBlock(block, state, new_block_index, view));
+            CBlockUndo blockundo;
+            BOOST_CHECK(chainstate.SpendBlock(block, new_block_index, view, state, blockundo));
+            BOOST_CHECK(chainstate.ConnectBlock(block, blockundo, state, new_block_index));
         }
         // Send block connected notification, then stop the index without
         // sending a chainstate flushed notification. Prior to #24138, this
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/compilerbug_tests.cpp b/libbitcoinkernel-sys/bitcoin/src/test/compilerbug_tests.cpp
deleted file mode 100644
index ef558c1e..00000000
--- a/libbitcoinkernel-sys/bitcoin/src/test/compilerbug_tests.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) 2019-2021 The Bitcoin Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include <boost/test/unit_test.hpp>
-
-BOOST_AUTO_TEST_SUITE(compilerbug_tests)
-
-#if defined(__GNUC__)
-// This block will also be built under clang, which is fine (as it supports noinline)
-void __attribute__ ((noinline)) set_one(unsigned char* ptr)
-{
-    *ptr = 1;
-}
-
-int __attribute__ ((noinline)) check_zero(unsigned char const* in, unsigned int len)
-{
-    for (unsigned int i = 0; i < len; ++i) {
-        if (in[i] != 0) return 0;
-    }
-    return 1;
-}
-
-void set_one_on_stack() {
-    unsigned char buf[1];
-    set_one(buf);
-}
-
-BOOST_AUTO_TEST_CASE(gccbug_90348) {
-    // Test for GCC bug 90348. See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90348
-    for (int i = 0; i <= 4; ++i) {
-        unsigned char in[4];
-        for (int j = 0; j < i; ++j) {
-            in[j] = 0;
-            set_one_on_stack(); // Apparently modifies in[0]
-        }
-        BOOST_CHECK(check_zero(in, i));
-    }
-}
-#endif
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/fs_tests.cpp b/libbitcoinkernel-sys/bitcoin/src/test/fs_tests.cpp
index 28fcf952..89188904 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/fs_tests.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/fs_tests.cpp
@@ -139,28 +139,4 @@ BOOST_AUTO_TEST_CASE(rename)
     fs::remove(path2);
 }
 
-#ifndef __MINGW64__ // no symlinks on mingw
-BOOST_AUTO_TEST_CASE(create_directories)
-{
-    // Test fs::create_directories workaround.
-    const fs::path tmpfolder{m_args.GetDataDirBase()};
-
-    const fs::path dir{tmpfolder / "a"};
-    fs::create_directory(dir);
-    BOOST_CHECK(fs::exists(dir));
-    BOOST_CHECK(fs::is_directory(dir));
-    BOOST_CHECK(!fs::create_directories(dir));
-
-    const fs::path symlink{tmpfolder / "b"};
-    fs::create_directory_symlink(dir, symlink);
-    BOOST_CHECK(fs::exists(symlink));
-    BOOST_CHECK(fs::is_symlink(symlink));
-    BOOST_CHECK(fs::is_directory(symlink));
-    BOOST_CHECK(!fs::create_directories(symlink));
-
-    fs::remove(symlink);
-    fs::remove(dir);
-}
-#endif // __MINGW64__
-
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/fuzz/coins_view.cpp b/libbitcoinkernel-sys/bitcoin/src/test/fuzz/coins_view.cpp
index dceec3d2..7b3af6c0 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/fuzz/coins_view.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/fuzz/coins_view.cpp
@@ -260,7 +260,10 @@ void TestCoinsView(FuzzedDataProvider& fuzzed_data_provider, CCoinsView& backend
                     // It is not allowed to call CheckTxInputs if CheckTransaction failed
                     return;
                 }
-                if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out)) {
+                // are the actual inputs available?
+                if (!coins_view_cache.HaveInputs(transaction)) return;
+                auto coins{coins_view_cache.AccessCoins(transaction)};
+                if (Consensus::CheckTxInputs(transaction, state, std::span{coins}, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out)) {
                     assert(MoneyRange(tx_fee_out));
                 }
             },
@@ -271,7 +274,8 @@ void TestCoinsView(FuzzedDataProvider& fuzzed_data_provider, CCoinsView& backend
                     // consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
                     return;
                 }
-                (void)GetP2SHSigOpCount(transaction, coins_view_cache);
+                auto coins{coins_view_cache.AccessCoins(transaction)};
+                (void)GetP2SHSigOpCount(transaction, std::span{coins});
             },
             [&] {
                 const CTransaction transaction{random_mutable_transaction};
@@ -286,7 +290,8 @@ void TestCoinsView(FuzzedDataProvider& fuzzed_data_provider, CCoinsView& backend
                     // script/interpreter.cpp:1705: size_t CountWitnessSigOps(const CScript &, const CScript &, const CScriptWitness &, unsigned int): Assertion `(flags & SCRIPT_VERIFY_P2SH) != 0' failed.
                     return;
                 }
-                (void)GetTransactionSigOpCost(transaction, coins_view_cache, flags);
+                auto coins{coins_view_cache.AccessCoins(transaction)};
+                (void)GetTransactionSigOpCost(transaction, std::span{coins}, flags);
             },
             [&] {
                 (void)IsWitnessStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/kernel/test_kernel.cpp b/libbitcoinkernel-sys/bitcoin/src/test/kernel/test_kernel.cpp
index e1c9376d..4040849d 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/kernel/test_kernel.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/kernel/test_kernel.cpp
@@ -146,7 +146,7 @@ class TestValidationInterface : public ValidationInterface
 public:
     std::optional<std::vector<std::byte>> m_expected_valid_block = std::nullopt;
 
-    void BlockChecked(Block block, const BlockValidationState state) override
+    void BlockChecked(Block block, const BlockValidationStateView state) override
     {
         if (m_expected_valid_block.has_value()) {
             auto ser_block{block.ToBytes()};
@@ -491,6 +491,14 @@ BOOST_AUTO_TEST_CASE(btck_transaction_input)
     CheckHandle(point_0, point_1);
 }
 
+BOOST_AUTO_TEST_CASE(btck_header_tests)
+{
+    BlockHeader header_0{hex_string_to_byte_vec("00e07a26beaaeee2e71d7eb19279545edbaf15de0999983626ec00000000000000000000579cf78b65229bfb93f4a11463af2eaa5ad91780f27f5d147a423bea5f7e4cdf2a47e268b4dd01173a9662ee")};
+    BOOST_CHECK_EQUAL(byte_span_to_hex_string_reversed(header_0.Hash().ToBytes()), "00000000000000000000325c7e14a4ee3b4fcb2343089a839287308a0ddbee4f");
+    BlockHeader header_1{hex_string_to_byte_vec("00c00020e7cb7b4de21d26d55bd384017b8bb9333ac3b2b55bed00000000000000000000d91b4484f801b99f03d36b9d26cfa83420b67f81da12d7e6c1e7f364e743c5ba9946e268b4dd011799c8533d")};
+    CheckHandle(header_0, header_1);
+}
+
 BOOST_AUTO_TEST_CASE(btck_script_verify_tests)
 {
     // Legacy transaction aca326a724eda9a461c10a876534ecd5ae7b27f10f26c3862fb996f80ea2d45d
@@ -826,6 +834,23 @@ BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)
     auto notifications{std::make_shared<TestKernelNotifications>()};
     auto context{create_context(notifications, ChainType::REGTEST)};
 
+    {
+        auto chainman{create_chainman(test_directory, false, false, false, false, context)};
+        for (const auto& data : REGTEST_BLOCK_DATA) {
+            Block block{hex_string_to_byte_vec(data)};
+            BlockHeader header = block.GetHeader();
+            BlockValidationState state{};
+            BOOST_CHECK(state.GetBlockValidationResult() == BlockValidationResult::UNSET);
+            BOOST_CHECK(chainman->ProcessBlockHeader(header,state));
+            BOOST_CHECK(state.GetValidationMode() == ValidationMode::VALID);
+            BlockTreeEntry entry{*chainman->GetBlockTreeEntry(header.Hash())};
+            BOOST_CHECK(!chainman->GetChain().Contains(entry));
+            BlockTreeEntry best_entry{chainman->GetBestEntry()};
+            BlockHash hash{entry.GetHash()};
+            BOOST_CHECK(hash == best_entry.GetHeader().Hash());
+        }
+    }
+
     // Validate 206 regtest blocks in total.
     // Stop halfway to check that it is possible to continue validating starting
     // from prior state.
@@ -879,8 +904,13 @@ BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)
     };
 
     for (const auto block_tree_entry : chain.Entries()) {
+        if (block_tree_entry.GetHeight() == 0) continue;
         auto block{chainman->ReadBlock(block_tree_entry)};
+        std::vector<std::vector<Coin>> spent_coins;
         for (const auto transaction : block->Transactions()) {
+            if (transaction.IsCoinbase()) continue;
+
+            std::vector<Coin> tx_spent_coins;
             std::vector<TransactionInput> inputs;
             std::vector<TransactionOutput> spent_outputs;
             for (const auto input : transaction.Inputs()) {
@@ -894,13 +924,27 @@ BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)
                 BOOST_CHECK(tx.has_value());
                 BOOST_CHECK(point.Txid() == tx->Txid());
                 spent_outputs.emplace_back(tx->GetOutput(point.index()));
+                tx_spent_coins.emplace_back(tx->GetOutput(point.index()), 0, false);
             }
+
             BOOST_CHECK(inputs.size() == spent_outputs.size());
             ScriptVerifyStatus status = ScriptVerifyStatus::OK;
             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));
             }
+
+            spent_coins.push_back(std::move(tx_spent_coins));
+        }
+        BlockSpentOutputs spent_outputs{spent_coins};
+        BlockSpentOutputs real_spent_outputs{chainman->ReadBlockSpentOutputs(block_tree_entry)};
+
+        BlockValidationState state{};
+
+        BOOST_CHECK(spent_outputs.Count() == real_spent_outputs.Count());
+        for (size_t i{0}; i < real_spent_outputs.Count(); ++i) {
+            BOOST_CHECK_EQUAL(spent_outputs.GetTxSpentOutputs(i).Count(), real_spent_outputs.GetTxSpentOutputs(i).Count());
         }
+        BOOST_CHECK(chainman->ValidateBlock(*block, spent_outputs, state));
     }
 
     // Read spent outputs for current tip and its previous block
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/net_tests.cpp b/libbitcoinkernel-sys/bitcoin/src/test/net_tests.cpp
index 711b067a..a2ff9a10 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/net_tests.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/net_tests.cpp
@@ -1301,7 +1301,7 @@ class V2TransportTester
     {
         // Construct contents consisting of 0x00 + 12-byte message type + payload.
         std::vector<uint8_t> contents(1 + CMessageHeader::MESSAGE_TYPE_SIZE + payload.size());
-        std::copy(mtype.begin(), mtype.end(), reinterpret_cast<char*>(contents.data() + 1));
+        std::copy(mtype.begin(), mtype.end(), contents.begin() + 1);
         std::copy(payload.begin(), payload.end(), contents.begin() + 1 + CMessageHeader::MESSAGE_TYPE_SIZE);
         // Send a packet with that as contents.
         SendPacket(contents);
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/script_p2sh_tests.cpp b/libbitcoinkernel-sys/bitcoin/src/test/script_p2sh_tests.cpp
index b4641118..aca07f8b 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/script_p2sh_tests.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/script_p2sh_tests.cpp
@@ -362,13 +362,14 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
 
     BOOST_CHECK(::AreInputsStandard(CTransaction(txTo), coins));
     // 22 P2SH sigops for all inputs (1 for vin[0], 6 for vin[3], 15 for vin[4]
-    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txTo), coins), 22U);
+    auto coinsTxTo{coins.AccessCoins(CTransaction(txTo))};
+    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txTo), std::span{coinsTxTo}), 22U);
 
     CMutableTransaction coinbase_tx_mut;
     coinbase_tx_mut.vin.resize(1);
     CTransaction coinbase_tx{coinbase_tx_mut};
     BOOST_CHECK(coinbase_tx.IsCoinBase());
-    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(coinbase_tx, coins), 0U);
+    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(coinbase_tx, std::span<const Coin>{}), 0U);
 
     CMutableTransaction txToNonStd1;
     txToNonStd1.vout.resize(1);
@@ -380,7 +381,8 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
     txToNonStd1.vin[0].scriptSig << std::vector<unsigned char>(sixteenSigops.begin(), sixteenSigops.end());
 
     BOOST_CHECK(!::AreInputsStandard(CTransaction(txToNonStd1), coins));
-    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd1), coins), 16U);
+    auto coinsTxToNonStd1{coins.AccessCoins(CTransaction(txToNonStd1))};
+    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd1), std::span{coinsTxToNonStd1}), 16U);
 
     CMutableTransaction txToNonStd2;
     txToNonStd2.vout.resize(1);
@@ -392,7 +394,8 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
     txToNonStd2.vin[0].scriptSig << std::vector<unsigned char>(twentySigops.begin(), twentySigops.end());
 
     BOOST_CHECK(!::AreInputsStandard(CTransaction(txToNonStd2), coins));
-    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd2), coins), 20U);
+    auto coinsTxToNonStd2{coins.AccessCoins(CTransaction(txToNonStd2))};
+    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd2), std::span{coinsTxToNonStd2}), 20U);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/sigopcount_tests.cpp b/libbitcoinkernel-sys/bitcoin/src/test/sigopcount_tests.cpp
index 41a4304f..21113ae8 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/sigopcount_tests.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/sigopcount_tests.cpp
@@ -131,13 +131,15 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
         CScript scriptSig = CScript() << OP_0 << OP_0;
 
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, CScriptWitness());
+        auto spending_coins{coins.AccessCoins(CTransaction(spendingTx))};
         // Legacy counting only includes signature operations in scriptSigs and scriptPubKeys
         // of a transaction and does not take the actual executed sig operations into account.
         // spendingTx in itself does not contain a signature operation.
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 0);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), std::span{spending_coins}, flags) == 0);
         // creationTx contains two signature operations in its scriptPubKey, but legacy counting
         // is not accurate.
-        assert(GetTransactionSigOpCost(CTransaction(creationTx), coins, flags) == MAX_PUBKEYS_PER_MULTISIG * WITNESS_SCALE_FACTOR);
+        auto creation_coins{coins.AccessCoins(CTransaction(creationTx))};
+        assert(GetTransactionSigOpCost(CTransaction(creationTx), std::span{creation_coins}, flags) == MAX_PUBKEYS_PER_MULTISIG * WITNESS_SCALE_FACTOR);
         // Sanity check: script verification fails because of an invalid signature.
         assert(VerifyWithFlag(CTransaction(creationTx), spendingTx, flags) == SCRIPT_ERR_CHECKMULTISIGVERIFY);
     }
@@ -149,11 +151,12 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
         CScript scriptSig = CScript() << OP_0 << OP_0 << ToByteVector(redeemScript);
 
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, CScriptWitness());
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 2 * WITNESS_SCALE_FACTOR);
+        auto spending_coins{coins.AccessCoins(CTransaction(spendingTx))};
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), std::span{spending_coins}, flags) == 2 * WITNESS_SCALE_FACTOR);
         assert(VerifyWithFlag(CTransaction(creationTx), spendingTx, flags) == SCRIPT_ERR_CHECKMULTISIGVERIFY);
 
         // P2SH sigops are not counted if we don't set the SCRIPT_VERIFY_P2SH flag
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, /*flags=*/0) == 0);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), std::span{spending_coins}, /*flags=*/0) == 0);
     }
 
     // P2WPKH witness program
@@ -166,22 +169,25 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
 
 
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 1);
+        auto spending_coins{coins.AccessCoins(CTransaction(spendingTx))};
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), std::span{spending_coins}, flags) == 1);
         // No signature operations if we don't verify the witness.
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags & ~SCRIPT_VERIFY_WITNESS) == 0);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), std::span{spending_coins}, flags & ~SCRIPT_VERIFY_WITNESS) == 0);
         assert(VerifyWithFlag(CTransaction(creationTx), spendingTx, flags) == SCRIPT_ERR_EQUALVERIFY);
 
         // The sig op cost for witness version != 0 is zero.
         assert(scriptPubKey[0] == 0x00);
         scriptPubKey[0] = 0x51;
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 0);
+        spending_coins = coins.AccessCoins(CTransaction(spendingTx));
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), std::span{spending_coins}, flags) == 0);
         scriptPubKey[0] = 0x00;
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
 
         // The witness of a coinbase transaction is not taken into account.
         spendingTx.vin[0].prevout.SetNull();
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 0);
+        spending_coins = coins.AccessCoins(CTransaction(spendingTx));
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), std::span{spending_coins}, flags) == 0);
     }
 
     // P2WPKH nested in P2SH
@@ -194,7 +200,8 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
         scriptWitness.stack.emplace_back(0);
 
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 1);
+        auto spending_coins{coins.AccessCoins(CTransaction(spendingTx))};
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), std::span{spending_coins}, flags) == 1);
         assert(VerifyWithFlag(CTransaction(creationTx), spendingTx, flags) == SCRIPT_ERR_EQUALVERIFY);
     }
 
@@ -209,8 +216,9 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
         scriptWitness.stack.emplace_back(witnessScript.begin(), witnessScript.end());
 
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 2);
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags & ~SCRIPT_VERIFY_WITNESS) == 0);
+        auto spending_coins{coins.AccessCoins(CTransaction(spendingTx))};
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), std::span{spending_coins}, flags) == 2);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), std::span{spending_coins}, flags & ~SCRIPT_VERIFY_WITNESS) == 0);
         assert(VerifyWithFlag(CTransaction(creationTx), spendingTx, flags) == SCRIPT_ERR_CHECKMULTISIGVERIFY);
     }
 
@@ -226,7 +234,8 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
         scriptWitness.stack.emplace_back(witnessScript.begin(), witnessScript.end());
 
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 2);
+        auto spending_coins{coins.AccessCoins(CTransaction(spendingTx))};
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), std::span{spending_coins}, flags) == 2);
         assert(VerifyWithFlag(CTransaction(creationTx), spendingTx, flags) == SCRIPT_ERR_CHECKMULTISIGVERIFY);
     }
 }
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/transaction_tests.cpp b/libbitcoinkernel-sys/bitcoin/src/test/transaction_tests.cpp
index 0ab9fbb4..91e00267 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/transaction_tests.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/transaction_tests.cpp
@@ -1051,7 +1051,8 @@ BOOST_AUTO_TEST_CASE(max_standard_legacy_sigops)
     AddCoins(coins, CTransaction(tx_create), 0, false);
 
     // 2490 sigops is below the limit.
-    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(tx_max_sigops), coins), 2490);
+    auto coins_tx_max_sigops{coins.AccessCoins(CTransaction(tx_max_sigops))};
+    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(tx_max_sigops), std::span{coins_tx_max_sigops}), 2490);
     BOOST_CHECK(::AreInputsStandard(CTransaction(tx_max_sigops), coins));
 
     // Adding one more input will bump this to 2505, hitting the limit.
@@ -1062,8 +1063,9 @@ BOOST_AUTO_TEST_CASE(max_standard_legacy_sigops)
     }
     tx_max_sigops.vin.emplace_back(prev_txid, p2sh_inputs_count, CScript() << ToByteVector(max_sigops_redeem_script));
     AddCoins(coins, CTransaction(tx_create), 0, false);
+    coins_tx_max_sigops = coins.AccessCoins(CTransaction(tx_max_sigops));
     BOOST_CHECK_GT((p2sh_inputs_count + 1) * MAX_P2SH_SIGOPS, MAX_TX_LEGACY_SIGOPS);
-    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(tx_max_sigops), coins), 2505);
+    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(tx_max_sigops), std::span{coins_tx_max_sigops}), 2505);
     BOOST_CHECK(!::AreInputsStandard(CTransaction(tx_max_sigops), coins));
 
     // Now, check the limit can be reached with regular P2PK outputs too. Use a separate
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/txvalidationcache_tests.cpp b/libbitcoinkernel-sys/bitcoin/src/test/txvalidationcache_tests.cpp
index 46cb8482..a147f608 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/txvalidationcache_tests.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/txvalidationcache_tests.cpp
@@ -21,7 +21,7 @@ struct Dersig100Setup : public TestChain100Setup {
 };
 
 bool CheckInputScripts(const CTransaction& tx, TxValidationState& state,
-                       const CCoinsViewCache& inputs, script_verify_flags flags, bool cacheSigStore,
+                       std::vector<CTxOut>&& spent_outputs, script_verify_flags flags, bool cacheSigStore,
                        bool cacheFullScriptStore, PrecomputedTransactionData& txdata,
                        ValidationCache& validation_cache,
                        std::vector<CScriptCheck>* pvChecks) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
@@ -124,6 +124,9 @@ static void ValidateCheckInputsForAllFlags(const CTransaction &tx, script_verify
 {
     PrecomputedTransactionData txdata;
 
+    std::vector<CTxOut> spent_outputs{active_coins_tip.GetUnspentOutputs(tx)};
+    txdata.Init(tx, std::move(spent_outputs));
+
     FastRandomContext insecure_rand(true);
 
     for (int count = 0; count < 10000; ++count) {
@@ -142,7 +145,7 @@ static void ValidateCheckInputsForAllFlags(const CTransaction &tx, script_verify
             // WITNESS requires P2SH
             test_flags |= SCRIPT_VERIFY_P2SH;
         }
-        bool ret = CheckInputScripts(tx, state, &active_coins_tip, test_flags, true, add_to_cache, txdata, validation_cache, nullptr);
+        bool ret = CheckInputScripts(tx, state, {}, test_flags, true, add_to_cache, txdata, validation_cache, nullptr);
         // CheckInputScripts should succeed iff test_flags doesn't intersect with
         // failing_flags
         bool expected_return_value = !(test_flags & failing_flags);
@@ -152,13 +155,13 @@ static void ValidateCheckInputsForAllFlags(const CTransaction &tx, script_verify
         if (ret && add_to_cache) {
             // Check that we get a cache hit if the tx was valid
             std::vector<CScriptCheck> scriptchecks;
-            BOOST_CHECK(CheckInputScripts(tx, state, &active_coins_tip, test_flags, true, add_to_cache, txdata, validation_cache, &scriptchecks));
+            BOOST_CHECK(CheckInputScripts(tx, state, {}, test_flags, true, add_to_cache, txdata, validation_cache, &scriptchecks));
             BOOST_CHECK(scriptchecks.empty());
         } else {
             // Check that we get script executions to check, if the transaction
             // was invalid, or we didn't add to cache.
             std::vector<CScriptCheck> scriptchecks;
-            BOOST_CHECK(CheckInputScripts(tx, state, &active_coins_tip, test_flags, true, add_to_cache, txdata, validation_cache, &scriptchecks));
+            BOOST_CHECK(CheckInputScripts(tx, state, {}, test_flags, true, add_to_cache, txdata, validation_cache, &scriptchecks));
             BOOST_CHECK_EQUAL(scriptchecks.size(), tx.vin.size());
         }
     }
@@ -216,13 +219,16 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, Dersig100Setup)
         TxValidationState state;
         PrecomputedTransactionData ptd_spend_tx;
 
-        BOOST_CHECK(!CheckInputScripts(CTransaction(spend_tx), state, &m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, m_node.chainman->m_validation_cache, nullptr));
+        std::vector<CTxOut> spent_outputs{m_node.chainman->ActiveChainstate().CoinsTip().GetUnspentOutputs(CTransaction(spend_tx))};
+        ptd_spend_tx.Init(spend_tx, std::move(spent_outputs));
+
+        BOOST_CHECK(!CheckInputScripts(CTransaction(spend_tx), state, {}, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, m_node.chainman->m_validation_cache, nullptr));
 
         // If we call again asking for scriptchecks (as happens in
         // ConnectBlock), we should add a script check object for this -- we're
         // not caching invalidity (if that changes, delete this test case).
         std::vector<CScriptCheck> scriptchecks;
-        BOOST_CHECK(CheckInputScripts(CTransaction(spend_tx), state, &m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, m_node.chainman->m_validation_cache, &scriptchecks));
+        BOOST_CHECK(CheckInputScripts(CTransaction(spend_tx), state, {}, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, m_node.chainman->m_validation_cache, &scriptchecks));
         BOOST_CHECK_EQUAL(scriptchecks.size(), 1U);
 
         // Test that CheckInputScripts returns true iff DERSIG-enforcing flags are
@@ -284,7 +290,10 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, Dersig100Setup)
         invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
         TxValidationState state;
         PrecomputedTransactionData txdata;
-        BOOST_CHECK(CheckInputScripts(CTransaction(invalid_with_cltv_tx), state, m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, true, true, txdata, m_node.chainman->m_validation_cache, nullptr));
+        std::vector<CTxOut> spent_outputs{m_node.chainman->ActiveChainstate().CoinsTip().GetUnspentOutputs(CTransaction(invalid_with_cltv_tx))};
+        txdata.Init(invalid_with_cltv_tx, std::move(spent_outputs));
+
+        BOOST_CHECK(CheckInputScripts(CTransaction(invalid_with_cltv_tx), state, {}, SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, true, true, txdata, m_node.chainman->m_validation_cache, nullptr));
     }
 
     // TEST CHECKSEQUENCEVERIFY
@@ -312,7 +321,10 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, Dersig100Setup)
         invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
         TxValidationState state;
         PrecomputedTransactionData txdata;
-        BOOST_CHECK(CheckInputScripts(CTransaction(invalid_with_csv_tx), state, &m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_CHECKSEQUENCEVERIFY, true, true, txdata, m_node.chainman->m_validation_cache, nullptr));
+        std::vector<CTxOut> spent_outputs{m_node.chainman->ActiveChainstate().CoinsTip().GetUnspentOutputs(CTransaction(invalid_with_csv_tx))};
+        txdata.Init(invalid_with_csv_tx, std::move(spent_outputs));
+
+        BOOST_CHECK(CheckInputScripts(CTransaction(invalid_with_csv_tx), state, {}, SCRIPT_VERIFY_CHECKSEQUENCEVERIFY, true, true, txdata, m_node.chainman->m_validation_cache, nullptr));
     }
 
     // TODO: add tests for remaining script flags
@@ -373,13 +385,16 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, Dersig100Setup)
 
         TxValidationState state;
         PrecomputedTransactionData txdata;
+        std::vector<CTxOut> spent_outputs{m_node.chainman->ActiveChainstate().CoinsTip().GetUnspentOutputs(CTransaction(tx))};
+        txdata.Init(tx, std::move(spent_outputs));
+
         // This transaction is now invalid under segwit, because of the second input.
-        BOOST_CHECK(!CheckInputScripts(CTransaction(tx), state, &m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true, true, txdata, m_node.chainman->m_validation_cache, nullptr));
+        BOOST_CHECK(!CheckInputScripts(CTransaction(tx), state, {}, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true, true, txdata, m_node.chainman->m_validation_cache, nullptr));
 
         std::vector<CScriptCheck> scriptchecks;
         // Make sure this transaction was not cached (ie because the first
         // input was valid)
-        BOOST_CHECK(CheckInputScripts(CTransaction(tx), state, &m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true, true, txdata, m_node.chainman->m_validation_cache, &scriptchecks));
+        BOOST_CHECK(CheckInputScripts(CTransaction(tx), state, {}, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true, true, txdata, m_node.chainman->m_validation_cache, &scriptchecks));
         // Should get 2 script checks back -- caching is on a whole-transaction basis.
         BOOST_CHECK_EQUAL(scriptchecks.size(), 2U);
     }
diff --git a/libbitcoinkernel-sys/bitcoin/src/txmempool.cpp b/libbitcoinkernel-sys/bitcoin/src/txmempool.cpp
index cae16a67..9afb66fc 100644
--- a/libbitcoinkernel-sys/bitcoin/src/txmempool.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/txmempool.cpp
@@ -777,7 +777,9 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
         TxValidationState dummy_state; // Not used. CheckTxInputs() should always pass
         CAmount txfee = 0;
         assert(!tx.IsCoinBase());
-        assert(Consensus::CheckTxInputs(tx, dummy_state, mempoolDuplicate, spendheight, txfee));
+        assert(mempoolDuplicate.HaveInputs(tx));
+        auto coins{mempoolDuplicate.AccessCoins(tx)};
+        assert(Consensus::CheckTxInputs(tx, dummy_state, std::span{coins}, spendheight, txfee));
         for (const auto& input: tx.vin) mempoolDuplicate.SpendCoin(input.prevout);
         AddCoins(mempoolDuplicate, tx, std::numeric_limits<int>::max());
     }
diff --git a/libbitcoinkernel-sys/bitcoin/src/univalue/include/univalue_escapes.h b/libbitcoinkernel-sys/bitcoin/src/univalue/include/univalue_escapes.h
index c486aeeb..7f4d89b0 100644
--- a/libbitcoinkernel-sys/bitcoin/src/univalue/include/univalue_escapes.h
+++ b/libbitcoinkernel-sys/bitcoin/src/univalue/include/univalue_escapes.h
@@ -6,261 +6,261 @@
 #ifndef BITCOIN_UNIVALUE_INCLUDE_UNIVALUE_ESCAPES_H
 #define BITCOIN_UNIVALUE_INCLUDE_UNIVALUE_ESCAPES_H
 static const char *escapes[256] = {
-	"\\u0000",
-	"\\u0001",
-	"\\u0002",
-	"\\u0003",
-	"\\u0004",
-	"\\u0005",
-	"\\u0006",
-	"\\u0007",
-	"\\b",
-	"\\t",
-	"\\n",
-	"\\u000b",
-	"\\f",
-	"\\r",
-	"\\u000e",
-	"\\u000f",
-	"\\u0010",
-	"\\u0011",
-	"\\u0012",
-	"\\u0013",
-	"\\u0014",
-	"\\u0015",
-	"\\u0016",
-	"\\u0017",
-	"\\u0018",
-	"\\u0019",
-	"\\u001a",
-	"\\u001b",
-	"\\u001c",
-	"\\u001d",
-	"\\u001e",
-	"\\u001f",
-	nullptr,
-	nullptr,
-	"\\\"",
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	"\\\\",
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	"\\u007f",
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
+    "\\u0000",
+    "\\u0001",
+    "\\u0002",
+    "\\u0003",
+    "\\u0004",
+    "\\u0005",
+    "\\u0006",
+    "\\u0007",
+    "\\b",
+    "\\t",
+    "\\n",
+    "\\u000b",
+    "\\f",
+    "\\r",
+    "\\u000e",
+    "\\u000f",
+    "\\u0010",
+    "\\u0011",
+    "\\u0012",
+    "\\u0013",
+    "\\u0014",
+    "\\u0015",
+    "\\u0016",
+    "\\u0017",
+    "\\u0018",
+    "\\u0019",
+    "\\u001a",
+    "\\u001b",
+    "\\u001c",
+    "\\u001d",
+    "\\u001e",
+    "\\u001f",
+    nullptr,
+    nullptr,
+    "\\\"",
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    "\\\\",
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    "\\u007f",
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
 };
 #endif // BITCOIN_UNIVALUE_INCLUDE_UNIVALUE_ESCAPES_H
diff --git a/libbitcoinkernel-sys/bitcoin/src/util/fs.h b/libbitcoinkernel-sys/bitcoin/src/util/fs.h
index 8b5c0460..147904d0 100644
--- a/libbitcoinkernel-sys/bitcoin/src/util/fs.h
+++ b/libbitcoinkernel-sys/bitcoin/src/util/fs.h
@@ -185,29 +185,6 @@ static inline path PathFromString(const std::string& string)
     return std::filesystem::path(string);
 #endif
 }
-
-/**
- * Create directory (and if necessary its parents), unless the leaf directory
- * already exists or is a symlink to an existing directory.
- * This is a temporary workaround for an issue in libstdc++ that has been fixed
- * upstream [PR101510].
- * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101510
- */
-static inline bool create_directories(const std::filesystem::path& p)
-{
-    if (std::filesystem::is_symlink(p) && std::filesystem::is_directory(p)) {
-        return false;
-    }
-    return std::filesystem::create_directories(p);
-}
-
-/**
- * This variant is not used. Delete it to prevent it from accidentally working
- * around the workaround. If it is needed, add a workaround in the same pattern
- * as above.
- */
-bool create_directories(const std::filesystem::path& p, std::error_code& ec) = delete;
-
 } // namespace fs
 
 /** Bridge operations to C stdio */
diff --git a/libbitcoinkernel-sys/bitcoin/src/util/subprocess.h b/libbitcoinkernel-sys/bitcoin/src/util/subprocess.h
index 9abca911..e90c1652 100644
--- a/libbitcoinkernel-sys/bitcoin/src/util/subprocess.h
+++ b/libbitcoinkernel-sys/bitcoin/src/util/subprocess.h
@@ -1146,7 +1146,7 @@ inline void Popen::execute_process() noexcept(false)
                             NULL,         // process security attributes
                             NULL,         // primary thread security attributes
                             TRUE,         // handles are inherited
-                            creation_flags,	// creation flags
+                            creation_flags, // creation flags
                             NULL,         // use parent's environment
                             NULL,         // use parent's current directory
                             &siStartInfo, // STARTUPINFOW pointer
diff --git a/libbitcoinkernel-sys/bitcoin/src/validation.cpp b/libbitcoinkernel-sys/bitcoin/src/validation.cpp
index e4196e1c..80864ebc 100644
--- a/libbitcoinkernel-sys/bitcoin/src/validation.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/validation.cpp
@@ -139,11 +139,11 @@ const CBlockIndex* Chainstate::FindForkInGlobalIndex(const CBlockLocator& locato
 }
 
 bool CheckInputScripts(const CTransaction& tx, TxValidationState& state,
-                       const CCoinsViewCache& inputs, script_verify_flags flags, bool cacheSigStore,
+                       std::vector<CTxOut>&& spent_outputs, script_verify_flags flags, bool cacheSigStore,
                        bool cacheFullScriptStore, PrecomputedTransactionData& txdata,
                        ValidationCache& validation_cache,
                        std::vector<CScriptCheck>* pvChecks = nullptr)
-                       EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
 bool CheckFinalTxAtTip(const CBlockIndex& active_chain_tip, const CTransaction& tx)
 {
@@ -427,8 +427,10 @@ static bool CheckInputsFromMempoolAndCache(const CTransaction& tx, TxValidationS
         }
     }
 
+    std::vector<CTxOut> spent_outputs{view.GetUnspentOutputs(tx)};
+
     // Call CheckInputScripts() to cache signature and script validity against current tip consensus rules.
-    return CheckInputScripts(tx, state, view, flags, /* cacheSigStore= */ true, /* cacheFullScriptStore= */ true, txdata, validation_cache);
+    return CheckInputScripts(tx, state, std::move(spent_outputs), flags, /* cacheSigStore= */ true, /* cacheFullScriptStore= */ true, txdata, validation_cache);
 }
 
 namespace {
@@ -889,8 +891,15 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
         return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "non-BIP68-final");
     }
 
+    // are the actual inputs available?
+    if (!m_view.HaveInputs(tx)) {
+        return state.Invalid(TxValidationResult::TX_MISSING_INPUTS, "bad-txns-inputs-missingorspent",
+                             strprintf("%s: inputs missing/spent", __func__));
+    }
+
     // The mempool holds txs for the next block, so pass height+1 to CheckTxInputs
-    if (!Consensus::CheckTxInputs(tx, state, m_view, m_active_chainstate.m_chain.Height() + 1, ws.m_base_fees)) {
+    auto coins{m_view.AccessCoins(tx)};
+    if (!Consensus::CheckTxInputs(tx, state, std::span{coins}, m_active_chainstate.m_chain.Height() + 1, ws.m_base_fees)) {
         return false; // state filled in by CheckTxInputs
     }
 
@@ -903,7 +912,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
         return state.Invalid(TxValidationResult::TX_WITNESS_MUTATED, "bad-witness-nonstandard");
     }
 
-    int64_t nSigOpsCost = GetTransactionSigOpCost(tx, m_view, STANDARD_SCRIPT_VERIFY_FLAGS);
+    int64_t nSigOpsCost = GetTransactionSigOpCost(tx, std::span{coins}, STANDARD_SCRIPT_VERIFY_FLAGS);
 
     // Keep track of transactions that spend a coinbase, which we re-scan
     // during reorgs to ensure COINBASE_MATURITY is still met.
@@ -1250,9 +1259,11 @@ bool MemPoolAccept::PolicyScriptChecks(const ATMPArgs& args, Workspace& ws)
 
     constexpr script_verify_flags scriptVerifyFlags = STANDARD_SCRIPT_VERIFY_FLAGS;
 
+    std::vector<CTxOut> spent_outputs{m_view.GetUnspentOutputs(tx)};
+
     // Check input scripts and signatures.
     // This is done last to help prevent CPU exhaustion denial-of-service attacks.
-    if (!CheckInputScripts(tx, state, m_view, scriptVerifyFlags, true, false, ws.m_precomputed_txdata, GetValidationCache())) {
+    if (!CheckInputScripts(tx, state, std::move(spent_outputs), scriptVerifyFlags, true, false, ws.m_precomputed_txdata, GetValidationCache())) {
         // Detect a failure due to a missing witness so that p2p code can handle rejection caching appropriately.
         if (!tx.HasWitness() && SpendsNonAnchorWitnessProg(tx, m_view)) {
             state.Invalid(TxValidationResult::TX_WITNESS_STRIPPED,
@@ -2139,7 +2150,7 @@ ValidationCache::ValidationCache(const size_t script_execution_cache_bytes, cons
  * Non-static (and redeclared) in src/test/txvalidationcache_tests.cpp
  */
 bool CheckInputScripts(const CTransaction& tx, TxValidationState& state,
-                       const CCoinsViewCache& inputs, script_verify_flags flags, bool cacheSigStore,
+                       std::vector<CTxOut>&& spent_outputs, script_verify_flags flags, bool cacheSigStore,
                        bool cacheFullScriptStore, PrecomputedTransactionData& txdata,
                        ValidationCache& validation_cache,
                        std::vector<CScriptCheck>* pvChecks)
@@ -2164,15 +2175,6 @@ bool CheckInputScripts(const CTransaction& tx, TxValidationState& state,
     }
 
     if (!txdata.m_spent_outputs_ready) {
-        std::vector<CTxOut> spent_outputs;
-        spent_outputs.reserve(tx.vin.size());
-
-        for (const auto& txin : tx.vin) {
-            const COutPoint& prevout = txin.prevout;
-            const Coin& coin = inputs.AccessCoin(prevout);
-            assert(!coin.IsSpent());
-            spent_outputs.emplace_back(coin.out);
-        }
         txdata.Init(tx, std::move(spent_outputs));
     }
     assert(txdata.m_spent_outputs.size() == tx.vin.size());
@@ -2368,18 +2370,14 @@ script_verify_flags GetBlockScriptFlags(const CBlockIndex& block_index, const Ch
     return flags;
 }
 
-
-/** Apply the effects of this block (with given index) on the UTXO set represented by coins.
- *  Validity checks that depend on the UTXO set are also done; ConnectBlock()
- *  can fail if those validity checks fail (among other reasons). */
-bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state, CBlockIndex* pindex,
-                               CCoinsViewCache& view, bool fJustCheck)
+bool Chainstate::ConnectBlock(const CBlock& block, const CBlockUndo& blockundo, BlockValidationState& state,
+                              CBlockIndex* pindex, bool fJustCheck)
 {
     AssertLockHeld(cs_main);
     assert(pindex);
-
-    uint256 block_hash{block.GetHash()};
-    assert(*pindex->phashBlock == block_hash);
+    Assume(pindex->GetBlockHash() == block.GetHash());
+    auto block_hash{pindex->GetBlockHash()};
+    assert(block.vtx.size() == blockundo.vtxundo.size() + 1);  // blockundo does not contain a CTxUndo for the coinbase
 
     const auto time_start{SteadyClock::now()};
     const CChainParams& params{m_chainman.GetParams()};
@@ -2408,17 +2406,11 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
         return false;
     }
 
-    // verify that the view's current state corresponds to the previous block
-    uint256 hashPrevBlock = pindex->pprev == nullptr ? uint256() : pindex->pprev->GetBlockHash();
-    assert(hashPrevBlock == view.GetBestBlock());
-
     m_chainman.num_blocks_total++;
 
     // Special case for the genesis block, skipping connection of its transactions
     // (its coinbase is unspendable)
     if (block_hash == params.GetConsensus().hashGenesisBlock) {
-        if (!fJustCheck)
-            view.SetBestBlock(pindex->GetBlockHash());
         return true;
     }
 
@@ -2469,92 +2461,6 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
              Ticks<SecondsDouble>(m_chainman.time_check),
              Ticks<MillisecondsDouble>(m_chainman.time_check) / m_chainman.num_blocks_total);
 
-    // Do not allow blocks that contain transactions which 'overwrite' older transactions,
-    // unless those are already completely spent.
-    // If such overwrites are allowed, coinbases and transactions depending upon those
-    // can be duplicated to remove the ability to spend the first instance -- even after
-    // being sent to another address.
-    // See BIP30, CVE-2012-1909, and https://r6.ca/blog/20120206T005236Z.html for more information.
-    // This rule was originally applied to all blocks with a timestamp after March 15, 2012, 0:00 UTC.
-    // Now that the whole chain is irreversibly beyond that time it is applied to all blocks except the
-    // two in the chain that violate it. This prevents exploiting the issue against nodes during their
-    // initial block download.
-    bool fEnforceBIP30 = !IsBIP30Repeat(*pindex);
-
-    // Once BIP34 activated it was not possible to create new duplicate coinbases and thus other than starting
-    // with the 2 existing duplicate coinbase pairs, not possible to create overwriting txs.  But by the
-    // time BIP34 activated, in each of the existing pairs the duplicate coinbase had overwritten the first
-    // before the first had been spent.  Since those coinbases are sufficiently buried it's no longer possible to create further
-    // duplicate transactions descending from the known pairs either.
-    // If we're on the known chain at height greater than where BIP34 activated, we can save the db accesses needed for the BIP30 check.
-
-    // BIP34 requires that a block at height X (block X) has its coinbase
-    // scriptSig start with a CScriptNum of X (indicated height X).  The above
-    // logic of no longer requiring BIP30 once BIP34 activates is flawed in the
-    // case that there is a block X before the BIP34 height of 227,931 which has
-    // an indicated height Y where Y is greater than X.  The coinbase for block
-    // X would also be a valid coinbase for block Y, which could be a BIP30
-    // violation.  An exhaustive search of all mainnet coinbases before the
-    // BIP34 height which have an indicated height greater than the block height
-    // reveals many occurrences. The 3 lowest indicated heights found are
-    // 209,921, 490,897, and 1,983,702 and thus coinbases for blocks at these 3
-    // heights would be the first opportunity for BIP30 to be violated.
-
-    // The search reveals a great many blocks which have an indicated height
-    // greater than 1,983,702, so we simply remove the optimization to skip
-    // BIP30 checking for blocks at height 1,983,702 or higher.  Before we reach
-    // that block in another 25 years or so, we should take advantage of a
-    // future consensus change to do a new and improved version of BIP34 that
-    // will actually prevent ever creating any duplicate coinbases in the
-    // future.
-    static constexpr int BIP34_IMPLIES_BIP30_LIMIT = 1983702;
-
-    // There is no potential to create a duplicate coinbase at block 209,921
-    // because this is still before the BIP34 height and so explicit BIP30
-    // checking is still active.
-
-    // The final case is block 176,684 which has an indicated height of
-    // 490,897. Unfortunately, this issue was not discovered until about 2 weeks
-    // before block 490,897 so there was not much opportunity to address this
-    // case other than to carefully analyze it and determine it would not be a
-    // problem. Block 490,897 was, in fact, mined with a different coinbase than
-    // block 176,684, but it is important to note that even if it hadn't been or
-    // is remined on an alternate fork with a duplicate coinbase, we would still
-    // not run into a BIP30 violation.  This is because the coinbase for 176,684
-    // is spent in block 185,956 in transaction
-    // d4f7fbbf92f4a3014a230b2dc70b8058d02eb36ac06b4a0736d9d60eaa9e8781.  This
-    // spending transaction can't be duplicated because it also spends coinbase
-    // 0328dd85c331237f18e781d692c92de57649529bd5edf1d01036daea32ffde29.  This
-    // coinbase has an indicated height of over 4.2 billion, and wouldn't be
-    // duplicatable until that height, and it's currently impossible to create a
-    // chain that long. Nevertheless we may wish to consider a future soft fork
-    // which retroactively prevents block 490,897 from creating a duplicate
-    // coinbase. The two historical BIP30 violations often provide a confusing
-    // edge case when manipulating the UTXO and it would be simpler not to have
-    // another edge case to deal with.
-
-    // testnet3 has no blocks before the BIP34 height with indicated heights
-    // post BIP34 before approximately height 486,000,000. After block
-    // 1,983,702 testnet3 starts doing unnecessary BIP30 checking again.
-    assert(pindex->pprev);
-    CBlockIndex* pindexBIP34height = pindex->pprev->GetAncestor(params.GetConsensus().BIP34Height);
-    //Only continue to enforce if we're below BIP34 activation height or the block hash at that height doesn't correspond.
-    fEnforceBIP30 = fEnforceBIP30 && (!pindexBIP34height || !(pindexBIP34height->GetBlockHash() == params.GetConsensus().BIP34Hash));
-
-    // TODO: Remove BIP30 checking from block height 1,983,702 on, once we have a
-    // consensus change that ensures coinbases at those heights cannot
-    // duplicate earlier coinbases.
-    if (fEnforceBIP30 || pindex->nHeight >= BIP34_IMPLIES_BIP30_LIMIT) {
-        for (const auto& tx : block.vtx) {
-            for (size_t o = 0; o < tx->vout.size(); o++) {
-                if (view.HaveCoin(COutPoint(tx->GetHash(), o))) {
-                    state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-BIP30",
-                                  "tried to overwrite transaction");
-                }
-            }
-        }
-    }
-
     // Enforce BIP68 (sequence locks)
     int nLockTimeFlags = 0;
     if (DeploymentActiveAt(*pindex, m_chainman, Consensus::DEPLOYMENT_CSV)) {
@@ -2583,8 +2489,6 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
         m_last_script_check_reason_logged = script_check_reason;
     }
 
-    CBlockUndo blockundo;
-
     // Precomputed transaction data pointers must not be invalidated
     // until after `control` has run the script checks (potentially
     // in multiple threads). Preallocate the vector size so a new allocation
@@ -2599,19 +2503,19 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
     CAmount nFees = 0;
     int nInputs = 0;
     int64_t nSigOpsCost = 0;
-    blockundo.vtxundo.reserve(block.vtx.size() - 1);
     for (unsigned int i = 0; i < block.vtx.size(); i++)
     {
         if (!state.IsValid()) break;
         const CTransaction &tx = *(block.vtx[i]);
-
         nInputs += tx.vin.size();
 
         if (!tx.IsCoinBase())
         {
+            auto spent_coins = std::span<const Coin>{blockundo.vtxundo[i - 1].vprevout};
             CAmount txfee = 0;
             TxValidationState tx_state;
-            if (!Consensus::CheckTxInputs(tx, tx_state, view, pindex->nHeight, txfee)) {
+
+            if (!Consensus::CheckTxInputs(tx, tx_state, spent_coins, pindex->nHeight, txfee)) {
                 // Any transaction validation failure in ConnectBlock is a block consensus failure
                 state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                               tx_state.GetRejectReason(),
@@ -2630,7 +2534,7 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
             // be in ConnectBlock because they require the UTXO set
             prevheights.resize(tx.vin.size());
             for (size_t j = 0; j < tx.vin.size(); j++) {
-                prevheights[j] = view.AccessCoin(tx.vin[j].prevout).nHeight;
+                prevheights[j] = spent_coins[j].nHeight;
             }
 
             if (!SequenceLocks(tx, nLockTimeFlags, prevheights, *pindex)) {
@@ -2644,7 +2548,11 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
         // * legacy (always)
         // * p2sh (when P2SH enabled in flags and excludes coinbase)
         // * witness (when witness enabled in flags and excludes coinbase)
-        nSigOpsCost += GetTransactionSigOpCost(tx, view, flags);
+        if (!tx.IsCoinBase()) {
+            nSigOpsCost += GetTransactionSigOpCost(tx, std::span<const Coin>{blockundo.vtxundo[i - 1].vprevout}, flags);
+        } else {
+            nSigOpsCost += GetTransactionSigOpCost(tx, std::span<const Coin>{}, flags);
+        }
         if (nSigOpsCost > MAX_BLOCK_SIGOPS_COST) {
             state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-sigops", "too many sigops");
             break;
@@ -2655,14 +2563,23 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
             bool fCacheResults = fJustCheck; /* Don't cache results if we're actually connecting blocks (still consult the cache, though) */
             bool tx_ok;
             TxValidationState tx_state;
+            const std::vector<Coin>& spent_coins = blockundo.vtxundo[i - 1].vprevout;
+            std::vector<CTxOut> spent_outputs;
+            spent_outputs.reserve(tx.vin.size());
+            std::transform(spent_coins.begin(), spent_coins.end(),
+                           std::back_inserter(spent_outputs),
+                           [](const Coin& coin) -> CTxOut {
+                               return coin.out; // Assuming Coin has a CTxOut member named 'out'
+                           });
+
             // If CheckInputScripts is called with a pointer to a checks vector, the resulting checks are appended to it. In that case
             // they need to be added to control which runs them asynchronously. Otherwise, CheckInputScripts runs the checks before returning.
             if (control) {
                 std::vector<CScriptCheck> vChecks;
-                tx_ok = CheckInputScripts(tx, tx_state, view, flags, fCacheResults, fCacheResults, txsdata[i], m_chainman.m_validation_cache, &vChecks);
+                tx_ok = CheckInputScripts(tx, tx_state, std::move(spent_outputs), flags, fCacheResults, fCacheResults, txsdata[i], m_chainman.m_validation_cache, &vChecks);
                 if (tx_ok) control->Add(std::move(vChecks));
             } else {
-                tx_ok = CheckInputScripts(tx, tx_state, view, flags, fCacheResults, fCacheResults, txsdata[i], m_chainman.m_validation_cache);
+                tx_ok = CheckInputScripts(tx, tx_state, std::move(spent_outputs), flags, fCacheResults, fCacheResults, txsdata[i], m_chainman.m_validation_cache);
             }
             if (!tx_ok) {
                 // Any transaction validation failure in ConnectBlock is a block consensus failure
@@ -2671,12 +2588,6 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
                 break;
             }
         }
-
-        CTxUndo undoDummy;
-        if (i > 0) {
-            blockundo.vtxundo.emplace_back();
-        }
-        UpdateCoins(tx, view, i == 0 ? undoDummy : blockundo.vtxundo.back(), pindex->nHeight);
     }
     const auto time_3{SteadyClock::now()};
     m_chainman.time_connect += time_3 - time_2;
@@ -2729,9 +2640,6 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
         m_blockman.m_dirty_blockindex.insert(pindex);
     }
 
-    // add this block to the view's block chain
-    view.SetBestBlock(pindex->GetBlockHash());
-
     const auto time_6{SteadyClock::now()};
     m_chainman.time_index += time_6 - time_5;
     LogDebug(BCLog::BENCH, "    - Index writing: %.2fms [%.2fs (%.2fms/blk)]\n",
@@ -2963,6 +2871,153 @@ static void UpdateTipLog(
                    !warning_messages.empty() ? strprintf(" warning='%s'", warning_messages) : "");
 }
 
+bool Chainstate::SpendBlock(
+    const CBlock& block,
+    const CBlockIndex* pindex,
+    CCoinsViewCache& view,
+    BlockValidationState& state,
+    CBlockUndo& blockundo)
+{
+    AssertLockHeld(cs_main);
+    assert(pindex);
+    Assume(pindex->GetBlockHash() == block.GetHash());
+    auto block_hash{pindex->GetBlockHash()};
+
+    const CChainParams& params{m_chainman.GetParams()};
+    // Special case for the genesis block, skipping connection of its transactions
+    // (its coinbase is unspendable)
+    if (block_hash == params.GetConsensus().hashGenesisBlock) {
+        return true;
+    }
+
+    // verify that the view's current state corresponds to the previous block
+    uint256 hashPrevBlock = pindex->pprev == nullptr ? uint256() : pindex->pprev->GetBlockHash();
+    assert(hashPrevBlock == view.GetBestBlock());
+
+    const auto time_start{SteadyClock::now()};
+
+    // Do not allow blocks that contain transactions which 'overwrite' older transactions,
+    // unless those are already completely spent.
+    // If such overwrites are allowed, coinbases and transactions depending upon those
+    // can be duplicated to remove the ability to spend the first instance -- even after
+    // being sent to another address.
+    // See BIP30, CVE-2012-1909, and https://r6.ca/blog/20120206T005236Z.html for more information.
+    // This rule was originally applied to all blocks with a timestamp after March 15, 2012, 0:00 UTC.
+    // Now that the whole chain is irreversibly beyond that time it is applied to all blocks except the
+    // two in the chain that violate it. This prevents exploiting the issue against nodes during their
+    // initial block download.
+    bool fEnforceBIP30 = !IsBIP30Repeat(*pindex);
+
+    // Once BIP34 activated it was not possible to create new duplicate coinbases and thus other than starting
+    // with the 2 existing duplicate coinbase pairs, not possible to create overwriting txs.  But by the
+    // time BIP34 activated, in each of the existing pairs the duplicate coinbase had overwritten the first
+    // before the first had been spent.  Since those coinbases are sufficiently buried it's no longer possible to create further
+    // duplicate transactions descending from the known pairs either.
+    // If we're on the known chain at height greater than where BIP34 activated, we can save the db accesses needed for the BIP30 check.
+
+    // BIP34 requires that a block at height X (block X) has its coinbase
+    // scriptSig start with a CScriptNum of X (indicated height X).  The above
+    // logic of no longer requiring BIP30 once BIP34 activates is flawed in the
+    // case that there is a block X before the BIP34 height of 227,931 which has
+    // an indicated height Y where Y is greater than X.  The coinbase for block
+    // X would also be a valid coinbase for block Y, which could be a BIP30
+    // violation.  An exhaustive search of all mainnet coinbases before the
+    // BIP34 height which have an indicated height greater than the block height
+    // reveals many occurrences. The 3 lowest indicated heights found are
+    // 209,921, 490,897, and 1,983,702 and thus coinbases for blocks at these 3
+    // heights would be the first opportunity for BIP30 to be violated.
+
+    // The search reveals a great many blocks which have an indicated height
+    // greater than 1,983,702, so we simply remove the optimization to skip
+    // BIP30 checking for blocks at height 1,983,702 or higher.  Before we reach
+    // that block in another 25 years or so, we should take advantage of a
+    // future consensus change to do a new and improved version of BIP34 that
+    // will actually prevent ever creating any duplicate coinbases in the
+    // future.
+    static constexpr int BIP34_IMPLIES_BIP30_LIMIT = 1983702;
+
+    // There is no potential to create a duplicate coinbase at block 209,921
+    // because this is still before the BIP34 height and so explicit BIP30
+    // checking is still active.
+
+    // The final case is block 176,684 which has an indicated height of
+    // 490,897. Unfortunately, this issue was not discovered until about 2 weeks
+    // before block 490,897 so there was not much opportunity to address this
+    // case other than to carefully analyze it and determine it would not be a
+    // problem. Block 490,897 was, in fact, mined with a different coinbase than
+    // block 176,684, but it is important to note that even if it hadn't been or
+    // is remined on an alternate fork with a duplicate coinbase, we would still
+    // not run into a BIP30 violation.  This is because the coinbase for 176,684
+    // is spent in block 185,956 in transaction
+    // d4f7fbbf92f4a3014a230b2dc70b8058d02eb36ac06b4a0736d9d60eaa9e8781.  This
+    // spending transaction can't be duplicated because it also spends coinbase
+    // 0328dd85c331237f18e781d692c92de57649529bd5edf1d01036daea32ffde29.  This
+    // coinbase has an indicated height of over 4.2 billion, and wouldn't be
+    // duplicatable until that height, and it's currently impossible to create a
+    // chain that long. Nevertheless we may wish to consider a future soft fork
+    // which retroactively prevents block 490,897 from creating a duplicate
+    // coinbase. The two historical BIP30 violations often provide a confusing
+    // edge case when manipulating the UTXO and it would be simpler not to have
+    // another edge case to deal with.
+
+    // testnet3 has no blocks before the BIP34 height with indicated heights
+    // post BIP34 before approximately height 486,000,000. After block
+    // 1,983,702 testnet3 starts doing unnecessary BIP30 checking again.
+    assert(pindex->pprev);
+    CBlockIndex* pindexBIP34height = pindex->pprev->GetAncestor(params.GetConsensus().BIP34Height);
+    //Only continue to enforce if we're below BIP34 activation height or the block hash at that height doesn't correspond.
+    fEnforceBIP30 = fEnforceBIP30 && (!pindexBIP34height || !(pindexBIP34height->GetBlockHash() == params.GetConsensus().BIP34Hash));
+
+    // TODO: Remove BIP30 checking from block height 1,983,702 on, once we have a
+    // consensus change that ensures coinbases at those heights cannot
+    // duplicate earlier coinbases.
+    if (fEnforceBIP30 || pindex->nHeight >= BIP34_IMPLIES_BIP30_LIMIT) {
+        for (const auto& tx : block.vtx) {
+            for (size_t o = 0; o < tx->vout.size(); o++) {
+                if (view.HaveCoin(COutPoint(tx->GetHash(), o))) {
+                    return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-BIP30",
+                                  "tried to overwrite transaction");
+                }
+            }
+        }
+    }
+
+    int nInputs = 0;
+
+    blockundo.vtxundo.reserve(block.vtx.size() - 1);
+    for (const CTransactionRef& tx : block.vtx) {
+        nInputs += tx->vin.size();
+        // are the actual inputs available?
+        if (!view.HaveInputs(*tx)) {
+            state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-inputs-missingorspent",
+                          strprintf("%s: inputs missing/spent in transaction %s", __func__, tx->GetHash().ToString()));
+            break;
+        }
+        if (!tx->IsCoinBase()) {
+            blockundo.vtxundo.emplace_back();
+        }
+        CTxUndo dummy;
+        UpdateCoins(*tx, view, tx->IsCoinBase() ? dummy : blockundo.vtxundo.back(), pindex->nHeight);
+    }
+
+    const auto time_1{SteadyClock::now()};
+    m_chainman.time_check += time_1 - time_start;
+    LogDebug(BCLog::BENCH, "      - Spend Block processed %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs (%.2fms/blk)]\n", (unsigned)block.vtx.size(),
+             Ticks<MillisecondsDouble>(time_1 - time_start),
+             block.vtx.size() == 0 ? 0 : Ticks<MillisecondsDouble>(time_1 - time_start) / block.vtx.size(),
+             nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_1 - time_start) / (nInputs - 1),
+             Ticks<SecondsDouble>(m_chainman.time_connect),
+             m_chainman.num_blocks_total == 0 ? 0 : Ticks<MillisecondsDouble>(m_chainman.time_connect) / m_chainman.num_blocks_total);
+
+    if (!state.IsValid()) {
+        LogInfo("Block validation error: %s", state.ToString());
+        return false;
+    }
+
+    assert(blockundo.vtxundo.size() == block.vtx.size() - 1);
+    return true;
+}
+
 void Chainstate::UpdateTip(const CBlockIndex* pindexNew)
 {
     AssertLockHeld(::cs_main);
@@ -3152,7 +3207,17 @@ bool Chainstate::ConnectTip(
              Ticks<MillisecondsDouble>(time_2 - time_1));
     {
         CCoinsViewCache view(&CoinsTip());
-        bool rv = ConnectBlock(*block_to_connect, state, pindexNew, view);
+        CBlockUndo blockundo;
+        if (!SpendBlock(*block_to_connect, pindexNew, view, state, blockundo)) {
+            assert(state.IsInvalid());
+            if (m_chainman.m_options.signals) {
+                m_chainman.m_options.signals->BlockChecked(block_to_connect, state);
+            }
+            InvalidBlockFound(pindexNew, state);
+            LogError("%s: SpendBlock %s failed, %s\n", __func__, pindexNew->GetBlockHash().ToString(), state.ToString());
+            return false;
+        }
+        bool rv = ConnectBlock(*block_to_connect, blockundo, state, pindexNew);
         if (m_chainman.m_options.signals) {
             m_chainman.m_options.signals->BlockChecked(block_to_connect, state);
         }
@@ -3162,6 +3227,8 @@ bool Chainstate::ConnectTip(
             LogError("%s: ConnectBlock %s failed, %s\n", __func__, pindexNew->GetBlockHash().ToString(), state.ToString());
             return false;
         }
+        // add this block to the view's block chain
+        view.SetBestBlock(pindexNew->GetBlockHash());
         time_3 = SteadyClock::now();
         m_chainman.time_connect_total += time_3 - time_2;
         assert(m_chainman.num_blocks_total > 0);
@@ -4569,6 +4636,31 @@ MempoolAcceptResult ChainstateManager::ProcessTransaction(const CTransactionRef&
     return result;
 }
 
+BlockValidationState ChainstateManager::ValidateBlock(
+    const CBlock& block,
+    CBlockUndo& block_undo)
+{
+    LOCK(cs_main);
+    BlockValidationState state;
+    CBlockIndex* index = m_blockman.LookupBlockIndex(block.GetHash());
+    assert(index);
+    if (!CheckBlock(block, state, GetConsensus(), /*fCheckPOW=*/true, /*fCheckMerkleRoot=*/true)) {
+        if (state.IsValid()) NONFATAL_UNREACHABLE();
+        return state;
+    }
+
+    if (!ContextualCheckBlock(block, state, *this, index->pprev)) {
+        if (state.IsValid()) NONFATAL_UNREACHABLE();
+        return state;
+    }
+
+    if (!ActiveChainstate().ConnectBlock(block, block_undo, state, index, /*fJustCheck=*/true)) {
+        if (state.IsValid()) NONFATAL_UNREACHABLE();
+        return state;
+    }
+
+    return state;
+}
 
 BlockValidationState TestBlockValidity(
     Chainstate& chainstate,
@@ -4631,8 +4723,15 @@ BlockValidationState TestBlockValidity(
     index_dummy.phashBlock = &block_hash;
     CCoinsViewCache view_dummy(&chainstate.CoinsTip());
 
+
+    CBlockUndo blockundo;
+    if (!chainstate.SpendBlock(block, &index_dummy, view_dummy, state, blockundo)) {
+        if (state.IsValid()) NONFATAL_UNREACHABLE();
+        return state;
+    }
+
     // Set fJustCheck to true in order to update, and not clear, validation caches.
-    if(!chainstate.ConnectBlock(block, state, &index_dummy, view_dummy, /*fJustCheck=*/true)) {
+    if (!chainstate.ConnectBlock(block, blockundo, state, &index_dummy, true)) {
         if (state.IsValid()) NONFATAL_UNREACHABLE();
         return state;
     }
@@ -4836,10 +4935,17 @@ VerifyDBResult CVerifyDB::VerifyDB(
                 LogPrintf("Verification error: ReadBlock failed at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
                 return VerifyDBResult::CORRUPTED_BLOCK_DB;
             }
-            if (!chainstate.ConnectBlock(block, state, pindex, coins)) {
+            CBlockUndo blockundo;
+            if (!chainstate.SpendBlock(block, pindex, coins, state, blockundo)) {
+                LogError("SpendBlock failed %s\n", state.ToString());
+                return VerifyDBResult::CORRUPTED_BLOCK_DB;
+            }
+
+            if (!chainstate.ConnectBlock(block, blockundo, state, pindex)) {
                 LogPrintf("Verification error: found unconnectable block at %d, hash=%s (%s)\n", pindex->nHeight, pindex->GetBlockHash().ToString(), state.ToString());
                 return VerifyDBResult::CORRUPTED_BLOCK_DB;
             }
+            coins.SetBestBlock(pindex->GetBlockHash());
             if (chainstate.m_chainman.m_interrupt) return VerifyDBResult::INTERRUPTED;
         }
     }
diff --git a/libbitcoinkernel-sys/bitcoin/src/validation.h b/libbitcoinkernel-sys/bitcoin/src/validation.h
index 291c1021..179b043e 100644
--- a/libbitcoinkernel-sys/bitcoin/src/validation.h
+++ b/libbitcoinkernel-sys/bitcoin/src/validation.h
@@ -735,8 +735,34 @@ class Chainstate
     // Block (dis)connection on a given view:
     DisconnectResult DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
-    bool ConnectBlock(const CBlock& block, BlockValidationState& state, CBlockIndex* pindex,
-                      CCoinsViewCache& view, bool fJustCheck = false) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+
+    /**
+     * Validates the block against the coins in the blockundo data, writes the
+     * undo data to disk, and raises the block validity in the block index.
+     *
+     * @param[in] block       The block to be validated
+     * @param[in] blockundo   Has to contain all coins spent by block. Written to disk on successful validation
+     * @param[out] state      This is set to an Error state if any error occurred while validating block
+     * @param[in, out] pindex Points to the block map entry associated with block. On successful validation, its nStatus block validity is raised.
+     * @param[in] fJustCheck  If set, no data is written to disk and pindex's validity is not raised
+     */
+    bool ConnectBlock(const CBlock& block, const CBlockUndo& blockundo, BlockValidationState& state,
+                      CBlockIndex* pindex, bool fJustCheck = false) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+
+    /**
+     * Spends the coins associated with a block. First checks that the block
+     * contains no duplicate transactions (BIP30), then for each transaction in
+     * the block checks that the outputs it is spending exist, spends them, and
+     * populates the CBlockUndo data structure.
+     *
+     * @param[in] block      The block to be spent
+     * @param[in] pindex     Points to the block map entry associated with block
+     * @param[in, out] view  Its coins are spent and used to populate CBlockUndo during its execution
+     * @param[out] state     This may be set to an Error state if any error occurred processing them
+     * @param[out] blockundo Coins consumed by the block are added to it.
+     */
+    bool SpendBlock(const CBlock& block, const CBlockIndex* pindex,
+                    CCoinsViewCache& view, BlockValidationState& state, CBlockUndo& blockundo) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     // Apply the effects of a block disconnection on the UTXO set.
     bool DisconnectTip(BlockValidationState& state, DisconnectedBlockTransactions* disconnectpool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool->cs);
@@ -1018,6 +1044,10 @@ class ChainstateManager
      */
     void CheckBlockIndex() const;
 
+    BlockValidationState ValidateBlock(
+        const CBlock& block,
+        CBlockUndo& block_undo);
+
     /**
      * Alias for ::cs_main.
      * Should be used in new code to make it easier to make ::cs_main a member
diff --git a/libbitcoinkernel-sys/bitcoin/test/functional/feature_block.py b/libbitcoinkernel-sys/bitcoin/test/functional/feature_block.py
index 34141a2c..5c4263ed 100755
--- a/libbitcoinkernel-sys/bitcoin/test/functional/feature_block.py
+++ b/libbitcoinkernel-sys/bitcoin/test/functional/feature_block.py
@@ -150,7 +150,7 @@ def run_test(self):
 
         # MAX_SCRIPT_SIZE + 1 wasn't added to the utxo set
         tx.vin[0] = min_size_unspendable_output
-        assert_raises_rpc_error(-25, f'TestBlockValidity failed: bad-txns-inputs-missingorspent, CheckTxInputs: inputs missing/spent in transaction {tx.txid_hex}', self.generateblock, self.nodes[0],  output="raw(55)", transactions=[tx.serialize().hex()])
+        assert_raises_rpc_error(-25, f'TestBlockValidity failed: bad-txns-inputs-missingorspent, SpendBlock: inputs missing/spent in transaction {tx.txid_hex}', self.generateblock, self.nodes[0],  output="raw(55)", transactions=[tx.serialize().hex()])
 
         # collect spendable outputs now to avoid cluttering the code later on
         out = []
diff --git a/src/core/block.rs b/src/core/block.rs
index 896186e4..1a50d8e3 100644
--- a/src/core/block.rs
+++ b/src/core/block.rs
@@ -109,13 +109,16 @@ use std::{
 };
 
 use libbitcoinkernel_sys::{
-    btck_Block, btck_BlockHash, btck_BlockSpentOutputs, btck_Coin, btck_TransactionSpentOutputs,
-    btck_block_copy, btck_block_count_transactions, btck_block_create, btck_block_destroy,
-    btck_block_get_hash, btck_block_get_transaction_at, btck_block_hash_copy,
-    btck_block_hash_create, btck_block_hash_destroy, btck_block_hash_equals,
-    btck_block_hash_to_bytes, btck_block_spent_outputs_copy, btck_block_spent_outputs_count,
-    btck_block_spent_outputs_destroy, btck_block_spent_outputs_get_transaction_spent_outputs_at,
-    btck_block_to_bytes, btck_coin_confirmation_height, btck_coin_copy, btck_coin_destroy,
+    btck_Block, btck_BlockHash, btck_BlockHeader, btck_BlockSpentOutputs, btck_Coin,
+    btck_TransactionSpentOutputs, btck_block_copy, btck_block_count_transactions,
+    btck_block_create, btck_block_destroy, btck_block_get_hash, btck_block_get_header,
+    btck_block_get_transaction_at, btck_block_hash_copy, btck_block_hash_create,
+    btck_block_hash_destroy, btck_block_hash_equals, btck_block_hash_to_bytes,
+    btck_block_header_copy, btck_block_header_create, btck_block_header_destroy,
+    btck_block_header_get_hash, btck_block_spent_outputs_copy, btck_block_spent_outputs_count,
+    btck_block_spent_outputs_create, btck_block_spent_outputs_destroy,
+    btck_block_spent_outputs_get_transaction_spent_outputs_at, btck_block_to_bytes,
+    btck_coin_confirmation_height, btck_coin_copy, btck_coin_create, btck_coin_destroy,
     btck_coin_get_output, btck_coin_is_coinbase, btck_transaction_spent_outputs_copy,
     btck_transaction_spent_outputs_count, btck_transaction_spent_outputs_destroy,
     btck_transaction_spent_outputs_get_coin_at,
@@ -127,7 +130,7 @@ use crate::{
         c_helpers::present,
         sealed::{AsPtr, FromMutPtr, FromPtr},
     },
-    KernelError,
+    KernelError, TxOut,
 };
 
 use super::transaction::{TransactionRef, TxOutRef};
@@ -270,6 +273,15 @@ impl AsPtr<btck_BlockHash> for BlockHash {
     }
 }
 
+impl<'a> FromPtr<btck_BlockHash> for BlockHashRef<'a> {
+    unsafe fn from_ptr(ptr: *const btck_BlockHash) -> Self {
+        BlockHashRef {
+            inner: ptr,
+            marker: PhantomData,
+        }
+    }
+}
+
 impl FromMutPtr<btck_BlockHash> for BlockHash {
     unsafe fn from_ptr(ptr: *mut btck_BlockHash) -> Self {
         BlockHash { inner: ptr }
@@ -377,15 +389,6 @@ impl<'a> AsPtr<btck_BlockHash> for BlockHashRef<'a> {
     }
 }
 
-impl<'a> FromPtr<btck_BlockHash> for BlockHashRef<'a> {
-    unsafe fn from_ptr(ptr: *const btck_BlockHash) -> Self {
-        BlockHashRef {
-            inner: ptr,
-            marker: PhantomData,
-        }
-    }
-}
-
 impl<'a> BlockHashExt for BlockHashRef<'a> {}
 
 impl<'a> Clone for BlockHashRef<'a> {
@@ -420,6 +423,114 @@ impl<'a> Eq for BlockHashRef<'a> {}
 
 impl<'a> Copy for BlockHashRef<'a> {}
 
+/// Common operations for block headers, implemented by both owned and borrow types.
+pub trait BlockHeaderExt: AsPtr<btck_BlockHeader> {
+    /// Return the block hash of the header.
+    fn hash(&self) -> BlockHash {
+        unsafe { BlockHash::from_ptr(btck_block_header_get_hash(self.as_ptr())) }
+    }
+}
+
+/// A Bitcoin block header.
+///
+/// Block headers can be created from raw serialized data or retrieved from the
+/// chain or blocks.
+pub struct BlockHeader {
+    inner: *mut btck_BlockHeader,
+}
+
+unsafe impl Send for BlockHeader {}
+unsafe impl Sync for BlockHeader {}
+
+impl BlockHeader {
+    pub fn new(header_bytes: &[u8]) -> Result<Self, KernelError> {
+        let inner = unsafe {
+            btck_block_header_create(header_bytes.as_ptr() as *const c_void, header_bytes.len())
+        };
+
+        if inner.is_null() {
+            Err(KernelError::Internal(
+                "Failed to create header from bytes".to_string(),
+            ))
+        } else {
+            Ok(BlockHeader { inner })
+        }
+    }
+
+    pub fn as_ref(&self) -> BlockHeaderRef<'_> {
+        unsafe { BlockHeaderRef::from_ptr(self.inner as *const _) }
+    }
+}
+
+impl FromMutPtr<btck_BlockHeader> for BlockHeader {
+    unsafe fn from_ptr(ptr: *mut btck_BlockHeader) -> Self {
+        BlockHeader { inner: ptr }
+    }
+}
+
+impl AsPtr<btck_BlockHeader> for BlockHeader {
+    fn as_ptr(&self) -> *const btck_BlockHeader {
+        self.inner as *const _
+    }
+}
+
+impl BlockHeaderExt for BlockHeader {}
+
+impl Clone for BlockHeader {
+    fn clone(&self) -> Self {
+        BlockHeader {
+            inner: unsafe { btck_block_header_copy(self.inner) },
+        }
+    }
+}
+
+impl Drop for BlockHeader {
+    fn drop(&mut self) {
+        unsafe { btck_block_header_destroy(self.inner) }
+    }
+}
+
+pub struct BlockHeaderRef<'a> {
+    inner: *const btck_BlockHeader,
+    marker: PhantomData<&'a ()>,
+}
+
+unsafe impl<'a> Send for BlockHeaderRef<'a> {}
+unsafe impl<'a> Sync for BlockHeaderRef<'a> {}
+
+impl<'a> BlockHeaderRef<'a> {
+    pub fn to_owned(&self) -> BlockHeader {
+        BlockHeader {
+            inner: unsafe { btck_block_header_copy(self.inner) },
+        }
+    }
+}
+
+impl<'a> AsPtr<btck_BlockHeader> for BlockHeaderRef<'a> {
+    fn as_ptr(&self) -> *const btck_BlockHeader {
+        self.inner
+    }
+}
+
+impl<'a> FromPtr<btck_BlockHeader> for BlockHeaderRef<'a> {
+    unsafe fn from_ptr(ptr: *const btck_BlockHeader) -> Self {
+        BlockHeaderRef {
+            inner: ptr,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'a> BlockHeaderExt for BlockHeaderRef<'a> {}
+
+impl<'a> Copy for BlockHeaderRef<'a> {}
+
+impl<'a> Clone for BlockHeaderRef<'a> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
 /// A block containing a header and transactions.
 ///
 /// Blocks are the fundamental units of the block chain, linking together
@@ -542,6 +653,10 @@ impl Block {
         unsafe { btck_block_count_transactions(self.inner) }
     }
 
+    pub fn header(&self) -> BlockHeader {
+        unsafe { BlockHeader::from_ptr(btck_block_get_header(self.inner)) }
+    }
+
     /// Returns a reference to the transaction at the specified index.
     ///
     /// # Arguments
@@ -891,6 +1006,36 @@ impl BlockSpentOutputs {
     pub fn as_ref(&self) -> BlockSpentOutputsRef<'_> {
         unsafe { BlockSpentOutputsRef::from_ptr(self.inner as *const _) }
     }
+
+    pub fn new(coins: &[Vec<Coin>]) -> Self {
+        struct CallbackContext<'a> {
+            coins: &'a [Vec<Coin>],
+        }
+
+        extern "C" fn coin_getter(
+            context: *mut c_void,
+            tx_index: usize,
+            coin_index: usize,
+        ) -> *const btck_Coin {
+            let ctx = unsafe { &*(context as *const CallbackContext) };
+            ctx.coins[tx_index][coin_index].as_ptr()
+        }
+
+        extern "C" fn count_getter(context: *mut c_void, tx_index: usize) -> usize {
+            let ctx = unsafe { &*(context as *const CallbackContext) };
+            ctx.coins[tx_index].len()
+        }
+
+        let context = CallbackContext { coins };
+        unsafe {
+            BlockSpentOutputs::from_ptr(btck_block_spent_outputs_create(
+                &context as *const CallbackContext as *mut c_void,
+                Some(coin_getter),
+                Some(count_getter),
+                coins.len(),
+            ))
+        }
+    }
 }
 
 impl FromMutPtr<btck_BlockSpentOutputs> for BlockSpentOutputs {
@@ -1446,6 +1591,10 @@ unsafe impl Send for Coin {}
 unsafe impl Sync for Coin {}
 
 impl Coin {
+    pub fn new(output: &TxOut) -> Coin {
+        unsafe { Coin::from_ptr(btck_coin_create(output.as_ptr(), 0, 0)) }
+    }
+
     /// Creates a borrowed reference to this coin.
     ///
     /// This allows converting from owned [`Coin`] to [`CoinRef`] without
@@ -1574,6 +1723,23 @@ mod tests {
 
     test_owned_trait_requirements!(test_block_requirements, Block, btck_Block);
 
+    test_owned_trait_requirements!(
+        test_block_header_requirements,
+        BlockHeader,
+        btck_BlockHeader
+    );
+    test_ref_trait_requirements!(
+        test_block_header_ref_requirements,
+        BlockHeaderRef<'static>,
+        btck_BlockHeader
+    );
+
+    test_owned_clone_and_send!(
+        test_block_header_clone_send,
+        Block::new(&read_block_data()[0]).unwrap().header(),
+        Block::new(&read_block_data()[1]).unwrap()
+    );
+
     test_owned_trait_requirements!(
         test_block_spent_outputs_requirements,
         BlockSpentOutputs,
diff --git a/src/core/block_tree_entry.rs b/src/core/block_tree_entry.rs
index 6506340f..a4d7fb0f 100644
--- a/src/core/block_tree_entry.rs
+++ b/src/core/block_tree_entry.rs
@@ -1,12 +1,13 @@
 use std::marker::PhantomData;
 
 use libbitcoinkernel_sys::{
-    btck_BlockTreeEntry, btck_block_tree_entry_get_block_hash, btck_block_tree_entry_get_height,
+    btck_BlockTreeEntry, btck_block_tree_entry_get_block_hash,
+    btck_block_tree_entry_get_block_header, btck_block_tree_entry_get_height,
     btck_block_tree_entry_get_previous,
 };
 
 use crate::{
-    core::block::BlockHashRef,
+    core::block::{BlockHashRef, BlockHeaderRef},
     ffi::sealed::{AsPtr, FromPtr},
     ChainstateManager,
 };
@@ -44,6 +45,10 @@ impl<'a> BlockTreeEntry<'a> {
         unsafe { btck_block_tree_entry_get_height(self.inner) }
     }
 
+    pub fn header(&self) -> BlockHeaderRef<'_> {
+        unsafe { BlockHeaderRef::from_ptr(btck_block_tree_entry_get_block_header(self.inner)) }
+    }
+
     /// Returns the current block hash associated with this BlockTreeEntry.
     pub fn block_hash(&self) -> BlockHashRef<'_> {
         let hash_ptr = unsafe { btck_block_tree_entry_get_block_hash(self.inner) };
diff --git a/src/core/transaction.rs b/src/core/transaction.rs
index e8c6fd2e..c4bbc69d 100644
--- a/src/core/transaction.rs
+++ b/src/core/transaction.rs
@@ -153,10 +153,10 @@ use libbitcoinkernel_sys::{
     btck_transaction_count_outputs, btck_transaction_create, btck_transaction_destroy,
     btck_transaction_get_input_at, btck_transaction_get_output_at, btck_transaction_get_txid,
     btck_transaction_input_copy, btck_transaction_input_destroy,
-    btck_transaction_input_get_out_point, btck_transaction_out_point_copy,
-    btck_transaction_out_point_destroy, btck_transaction_out_point_get_index,
-    btck_transaction_out_point_get_txid, btck_transaction_output_copy,
-    btck_transaction_output_create, btck_transaction_output_destroy,
+    btck_transaction_input_get_out_point, btck_transaction_is_coinbase,
+    btck_transaction_out_point_copy, btck_transaction_out_point_destroy,
+    btck_transaction_out_point_get_index, btck_transaction_out_point_get_txid,
+    btck_transaction_output_copy, btck_transaction_output_create, btck_transaction_output_destroy,
     btck_transaction_output_get_amount, btck_transaction_output_get_script_pubkey,
     btck_transaction_to_bytes, btck_txid_copy, btck_txid_destroy, btck_txid_equals,
     btck_txid_to_bytes,
@@ -165,7 +165,7 @@ use libbitcoinkernel_sys::{
 use crate::{
     c_serialize,
     ffi::{
-        c_helpers::present,
+        c_helpers::{self, present},
         sealed::{AsPtr, FromMutPtr, FromPtr},
     },
     KernelError, ScriptPubkeyExt,
@@ -379,6 +379,10 @@ pub trait TransactionExt: AsPtr<btck_Transaction> {
     fn outputs(&self) -> TxOutIter<'_> {
         TxOutIter::new(unsafe { TransactionRef::from_ptr(self.as_ptr()) })
     }
+
+    fn is_coinbase(&self) -> bool {
+        unsafe { c_helpers::enabled(btck_transaction_is_coinbase(self.as_ptr())) }
+    }
 }
 
 /// A Bitcoin transaction.
diff --git a/src/notifications/types.rs b/src/notifications/types.rs
index fe7c3609..e23220d7 100644
--- a/src/notifications/types.rs
+++ b/src/notifications/types.rs
@@ -2,12 +2,14 @@ use std::marker::PhantomData;
 
 use libbitcoinkernel_sys::{
     btck_BlockValidationResult, btck_BlockValidationState, btck_SynchronizationState,
-    btck_ValidationMode, btck_Warning, btck_block_validation_state_get_block_validation_result,
+    btck_ValidationMode, btck_Warning, btck_block_validation_state_copy,
+    btck_block_validation_state_create, btck_block_validation_state_destroy,
+    btck_block_validation_state_get_block_validation_result,
     btck_block_validation_state_get_validation_mode,
 };
 
 use crate::{
-    ffi::sealed::{AsPtr, FromPtr},
+    ffi::sealed::{AsPtr, FromMutPtr, FromPtr},
     BTCK_BLOCK_VALIDATION_RESULT_CACHED_INVALID, BTCK_BLOCK_VALIDATION_RESULT_CONSENSUS,
     BTCK_BLOCK_VALIDATION_RESULT_HEADER_LOW_WORK, BTCK_BLOCK_VALIDATION_RESULT_INVALID_HEADER,
     BTCK_BLOCK_VALIDATION_RESULT_INVALID_PREV, BTCK_BLOCK_VALIDATION_RESULT_MISSING_PREV,
@@ -191,6 +193,49 @@ pub trait BlockValidationStateExt: AsPtr<btck_BlockValidationState> {
     }
 }
 
+pub struct BlockValidationState {
+    inner: *mut btck_BlockValidationState,
+}
+
+unsafe impl Send for BlockValidationState {}
+unsafe impl Sync for BlockValidationState {}
+
+impl BlockValidationState {
+    pub fn new() -> BlockValidationState {
+        BlockValidationState {
+            inner: unsafe { btck_block_validation_state_create() },
+        }
+    }
+}
+
+impl AsPtr<btck_BlockValidationState> for BlockValidationState {
+    fn as_ptr(&self) -> *const btck_BlockValidationState {
+        self.inner as *const _
+    }
+}
+
+impl FromMutPtr<btck_BlockValidationState> for BlockValidationState {
+    unsafe fn from_ptr(ptr: *mut btck_BlockValidationState) -> Self {
+        BlockValidationState { inner: ptr }
+    }
+}
+
+impl BlockValidationStateExt for BlockValidationState {}
+
+impl Clone for BlockValidationState {
+    fn clone(&self) -> Self {
+        BlockValidationState {
+            inner: unsafe { btck_block_validation_state_copy(self.inner) },
+        }
+    }
+}
+
+impl Drop for BlockValidationState {
+    fn drop(&mut self) {
+        unsafe { btck_block_validation_state_destroy(self.inner) }
+    }
+}
+
 pub struct BlockValidationStateRef<'a> {
     inner: *const btck_BlockValidationState,
     marker: PhantomData<&'a ()>,
@@ -228,10 +273,18 @@ impl<'a> BlockValidationStateExt for BlockValidationStateRef<'a> {}
 mod tests {
     use libbitcoinkernel_sys::btck_BlockValidationState;
 
-    use crate::ffi::test_utils::test_ref_trait_requirements;
+    use crate::{
+        ffi::test_utils::{test_owned_trait_requirements, test_ref_trait_requirements},
+        notifications::types::{BlockValidationState, BlockValidationStateRef},
+    };
 
     use super::*;
 
+    test_owned_trait_requirements!(
+        test_block_validation_state_requirements,
+        BlockValidationState,
+        btck_BlockValidationState
+    );
     test_ref_trait_requirements!(
         test_block_validation_state_ref_requirements,
         BlockValidationStateRef<'static>,
diff --git a/src/state/chainstate.rs b/src/state/chainstate.rs
index 9c5160ee..152a64fb 100644
--- a/src/state/chainstate.rs
+++ b/src/state/chainstate.rs
@@ -28,22 +28,27 @@
 use std::ffi::CString;
 
 use libbitcoinkernel_sys::{
-    btck_BlockHash, btck_ChainstateManager, btck_ChainstateManagerOptions, btck_block_read,
-    btck_block_spent_outputs_read, btck_chainstate_manager_create, btck_chainstate_manager_destroy,
-    btck_chainstate_manager_get_active_chain, btck_chainstate_manager_get_block_tree_entry_by_hash,
-    btck_chainstate_manager_import_blocks, btck_chainstate_manager_options_create,
-    btck_chainstate_manager_options_destroy, btck_chainstate_manager_options_set_wipe_dbs,
+    btck_BlockHash, btck_BlockValidationState, btck_ChainstateManager,
+    btck_ChainstateManagerOptions, btck_block_read, btck_block_spent_outputs_read,
+    btck_chainstate_manager_create, btck_chainstate_manager_destroy,
+    btck_chainstate_manager_get_active_chain, btck_chainstate_manager_get_best_entry,
+    btck_chainstate_manager_get_block_tree_entry_by_hash, btck_chainstate_manager_import_blocks,
+    btck_chainstate_manager_options_create, btck_chainstate_manager_options_destroy,
+    btck_chainstate_manager_options_set_wipe_dbs,
     btck_chainstate_manager_options_set_worker_threads_num,
     btck_chainstate_manager_options_update_block_tree_db_in_memory,
     btck_chainstate_manager_options_update_chainstate_db_in_memory,
-    btck_chainstate_manager_process_block,
+    btck_chainstate_manager_process_block, btck_chainstate_manager_process_block_header,
+    btck_chainstate_manager_validate_block,
 };
 
 use crate::{
+    core::block::BlockHeader,
     ffi::{
         c_helpers,
         sealed::{AsPtr, FromMutPtr, FromPtr},
     },
+    notifications::types::BlockValidationState,
     Block, BlockHash, BlockSpentOutputs, BlockTreeEntry, KernelError,
 };
 
@@ -253,6 +258,35 @@ impl ChainstateManager {
         }
     }
 
+    pub fn process_header(&self, header: &BlockHeader) -> (bool, BlockValidationState) {
+        let state = BlockValidationState::new();
+        let accepted = unsafe {
+            btck_chainstate_manager_process_block_header(
+                self.inner,
+                header.as_ptr(),
+                state.as_ptr() as *mut btck_BlockValidationState,
+            )
+        };
+        (c_helpers::success(accepted), state)
+    }
+
+    pub fn validate_block(
+        &self,
+        block: &Block,
+        block_spent_outputs: &BlockSpentOutputs,
+    ) -> (bool, BlockValidationState) {
+        let state = BlockValidationState::new();
+        let accepted = unsafe {
+            btck_chainstate_manager_validate_block(
+                self.inner,
+                block.as_ptr(),
+                block_spent_outputs.as_ptr(),
+                state.as_ptr() as *mut btck_BlockValidationState,
+            )
+        };
+        (c_helpers::success(accepted), state)
+    }
+
     /// Initialize the chainstate manager and optionally trigger a reindex.
     ///
     /// This should be called after creating the chainstate manager to complete
@@ -261,6 +295,7 @@ impl ChainstateManager {
     ///
     /// # Errors
     /// Returns [`KernelError::Internal`] if initialization fails.
+
     pub fn import_blocks(&self) -> Result<(), KernelError> {
         let result = unsafe {
             btck_chainstate_manager_import_blocks(
@@ -347,6 +382,15 @@ impl ChainstateManager {
         unsafe { Chain::from_ptr(ptr) }
     }
 
+    pub fn best_entry(&self) -> Option<BlockTreeEntry<'_>> {
+        let ptr = unsafe { btck_chainstate_manager_get_best_entry(self.inner) };
+        if ptr.is_null() {
+            None
+        } else {
+            Some(unsafe { BlockTreeEntry::from_ptr(ptr) })
+        }
+    }
+
     /// Get a block tree entry by its block hash.
     ///
     /// Looks up a block in the block tree using its hash. The block tree contains
diff --git a/tests/test.rs b/tests/test.rs
index bef77569..817f32e8 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -1,11 +1,12 @@
 #[cfg(test)]
 mod tests {
+    use bitcoinkernel::core::transaction::{TxOutPointExt, TxOutPointRef};
     use bitcoinkernel::{
         prelude::*, verify, Block, BlockHash, BlockSpentOutputs, BlockTreeEntry,
         BlockValidationStateRef, ChainParams, ChainType, ChainstateManager,
         ChainstateManagerBuilder, Coin, Context, ContextBuilder, KernelError, Log, Logger,
         ScriptPubkey, ScriptVerifyError, Transaction, TransactionSpentOutputs, TxIn, TxOut,
-        TxOutRef, VERIFY_ALL_PRE_TAPROOT, VERIFY_TAPROOT, VERIFY_WITNESS,
+        TxOutRef, ValidationMode, VERIFY_ALL_PRE_TAPROOT, VERIFY_TAPROOT, VERIFY_WITNESS,
     };
     use std::fs::File;
     use std::io::{BufRead, BufReader};
@@ -370,6 +371,82 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn test_header_validation() {
+        let (context, data_dir) = testing_setup();
+        let blocks_dir = data_dir.clone() + "/blocks";
+        let block_data = read_block_data();
+        let blocks: Vec<Block> = block_data
+            .iter()
+            .map(|data| Block::new(data.as_slice()).unwrap())
+            .collect();
+        let chainman = ChainstateManager::new(&context, &data_dir, &blocks_dir).unwrap();
+
+        for block in blocks.iter() {
+            let (accepted, state) = chainman.process_header(&block.header());
+            assert!(accepted);
+            assert_eq!(state.mode(), ValidationMode::Valid);
+        }
+    }
+
+    fn find_output<'a>(blocks: &'a [Block], outpoint: TxOutPointRef) -> Option<TxOut> {
+        for block in blocks.iter() {
+            for i in 0..block.transaction_count() {
+                let tx = block.transaction(i).unwrap();
+                if tx.txid() != outpoint.txid() {
+                    continue;
+                }
+                return tx
+                    .output(outpoint.index() as usize)
+                    .ok()
+                    .map(|out| out.to_owned());
+            }
+        }
+        None
+    }
+
+    #[test]
+    fn test_block_validation() {
+        let (context, data_dir) = testing_setup();
+        let blocks_dir = data_dir.clone() + "/blocks";
+        let block_data = read_block_data();
+        let blocks: Vec<Block> = block_data
+            .iter()
+            .map(|data| Block::new(data.as_slice()).unwrap())
+            .collect();
+        let chainman = ChainstateManager::new(&context, &data_dir, &blocks_dir).unwrap();
+
+        let mut block_spent_outputs: Vec<BlockSpentOutputs> = vec![];
+
+        for block in blocks.iter() {
+            let mut coins: Vec<Vec<Coin>> = vec![];
+            for i in 0..block.transaction_count() {
+                let tx = block.transaction(i).unwrap();
+                if tx.is_coinbase() {
+                    println!("tx is coinbase!");
+                    continue;
+                }
+                coins.push(Vec::new());
+                for j in 0..tx.input_count() {
+                    let output = find_output(&blocks, tx.input(j).unwrap().outpoint()).unwrap();
+                    println!("Accessing coins i {i}");
+                    coins[i - 1].push(Coin::new(&output));
+                }
+            }
+            block_spent_outputs.push(BlockSpentOutputs::new(&coins));
+        }
+
+        for (block, block_spent_outputs) in blocks.iter().zip(block_spent_outputs.iter()) {
+            let (accepted, state) = chainman.process_header(&block.header());
+            assert!(accepted);
+            assert_eq!(state.mode(), ValidationMode::Valid);
+
+            let (result, state) = chainman.validate_block(block, &block_spent_outputs);
+            assert!(result);
+            assert_eq!(state.mode(), ValidationMode::Valid);
+        }
+    }
+
     #[test]
     fn test_chain_operations() {
         let (context, data_dir) = testing_setup();