diff --git a/libbitcoinkernel-sys/bitcoin/.github/workflows/ci.yml b/libbitcoinkernel-sys/bitcoin/.github/workflows/ci.yml
index 3ffaafe3..d4336462 100644
--- a/libbitcoinkernel-sys/bitcoin/.github/workflows/ci.yml
+++ b/libbitcoinkernel-sys/bitcoin/.github/workflows/ci.yml
@@ -468,7 +468,7 @@ jobs:
             file-env: './ci/test/00_setup_env_arm.sh'
             provider: 'gha'
 
-          - name: 'ASan + LSan + UBSan + integer'
+          - name: 'ASan + LSan + UBSan + integer, no depends, USDT'
             cirrus-runner: 'ghcr.io/cirruslabs/ubuntu-runner-amd64:24.04-md' # has to match container in ci/test/00_setup_env_native_asan.sh for tracing tools
             fallback-runner: 'ubuntu-24.04'
             timeout-minutes: 120
diff --git a/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_native_asan.sh b/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_native_asan.sh
index 0e732240..229d4fff 100755
--- a/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_native_asan.sh
+++ b/libbitcoinkernel-sys/bitcoin/ci/test/00_setup_env_native_asan.sh
@@ -26,7 +26,7 @@ export NO_DEPENDS=1
 export GOAL="install"
 export CI_LIMIT_STACK_SIZE=1
 export BITCOIN_CONFIG="\
- --preset=dev-mode \
+ -DWITH_USDT=ON -DWITH_ZMQ=ON -DBUILD_GUI=ON \
  -DSANITIZERS=address,float-divide-by-zero,integer,undefined \
  -DCMAKE_C_COMPILER=clang \
  -DCMAKE_CXX_COMPILER=clang++ \
diff --git a/libbitcoinkernel-sys/bitcoin/doc/i2p.md b/libbitcoinkernel-sys/bitcoin/doc/i2p.md
index 624b651f..b769a74d 100644
--- a/libbitcoinkernel-sys/bitcoin/doc/i2p.md
+++ b/libbitcoinkernel-sys/bitcoin/doc/i2p.md
@@ -166,13 +166,3 @@ In most cases, the default router settings should work fine.
 
 Please see the "General Guidance for Developers" section in https://geti2p.net/en/docs/api/samv3
 if you are developing a downstream application that may be bundling I2P with Bitcoin.
-
-## Privacy recommendations
-
-- Operating a node that listens on multiple networks (e.g. IPv4 and I2P) can help
-  strengthen the Bitcoin network, as nodes in this configuration (i.e. bridge nodes) increase
-  the cost and complexity of launching eclipse and partition attacks. However, under certain
-  conditions, an adversary that can connect to your node on multiple networks may be
-  able to correlate those identities by observing shared runtime characteristics. It
-  is not recommended to expose your node over multiple networks if you require
-  unlinkability across those identities.
diff --git a/libbitcoinkernel-sys/bitcoin/doc/tor.md b/libbitcoinkernel-sys/bitcoin/doc/tor.md
index e9db555f..839c02ee 100644
--- a/libbitcoinkernel-sys/bitcoin/doc/tor.md
+++ b/libbitcoinkernel-sys/bitcoin/doc/tor.md
@@ -238,10 +238,3 @@ for normal IPv4/IPv6 communication, use:
   Otherwise it is trivial to link them, which may reduce privacy. Onion
   services created automatically (as in section 2) always have only one port
   open.
-- Operating a node that listens on multiple networks (e.g. IPv4 and Tor) can help
-  strengthen the Bitcoin network, as nodes in this configuration (i.e. bridge nodes) increase
-  the cost and complexity of launching eclipse and partition attacks. However, under certain
-  conditions, an adversary that can connect to your node on multiple networks may be
-  able to correlate those identities by observing shared runtime characteristics. It
-  is not recommended to expose your node over multiple networks if you require
-  unlinkability across those identities.
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/chain.cpp b/libbitcoinkernel-sys/bitcoin/src/chain.cpp
index 94be7180..3dd22634 100644
--- a/libbitcoinkernel-sys/bitcoin/src/chain.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/chain.cpp
@@ -6,6 +6,12 @@
 #include <chain.h>
 #include <tinyformat.h>
 #include <util/check.h>
