From e8f8e581c4531366517261feb85c39ffd78b121f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?=
 <3044353+pwojcikdev@users.noreply.github.com>
Date: Fri, 6 Jun 2025 01:16:43 +0200
Subject: [PATCH] Use span in `db_val` instead of database specific types

---
 nano/node/wallet.cpp                |  36 +++++---
 nano/store/CMakeLists.txt           |   3 -
 nano/store/db_val.cpp               |   1 -
 nano/store/db_val.hpp               | 136 +++++++++++++---------------
 nano/store/db_val_impl.hpp          | 106 ++++++++++++++--------
 nano/store/lmdb/db_val.cpp          |  25 -----
 nano/store/lmdb/db_val.hpp          |   4 +-
 nano/store/lmdb/lmdb.cpp            |  26 ++++--
 nano/store/lmdb/wallet_value.cpp    |   6 +-
 nano/store/lmdb/wallet_value.hpp    |   4 +-
 nano/store/rocksdb/db_val.cpp       |  25 -----
 nano/store/rocksdb/db_val.hpp       |   4 +-
 nano/store/typed_iterator_templ.hpp |   6 +-
 13 files changed, 187 insertions(+), 195 deletions(-)
 delete mode 100644 nano/store/db_val.cpp
 delete mode 100644 nano/store/lmdb/db_val.cpp
 delete mode 100644 nano/store/rocksdb/db_val.cpp

diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp
index 2fd0f190..d9ce9b1a 100644
--- a/nano/node/wallet.cpp
+++ b/nano/node/wallet.cpp
@@ -279,7 +279,8 @@ nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, store::trans
 	if (!init_a)
 	{
 		MDB_val junk;
-		debug_assert (mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (version_special), &junk) == MDB_NOTFOUND);
+		nano::store::lmdb::db_val version_key (version_special);
+		debug_assert (mdb_get (env.tx (transaction_a), handle, version_key.mdb_val_ptr (), &junk) == MDB_NOTFOUND);
 		boost::property_tree::ptree wallet_l;
 		std::stringstream istream (json_a);
 		try
@@ -312,11 +313,15 @@ nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, store::trans
 				init_a = true;
 			}
 		}
-		init_a |= mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (version_special), &junk) != 0;
-		init_a |= mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (wallet_key_special), &junk) != 0;
-		init_a |= mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (salt_special), &junk) != 0;
-		init_a |= mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (check_special), &junk) != 0;
-		init_a |= mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (representative_special), &junk) != 0;
+		nano::store::lmdb::db_val wallet_key_key (wallet_key_special);
+		nano::store::lmdb::db_val salt_key (salt_special);
+		nano::store::lmdb::db_val check_key (check_special);
+		init_a |= mdb_get (env.tx (transaction_a), handle, version_key.mdb_val_ptr (), &junk) != 0;
+		init_a |= mdb_get (env.tx (transaction_a), handle, wallet_key_key.mdb_val_ptr (), &junk) != 0;
+		init_a |= mdb_get (env.tx (transaction_a), handle, salt_key.mdb_val_ptr (), &junk) != 0;
+		init_a |= mdb_get (env.tx (transaction_a), handle, check_key.mdb_val_ptr (), &junk) != 0;
+		nano::store::lmdb::db_val rep_key (representative_special);
+		init_a |= mdb_get (env.tx (transaction_a), handle, rep_key.mdb_val_ptr (), &junk) != 0;
 		nano::raw_key key;
 		key.clear ();
 		password.value_set (key);
