diff --git a/src/bench/checkblock.cpp b/src/bench/checkblock.cpp
index cbba543f2d8..9faf9ac137a 100644
--- a/src/bench/checkblock.cpp
+++ b/src/bench/checkblock.cpp
@@ -4,22 +4,14 @@
 
 #include <bench/bench.h>
 #include <bench/data/block413567.raw.h>
-#include <chainparams.h>
-#include <common/args.h>
 #include <consensus/validation.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
-#include <serialize.h>
-#include <span.h>
 #include <streams.h>
-#include <util/chaintype.h>
 #include <validation.h>
 
 #include <cassert>
 #include <cstddef>
-#include <memory>
-#include <optional>
-#include <vector>
 
 // These are the two major time-sinks which happen after we have fully received
 // a block off the wire, but before we can relay the block on to peers using
@@ -27,27 +19,29 @@
 
 static void DeserializeBlockTest(benchmark::Bench& bench)
 {
-    DataStream stream;
-    bench.unit("block").epochIterations(1)
-        .setup([&] { stream = DataStream{benchmark::data::block413567}; })
-        .run([&] { CBlock block; stream >> TX_WITH_WITNESS(block); });
+    const auto block_data{benchmark::data::block413567};
+    bench.unit("block").run([&] {
+        CBlock block;
+        SpanReader{block_data} >> TX_WITH_WITNESS(block);
+        assert(block.vtx.size() == 1557);
+    });
 }
 
 static void CheckBlockTest(benchmark::Bench& bench)
 {
-    ArgsManager bench_args;
-    const auto chainParams = CreateChainParams(bench_args, ChainType::MAIN);
+    const auto& chain_params{CChainParams::Main()};
+    const auto block_data{benchmark::data::block413567};
 
     CBlock block;
     bench.unit("block").epochIterations(1)
         .setup([&] {
             block = CBlock{};
-            DataStream stream{benchmark::data::block413567};
-            stream >> TX_WITH_WITNESS(block);
+            SpanReader{block_data} >> TX_WITH_WITNESS(block);
+            assert(block.vtx.size() == 1557);
         })
         .run([&] {
             BlockValidationState validationState;
-            bool checked = CheckBlock(block, validationState, chainParams->GetConsensus());
+            const bool checked{CheckBlock(block, validationState, chain_params->GetConsensus())};
             assert(checked);
         });
 }
diff --git a/src/bench/prevector.cpp b/src/bench/prevector.cpp
index 8d386ec2c44..e842aec4ed2 100644
--- a/src/bench/prevector.cpp
+++ b/src/bench/prevector.cpp
@@ -66,22 +66,22 @@ static void PrevectorResize(benchmark::Bench& bench)
 template <typename T>
 static void PrevectorDeserialize(benchmark::Bench& bench)
 {
-    DataStream s0{};
+    DataStream data{};
     prevector<CScriptBase::STATIC_SIZE, T> t0;
     t0.resize(CScriptBase::STATIC_SIZE);
     for (auto x = 0; x < 900; ++x) {
-        s0 << t0;
+        data << t0;
     }
     t0.resize(100);
-    for (auto x = 0; x < 101; ++x) {
-        s0 << t0;
+    for (auto x = 0; x < 100; ++x) {
+        data << t0;
     }
     bench.batch(1000).run([&] {
+        SpanReader s0{data};
         prevector<CScriptBase::STATIC_SIZE, T> t1;
         for (auto x = 0; x < 1000; ++x) {
             s0 >> t1;
         }
-        s0.Rewind();
     });
 }
 
diff --git a/src/bench/rpc_blockchain.cpp b/src/bench/rpc_blockchain.cpp
index 0e89ac78a13..fe83c4a26f7 100644
--- a/src/bench/rpc_blockchain.cpp
+++ b/src/bench/rpc_blockchain.cpp
@@ -31,10 +31,7 @@ struct TestBlockAndIndex {
 
     TestBlockAndIndex()
     {
-        DataStream stream{benchmark::data::block413567};
-        std::byte a{0};
-        stream.write({&a, 1}); // Prevent compaction
-
+        SpanReader stream{benchmark::data::block413567};
         stream >> TX_WITH_WITNESS(block);
 
         blockHash = block.GetHash();
diff --git a/src/streams.h b/src/streams.h
index d6d6d57fb93..6ef9d164494 100644
--- a/src/streams.h
+++ b/src/streams.h
@@ -206,27 +206,6 @@ public:
     value_type* data()                               { return vch.data() + m_read_pos; }
     const value_type* data() const                   { return vch.data() + m_read_pos; }
 
-    inline void Compact()
-    {
-        vch.erase(vch.begin(), vch.begin() + m_read_pos);
-        m_read_pos = 0;
-    }
-
-    bool Rewind(std::optional<size_type> n = std::nullopt)
-    {
-        // Total rewind if no size is passed
-        if (!n) {
-            m_read_pos = 0;
-            return true;
-        }
-        // Rewind by n characters if the buffer hasn't been compacted yet
-        if (*n > m_read_pos)
-            return false;
-        m_read_pos -= *n;
-        return true;
-    }
-
-
     //
     // Stream subset
     //
@@ -243,8 +222,8 @@ public:
         }
         memcpy(dst.data(), &vch[m_read_pos], dst.size());
         if (next_read_pos.value() == vch.size()) {
-            m_read_pos = 0;
-            vch.clear();
+            // If fully consumed, reset to empty state.
+            clear();
             return;
         }
         m_read_pos = next_read_pos.value();
@@ -258,8 +237,8 @@ public:
             throw std::ios_base::failure("DataStream::ignore(): end of data");
         }
         if (next_read_pos.value() == vch.size()) {
-            m_read_pos = 0;
-            vch.clear();
+            // If all bytes are ignored, reset to empty state.
+            clear();
             return;
         }
         m_read_pos = next_read_pos.value();