+#include <util/time.h>
+
+std::string CBlockFileInfo::ToString() const
+{
+    return strprintf("CBlockFileInfo(blocks=%u, size=%u, heights=%u...%u, time=%s...%s)", nBlocks, nSize, nHeightFirst, nHeightLast, FormatISO8601Date(nTimeFirst), FormatISO8601Date(nTimeLast));
+}
 
 std::string CBlockIndex::ToString() const
 {
diff --git a/libbitcoinkernel-sys/bitcoin/src/chain.h b/libbitcoinkernel-sys/bitcoin/src/chain.h
index 64c86357..2c865265 100644
--- a/libbitcoinkernel-sys/bitcoin/src/chain.h
+++ b/libbitcoinkernel-sys/bitcoin/src/chain.h
@@ -47,6 +47,47 @@ static constexpr int32_t SEQ_ID_INIT_FROM_DISK = 1;
  */
 static constexpr int64_t MAX_BLOCK_TIME_GAP = 90 * 60;
 
+class CBlockFileInfo
+{
+public:
+    unsigned int nBlocks{};      //!< number of blocks stored in file
+    unsigned int nSize{};        //!< number of used bytes of block file
+    unsigned int nUndoSize{};    //!< number of used bytes in the undo file
+    unsigned int nHeightFirst{}; //!< lowest height of block in file
+    unsigned int nHeightLast{};  //!< highest height of block in file
+    uint64_t nTimeFirst{};       //!< earliest time of block in file
+    uint64_t nTimeLast{};        //!< latest time of block in file
+
+    SERIALIZE_METHODS(CBlockFileInfo, obj)
+    {
+        READWRITE(VARINT(obj.nBlocks));
+        READWRITE(VARINT(obj.nSize));
+        READWRITE(VARINT(obj.nUndoSize));
+        READWRITE(VARINT(obj.nHeightFirst));
+        READWRITE(VARINT(obj.nHeightLast));
+        READWRITE(VARINT(obj.nTimeFirst));
+        READWRITE(VARINT(obj.nTimeLast));
+    }
+
+    CBlockFileInfo() = default;
+
+    std::string ToString() const;
+
+    /** update statistics (does not update nSize) */
+    void AddBlock(unsigned int nHeightIn, uint64_t nTimeIn)
+    {
+        if (nBlocks == 0 || nHeightFirst > nHeightIn)
+            nHeightFirst = nHeightIn;
+        if (nBlocks == 0 || nTimeFirst > nTimeIn)
+            nTimeFirst = nTimeIn;
+        nBlocks++;
+        if (nHeightIn > nHeightLast)
+            nHeightLast = nHeightIn;
+        if (nTimeIn > nTimeLast)
+            nTimeLast = nTimeIn;
+    }
+};
+
 enum BlockStatus : uint32_t {
     //! Unused.
     BLOCK_VALID_UNKNOWN      =    0,
diff --git a/libbitcoinkernel-sys/bitcoin/src/coins.cpp b/libbitcoinkernel-sys/bitcoin/src/coins.cpp
index 554a3ebe..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());
@@ -349,8 +372,8 @@ void CCoinsViewCache::SanityCheck() const
     assert(recomputed_usage == cachedCoinsUsage);
 }
 