@@ -337,7 +342,8 @@ nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, store::trans
 	{
 		int version_status;
 		MDB_val version_value;
-		version_status = mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (version_special), &version_value);
+		nano::store::lmdb::db_val version_lookup_key (version_special);
+		version_status = mdb_get (env.tx (transaction_a), handle, version_lookup_key.mdb_val_ptr (), &version_value);
 		if (version_status == MDB_NOTFOUND)
 		{
 			version_put (transaction_a, version_current);
@@ -439,7 +445,8 @@ bool nano::wallet_store::insert_watch (store::transaction const & transaction_a,
 
 void nano::wallet_store::erase (store::transaction const & transaction_a, nano::account const & pub)
 {
-	auto status (mdb_del (env.tx (transaction_a), handle, nano::store::lmdb::db_val (pub), nullptr));
+	nano::store::lmdb::db_val pub_key (pub);
+	auto status (mdb_del (env.tx (transaction_a), handle, pub_key.mdb_val_ptr (), nullptr));
 	(void)status;
 	debug_assert (status == 0);
 }
@@ -448,7 +455,8 @@ nano::wallet_value nano::wallet_store::entry_get_raw (store::transaction const &
 {
 	nano::wallet_value result;
 	nano::store::lmdb::db_val value;
-	auto status (mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (pub_a), value));
+	nano::store::lmdb::db_val pub_key (pub_a);
+	auto status (mdb_get (env.tx (transaction_a), handle, pub_key.mdb_val_ptr (), value.mdb_val_ptr ()));
 	if (status == 0)
 	{
 		result = nano::wallet_value (value);
@@ -463,7 +471,9 @@ nano::wallet_value nano::wallet_store::entry_get_raw (store::transaction const &
 
 void nano::wallet_store::entry_put_raw (store::transaction const & transaction_a, nano::account const & pub_a, nano::wallet_value const & entry_a)
 {
-	auto status (mdb_put (env.tx (transaction_a), handle, nano::store::lmdb::db_val (pub_a), nano::store::lmdb::db_val (sizeof (entry_a), const_cast<nano::wallet_value *> (&entry_a)), 0));
+	nano::store::lmdb::db_val pub_key (pub_a);
+	nano::store::lmdb::db_val entry_val (sizeof (entry_a), const_cast<nano::wallet_value *> (&entry_a));
+	auto status (mdb_put (env.tx (transaction_a), handle, pub_key.mdb_val_ptr (), entry_val.mdb_val_ptr (), 0));
 	(void)status;
 	debug_assert (status == 0);
 }
@@ -1003,9 +1013,10 @@ std::shared_ptr<nano::block> nano::wallet::send_action (nano::account const & so
 		if (id_mdb_val)
 		{
 			nano::store::lmdb::db_val result;
-			auto status (mdb_get (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, *id_mdb_val, result));
+			auto status (mdb_get (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, id_mdb_val->mdb_val_ptr (), result.mdb_val_ptr ()));
 			if (status == 0)
 			{
+				result.span_view = std::span<uint8_t const> (static_cast<uint8_t const *> (result.cached_mdb_val.mv_data), result.cached_mdb_val.mv_size);
 				nano::block_hash hash (result);
 				block = wallets.node.ledger.any.block_get (block_transaction, hash);
 				if (block != nullptr)
@@ -1058,7 +1069,8 @@ std::shared_ptr<nano::block> nano::wallet::send_action (nano::account const & so
 						details.epoch = info->epoch ();
 						if (id_mdb_val && block != nullptr)
 						{
-							auto status (mdb_put (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, *id_mdb_val, nano::store::lmdb::db_val (block->hash ()), 0));
+							nano::store::lmdb::db_val hash_val (block->hash ());
+							auto status (mdb_put (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, id_mdb_val->mdb_val_ptr (), hash_val.mdb_val_ptr (), 0));
 							if (status != 0)
 							{
 								block = nullptr;
diff --git a/nano/store/CMakeLists.txt b/nano/store/CMakeLists.txt
index e3f4ef17..d5b4b248 100644
--- a/nano/store/CMakeLists.txt
+++ b/nano/store/CMakeLists.txt
@@ -61,13 +61,11 @@ add_library(
   block.cpp
   component.cpp
   confirmation_height.cpp
-  db_val.cpp
   iterator.cpp
   final_vote.cpp
   lmdb/account.cpp
   lmdb/block.cpp
   lmdb/confirmation_height.cpp
-  lmdb/db_val.cpp
   lmdb/final_vote.cpp
   lmdb/iterator.cpp
   lmdb/lmdb.cpp
@@ -88,7 +86,6 @@ add_library(
   rocksdb/account.cpp
   rocksdb/block.cpp
   rocksdb/confirmation_height.cpp
-  rocksdb/db_val.cpp
   rocksdb/final_vote.cpp
   rocksdb/iterator.cpp
   rocksdb/online_weight.cpp
diff --git a/nano/store/db_val.cpp b/nano/store/db_val.cpp
deleted file mode 100644
index cab8d8ef..00000000
--- a/nano/store/db_val.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include <nano/store/db_val.hpp>
diff --git a/nano/store/db_val.hpp b/nano/store/db_val.hpp
index 12b81a14..933376ab 100644
--- a/nano/store/db_val.hpp
+++ b/nano/store/db_val.hpp
@@ -8,6 +8,10 @@
 #include <nano/store/versioning.hpp>
 
 #include <cstddef>
+#include <span>
+
+#include <lmdb/libraries/liblmdb/lmdb.h>
+#include <rocksdb/slice.h>
 
 namespace nano
 {
@@ -22,44 +26,45 @@ class vote;
 namespace nano::store
 {
 /**
- * Encapsulates database specific container
+ * Encapsulates database values using std::span for type safety and backend independence
  */
-template <typename Val>
 class db_val
 {
 public:
-	db_val (Val const & value_a) :
-		value (value_a)
+	db_val () = default;
+
+	db_val (std::span<uint8_t const> span) :
+		span_view (span)
 	{
 	}
 
-	db_val () :
-		db_val (0, nullptr)
+	db_val (size_t size, void const * data) :
+		span_view (static_cast<uint8_t const *> (data), size)
 	{
 	}
 
 	db_val (std::nullptr_t) :
-		db_val (0, this)
+		span_view ()
 	{
 	}
 
 	db_val (nano::uint128_union const & val_a) :
-		db_val (sizeof (val_a), const_cast<nano::uint128_union *> (&val_a))
+		span_view (val_a.bytes.data (), sizeof (val_a))
 	{
 	}
 
 	db_val (nano::uint256_union const & val_a) :
-		db_val (sizeof (val_a), const_cast<nano::uint256_union *> (&val_a))
+		span_view (val_a.bytes.data (), sizeof (val_a))
 	{
 	}
 
 	db_val (nano::uint512_union const & val_a) :
-		db_val (sizeof (val_a), const_cast<nano::uint512_union *> (&val_a))
+		span_view (val_a.bytes.data (), sizeof (val_a))
 	{
 	}
 
 	db_val (nano::qualified_root const & val_a) :
-		db_val (sizeof (val_a), const_cast<nano::qualified_root *> (&val_a))
+		span_view (reinterpret_cast<uint8_t const *> (&val_a), sizeof (val_a))
 	{
 	}
 
@@ -82,13 +87,13 @@ public:
 	}
 
 	db_val (nano::block_info const & val_a) :
-		db_val (sizeof (val_a), const_cast<nano::block_info *> (&val_a))
+		span_view (reinterpret_cast<uint8_t const *> (&val_a), sizeof (val_a))
 	{
 		static_assert (std::is_standard_layout<nano::block_info>::value, "Standard layout is required");
 	}
 
 	db_val (nano::endpoint_key const & val_a) :
-		db_val (sizeof (val_a), const_cast<nano::endpoint_key *> (&val_a))
+		span_view (reinterpret_cast<uint8_t const *> (&val_a), sizeof (val_a))
 	{
 		static_assert (std::is_standard_layout<nano::endpoint_key>::value, "Standard layout is required");
 	}
@@ -114,7 +119,7 @@ public:
 		nano::block_info result;
 		debug_assert (size () == sizeof (result));
 		static_assert (sizeof (nano::block_info::account) + sizeof (nano::block_info::balance) == sizeof (result), "Packed class");
-		std::copy (reinterpret_cast<uint8_t const *> (data ()), reinterpret_cast<uint8_t const *> (data ()) + sizeof (result), reinterpret_cast<uint8_t *> (&result));
+		std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
 		return result;
 	}
 
@@ -124,7 +129,7 @@ public:
 
 	explicit operator nano::confirmation_height_info () const
 	{
-		nano::bufferstream stream (reinterpret_cast<uint8_t const *> (data ()), size ());
+		nano::bufferstream stream (span_view.data (), span_view.size ());
 		nano::confirmation_height_info result;
 		bool error (result.deserialize (stream));
 		(void)error;
@@ -169,7 +174,7 @@ public:
 
 	explicit operator std::array<char, 64> () const
 	{
-		nano::bufferstream stream (reinterpret_cast<uint8_t const *> (data ()), size ());
+		nano::bufferstream stream (span_view.data (), span_view.size ());
 		std::array<char, 64> result;
 		auto error = nano::try_read (stream, result);
 		(void)error;
@@ -180,7 +185,8 @@ public:
 	explicit operator nano::endpoint_key () const
 	{
 		nano::endpoint_key result;
-		std::copy (reinterpret_cast<uint8_t const *> (data ()), reinterpret_cast<uint8_t const *> (data ()) + sizeof (result), reinterpret_cast<uint8_t *> (&result));
+		debug_assert (span_view.size () == sizeof (result));
+		std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
 		return result;
 	}
 
@@ -199,53 +205,20 @@ public:
 	explicit operator std::shared_ptr<nano::block> () const;
 
 	template <typename Block>
-	std::shared_ptr<Block> convert_to_block () const
-	{
-		nano::bufferstream stream (reinterpret_cast<uint8_t const *> (data ()), size ());
-		auto error (false);
-		auto result (std::make_shared<Block> (error, stream));
-		debug_assert (!error);
-		return result;
-	}
+	std::shared_ptr<Block> convert_to_block () const;
 
-	explicit operator std::shared_ptr<nano::send_block> () const
-	{
-		return convert_to_block<nano::send_block> ();
-	}
+	explicit operator std::shared_ptr<nano::send_block> () const;
+	explicit operator std::shared_ptr<nano::receive_block> () const;
+	explicit operator std::shared_ptr<nano::open_block> () const;
+	explicit operator std::shared_ptr<nano::change_block> () const;
+	explicit operator std::shared_ptr<nano::state_block> () const;
 
-	explicit operator std::shared_ptr<nano::receive_block> () const
-	{
-		return convert_to_block<nano::receive_block> ();
-	}
-
-	explicit operator std::shared_ptr<nano::open_block> () const
-	{
-		return convert_to_block<nano::open_block> ();
-	}
-
-	explicit operator std::shared_ptr<nano::change_block> () const
-	{
-		return convert_to_block<nano::change_block> ();
-	}
-
-	explicit operator std::shared_ptr<nano::state_block> () const
-	{
-		return convert_to_block<nano::state_block> ();
-	}
-
-	explicit operator std::shared_ptr<nano::vote> () const
-	{
-		nano::bufferstream stream (reinterpret_cast<uint8_t const *> (data ()), size ());
-		auto error (false);
-		auto result (nano::make_shared<nano::vote> (error, stream));
-		debug_assert (!error);
-		return result;
-	}
+	explicit operator std::shared_ptr<nano::vote> () const;
 
 	explicit operator uint64_t () const
 	{
 		uint64_t result;
-		nano::bufferstream stream (reinterpret_cast<uint8_t const *> (data ()), size ());
+		nano::bufferstream stream (span_view.data (), span_view.size ());
 		auto error (nano::try_read (stream, result));
 		(void)error;
 		debug_assert (!error);
@@ -253,33 +226,54 @@ public:
 		return result;
 	}
 
-	operator Val * () const
+	void * data () const
 	{
-		// Allow passing a temporary to a non-c++ function which doesn't have constness
-		return const_cast<Val *> (&value);
+		return const_cast<void *> (static_cast<void const *> (span_view.data ()));
 	}
 
-	operator Val const & () const
+	size_t size () const
 	{
-		return value;
+		return span_view.size ();
 	}
 
-	// Must be specialized
-	void * data () const;
-	size_t size () const;
-	db_val (size_t size_a, void * data_a);
-	void convert_buffer_to_value ();
+	// Conversion to MDB_val for LMDB compatibility
+	operator MDB_val () const
+	{
+		return MDB_val{ span_view.size (), const_cast<void *> (static_cast<void const *> (span_view.data ())) };
+	}
 
-	Val value;
+	// Conversion to rocksdb::Slice for RocksDB compatibility
+	operator ::rocksdb::Slice () const
+	{
+		return ::rocksdb::Slice{ reinterpret_cast<char const *> (span_view.data ()), span_view.size () };
+	}
+
+	// Get MDB_val* for LMDB functions that need pointers  
+	MDB_val * mdb_val_ptr () const
+	{
+		cached_mdb_val = MDB_val{ span_view.size (), const_cast<void *> (static_cast<void const *> (span_view.data ())) };
+		return &cached_mdb_val;
+	}
+
+	void convert_buffer_to_value ()
+	{
+		if (buffer)
+		{
+			span_view = std::span<uint8_t const> (buffer->data (), buffer->size ());
+		}
+	}
+
+	std::span<uint8_t const> span_view;
 	std::shared_ptr<std::vector<uint8_t>> buffer;
+	mutable MDB_val cached_mdb_val; // For LMDB compatibility
 
 private:
 	template <typename T>
 	T convert () const
 	{
 		T result;
-		debug_assert (size () == sizeof (result));
-		std::copy (reinterpret_cast<uint8_t const *> (data ()), reinterpret_cast<uint8_t const *> (data ()) + sizeof (result), result.bytes.data ());
+		debug_assert (span_view.size () == sizeof (result));
+		std::copy (span_view.begin (), span_view.end (), result.bytes.data ());
 		return result;
 	}
 };
diff --git a/nano/store/db_val_impl.hpp b/nano/store/db_val_impl.hpp
index f2eaf488..50c48937 100644
--- a/nano/store/db_val_impl.hpp
+++ b/nano/store/db_val_impl.hpp
@@ -3,22 +3,20 @@
 #include <nano/lib/blocks.hpp>
 #include <nano/secure/account_info.hpp>
 #include <nano/secure/pending_info.hpp>
+#include <nano/secure/vote.hpp>
 #include <nano/store/db_val.hpp>
 
-template <typename T>
-nano::store::db_val<T>::db_val (nano::account_info const & val_a) :
-	db_val (val_a.db_size (), const_cast<nano::account_info *> (&val_a))
+inline nano::store::db_val::db_val (nano::account_info const & val_a) :
+	span_view (reinterpret_cast<uint8_t const *> (&val_a), val_a.db_size ())
 {
 }
 
-template <typename T>
-nano::store::db_val<T>::db_val (nano::account_info_v22 const & val_a) :
-	db_val (val_a.db_size (), const_cast<nano::account_info_v22 *> (&val_a))
+inline nano::store::db_val::db_val (nano::account_info_v22 const & val_a) :
+	span_view (reinterpret_cast<uint8_t const *> (&val_a), val_a.db_size ())
 {
 }
 
-template <typename T>
-nano::store::db_val<T>::db_val (std::shared_ptr<nano::block> const & val_a) :
+inline nano::store::db_val::db_val (std::shared_ptr<nano::block> const & val_a) :
 	buffer (std::make_shared<std::vector<uint8_t>> ())
 {
 	{
@@ -28,50 +26,44 @@ nano::store::db_val<T>::db_val (std::shared_ptr<nano::block> const & val_a) :
 	convert_buffer_to_value ();
 }
 
-template <typename T>
-nano::store::db_val<T>::db_val (nano::pending_info const & val_a) :
-	db_val (val_a.db_size (), const_cast<nano::pending_info *> (&val_a))
+inline nano::store::db_val::db_val (nano::pending_info const & val_a) :
+	span_view (reinterpret_cast<uint8_t const *> (&val_a), val_a.db_size ())
 {
 	static_assert (std::is_standard_layout<nano::pending_info>::value, "Standard layout is required");
 }
 
-template <typename T>
-nano::store::db_val<T>::db_val (nano::pending_key const & val_a) :
-	db_val (sizeof (val_a), const_cast<nano::pending_key *> (&val_a))
+inline nano::store::db_val::db_val (nano::pending_key const & val_a) :
+	span_view (reinterpret_cast<uint8_t const *> (&val_a), sizeof (val_a))
 {
 	static_assert (std::is_standard_layout<nano::pending_key>::value, "Standard layout is required");
 }
 
-template <typename T>
-nano::store::db_val<T>::operator nano::account_info () const
+inline nano::store::db_val::operator nano::account_info () const
 {
 	nano::account_info result;
-	debug_assert (size () == result.db_size ());
-	std::copy (reinterpret_cast<uint8_t const *> (data ()), reinterpret_cast<uint8_t const *> (data ()) + result.db_size (), reinterpret_cast<uint8_t *> (&result));
+	debug_assert (span_view.size () == result.db_size ());
+	std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
 	return result;
 }
 
-template <typename T>
-nano::store::db_val<T>::operator nano::account_info_v22 () const
+inline nano::store::db_val::operator nano::account_info_v22 () const
 {
 	nano::account_info_v22 result;
-	debug_assert (size () == result.db_size ());
-	std::copy (reinterpret_cast<uint8_t const *> (data ()), reinterpret_cast<uint8_t const *> (data ()) + result.db_size (), reinterpret_cast<uint8_t *> (&result));
+	debug_assert (span_view.size () == result.db_size ());
+	std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
 	return result;
 }
 
-template <typename T>
-nano::store::db_val<T>::operator std::shared_ptr<nano::block> () const
+inline nano::store::db_val::operator std::shared_ptr<nano::block> () const
 {
-	nano::bufferstream stream (reinterpret_cast<uint8_t const *> (data ()), size ());
+	nano::bufferstream stream (span_view.data (), span_view.size ());
 	std::shared_ptr<nano::block> result (nano::deserialize_block (stream));
 	return result;
 }
 
-template <typename T>
-nano::store::db_val<T>::operator nano::store::block_w_sideband () const
+inline nano::store::db_val::operator nano::store::block_w_sideband () const
 {
-	nano::bufferstream stream (reinterpret_cast<uint8_t const *> (data ()), size ());
+	nano::bufferstream stream (span_view.data (), span_view.size ());
 	nano::store::block_w_sideband block_w_sideband;
 	block_w_sideband.block = (nano::deserialize_block (stream));
 	auto error = block_w_sideband.sideband.deserialize (stream, block_w_sideband.block->type ());
@@ -80,21 +72,63 @@ nano::store::db_val<T>::operator nano::store::block_w_sideband () const
 	return block_w_sideband;
 }
 
-template <typename T>
-nano::store::db_val<T>::operator nano::pending_info () const
+inline nano::store::db_val::operator nano::pending_info () const
 {
 	nano::pending_info result;
-	debug_assert (size () == result.db_size ());
-	std::copy (reinterpret_cast<uint8_t const *> (data ()), reinterpret_cast<uint8_t const *> (data ()) + result.db_size (), reinterpret_cast<uint8_t *> (&result));
+	debug_assert (span_view.size () == result.db_size ());
+	std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
 	return result;
 }
 
-template <typename T>
-nano::store::db_val<T>::operator nano::pending_key () const
+inline nano::store::db_val::operator nano::pending_key () const
 {
 	nano::pending_key result;
-	debug_assert (size () == sizeof (result));
+	debug_assert (span_view.size () == sizeof (result));
 	static_assert (sizeof (nano::pending_key::account) + sizeof (nano::pending_key::hash) == sizeof (result), "Packed class");
-	std::copy (reinterpret_cast<uint8_t const *> (data ()), reinterpret_cast<uint8_t const *> (data ()) + sizeof (result), reinterpret_cast<uint8_t *> (&result));
+	std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
+	return result;
+}
+
+inline nano::store::db_val::operator std::shared_ptr<nano::vote> () const
+{
+	nano::bufferstream stream (span_view.data (), span_view.size ());
+	auto error (false);
+	auto result (nano::make_shared<nano::vote> (error, stream));
+	debug_assert (!error);
+	return result;
+}
+
+inline nano::store::db_val::operator std::shared_ptr<nano::send_block> () const
+{
+	return convert_to_block<nano::send_block> ();
+}
+
+inline nano::store::db_val::operator std::shared_ptr<nano::receive_block> () const
+{
+	return convert_to_block<nano::receive_block> ();
+}
+
+inline nano::store::db_val::operator std::shared_ptr<nano::open_block> () const
+{
+	return convert_to_block<nano::open_block> ();
+}
+
+inline nano::store::db_val::operator std::shared_ptr<nano::change_block> () const
+{
+	return convert_to_block<nano::change_block> ();
+}
+
+inline nano::store::db_val::operator std::shared_ptr<nano::state_block> () const
+{
+	return convert_to_block<nano::state_block> ();
+}
+
+template <typename Block>
+inline std::shared_ptr<Block> nano::store::db_val::convert_to_block () const
+{
+	nano::bufferstream stream (span_view.data (), span_view.size ());
+	auto error (false);
+	auto result (nano::make_shared<Block> (error, stream));
+	debug_assert (!error);
 	return result;
 }
diff --git a/nano/store/lmdb/db_val.cpp b/nano/store/lmdb/db_val.cpp
deleted file mode 100644
index 7896bbaa..00000000
--- a/nano/store/lmdb/db_val.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <nano/store/lmdb/db_val.hpp>
-
-template <>
-void * nano::store::lmdb::db_val::data () const
-{
-	return value.mv_data;
-}
-
-template <>
-std::size_t nano::store::lmdb::db_val::size () const
-{
-	return value.mv_size;
-}
-
-template <>
-nano::store::lmdb::db_val::db_val (std::size_t size_a, void * data_a) :
-	value ({ size_a, data_a })
-{
-}
-
-template <>
-void nano::store::lmdb::db_val::convert_buffer_to_value ()
-{
-	value = { buffer->size (), const_cast<uint8_t *> (buffer->data ()) };
-}
diff --git a/nano/store/lmdb/db_val.hpp b/nano/store/lmdb/db_val.hpp
index 3b4966f5..463b6f4f 100644
--- a/nano/store/lmdb/db_val.hpp
+++ b/nano/store/lmdb/db_val.hpp
@@ -2,9 +2,7 @@
 
 #include <nano/store/db_val.hpp>
 
-#include <lmdb/libraries/liblmdb/lmdb.h>
-
 namespace nano::store::lmdb
 {
-using db_val = store::db_val<MDB_val>;
+using db_val = store::db_val;
 }
diff --git a/nano/store/lmdb/lmdb.cpp b/nano/store/lmdb/lmdb.cpp
index 9fc1cb74..ffd08599 100644
--- a/nano/store/lmdb/lmdb.cpp
+++ b/nano/store/lmdb/lmdb.cpp
@@ -405,17 +405,23 @@ bool nano::store::lmdb::component::exists (store::transaction const & transactio
 
 int nano::store::lmdb::component::get (store::transaction const & transaction_a, tables table_a, nano::store::lmdb::db_val const & key_a, nano::store::lmdb::db_val & value_a) const
 {
-	return mdb_get (env.tx (transaction_a), table_to_dbi (table_a), key_a, value_a);
+	auto result = mdb_get (env.tx (transaction_a), table_to_dbi (table_a), key_a.mdb_val_ptr (), value_a.mdb_val_ptr ());
+	if (result == MDB_SUCCESS)
+	{
+		// Update value_a span_view to point to the retrieved data
+		value_a.span_view = std::span<uint8_t const> (static_cast<uint8_t const *> (value_a.cached_mdb_val.mv_data), value_a.cached_mdb_val.mv_size);
+	}
+	return result;
 }
 
 int nano::store::lmdb::component::put (store::write_transaction const & transaction_a, tables table_a, nano::store::lmdb::db_val const & key_a, nano::store::lmdb::db_val const & value_a) const
 {
-	return (mdb_put (env.tx (transaction_a), table_to_dbi (table_a), key_a, value_a, 0));
+	return (mdb_put (env.tx (transaction_a), table_to_dbi (table_a), key_a.mdb_val_ptr (), value_a.mdb_val_ptr (), 0));
 }
 
 int nano::store::lmdb::component::del (store::write_transaction const & transaction_a, tables table_a, nano::store::lmdb::db_val const & key_a) const
 {
-	return (mdb_del (env.tx (transaction_a), table_to_dbi (table_a), key_a, nullptr));
+	return (mdb_del (env.tx (transaction_a), table_to_dbi (table_a), key_a.mdb_val_ptr (), nullptr));
 }
 
 int nano::store::lmdb::component::drop (store::write_transaction const & transaction_a, tables table_a)
@@ -502,7 +508,8 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
 		// Copy all values to temporary table
 		for (typed_iterator<nano::uint256_union, nano::store::lmdb::db_val> i{ store::iterator{ iterator::begin (env.tx (transaction_a), table) } }, n{ store::iterator{ iterator::end (env.tx (transaction_a), table) } }; i != n; ++i)
 		{
-			auto s = mdb_put (env.tx (transaction_a), temp, nano::store::lmdb::db_val (i->first), i->second, MDB_APPEND);
+			nano::store::lmdb::db_val key_val (i->first);
+			auto s = mdb_put (env.tx (transaction_a), temp, key_val.mdb_val_ptr (), i->second.mdb_val_ptr (), MDB_APPEND);
 			release_assert_success (s);
 		}
 		release_assert (count (transaction_a, table) == count (transaction_a, temp));
@@ -511,7 +518,8 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
 		// Put values from copy
 		for (typed_iterator<nano::uint256_union, nano::store::lmdb::db_val> i{ store::iterator{ iterator::begin (env.tx (transaction_a), temp) } }, n{ store::iterator{ iterator::end (env.tx (transaction_a), temp) } }; i != n; ++i)
 		{
-			auto s = mdb_put (env.tx (transaction_a), table, nano::store::lmdb::db_val (i->first), i->second, MDB_APPEND);
+			nano::store::lmdb::db_val key_val (i->first);
+			auto s = mdb_put (env.tx (transaction_a), table, key_val.mdb_val_ptr (), i->second.mdb_val_ptr (), MDB_APPEND);
 			release_assert_success (s);
 		}
 		release_assert (count (transaction_a, table) == count (transaction_a, temp));
@@ -525,7 +533,9 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
 		// Copy all values to temporary table
 		for (typed_iterator<nano::pending_key, nano::pending_info> i{ store::iterator{ iterator::begin (env.tx (transaction_a), pending_store.pending_handle) } }, n{ store::iterator{ iterator::end (env.tx (transaction_a), pending_store.pending_handle) } }; i != n; ++i)
 		{
-			auto s = mdb_put (env.tx (transaction_a), temp, nano::store::lmdb::db_val (i->first), nano::store::lmdb::db_val (i->second), MDB_APPEND);
+			nano::store::lmdb::db_val key_val (i->first);
+			nano::store::lmdb::db_val value_val (i->second);
+			auto s = mdb_put (env.tx (transaction_a), temp, key_val.mdb_val_ptr (), value_val.mdb_val_ptr (), MDB_APPEND);
 			release_assert_success (s);
 		}
 		release_assert (count (transaction_a, pending_store.pending_handle) == count (transaction_a, temp));
@@ -533,7 +543,9 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
 		// Put values from copy
 		for (typed_iterator<nano::pending_key, nano::pending_info> i{ store::iterator{ iterator::begin (env.tx (transaction_a), temp) } }, n{ store::iterator{ iterator::end (env.tx (transaction_a), temp) } }; i != n; ++i)
 		{
-			auto s = mdb_put (env.tx (transaction_a), pending_store.pending_handle, nano::store::lmdb::db_val (i->first), nano::store::lmdb::db_val (i->second), MDB_APPEND);
+			nano::store::lmdb::db_val key_val (i->first);
+			nano::store::lmdb::db_val value_val (i->second);
+			auto s = mdb_put (env.tx (transaction_a), pending_store.pending_handle, key_val.mdb_val_ptr (), value_val.mdb_val_ptr (), MDB_APPEND);
 			release_assert_success (s);
 		}
 		release_assert (count (transaction_a, pending_store.pending_handle) == count (transaction_a, temp));
diff --git a/nano/store/lmdb/wallet_value.cpp b/nano/store/lmdb/wallet_value.cpp
index 60aefabe..32beb245 100644
--- a/nano/store/lmdb/wallet_value.cpp
+++ b/nano/store/lmdb/wallet_value.cpp
@@ -1,6 +1,6 @@
 #include <nano/store/lmdb/wallet_value.hpp>
 
-nano::wallet_value::wallet_value (nano::store::db_val<MDB_val> const & val_a)
+nano::wallet_value::wallet_value (nano::store::db_val const & val_a)
 {
 	debug_assert (val_a.size () == sizeof (*this));
 	std::copy (reinterpret_cast<uint8_t const *> (val_a.data ()), reinterpret_cast<uint8_t const *> (val_a.data ()) + sizeof (key), key.chars.begin ());
@@ -13,8 +13,8 @@ nano::wallet_value::wallet_value (nano::raw_key const & key_a, uint64_t work_a)
 {
 }
 
-nano::store::db_val<MDB_val> nano::wallet_value::val () const
+nano::store::db_val nano::wallet_value::val () const
 {
 	static_assert (sizeof (*this) == sizeof (key) + sizeof (work), "Class not packed");
-	return nano::store::db_val<MDB_val> (sizeof (*this), const_cast<nano::wallet_value *> (this));
+	return nano::store::db_val (sizeof (*this), const_cast<nano::wallet_value *> (this));
 }
diff --git a/nano/store/lmdb/wallet_value.hpp b/nano/store/lmdb/wallet_value.hpp
index d272ae96..669b777a 100644
--- a/nano/store/lmdb/wallet_value.hpp
+++ b/nano/store/lmdb/wallet_value.hpp
@@ -11,9 +11,9 @@ class wallet_value
 {
 public:
 	wallet_value () = default;
-	wallet_value (store::db_val<MDB_val> const &);
+	wallet_value (store::db_val const &);
 	wallet_value (nano::raw_key const &, uint64_t);
-	store::db_val<MDB_val> val () const;
+	store::db_val val () const;
 	nano::raw_key key;
 	uint64_t work;
 };
diff --git a/nano/store/rocksdb/db_val.cpp b/nano/store/rocksdb/db_val.cpp
deleted file mode 100644
index e31654bb..00000000
--- a/nano/store/rocksdb/db_val.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <nano/store/rocksdb/db_val.hpp>
-
-template <>
-void * nano::store::rocksdb::db_val::data () const
-{
-	return (void *)value.data ();
-}
-
-template <>
-std::size_t nano::store::rocksdb::db_val::size () const
-{
-	return value.size ();
-}
-
-template <>
-nano::store::rocksdb::db_val::db_val (std::size_t size_a, void * data_a) :
-	value (static_cast<char const *> (data_a), size_a)
-{
-}
-
-template <>
-void nano::store::rocksdb::db_val::convert_buffer_to_value ()
-{
-	value = ::rocksdb::Slice (reinterpret_cast<char const *> (buffer->data ()), buffer->size ());
-}
diff --git a/nano/store/rocksdb/db_val.hpp b/nano/store/rocksdb/db_val.hpp
index 9c1085ee..04b5754d 100644
--- a/nano/store/rocksdb/db_val.hpp
+++ b/nano/store/rocksdb/db_val.hpp
@@ -2,9 +2,7 @@
 
 #include <nano/store/db_val.hpp>
 
-#include <rocksdb/slice.h>
-
 namespace nano::store::rocksdb
 {
-using db_val = store::db_val<::rocksdb::Slice>;
+using db_val = store::db_val;
 }
diff --git a/nano/store/typed_iterator_templ.hpp b/nano/store/typed_iterator_templ.hpp
index 9ce464c1..f3053359 100644
--- a/nano/store/typed_iterator_templ.hpp
+++ b/nano/store/typed_iterator_templ.hpp
@@ -1,6 +1,5 @@
 #include <nano/lib/utility.hpp>
 #include <nano/store/db_val_impl.hpp>
-#include <nano/store/lmdb/db_val.hpp>
 #include <nano/store/typed_iterator.hpp>
 
 namespace nano::store
@@ -10,10 +9,9 @@ void typed_iterator<Key, Value>::update ()
 {
 	if (!iter.is_end ())
 	{
-		// FIXME Don't convert via lmdb::db_val, this is just a placeholder
 		auto const & data = *iter;
-		lmdb::db_val key_val{ MDB_val{ data.first.size (), const_cast<void *> (reinterpret_cast<void const *> (data.first.data ())) } };
-		lmdb::db_val value_val{ MDB_val{ data.second.size (), const_cast<void *> (reinterpret_cast<void const *> (data.second.data ())) } };
+		db_val key_val{ data.first };
+		db_val value_val{ data.second };
 		current = std::make_pair (static_cast<Key> (key_val), static_cast<Value> (value_val));
 	}
 	else