-static const uint64_t MIN_TRANSACTION_OUTPUT_WEIGHT{WITNESS_SCALE_FACTOR * ::GetSerializeSize(CTxOut())};
-static const uint64_t MAX_OUTPUTS_PER_BLOCK{MAX_BLOCK_WEIGHT / MIN_TRANSACTION_OUTPUT_WEIGHT};
+static const size_t MIN_TRANSACTION_OUTPUT_WEIGHT = WITNESS_SCALE_FACTOR * ::GetSerializeSize(CTxOut());
+static const size_t MAX_OUTPUTS_PER_BLOCK = MAX_BLOCK_WEIGHT / MIN_TRANSACTION_OUTPUT_WEIGHT;
 
 const Coin& AccessByTxid(const CCoinsViewCache& view, const Txid& txid)
 {
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/flatfile.h b/libbitcoinkernel-sys/bitcoin/src/flatfile.h
index 3ec4eaf3..3edb0b85 100644
--- a/libbitcoinkernel-sys/bitcoin/src/flatfile.h
+++ b/libbitcoinkernel-sys/bitcoin/src/flatfile.h
@@ -13,16 +13,16 @@
 
 struct FlatFilePos
 {
-    int32_t nFile{-1};
-    uint32_t nPos{0};
+    int nFile{-1};
+    unsigned int nPos{0};
 
     SERIALIZE_METHODS(FlatFilePos, obj) { READWRITE(VARINT_MODE(obj.nFile, VarIntMode::NONNEGATIVE_SIGNED), VARINT(obj.nPos)); }
 
     FlatFilePos() = default;
 
-    FlatFilePos(int32_t nFileIn, uint32_t nPosIn)
-        : nFile{nFileIn},
-          nPos{nPosIn}
+    FlatFilePos(int nFileIn, unsigned int nPosIn) :
+        nFile(nFileIn),
+        nPos(nPosIn)
     {}
 
     friend bool operator==(const FlatFilePos &a, const FlatFilePos &b) {
diff --git a/libbitcoinkernel-sys/bitcoin/src/index/blockfilterindex.cpp b/libbitcoinkernel-sys/bitcoin/src/index/blockfilterindex.cpp
index 4bf2f5e6..032a0b60 100644
--- a/libbitcoinkernel-sys/bitcoin/src/index/blockfilterindex.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/index/blockfilterindex.cpp
@@ -222,9 +222,9 @@ size_t BlockFilterIndex::WriteFilterToDisk(FlatFilePos& pos, const BlockFilter&
 {
     assert(filter.GetFilterType() == GetFilterType());
 
-    uint64_t data_size{
+    size_t data_size =
         GetSerializeSize(filter.GetBlockHash()) +
-        GetSerializeSize(filter.GetEncodedFilter())};
+        GetSerializeSize(filter.GetEncodedFilter());
 
     // If writing the filter would overflow the file, flush and move to the next one.
     if (pos.nPos + data_size > MAX_FLTR_FILE_SIZE) {
diff --git a/libbitcoinkernel-sys/bitcoin/src/index/disktxpos.h b/libbitcoinkernel-sys/bitcoin/src/index/disktxpos.h
index 5e4352db..a0363846 100644
--- a/libbitcoinkernel-sys/bitcoin/src/index/disktxpos.h
+++ b/libbitcoinkernel-sys/bitcoin/src/index/disktxpos.h
@@ -10,14 +10,14 @@
 
 struct CDiskTxPos : public FlatFilePos
 {
-    uint32_t nTxOffset{0}; // after header
+    unsigned int nTxOffset{0}; // after header
 
     SERIALIZE_METHODS(CDiskTxPos, obj)
     {
         READWRITE(AsBase<FlatFilePos>(obj), VARINT(obj.nTxOffset));
     }
 
-    CDiskTxPos(const FlatFilePos& blockIn, uint32_t nTxOffsetIn) : FlatFilePos{blockIn.nFile, blockIn.nPos}, nTxOffset{nTxOffsetIn} {
+    CDiskTxPos(const FlatFilePos &blockIn, unsigned int nTxOffsetIn) : FlatFilePos(blockIn.nFile, blockIn.nPos), nTxOffset(nTxOffsetIn) {
     }
 
     CDiskTxPos() = default;
diff --git a/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel.cpp b/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel.cpp
index 0b9ea513..0030f49a 100644
--- a/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/kernel/bitcoinkernel.cpp
@@ -494,12 +494,10 @@ 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)
 {
-    if (raw_transaction == nullptr && raw_transaction_len != 0) {
-        return nullptr;
-    }
     try {
         DataStream stream{std::span{reinterpret_cast<const std::byte*>(raw_transaction), raw_transaction_len}};
         return btck_Transaction::create(std::make_shared<const CTransaction>(deserialize, TX_WITH_WITNESS, stream));
@@ -559,9 +557,6 @@ void btck_transaction_destroy(btck_Transaction* transaction)
 
 btck_ScriptPubkey* btck_script_pubkey_create(const void* script_pubkey, size_t script_pubkey_len)
 {
-    if (script_pubkey == nullptr && script_pubkey_len != 0) {
-        return nullptr;
-    }
     auto data = std::span{reinterpret_cast<const uint8_t*>(script_pubkey), script_pubkey_len};
     return btck_ScriptPubkey::create(data.begin(), data.end());
 }
@@ -860,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_);
@@ -1004,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)
 {
     {
@@ -1039,9 +1055,6 @@ int btck_chainstate_manager_import_blocks(btck_ChainstateManager* chainman, cons
 
 btck_Block* btck_block_create(const void* raw_block, size_t raw_block_length)
 {
-    if (raw_block == nullptr && raw_block_length != 0) {
-        return nullptr;
-    }
     auto block{std::make_shared<CBlock>()};
 
     DataStream stream{std::span{reinterpret_cast<const std::byte*>(raw_block), raw_block_length}};
@@ -1072,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 {
@@ -1103,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;
@@ -1152,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);
@@ -1196,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);
@@ -1234,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()));
@@ -1256,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 93e160cd..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))
@@ -469,12 +479,12 @@ typedef uint8_t btck_ChainType;
 /**
  * @brief Create a new transaction from the serialized data.
  *
- * @param[in] raw_transaction     Serialized transaction.
+ * @param[in] raw_transaction     Non-null.
  * @param[in] raw_transaction_len Length of the serialized transaction.
  * @return                        The transaction, or null on error.
  */
 BITCOINKERNEL_API btck_Transaction* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_create(
-    const void* raw_transaction, size_t raw_transaction_len);
+    const void* raw_transaction, size_t raw_transaction_len) BITCOINKERNEL_ARG_NONNULL(1);
 
 /**
  * @brief Copy a transaction. Transactions are reference counted, so this just
@@ -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.
  */
@@ -567,12 +586,12 @@ BITCOINKERNEL_API void btck_transaction_destroy(btck_Transaction* transaction);
 
 /**
  * @brief Create a script pubkey from serialized data.
- * @param[in] script_pubkey     Serialized script pubkey.
+ * @param[in] script_pubkey     Non-null.
  * @param[in] script_pubkey_len Length of the script pubkey data.
  * @return                      The script pubkey.
  */
 BITCOINKERNEL_API btck_ScriptPubkey* BITCOINKERNEL_WARN_UNUSED_RESULT btck_script_pubkey_create(
-    const void* script_pubkey, size_t script_pubkey_len);
+    const void* script_pubkey, size_t script_pubkey_len) BITCOINKERNEL_ARG_NONNULL(1);
 
 /**
  * @brief Copy a script pubkey.
@@ -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
@@ -1111,12 +1180,12 @@ BITCOINKERNEL_API btck_Block* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_read(
 /**
  * @brief Parse a serialized raw block into a new block object.
  *
- * @param[in] raw_block     Serialized block.
+ * @param[in] raw_block     Non-null, serialized block.
  * @param[in] raw_block_len Length of the serialized block.
  * @return                  The allocated block, or null on error.
  */
 BITCOINKERNEL_API btck_Block* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_create(
-    const void* raw_block, size_t raw_block_len);
+    const void* raw_block, size_t raw_block_len) BITCOINKERNEL_ARG_NONNULL(1);
 
 /**
  * @brief Copy a block. Blocks are reference counted, so this just increments
@@ -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/blockstorage.cpp b/libbitcoinkernel-sys/bitcoin/src/node/blockstorage.cpp
index a9b9b9a6..00ba109b 100644
--- a/libbitcoinkernel-sys/bitcoin/src/node/blockstorage.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/node/blockstorage.cpp
@@ -35,7 +35,6 @@
 #include <util/signalinterrupt.h>
 #include <util/strencodings.h>
 #include <util/syserror.h>
-#include <util/time.h>
 #include <util/translation.h>
 #include <validation.h>
 
@@ -152,11 +151,6 @@ bool BlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams, s
 
     return true;
 }
-
-std::string CBlockFileInfo::ToString() const
-{
-    return strprintf("CBlockFileInfo(blocks=%u, size=%u, heights=%u...%u, time=%s...%s)", nBlocks, nSize, nHeightFirst, nHeightLast, FormatISO8601Date(nTimeFirst), FormatISO8601Date(nTimeLast));
-}
 } // namespace kernel
 
 namespace node {
diff --git a/libbitcoinkernel-sys/bitcoin/src/node/blockstorage.h b/libbitcoinkernel-sys/bitcoin/src/node/blockstorage.h
index d5da95c7..caf291e9 100644
--- a/libbitcoinkernel-sys/bitcoin/src/node/blockstorage.h
+++ b/libbitcoinkernel-sys/bitcoin/src/node/blockstorage.h
@@ -47,47 +47,6 @@ class SignalInterrupt;
 } // namespace util
 
 namespace kernel {
-class CBlockFileInfo
-{
-public:
-    uint32_t nBlocks{};      //!< number of blocks stored in file
-    uint32_t nSize{};        //!< number of used bytes of block file
-    uint32_t nUndoSize{};    //!< number of used bytes in the undo file
-    uint32_t nHeightFirst{}; //!< lowest height of block in file
-    uint32_t nHeightLast{};  //!< highest height of block in file
-    uint64_t nTimeFirst{};   //!< earliest time of block in file
-    uint64_t nTimeLast{};    //!< latest time of block in file
-
-    SERIALIZE_METHODS(CBlockFileInfo, obj)
-    {
-        READWRITE(VARINT(obj.nBlocks));
-        READWRITE(VARINT(obj.nSize));
-        READWRITE(VARINT(obj.nUndoSize));
-        READWRITE(VARINT(obj.nHeightFirst));
-        READWRITE(VARINT(obj.nHeightLast));
-        READWRITE(VARINT(obj.nTimeFirst));
-        READWRITE(VARINT(obj.nTimeLast));
-    }
-
-    CBlockFileInfo() = default;
-
-    std::string ToString() const;
-
-    /** update statistics (does not update nSize) */
-    void AddBlock(unsigned int nHeightIn, uint64_t nTimeIn)
-    {
-        if (nBlocks == 0 || nHeightFirst > nHeightIn)
-            nHeightFirst = nHeightIn;
-        if (nBlocks == 0 || nTimeFirst > nTimeIn)
-            nTimeFirst = nTimeIn;
-        nBlocks++;
-        if (nHeightIn > nHeightLast)
-            nHeightLast = nHeightIn;
-        if (nTimeIn > nTimeLast)
-            nTimeLast = nTimeIn;
-    }
-};
-
 /** Access to the block database (blocks/index/) */
 class BlockTreeDB : public CDBWrapper
 {
@@ -106,7 +65,6 @@ class BlockTreeDB : public CDBWrapper
 } // namespace kernel
 
 namespace node {
-using kernel::CBlockFileInfo;
 using kernel::BlockTreeDB;
 
 /** The pre-allocation chunk size for blk?????.dat files (since 0.8) */
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/policy/policy.cpp b/libbitcoinkernel-sys/bitcoin/src/policy/policy.cpp
index e749b14f..3da6cb74 100644
--- a/libbitcoinkernel-sys/bitcoin/src/policy/policy.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/policy/policy.cpp
@@ -42,7 +42,7 @@ CAmount GetDustThreshold(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
     if (txout.scriptPubKey.IsUnspendable())
         return 0;
 
-    uint64_t nSize{GetSerializeSize(txout)};
+    size_t nSize = GetSerializeSize(txout);
     int witnessversion = 0;
     std::vector<unsigned char> witnessprogram;
 
diff --git a/libbitcoinkernel-sys/bitcoin/src/rpc/blockchain.cpp b/libbitcoinkernel-sys/bitcoin/src/rpc/blockchain.cpp
index 4ef7bc96..2ff5f529 100644
--- a/libbitcoinkernel-sys/bitcoin/src/rpc/blockchain.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/rpc/blockchain.cpp
@@ -185,9 +185,9 @@ UniValue blockToJSON(BlockManager& blockman, const CBlock& block, const CBlockIn
 {
     UniValue result = blockheaderToJSON(tip, blockindex, pow_limit);
 
-    result.pushKV("strippedsize", ::GetSerializeSize(TX_NO_WITNESS(block)));
-    result.pushKV("size", ::GetSerializeSize(TX_WITH_WITNESS(block)));
-    result.pushKV("weight", ::GetBlockWeight(block));
+    result.pushKV("strippedsize", (int)::GetSerializeSize(TX_NO_WITNESS(block)));
+    result.pushKV("size", (int)::GetSerializeSize(TX_WITH_WITNESS(block)));
+    result.pushKV("weight", (int)::GetBlockWeight(block));
     UniValue txs(UniValue::VARR);
     txs.reserve(block.vtx.size());
 
@@ -2033,7 +2033,7 @@ static RPCHelpMan getblockstats()
             for (const CTxOut& out : tx->vout) {
                 tx_total_out += out.nValue;
 
-                uint64_t out_size{GetSerializeSize(out) + PER_UTXO_OVERHEAD};
+                size_t out_size = GetSerializeSize(out) + PER_UTXO_OVERHEAD;
                 utxo_size_inc += out_size;
 
                 // The Genesis block and the repeated BIP30 block coinbases don't change the UTXO
@@ -2085,7 +2085,7 @@ static RPCHelpMan getblockstats()
                 const CTxOut& prevoutput = coin.out;
 
                 tx_total_in += prevoutput.nValue;
-                uint64_t prevout_size{GetSerializeSize(prevoutput) + PER_UTXO_OVERHEAD};
+                size_t prevout_size = GetSerializeSize(prevoutput) + PER_UTXO_OVERHEAD;
                 utxo_size_inc -= prevout_size;
                 utxo_size_inc_actual -= prevout_size;
             }
diff --git a/libbitcoinkernel-sys/bitcoin/src/serialize.h b/libbitcoinkernel-sys/bitcoin/src/serialize.h
index 4da48a0b..e88a25fa 100644
--- a/libbitcoinkernel-sys/bitcoin/src/serialize.h
+++ b/libbitcoinkernel-sys/bitcoin/src/serialize.h
@@ -1051,32 +1051,31 @@ struct ActionUnserialize {
 class SizeComputer
 {
 protected:
-    uint64_t m_size{0};
+    size_t nSize{0};
 
 public:
     SizeComputer() = default;
 
     void write(std::span<const std::byte> src)
     {
-        m_size += src.size();
+        this->nSize += src.size();
     }
 
-    /** Pretend this many bytes are written, without specifying them. */
-    void seek(uint64_t num)
+    /** Pretend _nSize bytes are written, without specifying them. */
+    void seek(size_t _nSize)
     {
-        m_size += num;
+        this->nSize += _nSize;
     }
 
-    template <typename T>
+    template<typename T>
     SizeComputer& operator<<(const T& obj)
     {
         ::Serialize(*this, obj);
-        return *this;
+        return (*this);
     }
 
-    uint64_t size() const
-    {
-        return m_size;
+    size_t size() const {
+        return nSize;
     }
 };
 
@@ -1092,7 +1091,7 @@ inline void WriteCompactSize(SizeComputer &s, uint64_t nSize)
 }
 
 template <typename T>
-uint64_t GetSerializeSize(const T& t)
+size_t GetSerializeSize(const T& t)
 {
     return (SizeComputer() << t).size();
 }
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/arith_uint256_tests.cpp b/libbitcoinkernel-sys/bitcoin/src/test/arith_uint256_tests.cpp
index b0d75cde..38ff46cc 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/arith_uint256_tests.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/arith_uint256_tests.cpp
@@ -368,7 +368,7 @@ static bool almostEqual(double d1, double d2)
     return fabs(d1-d2) <= 4*fabs(d1)*std::numeric_limits<double>::epsilon();
 }
 
-BOOST_AUTO_TEST_CASE(methods)
+BOOST_AUTO_TEST_CASE(methods) // GetHex operator= size() GetLow64 GetSerializeSize, Serialize, Unserialize
 {
     BOOST_CHECK(R1L.GetHex() == R1L.ToString());
     BOOST_CHECK(R2L.GetHex() == R2L.ToString());
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/blockmanager_tests.cpp b/libbitcoinkernel-sys/bitcoin/src/test/blockmanager_tests.cpp
index a3504da6..e6d5f153 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/blockmanager_tests.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/blockmanager_tests.cpp
@@ -17,7 +17,6 @@
 #include <test/util/logging.h>
 #include <test/util/setup_common.h>
 
-using kernel::CBlockFileInfo;
 using node::STORAGE_HEADER_BYTES;
 using node::BlockManager;
 using node::KernelNotifications;
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/flatfile_tests.cpp b/libbitcoinkernel-sys/bitcoin/src/test/flatfile_tests.cpp
index 5ef603ca..d94cab64 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/flatfile_tests.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/flatfile_tests.cpp
@@ -39,8 +39,8 @@ BOOST_AUTO_TEST_CASE(flatfile_open)
     std::string line2("Digital signatures provide part of the solution, but the main benefits are "
                       "lost if a trusted third party is still required to prevent double-spending.");
 
-    uint64_t pos1{0};
-    uint64_t pos2{pos1 + GetSerializeSize(line1)};
+    size_t pos1 = 0;
+    size_t pos2 = pos1 + GetSerializeSize(line1);
 
     // Write first line to file.
     {
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/fuzz/block_index.cpp b/libbitcoinkernel-sys/bitcoin/src/test/fuzz/block_index.cpp
index 8e7210e5..5bc6240c 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/fuzz/block_index.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/fuzz/block_index.cpp
@@ -12,8 +12,6 @@
 #include <txdb.h>
 #include <validation.h>
 
-using kernel::CBlockFileInfo;
-
 namespace {
 
 const BasicTestingSetup* g_setup;
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/fuzz/deserialize.cpp b/libbitcoinkernel-sys/bitcoin/src/test/fuzz/deserialize.cpp
index 97985ef0..05ca62b6 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/fuzz/deserialize.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/fuzz/deserialize.cpp
@@ -17,7 +17,6 @@
 #include <net.h>
 #include <netbase.h>
 #include <netgroup.h>
-#include <node/blockstorage.h>
 #include <node/utxo_snapshot.h>
 #include <primitives/block.h>
 #include <protocol.h>
@@ -35,7 +34,6 @@
 #include <optional>
 #include <stdexcept>
 
-using kernel::CBlockFileInfo;
 using node::SnapshotMetadata;
 
 namespace {
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/fuzz/miniscript.cpp b/libbitcoinkernel-sys/bitcoin/src/test/fuzz/miniscript.cpp
index 42195313..aea31c6f 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/fuzz/miniscript.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/fuzz/miniscript.cpp
@@ -1120,7 +1120,7 @@ void TestNode(const MsCtx script_ctx, const NodeRef& node, FuzzedDataProvider& p
         assert(mal_success);
         assert(stack_nonmal == stack_mal);
         // Compute witness size (excluding script push, control block, and witness count encoding).
-        const uint64_t wit_size{GetSerializeSize(stack_nonmal) - GetSizeOfCompactSize(stack_nonmal.size())};
+        const size_t wit_size = GetSerializeSize(stack_nonmal) - GetSizeOfCompactSize(stack_nonmal.size());
         assert(wit_size <= *node->GetWitnessSize());
 
         // Test non-malleable satisfaction.
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/kernel/test_kernel.cpp b/libbitcoinkernel-sys/bitcoin/src/test/kernel/test_kernel.cpp
index 75c9e466..4040849d 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/kernel/test_kernel.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/kernel/test_kernel.cpp
@@ -14,6 +14,7 @@
 #include <cstdint>
 #include <cstdlib>
 #include <filesystem>
+#include <format>
 #include <iostream>
 #include <memory>
 #include <optional>
@@ -145,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()};
@@ -394,12 +395,6 @@ BOOST_AUTO_TEST_CASE(btck_transaction_tests)
     auto tx2{Transaction{tx_data_2}};
     CheckHandle(tx, tx2);
 
-    auto invalid_data = hex_string_to_byte_vec("012300");
-    BOOST_CHECK_THROW(Transaction{invalid_data}, std::runtime_error);
-    auto empty_data = hex_string_to_byte_vec("");
-    BOOST_CHECK_THROW(Transaction{empty_data}, std::runtime_error);
-    BOOST_CHECK_THROW(Transaction{std::span<std::byte>(static_cast<std::byte*>(nullptr), 2)}, std::runtime_error);
-
     BOOST_CHECK_EQUAL(tx.CountOutputs(), 2);
     BOOST_CHECK_EQUAL(tx.CountInputs(), 1);
     auto broken_tx_data{std::span<std::byte>{tx_data.begin(), tx_data.begin() + 10}};
@@ -474,8 +469,6 @@ BOOST_AUTO_TEST_CASE(btck_script_pubkey)
     ScriptPubkey script{script_data};
     ScriptPubkey script2{script_data_2};
     CheckHandle(script, script2);
-
-    BOOST_CHECK_THROW(ScriptPubkey{std::span<std::byte>(static_cast<std::byte*>(nullptr), 2)}, std::runtime_error);
 }
 
 BOOST_AUTO_TEST_CASE(btck_transaction_output)
@@ -498,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
@@ -588,11 +589,6 @@ BOOST_AUTO_TEST_CASE(btck_block)
     CheckHandle(block, block_100);
     Block block_tx{hex_string_to_byte_vec(REGTEST_BLOCK_DATA[205])};
     CheckRange(block_tx.Transactions(), block_tx.CountTransactions());
-    auto invalid_data = hex_string_to_byte_vec("012300");
-    BOOST_CHECK_THROW(Block{invalid_data}, std::runtime_error);
-    auto empty_data = hex_string_to_byte_vec("");
-    BOOST_CHECK_THROW(Block{empty_data}, std::runtime_error);
-    BOOST_CHECK_THROW(Block{std::span<std::byte>(static_cast<std::byte*>(nullptr), 2)}, std::runtime_error);
 }
 
 Context create_context(std::shared_ptr<TestKernelNotifications> notifications, ChainType chain_type, std::shared_ptr<TestValidationInterface> validation_interface = nullptr)
@@ -725,6 +721,17 @@ void chainman_mainnet_validation_test(TestDirectory& test_directory)
     auto context{create_context(notifications, ChainType::MAINNET, validation_interface)};
     auto chainman{create_chainman(test_directory, false, false, false, false, context)};
 
+    {
+        // Process an invalid block
+        auto raw_block = hex_string_to_byte_vec("012300");
+        BOOST_CHECK_THROW(Block{raw_block}, std::runtime_error);
+    }
+    {
+        // Process an empty block
+        auto raw_block = hex_string_to_byte_vec("");
+        BOOST_CHECK_THROW(Block{raw_block}, std::runtime_error);
+    }
+
     // mainnet block 1
     auto raw_block = hex_string_to_byte_vec("010000006fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000982051fd1e4ba744bbbe680e1fee14677ba1a3c3540bf7b1cdb606e857233e0e61bc6649ffff001d01e362990101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0704ffff001d0104ffffffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac00000000");
     Block block{raw_block};
@@ -827,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.
@@ -880,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()) {
@@ -895,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/miner_tests.cpp b/libbitcoinkernel-sys/bitcoin/src/test/miner_tests.cpp
index a3c576dd..94ade598 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/miner_tests.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/miner_tests.cpp
@@ -188,7 +188,7 @@ void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const
     tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 0 fee
     Txid hashFreeTx = tx.GetHash();
     AddToMempool(tx_mempool, entry.Fee(0).FromTx(tx));
-    uint64_t freeTxSize{::GetSerializeSize(TX_WITH_WITNESS(tx))};
+    size_t freeTxSize = ::GetSerializeSize(TX_WITH_WITNESS(tx));
 
     // Calculate a fee on child transaction that will put the package just
     // below the block min tx fee (assuming 1 child tx of the same size).
diff --git a/libbitcoinkernel-sys/bitcoin/src/test/miniscript_tests.cpp b/libbitcoinkernel-sys/bitcoin/src/test/miniscript_tests.cpp
index 4d31968c..0a32727f 100644
--- a/libbitcoinkernel-sys/bitcoin/src/test/miniscript_tests.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/test/miniscript_tests.cpp
@@ -372,7 +372,7 @@ void TestSatisfy(const KeyConverter& converter, const std::string& testcase, con
             CScriptWitness witness_nonmal;
             const bool nonmal_success = node->Satisfy(satisfier, witness_nonmal.stack, true) == miniscript::Availability::YES;
             // Compute witness size (excluding script push, control block, and witness count encoding).
-            const uint64_t wit_size{GetSerializeSize(witness_nonmal.stack) - GetSizeOfCompactSize(witness_nonmal.stack.size())};
+            const size_t wit_size = GetSerializeSize(witness_nonmal.stack) - GetSizeOfCompactSize(witness_nonmal.stack.size());
             SatisfactionToWitness(converter.MsContext(), witness_nonmal, script, builder);
 
             if (nonmal_success) {
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/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/src/wallet/spend.cpp b/libbitcoinkernel-sys/bitcoin/src/wallet/spend.cpp
index bd7bb01f..146fb49e 100644
--- a/libbitcoinkernel-sys/bitcoin/src/wallet/spend.cpp
+++ b/libbitcoinkernel-sys/bitcoin/src/wallet/spend.cpp
@@ -1034,7 +1034,7 @@ void DiscourageFeeSniping(CMutableTransaction& tx, FastRandomContext& rng_fast,
     }
 }
 
-uint64_t GetSerializeSizeForRecipient(const CRecipient& recipient)
+size_t GetSerializeSizeForRecipient(const CRecipient& recipient)
 {
     return ::GetSerializeSize(CTxOut(recipient.nAmount, GetScriptForDestination(recipient.dest)));
 }
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 bb338d24..203173bf 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,122 @@ 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) }
+    }
+}
+
+impl TryFrom<&[u8]> for BlockHeader {
+    type Error = KernelError;
+
+    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
+        BlockHeader::new(bytes)
+    }
+}
+
+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 +661,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 +1014,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 +1599,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 +1731,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/mod.rs b/src/core/mod.rs
index 083922d7..33bbcf93 100644
--- a/src/core/mod.rs
+++ b/src/core/mod.rs
@@ -5,7 +5,7 @@ pub mod transaction;
 pub mod verify;
 
 pub use block::{
-    Block, BlockHash, BlockSpentOutputs, BlockSpentOutputsRef, Coin, CoinRef,
+    Block, BlockHash, BlockHeader, BlockSpentOutputs, BlockSpentOutputsRef, Coin, CoinRef,
     TransactionSpentOutputs, TransactionSpentOutputsRef,
 };
 pub use block_tree_entry::BlockTreeEntry;
diff --git a/src/core/transaction.rs b/src/core/transaction.rs
index be348fae..0ca05160 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/lib.rs b/src/lib.rs
index b7f26d54..265a2adb 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -291,8 +291,8 @@ impl std::error::Error for KernelError {
 }
 
 pub use crate::core::{
-    verify, Block, BlockHash, BlockSpentOutputs, BlockSpentOutputsRef, BlockTreeEntry, Coin,
-    CoinRef, ScriptPubkey, ScriptPubkeyRef, ScriptVerifyError, Transaction, TransactionRef,
+    verify, Block, BlockHash, BlockHeader, BlockSpentOutputs, BlockSpentOutputsRef, BlockTreeEntry,
+    Coin, CoinRef, ScriptPubkey, ScriptPubkeyRef, ScriptVerifyError, Transaction, TransactionRef,
     TransactionSpentOutputs, TransactionSpentOutputsRef, TxIn, TxInRef, TxOut, TxOutPoint,
     TxOutPointRef, TxOutRef, Txid, TxidRef,
 };
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 43be8f66..586d1e80 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..91c83d67 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,
+        prelude::*, verify, Block, BlockHash, BlockHeader, 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,83 @@ 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 header: BlockHeader = block.header().clone();
+            let (accepted, state) = chainman.process_header(&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();