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 1/6] 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

From 9d6152d08c085984ad5db50a2ff490394433fce8 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 16:32:31 +0200
Subject: [PATCH 2/6] Remove database specific code from `db_val`

---
 nano/node/wallet.cpp                       | 61 +++++++++++++++-------
 nano/secure/common.hpp                     |  1 +
 nano/secure/ledger_set_any.cpp             |  1 +
 nano/secure/ledger_set_confirmed.cpp       |  1 +
 nano/store/db_val.hpp                      | 28 +---------
 nano/store/db_val_impl.hpp                 |  1 +
 nano/store/lmdb/account.cpp                |  3 +-
 nano/store/lmdb/block.cpp                  |  3 +-
 nano/store/lmdb/confirmation_height.cpp    |  3 +-
 nano/store/lmdb/final_vote.cpp             |  3 +-
 nano/store/lmdb/lmdb.cpp                   | 30 ++++++++---
 nano/store/lmdb/pending.cpp                |  3 +-
 nano/store/lmdb/pruned.cpp                 |  3 +-
 nano/store/lmdb/rep_weight.cpp             |  3 +-
 nano/store/rocksdb/account.cpp             |  3 +-
 nano/store/rocksdb/block.cpp               |  3 +-
 nano/store/rocksdb/confirmation_height.cpp |  3 +-
 nano/store/rocksdb/final_vote.cpp          |  3 +-
 nano/store/rocksdb/pending.cpp             |  3 +-
 nano/store/rocksdb/pruned.cpp              |  3 +-
 nano/store/rocksdb/rep_weight.cpp          |  3 +-
 nano/store/rocksdb/rocksdb.cpp             | 17 +++---
 22 files changed, 108 insertions(+), 74 deletions(-)

diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp
index d9ce9b1a..6d85ed3a 100644
--- a/nano/node/wallet.cpp
+++ b/nano/node/wallet.cpp
@@ -280,7 +280,8 @@ nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, store::trans
 	{
 		MDB_val junk;
 		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);
+		MDB_val mdb_version_key{ version_key.size (), version_key.data () };
+		debug_assert (mdb_get (env.tx (transaction_a), handle, &mdb_version_key, &junk) == MDB_NOTFOUND);
 		boost::property_tree::ptree wallet_l;
 		std::stringstream istream (json_a);
 		try
@@ -316,12 +317,17 @@ nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, store::trans
 		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;
+		MDB_val mdb_version_key2{ version_key.size (), version_key.data () };
+		MDB_val mdb_wallet_key_key{ wallet_key_key.size (), wallet_key_key.data () };
+		MDB_val mdb_salt_key{ salt_key.size (), salt_key.data () };
+		MDB_val mdb_check_key{ check_key.size (), check_key.data () };
+		init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_version_key2, &junk) != 0;
+		init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_wallet_key_key, &junk) != 0;
+		init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_salt_key, &junk) != 0;
+		init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_check_key, &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;
+		MDB_val mdb_rep_key{ rep_key.size (), rep_key.data () };
+		init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_rep_key, &junk) != 0;
 		nano::raw_key key;
 		key.clear ();
 		password.value_set (key);
@@ -343,7 +349,8 @@ nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, store::trans
 		int version_status;
 		MDB_val 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);
+		MDB_val mdb_version_lookup_key{ version_lookup_key.size (), version_lookup_key.data () };
+		version_status = mdb_get (env.tx (transaction_a), handle, &mdb_version_lookup_key, &version_value);
 		if (version_status == MDB_NOTFOUND)
 		{
 			version_put (transaction_a, version_current);
@@ -446,7 +453,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)
 {
 	nano::store::lmdb::db_val pub_key (pub);
-	auto status (mdb_del (env.tx (transaction_a), handle, pub_key.mdb_val_ptr (), nullptr));
+	MDB_val mdb_pub_key{ pub_key.size (), pub_key.data () };
+	auto status (mdb_del (env.tx (transaction_a), handle, &mdb_pub_key, nullptr));
 	(void)status;
 	debug_assert (status == 0);
 }
@@ -456,9 +464,12 @@ nano::wallet_value nano::wallet_store::entry_get_raw (store::transaction const &
 	nano::wallet_value result;
 	nano::store::lmdb::db_val 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 ()));
+	MDB_val mdb_pub_key{ pub_key.size (), pub_key.data () };
+	MDB_val mdb_value{};
+	auto status (mdb_get (env.tx (transaction_a), handle, &mdb_pub_key, &mdb_value));
 	if (status == 0)
 	{
+		value.span_view = std::span<uint8_t const> (static_cast<uint8_t const *> (mdb_value.mv_data), mdb_value.mv_size);
 		result = nano::wallet_value (value);
 	}
 	else
@@ -473,7 +484,9 @@ void nano::wallet_store::entry_put_raw (store::transaction const & transaction_a
 {
 	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));
+	MDB_val mdb_pub_key{ pub_key.size (), pub_key.data () };
+	MDB_val mdb_entry_val{ entry_val.size (), entry_val.data () };
+	auto status (mdb_put (env.tx (transaction_a), handle, &mdb_pub_key, &mdb_entry_val, 0));
 	(void)status;
 	debug_assert (status == 0);
 }
@@ -1013,10 +1026,12 @@ 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->mdb_val_ptr (), result.mdb_val_ptr ()));
+			MDB_val mdb_id_key{ id_mdb_val->size (), id_mdb_val->data () };
+			MDB_val mdb_result{};
+			auto status (mdb_get (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, &mdb_id_key, &mdb_result));
 			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);
+				result.span_view = std::span<uint8_t const> (static_cast<uint8_t const *> (mdb_result.mv_data), mdb_result.mv_size);
 				nano::block_hash hash (result);
 				block = wallets.node.ledger.any.block_get (block_transaction, hash);
 				if (block != nullptr)
@@ -1070,7 +1085,9 @@ std::shared_ptr<nano::block> nano::wallet::send_action (nano::account const & so
 						if (id_mdb_val && block != nullptr)
 						{
 							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));
+							MDB_val mdb_id_key{ id_mdb_val->size (), id_mdb_val->data () };
+							MDB_val mdb_hash_val{ hash_val.size (), hash_val.data () };
+							auto status (mdb_put (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, &mdb_id_key, &mdb_hash_val, 0));
 							if (status != 0)
 							{
 								block = nullptr;
@@ -1456,8 +1473,10 @@ nano::wallets::wallets (bool error_a, nano::node & node_a) :
 		nano::store::lmdb::db_val beginning_val{ beginning.size (), const_cast<char *> (beginning.c_str ()) };
 		std::string end ((nano::uint256_union (nano::uint256_t (0) - nano::uint256_t (1))).to_string ());
 		nano::store::lmdb::db_val end_val{ end.size (), const_cast<char *> (end.c_str ()) };
-		store::iterator i{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, beginning_val) };
-		store::iterator n{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, end_val) };
+		MDB_val mdb_beginning_val{ beginning_val.size (), beginning_val.data () };
+		MDB_val mdb_end_val{ end_val.size (), end_val.data () };
+		store::iterator i{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, mdb_beginning_val) };
+		store::iterator n{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, mdb_end_val) };
 		for (; i != n; ++i)
 		{
 			nano::wallet_id id;
@@ -1616,8 +1635,10 @@ void nano::wallets::reload ()
 	nano::store::lmdb::db_val beginning_val{ beginning.size (), const_cast<char *> (beginning.c_str ()) };
 	std::string end ((nano::uint256_union (nano::uint256_t (0) - nano::uint256_t (1))).to_string ());
 	nano::store::lmdb::db_val end_val{ end.size (), const_cast<char *> (end.c_str ()) };
-	store::iterator i{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, beginning_val) };
-	store::iterator n{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, end_val) };
+	MDB_val mdb_beginning_val{ beginning_val.size (), beginning_val.data () };
+	MDB_val mdb_end_val{ end_val.size (), end_val.data () };
+	store::iterator i{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, mdb_beginning_val) };
+	store::iterator n{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, mdb_end_val) };
 	for (; i != n; ++i)
 	{
 		nano::wallet_id id;
@@ -1862,14 +1883,16 @@ auto nano::wallet_store::begin (store::transaction const & transaction_a) -> ite
 {
 	nano::account account{ special_count };
 	nano::store::lmdb::db_val val{ account };
-	return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, val) } };
+	MDB_val mdb_val{ val.size (), val.data () };
+	return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, mdb_val) } };
 }
 
 auto nano::wallet_store::begin (store::transaction const & transaction_a, nano::account const & key) -> iterator
 {
 	nano::account account (key);
 	nano::store::lmdb::db_val val{ account };
-	return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, val) } };
+	MDB_val mdb_val{ val.size (), val.data () };
+	return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, mdb_val) } };
 }
 
 auto nano::wallet_store::find (store::transaction const & transaction_a, nano::account const & key) -> iterator
diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp
index 60b7ef31..f9f19fba 100644
--- a/nano/secure/common.hpp
+++ b/nano/secure/common.hpp
@@ -11,6 +11,7 @@
 #include <nano/lib/object_stream.hpp>
 #include <nano/lib/timer.hpp>
 #include <nano/lib/utility.hpp>
+#include <nano/store/block_w_sideband.hpp>
 
 #include <array>
 #include <unordered_map>
diff --git a/nano/secure/ledger_set_any.cpp b/nano/secure/ledger_set_any.cpp
index 5691cb39..6763264b 100644
--- a/nano/secure/ledger_set_any.cpp
+++ b/nano/secure/ledger_set_any.cpp
@@ -1,6 +1,7 @@
 #include <nano/secure/ledger.hpp>
 #include <nano/secure/ledger_set_any.hpp>
 #include <nano/store/account.hpp>
+#include <nano/store/block.hpp>
 #include <nano/store/component.hpp>
 #include <nano/store/pending.hpp>
 #include <nano/store/pruned.hpp>
diff --git a/nano/secure/ledger_set_confirmed.cpp b/nano/secure/ledger_set_confirmed.cpp
index 655f04ed..76cb58e1 100644
--- a/nano/secure/ledger_set_confirmed.cpp
+++ b/nano/secure/ledger_set_confirmed.cpp
@@ -1,6 +1,7 @@
 #include <nano/secure/ledger.hpp>
 #include <nano/secure/ledger_set_confirmed.hpp>
 #include <nano/store/account.hpp>
+#include <nano/store/block.hpp>
 #include <nano/store/component.hpp>
 #include <nano/store/confirmation_height.hpp>
 #include <nano/store/pending.hpp>
diff --git a/nano/store/db_val.hpp b/nano/store/db_val.hpp
index 933376ab..3e4d8af5 100644
--- a/nano/store/db_val.hpp
+++ b/nano/store/db_val.hpp
@@ -3,16 +3,10 @@
 #include <nano/lib/numbers.hpp>
 #include <nano/lib/stream.hpp>
 #include <nano/secure/common.hpp>
-#include <nano/store/block.hpp>
-#include <nano/store/component.hpp>
-#include <nano/store/versioning.hpp>
 
 #include <cstddef>
 #include <span>
 
-#include <lmdb/libraries/liblmdb/lmdb.h>
-#include <rocksdb/slice.h>
-
 namespace nano
 {
 class account_info;
@@ -236,25 +230,6 @@ public:
 		return span_view.size ();
 	}
 
-	// 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 ())) };
-	}
-
-	// 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)
@@ -265,7 +240,6 @@ public:
 
 	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>
@@ -277,4 +251,4 @@ private:
 		return result;
 	}
 };
-} // namespace nano::store
+}
diff --git a/nano/store/db_val_impl.hpp b/nano/store/db_val_impl.hpp
index 50c48937..54142860 100644
--- a/nano/store/db_val_impl.hpp
+++ b/nano/store/db_val_impl.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <nano/lib/blocks.hpp>
+#include <nano/lib/memory.hpp>
 #include <nano/secure/account_info.hpp>
 #include <nano/secure/pending_info.hpp>
 #include <nano/secure/vote.hpp>
diff --git a/nano/store/lmdb/account.cpp b/nano/store/lmdb/account.cpp
index c84b6ec1..607bee11 100644
--- a/nano/store/lmdb/account.cpp
+++ b/nano/store/lmdb/account.cpp
@@ -46,7 +46,8 @@ size_t nano::store::lmdb::account::count (store::transaction const & transaction
 auto nano::store::lmdb::account::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
 {
 	lmdb::db_val val{ account };
-	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), accounts_handle, val) } };
+	MDB_val mdb_val{ val.size (), val.data () };
+	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), accounts_handle, mdb_val) } };
 }
 
 auto nano::store::lmdb::account::begin (store::transaction const & transaction) const -> iterator
diff --git a/nano/store/lmdb/block.cpp b/nano/store/lmdb/block.cpp
index fe698808..dbd23167 100644
--- a/nano/store/lmdb/block.cpp
+++ b/nano/store/lmdb/block.cpp
@@ -130,7 +130,8 @@ auto nano::store::lmdb::block::begin (store::transaction const & transaction) co
 auto nano::store::lmdb::block::begin (store::transaction const & transaction, nano::block_hash const & hash) const -> iterator
 {
 	lmdb::db_val val{ hash };
-	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), blocks_handle, val) } };
+	MDB_val mdb_val{ val.size (), val.data () };
+	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), blocks_handle, mdb_val) } };
 }
 
 auto nano::store::lmdb::block::end (store::transaction const & transaction_a) const -> iterator
diff --git a/nano/store/lmdb/confirmation_height.cpp b/nano/store/lmdb/confirmation_height.cpp
index 48e319b1..3dd6cf6e 100644
--- a/nano/store/lmdb/confirmation_height.cpp
+++ b/nano/store/lmdb/confirmation_height.cpp
@@ -62,7 +62,8 @@ void nano::store::lmdb::confirmation_height::clear (store::write_transaction con
 auto nano::store::lmdb::confirmation_height::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
 {
 	lmdb::db_val val{ account };
-	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), confirmation_height_handle, val) } };
+	MDB_val mdb_val{ val.size (), val.data () };
+	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), confirmation_height_handle, mdb_val) } };
 }
 
 auto nano::store::lmdb::confirmation_height::begin (store::transaction const & transaction) const -> iterator
diff --git a/nano/store/lmdb/final_vote.cpp b/nano/store/lmdb/final_vote.cpp
index e6e0ea77..dcd52549 100644
--- a/nano/store/lmdb/final_vote.cpp
+++ b/nano/store/lmdb/final_vote.cpp
@@ -54,7 +54,8 @@ void nano::store::lmdb::final_vote::clear (store::write_transaction const & tran
 auto nano::store::lmdb::final_vote::begin (store::transaction const & transaction, nano::qualified_root const & root) const -> iterator
 {
 	lmdb::db_val val{ root };
-	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), final_votes_handle, val) } };
+	MDB_val mdb_val{ val.size (), val.data () };
+	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), final_votes_handle, mdb_val) } };
 }
 
 auto nano::store::lmdb::final_vote::begin (store::transaction const & transaction) const -> iterator
diff --git a/nano/store/lmdb/lmdb.cpp b/nano/store/lmdb/lmdb.cpp
index ffd08599..2ed6febe 100644
--- a/nano/store/lmdb/lmdb.cpp
+++ b/nano/store/lmdb/lmdb.cpp
@@ -405,23 +405,29 @@ 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
 {
-	auto result = mdb_get (env.tx (transaction_a), table_to_dbi (table_a), key_a.mdb_val_ptr (), value_a.mdb_val_ptr ());
+	MDB_val mdb_key{ key_a.size (), key_a.data () };
+	MDB_val mdb_value{};
+	
+	auto result = mdb_get (env.tx (transaction_a), table_to_dbi (table_a), &mdb_key, &mdb_value);
 	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);
+		value_a.span_view = std::span<uint8_t const> (static_cast<uint8_t const *> (mdb_value.mv_data), mdb_value.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.mdb_val_ptr (), value_a.mdb_val_ptr (), 0));
+	MDB_val mdb_key{ key_a.size (), key_a.data () };
+	MDB_val mdb_value{ value_a.size (), value_a.data () };
+	return (mdb_put (env.tx (transaction_a), table_to_dbi (table_a), &mdb_key, &mdb_value, 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.mdb_val_ptr (), nullptr));
+	MDB_val mdb_key{ key_a.size (), key_a.data () };
+	return (mdb_del (env.tx (transaction_a), table_to_dbi (table_a), &mdb_key, nullptr));
 }
 
 int nano::store::lmdb::component::drop (store::write_transaction const & transaction_a, tables table_a)
@@ -509,7 +515,9 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
 		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)
 		{
 			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);
+			MDB_val mdb_key{ key_val.size (), key_val.data () };
+			MDB_val mdb_value{ i->second.size (), i->second.data () };
+			auto s = mdb_put (env.tx (transaction_a), temp, &mdb_key, &mdb_value, MDB_APPEND);
 			release_assert_success (s);
 		}
 		release_assert (count (transaction_a, table) == count (transaction_a, temp));
@@ -519,7 +527,9 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
 		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)
 		{
 			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);
+			MDB_val mdb_key{ key_val.size (), key_val.data () };
+			MDB_val mdb_value{ i->second.size (), i->second.data () };
+			auto s = mdb_put (env.tx (transaction_a), table, &mdb_key, &mdb_value, MDB_APPEND);
 			release_assert_success (s);
 		}
 		release_assert (count (transaction_a, table) == count (transaction_a, temp));
@@ -535,7 +545,9 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
 		{
 			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);
+			MDB_val mdb_key{ key_val.size (), key_val.data () };
+			MDB_val mdb_value{ value_val.size (), value_val.data () };
+			auto s = mdb_put (env.tx (transaction_a), temp, &mdb_key, &mdb_value, MDB_APPEND);
 			release_assert_success (s);
 		}
 		release_assert (count (transaction_a, pending_store.pending_handle) == count (transaction_a, temp));
@@ -545,7 +557,9 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
 		{
 			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);
+			MDB_val mdb_key{ key_val.size (), key_val.data () };
+			MDB_val mdb_value{ value_val.size (), value_val.data () };
+			auto s = mdb_put (env.tx (transaction_a), pending_store.pending_handle, &mdb_key, &mdb_value, 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/pending.cpp b/nano/store/lmdb/pending.cpp
index 7daedcc4..1cc116fd 100644
--- a/nano/store/lmdb/pending.cpp
+++ b/nano/store/lmdb/pending.cpp
@@ -48,7 +48,8 @@ bool nano::store::lmdb::pending::any (store::transaction const & transaction_a,
 auto nano::store::lmdb::pending::begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const -> iterator
 {
 	lmdb::db_val val{ key_a };
-	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction_a), pending_handle, val) } };
+	MDB_val mdb_val{ val.size (), val.data () };
+	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction_a), pending_handle, mdb_val) } };
 }
 
 auto nano::store::lmdb::pending::begin (store::transaction const & transaction_a) const -> iterator
diff --git a/nano/store/lmdb/pruned.cpp b/nano/store/lmdb/pruned.cpp
index ca853bca..2d425c16 100644
--- a/nano/store/lmdb/pruned.cpp
+++ b/nano/store/lmdb/pruned.cpp
@@ -48,7 +48,8 @@ void nano::store::lmdb::pruned::clear (store::write_transaction const & transact
 auto nano::store::lmdb::pruned::begin (store::transaction const & transaction, nano::block_hash const & hash) const -> iterator
 {
 	lmdb::db_val val{ hash };
-	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), pruned_handle, val) } };
+	MDB_val mdb_val{ val.size (), val.data () };
+	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), pruned_handle, mdb_val) } };
 }
 
 auto nano::store::lmdb::pruned::begin (store::transaction const & transaction) const -> iterator
diff --git a/nano/store/lmdb/rep_weight.cpp b/nano/store/lmdb/rep_weight.cpp
index e9068ac0..6b51c3e7 100644
--- a/nano/store/lmdb/rep_weight.cpp
+++ b/nano/store/lmdb/rep_weight.cpp
@@ -46,7 +46,8 @@ void nano::store::lmdb::rep_weight::del (store::write_transaction const & txn_a,
 auto nano::store::lmdb::rep_weight::begin (store::transaction const & transaction_a, nano::account const & representative_a) const -> iterator
 {
 	lmdb::db_val val{ representative_a };
-	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction_a), rep_weights_handle, val) } };
+	MDB_val mdb_val{ val.size (), val.data () };
+	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction_a), rep_weights_handle, mdb_val) } };
 }
 
 auto nano::store::lmdb::rep_weight::begin (store::transaction const & transaction_a) const -> iterator
diff --git a/nano/store/rocksdb/account.cpp b/nano/store/rocksdb/account.cpp
index 579dff95..35d17d34 100644
--- a/nano/store/rocksdb/account.cpp
+++ b/nano/store/rocksdb/account.cpp
@@ -46,7 +46,8 @@ size_t nano::store::rocksdb::account::count (store::transaction const & transact
 auto nano::store::rocksdb::account::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
 {
 	rocksdb::db_val val{ account };
-	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::accounts), val) } };
+	::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
+	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::accounts), slice) } };
 }
 
 auto nano::store::rocksdb::account::begin (store::transaction const & transaction) const -> iterator
diff --git a/nano/store/rocksdb/block.cpp b/nano/store/rocksdb/block.cpp
index 6b9cd670..9b3882cc 100644
--- a/nano/store/rocksdb/block.cpp
+++ b/nano/store/rocksdb/block.cpp
@@ -131,7 +131,8 @@ auto nano::store::rocksdb::block::begin (store::transaction const & transaction)
 auto nano::store::rocksdb::block::begin (store::transaction const & transaction, nano::block_hash const & hash) const -> iterator
 {
 	rocksdb::db_val val{ hash };
-	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::blocks), val) } };
+	::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
+	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::blocks), slice) } };
 }
 
 auto nano::store::rocksdb::block::end (store::transaction const & transaction_a) const -> iterator
diff --git a/nano/store/rocksdb/confirmation_height.cpp b/nano/store/rocksdb/confirmation_height.cpp
index 2cc21131..229acdfd 100644
--- a/nano/store/rocksdb/confirmation_height.cpp
+++ b/nano/store/rocksdb/confirmation_height.cpp
@@ -63,7 +63,8 @@ void nano::store::rocksdb::confirmation_height::clear (store::write_transaction
 auto nano::store::rocksdb::confirmation_height::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
 {
 	rocksdb::db_val val{ account };
-	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::confirmation_height), val) } };
+	::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
+	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::confirmation_height), slice) } };
 }
 
 auto nano::store::rocksdb::confirmation_height::begin (store::transaction const & transaction) const -> iterator
diff --git a/nano/store/rocksdb/final_vote.cpp b/nano/store/rocksdb/final_vote.cpp
index 614df9f2..f57f2fbd 100644
--- a/nano/store/rocksdb/final_vote.cpp
+++ b/nano/store/rocksdb/final_vote.cpp
@@ -55,7 +55,8 @@ void nano::store::rocksdb::final_vote::clear (store::write_transaction const & t
 auto nano::store::rocksdb::final_vote::begin (store::transaction const & transaction, nano::qualified_root const & root) const -> iterator
 {
 	rocksdb::db_val val{ root };
-	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::final_votes), val) } };
+	::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
+	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::final_votes), slice) } };
 }
 
 auto nano::store::rocksdb::final_vote::begin (store::transaction const & transaction) const -> iterator
diff --git a/nano/store/rocksdb/pending.cpp b/nano/store/rocksdb/pending.cpp
index b9555b5a..40fe743b 100644
--- a/nano/store/rocksdb/pending.cpp
+++ b/nano/store/rocksdb/pending.cpp
@@ -49,7 +49,8 @@ bool nano::store::rocksdb::pending::any (store::transaction const & transaction_
 auto nano::store::rocksdb::pending::begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const -> iterator
 {
 	rocksdb::db_val val{ key_a };
-	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction_a), store.table_to_column_family (tables::pending), val) } };
+	::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
+	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction_a), store.table_to_column_family (tables::pending), slice) } };
 }
 
 auto nano::store::rocksdb::pending::begin (store::transaction const & transaction_a) const -> iterator
diff --git a/nano/store/rocksdb/pruned.cpp b/nano/store/rocksdb/pruned.cpp
index b85eae1a..c3f387ef 100644
--- a/nano/store/rocksdb/pruned.cpp
+++ b/nano/store/rocksdb/pruned.cpp
@@ -49,7 +49,8 @@ void nano::store::rocksdb::pruned::clear (store::write_transaction const & trans
 auto nano::store::rocksdb::pruned::begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const -> iterator
 {
 	rocksdb::db_val val{ hash_a };
-	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction_a), store.table_to_column_family (tables::pruned), val) } };
+	::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
+	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction_a), store.table_to_column_family (tables::pruned), slice) } };
 }
 
 auto nano::store::rocksdb::pruned::begin (store::transaction const & transaction_a) const -> iterator
diff --git a/nano/store/rocksdb/rep_weight.cpp b/nano/store/rocksdb/rep_weight.cpp
index ee081a58..bea73196 100644
--- a/nano/store/rocksdb/rep_weight.cpp
+++ b/nano/store/rocksdb/rep_weight.cpp
@@ -46,7 +46,8 @@ void nano::store::rocksdb::rep_weight::del (store::write_transaction const & txn
 auto nano::store::rocksdb::rep_weight::begin (store::transaction const & txn_a, nano::account const & representative_a) const -> iterator
 {
 	rocksdb::db_val val{ representative_a };
-	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (txn_a), store.table_to_column_family (tables::rep_weights), val) } };
+	::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
+	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (txn_a), store.table_to_column_family (tables::rep_weights), slice) } };
 }
 
 auto nano::store::rocksdb::rep_weight::begin (store::transaction const & txn_a) const -> iterator
diff --git a/nano/store/rocksdb/rocksdb.cpp b/nano/store/rocksdb/rocksdb.cpp
index 4ef2c798..755ef153 100644
--- a/nano/store/rocksdb/rocksdb.cpp
+++ b/nano/store/rocksdb/rocksdb.cpp
@@ -533,6 +533,7 @@ rocksdb::ColumnFamilyHandle * nano::store::rocksdb::component::table_to_column_f
 bool nano::store::rocksdb::component::exists (store::transaction const & transaction_a, tables table_a, nano::store::rocksdb::db_val const & key_a) const
 {
 	::rocksdb::PinnableSlice slice;
+	::rocksdb::Slice key_slice{ reinterpret_cast<char const *> (key_a.data ()), key_a.size () };
 	auto internals = rocksdb::tx (transaction_a);
 	auto status = std::visit ([&] (auto && ptr) {
 		using V = std::remove_cvref_t<decltype (ptr)>;
@@ -540,11 +541,11 @@ bool nano::store::rocksdb::component::exists (store::transaction const & transac
 		{
 			::rocksdb::ReadOptions options;
 			options.fill_cache = false;
-			return ptr->Get (options, table_to_column_family (table_a), key_a, &slice);
+			return ptr->Get (options, table_to_column_family (table_a), key_slice, &slice);
 		}
 		else if constexpr (std::is_same_v<V, ::rocksdb::ReadOptions *>)
 		{
-			return db->Get (*ptr, table_to_column_family (table_a), key_a, &slice);
+			return db->Get (*ptr, table_to_column_family (table_a), key_slice, &slice);
 		}
 		else
 		{
@@ -562,7 +563,8 @@ int nano::store::rocksdb::component::del (store::write_transaction const & trans
 	// RocksDB does not report not_found status, it is a pre-condition that the key exists
 	debug_assert (exists (transaction_a, table_a, key_a));
 	flush_tombstones_check (table_a);
-	return std::get<::rocksdb::Transaction *> (rocksdb::tx (transaction_a))->Delete (table_to_column_family (table_a), key_a).code ();
+	::rocksdb::Slice key_slice{ reinterpret_cast<char const *> (key_a.data ()), key_a.size () };
+	return std::get<::rocksdb::Transaction *> (rocksdb::tx (transaction_a))->Delete (table_to_column_family (table_a), key_slice).code ();
 }
 
 void nano::store::rocksdb::component::flush_tombstones_check (tables table_a)
@@ -589,17 +591,18 @@ int nano::store::rocksdb::component::get (store::transaction const & transaction
 {
 	::rocksdb::ReadOptions options;
 	::rocksdb::PinnableSlice slice;
+	::rocksdb::Slice key_slice{ reinterpret_cast<char const *> (key_a.data ()), key_a.size () };
 	auto handle = table_to_column_family (table_a);
 	auto internals = rocksdb::tx (transaction_a);
 	auto status = std::visit ([&] (auto && ptr) {
 		using V = std::remove_cvref_t<decltype (ptr)>;
 		if constexpr (std::is_same_v<V, ::rocksdb::Transaction *>)
 		{
-			return ptr->Get (options, handle, key_a, &slice);
+			return ptr->Get (options, handle, key_slice, &slice);
 		}
 		else if constexpr (std::is_same_v<V, ::rocksdb::ReadOptions *>)
 		{
-			return db->Get (*ptr, handle, key_a, &slice);
+			return db->Get (*ptr, handle, key_slice, &slice);
 		}
 		else
 		{
@@ -620,7 +623,9 @@ int nano::store::rocksdb::component::get (store::transaction const & transaction
 int nano::store::rocksdb::component::put (store::write_transaction const & transaction_a, tables table_a, nano::store::rocksdb::db_val const & key_a, nano::store::rocksdb::db_val const & value_a)
 {
 	debug_assert (transaction_a.contains (table_a));
-	return std::get<::rocksdb::Transaction *> (rocksdb::tx (transaction_a))->Put (table_to_column_family (table_a), key_a, value_a).code ();
+	::rocksdb::Slice key_slice{ reinterpret_cast<char const *> (key_a.data ()), key_a.size () };
+	::rocksdb::Slice value_slice{ reinterpret_cast<char const *> (value_a.data ()), value_a.size () };
+	return std::get<::rocksdb::Transaction *> (rocksdb::tx (transaction_a))->Put (table_to_column_family (table_a), key_slice, value_slice).code ();
 }
 
 bool nano::store::rocksdb::component::not_found (int status) const

From b7cde2b1d9dd60a6ce77efeeafd6c7c4c28fba90 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 17:21:49 +0200
Subject: [PATCH 3/6] Simplify db val conversions

---
 nano/node/wallet.cpp                       | 45 ++++++++++------------
 nano/store/db_val.hpp                      |  6 +++
 nano/store/lmdb/account.cpp                |  5 +--
 nano/store/lmdb/block.cpp                  |  5 +--
 nano/store/lmdb/confirmation_height.cpp    |  5 +--
 nano/store/lmdb/final_vote.cpp             |  5 +--
 nano/store/lmdb/lmdb.cpp                   | 30 +++++++--------
 nano/store/lmdb/pending.cpp                |  5 +--
 nano/store/lmdb/pruned.cpp                 |  5 +--
 nano/store/lmdb/rep_weight.cpp             |  5 +--
 nano/store/lmdb/utility.hpp                | 25 ++++++++++++
 nano/store/rocksdb/account.cpp             |  4 +-
 nano/store/rocksdb/block.cpp               |  4 +-
 nano/store/rocksdb/confirmation_height.cpp |  4 +-
 nano/store/rocksdb/final_vote.cpp          |  4 +-
 nano/store/rocksdb/pending.cpp             |  6 +--
 nano/store/rocksdb/pending.hpp             |  4 ++
 nano/store/rocksdb/pruned.cpp              |  4 +-
 nano/store/rocksdb/rep_weight.cpp          |  4 +-
 nano/store/rocksdb/rocksdb.cpp             | 14 +++----
 nano/store/rocksdb/utility.hpp             | 22 +++++++++++
 21 files changed, 121 insertions(+), 90 deletions(-)
 create mode 100644 nano/store/lmdb/utility.hpp

diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp
index 6d85ed3a..ebd7c4b4 100644
--- a/nano/node/wallet.cpp
+++ b/nano/node/wallet.cpp
@@ -12,6 +12,7 @@
 #include <nano/secure/ledger_set_any.hpp>
 #include <nano/secure/ledger_set_confirmed.hpp>
 #include <nano/store/lmdb/iterator.hpp>
+#include <nano/store/lmdb/utility.hpp>
 #include <nano/store/typed_iterator_templ.hpp>
 
 #include <boost/format.hpp>
@@ -280,7 +281,7 @@ nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, store::trans
 	{
 		MDB_val junk;
 		nano::store::lmdb::db_val version_key (version_special);
-		MDB_val mdb_version_key{ version_key.size (), version_key.data () };
+		auto mdb_version_key = nano::store::lmdb::to_mdb_val (version_key);
 		debug_assert (mdb_get (env.tx (transaction_a), handle, &mdb_version_key, &junk) == MDB_NOTFOUND);
 		boost::property_tree::ptree wallet_l;
 		std::stringstream istream (json_a);
@@ -317,16 +318,16 @@ nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, store::trans
 		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);
-		MDB_val mdb_version_key2{ version_key.size (), version_key.data () };
-		MDB_val mdb_wallet_key_key{ wallet_key_key.size (), wallet_key_key.data () };
-		MDB_val mdb_salt_key{ salt_key.size (), salt_key.data () };
-		MDB_val mdb_check_key{ check_key.size (), check_key.data () };
+		auto mdb_version_key2 = nano::store::lmdb::to_mdb_val (version_key);
+		auto mdb_wallet_key_key = nano::store::lmdb::to_mdb_val (wallet_key_key);
+		auto mdb_salt_key = nano::store::lmdb::to_mdb_val (salt_key);
+		auto mdb_check_key = nano::store::lmdb::to_mdb_val (check_key);
 		init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_version_key2, &junk) != 0;
 		init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_wallet_key_key, &junk) != 0;
 		init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_salt_key, &junk) != 0;
 		init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_check_key, &junk) != 0;
 		nano::store::lmdb::db_val rep_key (representative_special);
-		MDB_val mdb_rep_key{ rep_key.size (), rep_key.data () };
+		auto mdb_rep_key = nano::store::lmdb::to_mdb_val (rep_key);
 		init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_rep_key, &junk) != 0;
 		nano::raw_key key;
 		key.clear ();
@@ -349,7 +350,7 @@ nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, store::trans
 		int version_status;
 		MDB_val version_value;
 		nano::store::lmdb::db_val version_lookup_key (version_special);
-		MDB_val mdb_version_lookup_key{ version_lookup_key.size (), version_lookup_key.data () };
+		auto mdb_version_lookup_key = nano::store::lmdb::to_mdb_val (version_lookup_key);
 		version_status = mdb_get (env.tx (transaction_a), handle, &mdb_version_lookup_key, &version_value);
 		if (version_status == MDB_NOTFOUND)
 		{
@@ -464,12 +465,12 @@ nano::wallet_value nano::wallet_store::entry_get_raw (store::transaction const &
 	nano::wallet_value result;
 	nano::store::lmdb::db_val value;
 	nano::store::lmdb::db_val pub_key (pub_a);
-	MDB_val mdb_pub_key{ pub_key.size (), pub_key.data () };
+	auto mdb_pub_key = nano::store::lmdb::to_mdb_val (pub_key);
 	MDB_val mdb_value{};
 	auto status (mdb_get (env.tx (transaction_a), handle, &mdb_pub_key, &mdb_value));
 	if (status == 0)
 	{
-		value.span_view = std::span<uint8_t const> (static_cast<uint8_t const *> (mdb_value.mv_data), mdb_value.mv_size);
+		value = nano::store::lmdb::from_mdb_val (mdb_value);
 		result = nano::wallet_value (value);
 	}
 	else
@@ -484,8 +485,8 @@ void nano::wallet_store::entry_put_raw (store::transaction const & transaction_a
 {
 	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));
-	MDB_val mdb_pub_key{ pub_key.size (), pub_key.data () };
-	MDB_val mdb_entry_val{ entry_val.size (), entry_val.data () };
+	auto mdb_pub_key = nano::store::lmdb::to_mdb_val (pub_key);
+	auto mdb_entry_val = nano::store::lmdb::to_mdb_val (entry_val);
 	auto status (mdb_put (env.tx (transaction_a), handle, &mdb_pub_key, &mdb_entry_val, 0));
 	(void)status;
 	debug_assert (status == 0);
@@ -1031,7 +1032,7 @@ std::shared_ptr<nano::block> nano::wallet::send_action (nano::account const & so
 			auto status (mdb_get (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, &mdb_id_key, &mdb_result));
 			if (status == 0)
 			{
-				result.span_view = std::span<uint8_t const> (static_cast<uint8_t const *> (mdb_result.mv_data), mdb_result.mv_size);
+				result = nano::store::lmdb::from_mdb_val (mdb_result);
 				nano::block_hash hash (result);
 				block = wallets.node.ledger.any.block_get (block_transaction, hash);
 				if (block != nullptr)
@@ -1085,8 +1086,8 @@ std::shared_ptr<nano::block> nano::wallet::send_action (nano::account const & so
 						if (id_mdb_val && block != nullptr)
 						{
 							nano::store::lmdb::db_val hash_val (block->hash ());
-							MDB_val mdb_id_key{ id_mdb_val->size (), id_mdb_val->data () };
-							MDB_val mdb_hash_val{ hash_val.size (), hash_val.data () };
+							auto mdb_id_key = nano::store::lmdb::to_mdb_val (*id_mdb_val);
+							auto mdb_hash_val = nano::store::lmdb::to_mdb_val (hash_val);
 							auto status (mdb_put (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, &mdb_id_key, &mdb_hash_val, 0));
 							if (status != 0)
 							{
@@ -1473,8 +1474,8 @@ nano::wallets::wallets (bool error_a, nano::node & node_a) :
 		nano::store::lmdb::db_val beginning_val{ beginning.size (), const_cast<char *> (beginning.c_str ()) };
 		std::string end ((nano::uint256_union (nano::uint256_t (0) - nano::uint256_t (1))).to_string ());
 		nano::store::lmdb::db_val end_val{ end.size (), const_cast<char *> (end.c_str ()) };
-		MDB_val mdb_beginning_val{ beginning_val.size (), beginning_val.data () };
-		MDB_val mdb_end_val{ end_val.size (), end_val.data () };
+		auto mdb_beginning_val = nano::store::lmdb::to_mdb_val (beginning_val);
+		auto mdb_end_val = nano::store::lmdb::to_mdb_val (end_val);
 		store::iterator i{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, mdb_beginning_val) };
 		store::iterator n{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, mdb_end_val) };
 		for (; i != n; ++i)
@@ -1635,8 +1636,8 @@ void nano::wallets::reload ()
 	nano::store::lmdb::db_val beginning_val{ beginning.size (), const_cast<char *> (beginning.c_str ()) };
 	std::string end ((nano::uint256_union (nano::uint256_t (0) - nano::uint256_t (1))).to_string ());
 	nano::store::lmdb::db_val end_val{ end.size (), const_cast<char *> (end.c_str ()) };
-	MDB_val mdb_beginning_val{ beginning_val.size (), beginning_val.data () };
-	MDB_val mdb_end_val{ end_val.size (), end_val.data () };
+	auto mdb_beginning_val = nano::store::lmdb::to_mdb_val (beginning_val);
+	auto mdb_end_val = nano::store::lmdb::to_mdb_val (end_val);
 	store::iterator i{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, mdb_beginning_val) };
 	store::iterator n{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, mdb_end_val) };
 	for (; i != n; ++i)
@@ -1882,17 +1883,13 @@ nano::uint128_t const nano::wallets::high_priority = std::numeric_limits<nano::u
 auto nano::wallet_store::begin (store::transaction const & transaction_a) -> iterator
 {
 	nano::account account{ special_count };
-	nano::store::lmdb::db_val val{ account };
-	MDB_val mdb_val{ val.size (), val.data () };
-	return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, mdb_val) } };
+	return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, store::lmdb::to_mdb_val (account)) } };
 }
 
 auto nano::wallet_store::begin (store::transaction const & transaction_a, nano::account const & key) -> iterator
 {
 	nano::account account (key);
-	nano::store::lmdb::db_val val{ account };
-	MDB_val mdb_val{ val.size (), val.data () };
-	return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, mdb_val) } };
+	return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, store::lmdb::to_mdb_val (account)) } };
 }
 
 auto nano::wallet_store::find (store::transaction const & transaction_a, nano::account const & key) -> iterator
diff --git a/nano/store/db_val.hpp b/nano/store/db_val.hpp
index 3e4d8af5..42fdb59b 100644
--- a/nano/store/db_val.hpp
+++ b/nano/store/db_val.hpp
@@ -42,6 +42,12 @@ public:
 	{
 	}
 
+	db_val (std::shared_ptr<std::vector<uint8_t>> buffer_a) :
+		buffer (buffer_a)
+	{
+		convert_buffer_to_value ();
+	}
+
 	db_val (nano::uint128_union const & val_a) :
 		span_view (val_a.bytes.data (), sizeof (val_a))
 	{
diff --git a/nano/store/lmdb/account.cpp b/nano/store/lmdb/account.cpp
index 607bee11..58072a42 100644
--- a/nano/store/lmdb/account.cpp
+++ b/nano/store/lmdb/account.cpp
@@ -2,6 +2,7 @@
 #include <nano/store/lmdb/account.hpp>
 #include <nano/store/lmdb/db_val.hpp>
 #include <nano/store/lmdb/lmdb.hpp>
+#include <nano/store/lmdb/utility.hpp>
 
 nano::store::lmdb::account::account (nano::store::lmdb::component & store_a) :
 	store (store_a){};
@@ -45,9 +46,7 @@ size_t nano::store::lmdb::account::count (store::transaction const & transaction
 
 auto nano::store::lmdb::account::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
 {
-	lmdb::db_val val{ account };
-	MDB_val mdb_val{ val.size (), val.data () };
-	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), accounts_handle, mdb_val) } };
+	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), accounts_handle, to_mdb_val (account)) } };
 }
 
 auto nano::store::lmdb::account::begin (store::transaction const & transaction) const -> iterator
diff --git a/nano/store/lmdb/block.cpp b/nano/store/lmdb/block.cpp
index dbd23167..e2b823ca 100644
--- a/nano/store/lmdb/block.cpp
+++ b/nano/store/lmdb/block.cpp
@@ -2,6 +2,7 @@
 #include <nano/store/db_val_impl.hpp>
 #include <nano/store/lmdb/block.hpp>
 #include <nano/store/lmdb/lmdb.hpp>
+#include <nano/store/lmdb/utility.hpp>
 
 namespace nano::store::lmdb
 {
@@ -129,9 +130,7 @@ auto nano::store::lmdb::block::begin (store::transaction const & transaction) co
 
 auto nano::store::lmdb::block::begin (store::transaction const & transaction, nano::block_hash const & hash) const -> iterator
 {
-	lmdb::db_val val{ hash };
-	MDB_val mdb_val{ val.size (), val.data () };
-	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), blocks_handle, mdb_val) } };
+	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), blocks_handle, to_mdb_val (hash)) } };
 }
 
 auto nano::store::lmdb::block::end (store::transaction const & transaction_a) const -> iterator
diff --git a/nano/store/lmdb/confirmation_height.cpp b/nano/store/lmdb/confirmation_height.cpp
index 3dd6cf6e..f175d33c 100644
--- a/nano/store/lmdb/confirmation_height.cpp
+++ b/nano/store/lmdb/confirmation_height.cpp
@@ -1,6 +1,7 @@
 #include <nano/secure/parallel_traversal.hpp>
 #include <nano/store/lmdb/confirmation_height.hpp>
 #include <nano/store/lmdb/lmdb.hpp>
+#include <nano/store/lmdb/utility.hpp>
 
 nano::store::lmdb::confirmation_height::confirmation_height (nano::store::lmdb::component & store) :
 	store{ store }
@@ -61,9 +62,7 @@ void nano::store::lmdb::confirmation_height::clear (store::write_transaction con
 
 auto nano::store::lmdb::confirmation_height::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
 {
-	lmdb::db_val val{ account };
-	MDB_val mdb_val{ val.size (), val.data () };
-	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), confirmation_height_handle, mdb_val) } };
+	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), confirmation_height_handle, to_mdb_val (account)) } };
 }
 
 auto nano::store::lmdb::confirmation_height::begin (store::transaction const & transaction) const -> iterator
diff --git a/nano/store/lmdb/final_vote.cpp b/nano/store/lmdb/final_vote.cpp
index dcd52549..c27f3f70 100644
--- a/nano/store/lmdb/final_vote.cpp
+++ b/nano/store/lmdb/final_vote.cpp
@@ -1,6 +1,7 @@
 #include <nano/secure/parallel_traversal.hpp>
 #include <nano/store/lmdb/final_vote.hpp>
 #include <nano/store/lmdb/lmdb.hpp>
+#include <nano/store/lmdb/utility.hpp>
 
 nano::store::lmdb::final_vote::final_vote (nano::store::lmdb::component & store) :
 	store{ store } {};
@@ -53,9 +54,7 @@ void nano::store::lmdb::final_vote::clear (store::write_transaction const & tran
 
 auto nano::store::lmdb::final_vote::begin (store::transaction const & transaction, nano::qualified_root const & root) const -> iterator
 {
-	lmdb::db_val val{ root };
-	MDB_val mdb_val{ val.size (), val.data () };
-	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), final_votes_handle, mdb_val) } };
+	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), final_votes_handle, to_mdb_val (root)) } };
 }
 
 auto nano::store::lmdb::final_vote::begin (store::transaction const & transaction) const -> iterator
diff --git a/nano/store/lmdb/lmdb.cpp b/nano/store/lmdb/lmdb.cpp
index 2ed6febe..bbfa6b76 100644
--- a/nano/store/lmdb/lmdb.cpp
+++ b/nano/store/lmdb/lmdb.cpp
@@ -5,6 +5,7 @@
 #include <nano/secure/parallel_traversal.hpp>
 #include <nano/store/lmdb/iterator.hpp>
 #include <nano/store/lmdb/lmdb.hpp>
+#include <nano/store/lmdb/utility.hpp>
 #include <nano/store/lmdb/wallet_value.hpp>
 #include <nano/store/typed_iterator_templ.hpp>
 #include <nano/store/version.hpp>
@@ -405,28 +406,27 @@ 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
 {
-	MDB_val mdb_key{ key_a.size (), key_a.data () };
+	auto mdb_key = to_mdb_val (key_a);
 	MDB_val mdb_value{};
-	
+
 	auto result = mdb_get (env.tx (transaction_a), table_to_dbi (table_a), &mdb_key, &mdb_value);
 	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 *> (mdb_value.mv_data), mdb_value.mv_size);
+		value_a = from_mdb_val (mdb_value);
 	}
 	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
 {
-	MDB_val mdb_key{ key_a.size (), key_a.data () };
-	MDB_val mdb_value{ value_a.size (), value_a.data () };
+	auto mdb_key = to_mdb_val (key_a);
+	auto mdb_value = to_mdb_val (value_a);
 	return (mdb_put (env.tx (transaction_a), table_to_dbi (table_a), &mdb_key, &mdb_value, 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
 {
-	MDB_val mdb_key{ key_a.size (), key_a.data () };
+	auto mdb_key = to_mdb_val (key_a);
 	return (mdb_del (env.tx (transaction_a), table_to_dbi (table_a), &mdb_key, nullptr));
 }
 
@@ -515,8 +515,8 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
 		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)
 		{
 			nano::store::lmdb::db_val key_val (i->first);
-			MDB_val mdb_key{ key_val.size (), key_val.data () };
-			MDB_val mdb_value{ i->second.size (), i->second.data () };
+			auto mdb_key = to_mdb_val (key_val);
+			auto mdb_value = to_mdb_val (i->second);
 			auto s = mdb_put (env.tx (transaction_a), temp, &mdb_key, &mdb_value, MDB_APPEND);
 			release_assert_success (s);
 		}
@@ -527,8 +527,8 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
 		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)
 		{
 			nano::store::lmdb::db_val key_val (i->first);
-			MDB_val mdb_key{ key_val.size (), key_val.data () };
-			MDB_val mdb_value{ i->second.size (), i->second.data () };
+			auto mdb_key = to_mdb_val (key_val);
+			auto mdb_value = to_mdb_val (i->second);
 			auto s = mdb_put (env.tx (transaction_a), table, &mdb_key, &mdb_value, MDB_APPEND);
 			release_assert_success (s);
 		}
@@ -545,8 +545,8 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
 		{
 			nano::store::lmdb::db_val key_val (i->first);
 			nano::store::lmdb::db_val value_val (i->second);
-			MDB_val mdb_key{ key_val.size (), key_val.data () };
-			MDB_val mdb_value{ value_val.size (), value_val.data () };
+			auto mdb_key = to_mdb_val (key_val);
+			auto mdb_value = to_mdb_val (value_val);
 			auto s = mdb_put (env.tx (transaction_a), temp, &mdb_key, &mdb_value, MDB_APPEND);
 			release_assert_success (s);
 		}
@@ -557,8 +557,8 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
 		{
 			nano::store::lmdb::db_val key_val (i->first);
 			nano::store::lmdb::db_val value_val (i->second);
-			MDB_val mdb_key{ key_val.size (), key_val.data () };
-			MDB_val mdb_value{ value_val.size (), value_val.data () };
+			auto mdb_key = to_mdb_val (key_val);
+			auto mdb_value = to_mdb_val (value_val);
 			auto s = mdb_put (env.tx (transaction_a), pending_store.pending_handle, &mdb_key, &mdb_value, MDB_APPEND);
 			release_assert_success (s);
 		}
diff --git a/nano/store/lmdb/pending.cpp b/nano/store/lmdb/pending.cpp
index 1cc116fd..fb9b17e9 100644
--- a/nano/store/lmdb/pending.cpp
+++ b/nano/store/lmdb/pending.cpp
@@ -1,6 +1,7 @@
 #include <nano/secure/parallel_traversal.hpp>
 #include <nano/store/lmdb/lmdb.hpp>
 #include <nano/store/lmdb/pending.hpp>
+#include <nano/store/lmdb/utility.hpp>
 
 nano::store::lmdb::pending::pending (nano::store::lmdb::component & store) :
 	store{ store } {};
@@ -47,9 +48,7 @@ bool nano::store::lmdb::pending::any (store::transaction const & transaction_a,
 
 auto nano::store::lmdb::pending::begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const -> iterator
 {
-	lmdb::db_val val{ key_a };
-	MDB_val mdb_val{ val.size (), val.data () };
-	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction_a), pending_handle, mdb_val) } };
+	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction_a), pending_handle, to_mdb_val (key_a)) } };
 }
 
 auto nano::store::lmdb::pending::begin (store::transaction const & transaction_a) const -> iterator
diff --git a/nano/store/lmdb/pruned.cpp b/nano/store/lmdb/pruned.cpp
index 2d425c16..2eeedf91 100644
--- a/nano/store/lmdb/pruned.cpp
+++ b/nano/store/lmdb/pruned.cpp
@@ -1,6 +1,7 @@
 #include <nano/secure/parallel_traversal.hpp>
 #include <nano/store/lmdb/lmdb.hpp>
 #include <nano/store/lmdb/pruned.hpp>
+#include <nano/store/lmdb/utility.hpp>
 
 nano::store::lmdb::pruned::pruned (nano::store::lmdb::component & store_a) :
 	store{ store_a } {};
@@ -47,9 +48,7 @@ void nano::store::lmdb::pruned::clear (store::write_transaction const & transact
 
 auto nano::store::lmdb::pruned::begin (store::transaction const & transaction, nano::block_hash const & hash) const -> iterator
 {
-	lmdb::db_val val{ hash };
-	MDB_val mdb_val{ val.size (), val.data () };
-	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), pruned_handle, mdb_val) } };
+	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), pruned_handle, to_mdb_val (hash)) } };
 }
 
 auto nano::store::lmdb::pruned::begin (store::transaction const & transaction) const -> iterator
diff --git a/nano/store/lmdb/rep_weight.cpp b/nano/store/lmdb/rep_weight.cpp
index 6b51c3e7..d5e180d3 100644
--- a/nano/store/lmdb/rep_weight.cpp
+++ b/nano/store/lmdb/rep_weight.cpp
@@ -2,6 +2,7 @@
 #include <nano/secure/parallel_traversal.hpp>
 #include <nano/store/lmdb/lmdb.hpp>
 #include <nano/store/lmdb/rep_weight.hpp>
+#include <nano/store/lmdb/utility.hpp>
 
 #include <iostream>
 #include <stdexcept>
@@ -45,9 +46,7 @@ void nano::store::lmdb::rep_weight::del (store::write_transaction const & txn_a,
 
 auto nano::store::lmdb::rep_weight::begin (store::transaction const & transaction_a, nano::account const & representative_a) const -> iterator
 {
-	lmdb::db_val val{ representative_a };
-	MDB_val mdb_val{ val.size (), val.data () };
-	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction_a), rep_weights_handle, mdb_val) } };
+	return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction_a), rep_weights_handle, to_mdb_val (representative_a)) } };
 }
 
 auto nano::store::lmdb::rep_weight::begin (store::transaction const & transaction_a) const -> iterator
diff --git a/nano/store/lmdb/utility.hpp b/nano/store/lmdb/utility.hpp
new file mode 100644
index 00000000..bbf4d0b5
--- /dev/null
+++ b/nano/store/lmdb/utility.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <nano/store/db_val.hpp>
+
+#include <lmdb/libraries/liblmdb/lmdb.h>
+
+namespace nano::store::lmdb
+{
+/**
+ * Converts a db_val to MDB_val for LMDB operations
+ */
+inline MDB_val to_mdb_val (nano::store::db_val const & val)
+{
+	return MDB_val{ val.size (), val.data () };
+}
+
+/**
+ * Creates a db_val from MDB_val for read operations
+ */
+inline nano::store::db_val from_mdb_val (MDB_val const & val)
+{
+	auto span = std::span<uint8_t const>{ static_cast<uint8_t const *> (val.mv_data), val.mv_size };
+	return nano::store::db_val (span);
+}
+}
\ No newline at end of file
diff --git a/nano/store/rocksdb/account.cpp b/nano/store/rocksdb/account.cpp
index 35d17d34..0ba2e4cb 100644
--- a/nano/store/rocksdb/account.cpp
+++ b/nano/store/rocksdb/account.cpp
@@ -45,9 +45,7 @@ size_t nano::store::rocksdb::account::count (store::transaction const & transact
 
 auto nano::store::rocksdb::account::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
 {
-	rocksdb::db_val val{ account };
-	::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
-	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::accounts), slice) } };
+	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::accounts), to_slice (account)) } };
 }
 
 auto nano::store::rocksdb::account::begin (store::transaction const & transaction) const -> iterator
diff --git a/nano/store/rocksdb/block.cpp b/nano/store/rocksdb/block.cpp
index 9b3882cc..8ac63885 100644
--- a/nano/store/rocksdb/block.cpp
+++ b/nano/store/rocksdb/block.cpp
@@ -130,9 +130,7 @@ auto nano::store::rocksdb::block::begin (store::transaction const & transaction)
 
 auto nano::store::rocksdb::block::begin (store::transaction const & transaction, nano::block_hash const & hash) const -> iterator
 {
-	rocksdb::db_val val{ hash };
-	::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
-	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::blocks), slice) } };
+	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::blocks), to_slice (hash)) } };
 }
 
 auto nano::store::rocksdb::block::end (store::transaction const & transaction_a) const -> iterator
diff --git a/nano/store/rocksdb/confirmation_height.cpp b/nano/store/rocksdb/confirmation_height.cpp
index 229acdfd..d76d7b81 100644
--- a/nano/store/rocksdb/confirmation_height.cpp
+++ b/nano/store/rocksdb/confirmation_height.cpp
@@ -62,9 +62,7 @@ void nano::store::rocksdb::confirmation_height::clear (store::write_transaction
 
 auto nano::store::rocksdb::confirmation_height::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
 {
-	rocksdb::db_val val{ account };
-	::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
-	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::confirmation_height), slice) } };
+	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::confirmation_height), to_slice (account)) } };
 }
 
 auto nano::store::rocksdb::confirmation_height::begin (store::transaction const & transaction) const -> iterator
diff --git a/nano/store/rocksdb/final_vote.cpp b/nano/store/rocksdb/final_vote.cpp
index f57f2fbd..7de8f991 100644
--- a/nano/store/rocksdb/final_vote.cpp
+++ b/nano/store/rocksdb/final_vote.cpp
@@ -54,9 +54,7 @@ void nano::store::rocksdb::final_vote::clear (store::write_transaction const & t
 
 auto nano::store::rocksdb::final_vote::begin (store::transaction const & transaction, nano::qualified_root const & root) const -> iterator
 {
-	rocksdb::db_val val{ root };
-	::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
-	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::final_votes), slice) } };
+	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::final_votes), to_slice (root)) } };
 }
 
 auto nano::store::rocksdb::final_vote::begin (store::transaction const & transaction) const -> iterator
diff --git a/nano/store/rocksdb/pending.cpp b/nano/store/rocksdb/pending.cpp
index 40fe743b..ab958883 100644
--- a/nano/store/rocksdb/pending.cpp
+++ b/nano/store/rocksdb/pending.cpp
@@ -1,5 +1,5 @@
 #include <nano/secure/parallel_traversal.hpp>
-#include <nano/store/lmdb/pending.hpp>
+#include <nano/store/rocksdb/pending.hpp>
 #include <nano/store/rocksdb/rocksdb.hpp>
 #include <nano/store/rocksdb/utility.hpp>
 
@@ -48,9 +48,7 @@ bool nano::store::rocksdb::pending::any (store::transaction const & transaction_
 
 auto nano::store::rocksdb::pending::begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const -> iterator
 {
-	rocksdb::db_val val{ key_a };
-	::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
-	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction_a), store.table_to_column_family (tables::pending), slice) } };
+	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction_a), store.table_to_column_family (tables::pending), to_slice (key_a)) } };
 }
 
 auto nano::store::rocksdb::pending::begin (store::transaction const & transaction_a) const -> iterator
diff --git a/nano/store/rocksdb/pending.hpp b/nano/store/rocksdb/pending.hpp
index 061d0031..45274975 100644
--- a/nano/store/rocksdb/pending.hpp
+++ b/nano/store/rocksdb/pending.hpp
@@ -2,6 +2,10 @@
 
 #include <nano/store/pending.hpp>
 
+namespace nano::store::rocksdb
+{
+class component;
+}
 namespace nano::store::rocksdb
 {
 class pending : public nano::store::pending
diff --git a/nano/store/rocksdb/pruned.cpp b/nano/store/rocksdb/pruned.cpp
index c3f387ef..0a2f869b 100644
--- a/nano/store/rocksdb/pruned.cpp
+++ b/nano/store/rocksdb/pruned.cpp
@@ -48,9 +48,7 @@ void nano::store::rocksdb::pruned::clear (store::write_transaction const & trans
 
 auto nano::store::rocksdb::pruned::begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const -> iterator
 {
-	rocksdb::db_val val{ hash_a };
-	::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
-	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction_a), store.table_to_column_family (tables::pruned), slice) } };
+	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction_a), store.table_to_column_family (tables::pruned), to_slice (hash_a)) } };
 }
 
 auto nano::store::rocksdb::pruned::begin (store::transaction const & transaction_a) const -> iterator
diff --git a/nano/store/rocksdb/rep_weight.cpp b/nano/store/rocksdb/rep_weight.cpp
index bea73196..eeb1b560 100644
--- a/nano/store/rocksdb/rep_weight.cpp
+++ b/nano/store/rocksdb/rep_weight.cpp
@@ -45,9 +45,7 @@ void nano::store::rocksdb::rep_weight::del (store::write_transaction const & txn
 
 auto nano::store::rocksdb::rep_weight::begin (store::transaction const & txn_a, nano::account const & representative_a) const -> iterator
 {
-	rocksdb::db_val val{ representative_a };
-	::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
-	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (txn_a), store.table_to_column_family (tables::rep_weights), slice) } };
+	return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (txn_a), store.table_to_column_family (tables::rep_weights), to_slice (representative_a)) } };
 }
 
 auto nano::store::rocksdb::rep_weight::begin (store::transaction const & txn_a) const -> iterator
diff --git a/nano/store/rocksdb/rocksdb.cpp b/nano/store/rocksdb/rocksdb.cpp
index 755ef153..fa69b66d 100644
--- a/nano/store/rocksdb/rocksdb.cpp
+++ b/nano/store/rocksdb/rocksdb.cpp
@@ -533,7 +533,7 @@ rocksdb::ColumnFamilyHandle * nano::store::rocksdb::component::table_to_column_f
 bool nano::store::rocksdb::component::exists (store::transaction const & transaction_a, tables table_a, nano::store::rocksdb::db_val const & key_a) const
 {
 	::rocksdb::PinnableSlice slice;
-	::rocksdb::Slice key_slice{ reinterpret_cast<char const *> (key_a.data ()), key_a.size () };
+	auto key_slice = to_slice (key_a);
 	auto internals = rocksdb::tx (transaction_a);
 	auto status = std::visit ([&] (auto && ptr) {
 		using V = std::remove_cvref_t<decltype (ptr)>;
@@ -563,7 +563,7 @@ int nano::store::rocksdb::component::del (store::write_transaction const & trans
 	// RocksDB does not report not_found status, it is a pre-condition that the key exists
 	debug_assert (exists (transaction_a, table_a, key_a));
 	flush_tombstones_check (table_a);
-	::rocksdb::Slice key_slice{ reinterpret_cast<char const *> (key_a.data ()), key_a.size () };
+	auto key_slice = to_slice (key_a);
 	return std::get<::rocksdb::Transaction *> (rocksdb::tx (transaction_a))->Delete (table_to_column_family (table_a), key_slice).code ();
 }
 
@@ -591,7 +591,7 @@ int nano::store::rocksdb::component::get (store::transaction const & transaction
 {
 	::rocksdb::ReadOptions options;
 	::rocksdb::PinnableSlice slice;
-	::rocksdb::Slice key_slice{ reinterpret_cast<char const *> (key_a.data ()), key_a.size () };
+	auto key_slice = to_slice (key_a);
 	auto handle = table_to_column_family (table_a);
 	auto internals = rocksdb::tx (transaction_a);
 	auto status = std::visit ([&] (auto && ptr) {
@@ -613,9 +613,7 @@ int nano::store::rocksdb::component::get (store::transaction const & transaction
 
 	if (status.ok ())
 	{
-		value_a.buffer = std::make_shared<std::vector<uint8_t>> (slice.size ());
-		std::memcpy (value_a.buffer->data (), slice.data (), slice.size ());
-		value_a.convert_buffer_to_value ();
+		value_a = from_slice (slice);
 	}
 	return status.code ();
 }
@@ -623,8 +621,8 @@ int nano::store::rocksdb::component::get (store::transaction const & transaction
 int nano::store::rocksdb::component::put (store::write_transaction const & transaction_a, tables table_a, nano::store::rocksdb::db_val const & key_a, nano::store::rocksdb::db_val const & value_a)
 {
 	debug_assert (transaction_a.contains (table_a));
-	::rocksdb::Slice key_slice{ reinterpret_cast<char const *> (key_a.data ()), key_a.size () };
-	::rocksdb::Slice value_slice{ reinterpret_cast<char const *> (value_a.data ()), value_a.size () };
+	auto key_slice = to_slice (key_a);
+	auto value_slice = to_slice (value_a);
 	return std::get<::rocksdb::Transaction *> (rocksdb::tx (transaction_a))->Put (table_to_column_family (table_a), key_slice, value_slice).code ();
 }
 
diff --git a/nano/store/rocksdb/utility.hpp b/nano/store/rocksdb/utility.hpp
index 7686b6b4..aff0e32d 100644
--- a/nano/store/rocksdb/utility.hpp
+++ b/nano/store/rocksdb/utility.hpp
@@ -1,7 +1,10 @@
 #pragma once
 
+#include <nano/store/rocksdb/db_val.hpp>
+
 #include <variant>
 
+#include <rocksdb/slice.h>
 #include <rocksdb/utilities/transaction_db.h>
 
 namespace nano::store
@@ -12,4 +15,23 @@ class transaction;
 namespace nano::store::rocksdb
 {
 auto tx (store::transaction const & transaction_a) -> std::variant<::rocksdb::Transaction *, ::rocksdb::ReadOptions *>;
+
+/**
+ * Converts a db_val to rocksdb::Slice for RocksDB operations
+ */
+inline ::rocksdb::Slice to_slice (nano::store::db_val const & val)
+{
+	return ::rocksdb::Slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
+}
+
+/**
+ * Creates a db_val from rocksdb::Slice for read operations
+ */
+inline nano::store::db_val from_slice (::rocksdb::Slice const & slice)
+{
+	auto buffer = std::make_shared<std::vector<uint8_t>> (
+	reinterpret_cast<uint8_t const *> (slice.data ()),
+	reinterpret_cast<uint8_t const *> (slice.data ()) + slice.size ());
+	return nano::store::db_val (buffer);
+}
 }

From cfcf3fa83747c03254ccc9c6fd416c6c15cefad5 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 19:12:05 +0200
Subject: [PATCH 4/6] Split `db_val` implementation

---
 nano/store/CMakeLists.txt           |   2 +-
 nano/store/account.hpp              |   2 +-
 nano/store/db_val.hpp               | 208 +++----------------
 nano/store/db_val_impl.hpp          | 135 ------------
 nano/store/db_val_templ.hpp         | 310 ++++++++++++++++++++++++++++
 nano/store/lmdb/block.cpp           |   2 +-
 nano/store/rocksdb/block.cpp        |   2 +-
 nano/store/typed_iterator_templ.hpp |   2 +-
 8 files changed, 346 insertions(+), 317 deletions(-)
 delete mode 100644 nano/store/db_val_impl.hpp
 create mode 100644 nano/store/db_val_templ.hpp

diff --git a/nano/store/CMakeLists.txt b/nano/store/CMakeLists.txt
index d5b4b248..53504cb6 100644
--- a/nano/store/CMakeLists.txt
+++ b/nano/store/CMakeLists.txt
@@ -6,7 +6,7 @@ add_library(
   component.hpp
   confirmation_height.hpp
   db_val.hpp
-  db_val_impl.hpp
+  db_val_templ.hpp
   iterator.hpp
   final_vote.hpp
   fwd.hpp
diff --git a/nano/store/account.hpp b/nano/store/account.hpp
index dab7556b..34ba21e4 100644
--- a/nano/store/account.hpp
+++ b/nano/store/account.hpp
@@ -2,7 +2,7 @@
 
 #include <nano/lib/numbers.hpp>
 #include <nano/store/component.hpp>
-#include <nano/store/db_val_impl.hpp>
+#include <nano/store/db_val_templ.hpp>
 #include <nano/store/reverse_iterator.hpp>
 #include <nano/store/typed_iterator.hpp>
 
diff --git a/nano/store/db_val.hpp b/nano/store/db_val.hpp
index 42fdb59b..7df6cd7d 100644
--- a/nano/store/db_val.hpp
+++ b/nano/store/db_val.hpp
@@ -48,161 +48,41 @@ public:
 		convert_buffer_to_value ();
 	}
 
-	db_val (nano::uint128_union const & val_a) :
-		span_view (val_a.bytes.data (), sizeof (val_a))
-	{
-	}
-
-	db_val (nano::uint256_union const & val_a) :
-		span_view (val_a.bytes.data (), sizeof (val_a))
-	{
-	}
-
-	db_val (nano::uint512_union const & val_a) :
-		span_view (val_a.bytes.data (), sizeof (val_a))
-	{
-	}
-
-	db_val (nano::qualified_root const & val_a) :
-		span_view (reinterpret_cast<uint8_t const *> (&val_a), sizeof (val_a))
-	{
-	}
-
-	db_val (nano::account_info const & val_a);
-
-	db_val (nano::account_info_v22 const & val_a);
-
-	db_val (nano::pending_info const & val_a);
-
-	db_val (nano::pending_key const & val_a);
-
-	db_val (nano::confirmation_height_info const & val_a) :
-		buffer (std::make_shared<std::vector<uint8_t>> ())
-	{
-		{
-			nano::vectorstream stream (*buffer);
-			val_a.serialize (stream);
-		}
-		convert_buffer_to_value ();
-	}
-
-	db_val (nano::block_info const & 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) :
-		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");
-	}
-
-	db_val (std::shared_ptr<nano::block> const & val_a);
-
-	db_val (uint64_t val_a) :
-		buffer (std::make_shared<std::vector<uint8_t>> ())
-	{
-		{
-			boost::endian::native_to_big_inplace (val_a);
-			nano::vectorstream stream (*buffer);
-			nano::write (stream, val_a);
-		}
-		convert_buffer_to_value ();
-	}
+	db_val (uint64_t);
+	db_val (nano::uint128_union const &);
+	db_val (nano::uint256_union const &);
+	db_val (nano::uint512_union const &);
+	db_val (nano::qualified_root const &);
+	db_val (nano::account_info const &);
+	db_val (nano::account_info_v22 const &);
+	db_val (nano::pending_info const &);
+	db_val (nano::pending_key const &);
+	db_val (nano::confirmation_height_info const &);
+	db_val (nano::block_info const &);
+	db_val (nano::endpoint_key const &);
+	db_val (std::shared_ptr<nano::block> const &);
 
+	explicit operator uint64_t () const;
+	explicit operator nano::uint128_union () const;
+	explicit operator nano::uint256_union () const;
+	explicit operator nano::uint512_union () const;
+	explicit operator nano::qualified_root () const;
 	explicit operator nano::account_info () const;
 	explicit operator nano::account_info_v22 () const;
-
-	explicit operator block_info () const
-	{
-		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 (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
-		return result;
-	}
-
 	explicit operator nano::pending_info () const;
-
 	explicit operator nano::pending_key () const;
-
-	explicit operator nano::confirmation_height_info () const
-	{
-		nano::bufferstream stream (span_view.data (), span_view.size ());
-		nano::confirmation_height_info result;
-		bool error (result.deserialize (stream));
-		(void)error;
-		debug_assert (!error);
-		return result;
-	}
-
-	explicit operator nano::uint128_union () const
-	{
-		return convert<nano::uint128_union> ();
-	}
-
-	explicit operator nano::amount () const
-	{
-		return convert<nano::amount> ();
-	}
-
-	explicit operator nano::block_hash () const
-	{
-		return convert<nano::block_hash> ();
-	}
-
-	explicit operator nano::public_key () const
-	{
-		return convert<nano::public_key> ();
-	}
-
-	explicit operator nano::qualified_root () const
-	{
-		return convert<nano::qualified_root> ();
-	}
-
-	explicit operator nano::uint256_union () const
-	{
-		return convert<nano::uint256_union> ();
-	}
-
-	explicit operator nano::uint512_union () const
-	{
-		return convert<nano::uint512_union> ();
-	}
-
-	explicit operator std::array<char, 64> () const
-	{
-		nano::bufferstream stream (span_view.data (), span_view.size ());
-		std::array<char, 64> result;
-		auto error = nano::try_read (stream, result);
-		(void)error;
-		debug_assert (!error);
-		return result;
-	}
-
-	explicit operator nano::endpoint_key () const
-	{
-		nano::endpoint_key result;
-		debug_assert (span_view.size () == sizeof (result));
-		std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
-		return result;
-	}
-
-	explicit operator block_w_sideband () const;
-
-	explicit operator std::nullptr_t () const
-	{
-		return nullptr;
-	}
-
-	explicit operator nano::no_value () const
-	{
-		return no_value::dummy;
-	}
-
+	explicit operator nano::confirmation_height_info () const;
+	explicit operator nano::block_info () const;
+	explicit operator nano::endpoint_key () const;
 	explicit operator std::shared_ptr<nano::block> () const;
+	explicit operator nano::amount () const;
+	explicit operator nano::block_hash () const;
+	explicit operator nano::public_key () const;
+	explicit operator std::array<char, 64> () const;
+	explicit operator block_w_sideband () const;
+	explicit operator std::shared_ptr<nano::vote> () const;
+	explicit operator std::nullptr_t () const;
+	explicit operator nano::no_value () const;
 
 	template <typename Block>
 	std::shared_ptr<Block> convert_to_block () const;
@@ -213,48 +93,22 @@ public:
 	explicit operator std::shared_ptr<nano::change_block> () const;
 	explicit operator std::shared_ptr<nano::state_block> () const;
 
-	explicit operator std::shared_ptr<nano::vote> () const;
-
-	explicit operator uint64_t () const
-	{
-		uint64_t result;
-		nano::bufferstream stream (span_view.data (), span_view.size ());
-		auto error (nano::try_read (stream, result));
-		(void)error;
-		debug_assert (!error);
-		boost::endian::big_to_native_inplace (result);
-		return result;
-	}
-
 	void * data () const
 	{
 		return const_cast<void *> (static_cast<void const *> (span_view.data ()));
 	}
-
 	size_t size () const
 	{
 		return span_view.size ();
 	}
 
-	void convert_buffer_to_value ()
-	{
-		if (buffer)
-		{
-			span_view = std::span<uint8_t const> (buffer->data (), buffer->size ());
-		}
-	}
+	void convert_buffer_to_value ();
 
 	std::span<uint8_t const> span_view;
 	std::shared_ptr<std::vector<uint8_t>> buffer;
 
 private:
 	template <typename T>
-	T convert () const
-	{
-		T result;
-		debug_assert (span_view.size () == sizeof (result));
-		std::copy (span_view.begin (), span_view.end (), result.bytes.data ());
-		return result;
-	}
+	T convert () const;
 };
 }
diff --git a/nano/store/db_val_impl.hpp b/nano/store/db_val_impl.hpp
deleted file mode 100644
index 54142860..00000000
--- a/nano/store/db_val_impl.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-#pragma once
-
-#include <nano/lib/blocks.hpp>
-#include <nano/lib/memory.hpp>
-#include <nano/secure/account_info.hpp>
-#include <nano/secure/pending_info.hpp>
-#include <nano/secure/vote.hpp>
-#include <nano/store/db_val.hpp>
-
-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 ())
-{
-}
-
-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 ())
-{
-}
-
-inline nano::store::db_val::db_val (std::shared_ptr<nano::block> const & val_a) :
-	buffer (std::make_shared<std::vector<uint8_t>> ())
-{
-	{
-		nano::vectorstream stream (*buffer);
-		nano::serialize_block (stream, *val_a);
-	}
-	convert_buffer_to_value ();
-}
-
-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");
-}
-
-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");
-}
-
-inline nano::store::db_val::operator nano::account_info () const
-{
-	nano::account_info result;
-	debug_assert (span_view.size () == result.db_size ());
-	std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
-	return result;
-}
-
-inline nano::store::db_val::operator nano::account_info_v22 () const
-{
-	nano::account_info_v22 result;
-	debug_assert (span_view.size () == result.db_size ());
-	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::block> () const
-{
-	nano::bufferstream stream (span_view.data (), span_view.size ());
-	std::shared_ptr<nano::block> result (nano::deserialize_block (stream));
-	return result;
-}
-
-inline nano::store::db_val::operator nano::store::block_w_sideband () const
-{
-	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 ());
-	release_assert (!error);
-	block_w_sideband.block->sideband_set (block_w_sideband.sideband);
-	return block_w_sideband;
-}
-
-inline nano::store::db_val::operator nano::pending_info () const
-{
-	nano::pending_info result;
-	debug_assert (span_view.size () == result.db_size ());
-	std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
-	return result;
-}
-
-inline nano::store::db_val::operator nano::pending_key () const
-{
-	nano::pending_key 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 (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/db_val_templ.hpp b/nano/store/db_val_templ.hpp
new file mode 100644
index 00000000..5d9f711c
--- /dev/null
+++ b/nano/store/db_val_templ.hpp
@@ -0,0 +1,310 @@
+#pragma once
+
+#include <nano/lib/blocks.hpp>
+#include <nano/lib/memory.hpp>
+#include <nano/lib/stream.hpp>
+#include <nano/secure/account_info.hpp>
+#include <nano/secure/pending_info.hpp>
+#include <nano/secure/vote.hpp>
+#include <nano/store/db_val.hpp>
+
+namespace nano::store
+{
+/*
+ * Constructors
+ */
+
+inline db_val::db_val (uint64_t val_a) :
+	buffer (std::make_shared<std::vector<uint8_t>> ())
+{
+	{
+		boost::endian::native_to_big_inplace (val_a);
+		nano::vectorstream stream (*buffer);
+		nano::write (stream, val_a);
+	}
+	convert_buffer_to_value ();
+}
+
+inline db_val::db_val (nano::uint128_union const & val_a) :
+	span_view (val_a.bytes.data (), sizeof (val_a))
+{
+}
+
+inline db_val::db_val (nano::uint256_union const & val_a) :
+	span_view (val_a.bytes.data (), sizeof (val_a))
+{
+}
+
+inline db_val::db_val (nano::uint512_union const & val_a) :
+	span_view (val_a.bytes.data (), sizeof (val_a))
+{
+}
+
+inline db_val::db_val (nano::qualified_root const & val_a) :
+	span_view (reinterpret_cast<uint8_t const *> (&val_a), sizeof (val_a))
+{
+}
+
+inline db_val::db_val (nano::account_info const & val_a) :
+	span_view (reinterpret_cast<uint8_t const *> (&val_a), val_a.db_size ())
+{
+}
+
+inline db_val::db_val (nano::account_info_v22 const & val_a) :
+	span_view (reinterpret_cast<uint8_t const *> (&val_a), val_a.db_size ())
+{
+}
+
+inline 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");
+}
+
+inline 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");
+}
+
+inline db_val::db_val (nano::confirmation_height_info const & val_a) :
+	buffer (std::make_shared<std::vector<uint8_t>> ())
+{
+	{
+		nano::vectorstream stream (*buffer);
+		val_a.serialize (stream);
+	}
+	convert_buffer_to_value ();
+}
+
+inline db_val::db_val (nano::block_info const & 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");
+}
+
+inline db_val::db_val (nano::endpoint_key const & 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");
+}
+
+inline db_val::db_val (std::shared_ptr<nano::block> const & val_a) :
+	buffer (std::make_shared<std::vector<uint8_t>> ())
+{
+	{
+		nano::vectorstream stream (*buffer);
+		nano::serialize_block (stream, *val_a);
+	}
+	convert_buffer_to_value ();
+}
+
+/*
+ * Conversion operators
+ */
+
+inline db_val::operator uint64_t () const
+{
+	uint64_t result;
+	nano::bufferstream stream (span_view.data (), span_view.size ());
+	auto error (nano::try_read (stream, result));
+	(void)error;
+	debug_assert (!error);
+	boost::endian::big_to_native_inplace (result);
+	return result;
+}
+
+inline db_val::operator nano::uint128_union () const
+{
+	return convert<nano::uint128_union> ();
+}
+
+inline db_val::operator nano::uint256_union () const
+{
+	return convert<nano::uint256_union> ();
+}
+
+inline db_val::operator nano::uint512_union () const
+{
+	return convert<nano::uint512_union> ();
+}
+
+inline db_val::operator nano::qualified_root () const
+{
+	return convert<nano::qualified_root> ();
+}
+
+inline db_val::operator nano::account_info () const
+{
+	nano::account_info result;
+	debug_assert (span_view.size () == result.db_size ());
+	std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
+	return result;
+}
+
+inline db_val::operator nano::account_info_v22 () const
+{
+	nano::account_info_v22 result;
+	debug_assert (span_view.size () == result.db_size ());
+	std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
+	return result;
+}
+
+inline db_val::operator nano::pending_info () const
+{
+	nano::pending_info result;
+	debug_assert (span_view.size () == result.db_size ());
+	std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
+	return result;
+}
+
+inline db_val::operator nano::pending_key () const
+{
+	nano::pending_key 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 (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
+	return result;
+}
+
+inline db_val::operator nano::confirmation_height_info () const
+{
+	nano::bufferstream stream (span_view.data (), span_view.size ());
+	nano::confirmation_height_info result;
+	bool error (result.deserialize (stream));
+	(void)error;
+	debug_assert (!error);
+	return result;
+}
+
+inline db_val::operator block_info () const
+{
+	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 (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
+	return result;
+}
+
+inline db_val::operator nano::endpoint_key () const
+{
+	nano::endpoint_key result;
+	debug_assert (span_view.size () == sizeof (result));
+	std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
+	return result;
+}
+
+inline db_val::operator std::shared_ptr<nano::block> () const
+{
+	nano::bufferstream stream (span_view.data (), span_view.size ());
+	std::shared_ptr<nano::block> result (nano::deserialize_block (stream));
+	return result;
+}
+
+inline db_val::operator nano::amount () const
+{
+	return convert<nano::amount> ();
+}
+
+inline db_val::operator nano::block_hash () const
+{
+	return convert<nano::block_hash> ();
+}
+
+inline db_val::operator nano::public_key () const
+{
+	return convert<nano::public_key> ();
+}
+
+inline db_val::operator std::array<char, 64> () const
+{
+	nano::bufferstream stream (span_view.data (), span_view.size ());
+	std::array<char, 64> result;
+	auto error = nano::try_read (stream, result);
+	(void)error;
+	debug_assert (!error);
+	return result;
+}
+
+inline db_val::operator nano::store::block_w_sideband () const
+{
+	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 ());
+	release_assert (!error);
+	block_w_sideband.block->sideband_set (block_w_sideband.sideband);
+	return block_w_sideband;
+}
+
+inline 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 db_val::operator std::nullptr_t () const
+{
+	return nullptr;
+}
+
+inline db_val::operator nano::no_value () const
+{
+	return no_value::dummy;
+}
+
+template <typename Block>
+inline std::shared_ptr<Block> 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;
+}
+
+inline db_val::operator std::shared_ptr<nano::send_block> () const
+{
+	return convert_to_block<nano::send_block> ();
+}
+
+inline db_val::operator std::shared_ptr<nano::receive_block> () const
+{
+	return convert_to_block<nano::receive_block> ();
+}
+
+inline db_val::operator std::shared_ptr<nano::open_block> () const
+{
+	return convert_to_block<nano::open_block> ();
+}
+
+inline db_val::operator std::shared_ptr<nano::change_block> () const
+{
+	return convert_to_block<nano::change_block> ();
+}
+
+inline db_val::operator std::shared_ptr<nano::state_block> () const
+{
+	return convert_to_block<nano::state_block> ();
+}
+
+inline void db_val::convert_buffer_to_value ()
+{
+	if (buffer)
+	{
+		span_view = std::span<uint8_t const> (buffer->data (), buffer->size ());
+	}
+}
+
+template <typename T>
+inline T db_val::convert () const
+{
+	T result;
+	debug_assert (span_view.size () == sizeof (result));
+	std::copy (span_view.begin (), span_view.end (), result.bytes.data ());
+	return result;
+}
+}
\ No newline at end of file
diff --git a/nano/store/lmdb/block.cpp b/nano/store/lmdb/block.cpp
index e2b823ca..f0f81a16 100644
--- a/nano/store/lmdb/block.cpp
+++ b/nano/store/lmdb/block.cpp
@@ -1,5 +1,5 @@
 #include <nano/secure/parallel_traversal.hpp>
-#include <nano/store/db_val_impl.hpp>
+#include <nano/store/db_val_templ.hpp>
 #include <nano/store/lmdb/block.hpp>
 #include <nano/store/lmdb/lmdb.hpp>
 #include <nano/store/lmdb/utility.hpp>
diff --git a/nano/store/rocksdb/block.cpp b/nano/store/rocksdb/block.cpp
index 8ac63885..c73f48f9 100644
--- a/nano/store/rocksdb/block.cpp
+++ b/nano/store/rocksdb/block.cpp
@@ -1,5 +1,5 @@
 #include <nano/secure/parallel_traversal.hpp>
-#include <nano/store/db_val_impl.hpp>
+#include <nano/store/db_val_templ.hpp>
 #include <nano/store/rocksdb/block.hpp>
 #include <nano/store/rocksdb/rocksdb.hpp>
 #include <nano/store/rocksdb/utility.hpp>
diff --git a/nano/store/typed_iterator_templ.hpp b/nano/store/typed_iterator_templ.hpp
index f3053359..bb55f159 100644
--- a/nano/store/typed_iterator_templ.hpp
+++ b/nano/store/typed_iterator_templ.hpp
@@ -1,5 +1,5 @@
 #include <nano/lib/utility.hpp>
-#include <nano/store/db_val_impl.hpp>
+#include <nano/store/db_val_templ.hpp>
 #include <nano/store/typed_iterator.hpp>
 
 namespace nano::store

From 54286a25a17551e3316a46aa621512a0667bb60c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?=
 <3044353+pwojcikdev@users.noreply.github.com>
Date: Tue, 10 Jun 2025 13:44:36 +0200
Subject: [PATCH 5/6] Code style cleanup

---
 nano/store/db_val.hpp       |  30 +++++-----
 nano/store/db_val_templ.hpp | 112 ++++++++++++++++++------------------
 2 files changed, 70 insertions(+), 72 deletions(-)

diff --git a/nano/store/db_val.hpp b/nano/store/db_val.hpp
index 7df6cd7d..b97136ce 100644
--- a/nano/store/db_val.hpp
+++ b/nano/store/db_val.hpp
@@ -22,33 +22,33 @@ namespace nano::store
 /**
  * Encapsulates database values using std::span for type safety and backend independence
  */
-class db_val
+class db_val final
 {
 public:
 	db_val () = default;
 
-	db_val (std::span<uint8_t const> span) :
-		span_view (span)
+	db_val (std::span<uint8_t const> span) noexcept :
+		span_view{ span }
 	{
 	}
 
-	db_val (size_t size, void const * data) :
-		span_view (static_cast<uint8_t const *> (data), size)
+	db_val (size_t size, void const * data) noexcept :
+		span_view{ static_cast<uint8_t const *> (data), size }
 	{
 	}
 
-	db_val (std::nullptr_t) :
-		span_view ()
+	db_val (std::nullptr_t) noexcept :
+		span_view{}
 	{
 	}
 
-	db_val (std::shared_ptr<std::vector<uint8_t>> buffer_a) :
-		buffer (buffer_a)
+	db_val (std::shared_ptr<std::vector<uint8_t>> buffer) noexcept :
+		buffer{ buffer }
 	{
 		convert_buffer_to_value ();
 	}
 
-	db_val (uint64_t);
+	db_val (uint64_t value);
 	db_val (nano::uint128_union const &);
 	db_val (nano::uint256_union const &);
 	db_val (nano::uint512_union const &);
@@ -85,7 +85,7 @@ public:
 	explicit operator nano::no_value () const;
 
 	template <typename Block>
-	std::shared_ptr<Block> convert_to_block () const;
+	auto convert_to_block () const -> std::shared_ptr<Block>;
 
 	explicit operator std::shared_ptr<nano::send_block> () const;
 	explicit operator std::shared_ptr<nano::receive_block> () const;
@@ -93,22 +93,22 @@ public:
 	explicit operator std::shared_ptr<nano::change_block> () const;
 	explicit operator std::shared_ptr<nano::state_block> () const;
 
-	void * data () const
+	auto data () const noexcept -> void *
 	{
 		return const_cast<void *> (static_cast<void const *> (span_view.data ()));
 	}
-	size_t size () const
+	auto size () const noexcept -> size_t
 	{
 		return span_view.size ();
 	}
 
-	void convert_buffer_to_value ();
+	auto convert_buffer_to_value () noexcept -> void;
 
 	std::span<uint8_t const> span_view;
 	std::shared_ptr<std::vector<uint8_t>> buffer;
 
 private:
 	template <typename T>
-	T convert () const;
+	auto convert () const -> T;
 };
 }
diff --git a/nano/store/db_val_templ.hpp b/nano/store/db_val_templ.hpp
index 5d9f711c..8955ab23 100644
--- a/nano/store/db_val_templ.hpp
+++ b/nano/store/db_val_templ.hpp
@@ -10,104 +10,100 @@
 
 namespace nano::store
 {
-/*
- * Constructors
- */
+// Constructor implementations
 
-inline db_val::db_val (uint64_t val_a) :
-	buffer (std::make_shared<std::vector<uint8_t>> ())
+inline db_val::db_val (uint64_t value) :
+	buffer{ std::make_shared<std::vector<uint8_t>> () }
 {
 	{
-		boost::endian::native_to_big_inplace (val_a);
-		nano::vectorstream stream (*buffer);
-		nano::write (stream, val_a);
+		boost::endian::native_to_big_inplace (value);
+		nano::vectorstream stream{ *buffer };
+		nano::write (stream, value);
 	}
 	convert_buffer_to_value ();
 }
 
-inline db_val::db_val (nano::uint128_union const & val_a) :
-	span_view (val_a.bytes.data (), sizeof (val_a))
+inline db_val::db_val (nano::uint128_union const & value) :
+	span_view{ value.bytes.data (), sizeof (value) }
 {
 }
 
-inline db_val::db_val (nano::uint256_union const & val_a) :
-	span_view (val_a.bytes.data (), sizeof (val_a))
+inline db_val::db_val (nano::uint256_union const & value) :
+	span_view{ value.bytes.data (), sizeof (value) }
 {
 }
 
-inline db_val::db_val (nano::uint512_union const & val_a) :
-	span_view (val_a.bytes.data (), sizeof (val_a))
+inline db_val::db_val (nano::uint512_union const & value) :
+	span_view{ value.bytes.data (), sizeof (value) }
 {
 }
 
-inline db_val::db_val (nano::qualified_root const & val_a) :
-	span_view (reinterpret_cast<uint8_t const *> (&val_a), sizeof (val_a))
+inline db_val::db_val (nano::qualified_root const & value) :
+	span_view{ reinterpret_cast<uint8_t const *> (&value), sizeof (value) }
 {
 }
 
-inline db_val::db_val (nano::account_info const & val_a) :
-	span_view (reinterpret_cast<uint8_t const *> (&val_a), val_a.db_size ())
+inline db_val::db_val (nano::account_info const & value) :
+	span_view{ reinterpret_cast<uint8_t const *> (&value), value.db_size () }
 {
 }
 
-inline db_val::db_val (nano::account_info_v22 const & val_a) :
-	span_view (reinterpret_cast<uint8_t const *> (&val_a), val_a.db_size ())
+inline db_val::db_val (nano::account_info_v22 const & value) :
+	span_view{ reinterpret_cast<uint8_t const *> (&value), value.db_size () }
 {
 }
 
-inline db_val::db_val (nano::pending_info const & val_a) :
-	span_view (reinterpret_cast<uint8_t const *> (&val_a), val_a.db_size ())
+inline db_val::db_val (nano::pending_info const & value) :
+	span_view{ reinterpret_cast<uint8_t const *> (&value), value.db_size () }
 {
 	static_assert (std::is_standard_layout<nano::pending_info>::value, "Standard layout is required");
 }
 
-inline db_val::db_val (nano::pending_key const & val_a) :
-	span_view (reinterpret_cast<uint8_t const *> (&val_a), sizeof (val_a))
+inline db_val::db_val (nano::pending_key const & value) :
+	span_view{ reinterpret_cast<uint8_t const *> (&value), sizeof (value) }
 {
 	static_assert (std::is_standard_layout<nano::pending_key>::value, "Standard layout is required");
 }
 
-inline db_val::db_val (nano::confirmation_height_info const & val_a) :
-	buffer (std::make_shared<std::vector<uint8_t>> ())
+inline db_val::db_val (nano::confirmation_height_info const & value) :
+	buffer{ std::make_shared<std::vector<uint8_t>> () }
 {
 	{
-		nano::vectorstream stream (*buffer);
-		val_a.serialize (stream);
+		nano::vectorstream stream{ *buffer };
+		value.serialize (stream);
 	}
 	convert_buffer_to_value ();
 }
 
-inline db_val::db_val (nano::block_info const & val_a) :
-	span_view (reinterpret_cast<uint8_t const *> (&val_a), sizeof (val_a))
+inline db_val::db_val (nano::block_info const & value) :
+	span_view{ reinterpret_cast<uint8_t const *> (&value), sizeof (value) }
 {
 	static_assert (std::is_standard_layout<nano::block_info>::value, "Standard layout is required");
 }
 
-inline db_val::db_val (nano::endpoint_key const & val_a) :
-	span_view (reinterpret_cast<uint8_t const *> (&val_a), sizeof (val_a))
+inline db_val::db_val (nano::endpoint_key const & value) :
+	span_view{ reinterpret_cast<uint8_t const *> (&value), sizeof (value) }
 {
 	static_assert (std::is_standard_layout<nano::endpoint_key>::value, "Standard layout is required");
 }
 
-inline db_val::db_val (std::shared_ptr<nano::block> const & val_a) :
-	buffer (std::make_shared<std::vector<uint8_t>> ())
+inline db_val::db_val (std::shared_ptr<nano::block> const & block) :
+	buffer{ std::make_shared<std::vector<uint8_t>> () }
 {
 	{
-		nano::vectorstream stream (*buffer);
-		nano::serialize_block (stream, *val_a);
+		nano::vectorstream stream{ *buffer };
+		nano::serialize_block (stream, *block);
 	}
 	convert_buffer_to_value ();
 }
 
-/*
- * Conversion operators
- */
+// Conversion operator implementations
 
 inline db_val::operator uint64_t () const
 {
 	uint64_t result;
-	nano::bufferstream stream (span_view.data (), span_view.size ());
-	auto error (nano::try_read (stream, result));
+	nano::bufferstream stream{ span_view.data (), span_view.size () };
+	auto error{ nano::try_read (stream, result) };
 	(void)error;
 	debug_assert (!error);
 	boost::endian::big_to_native_inplace (result);
@@ -169,9 +165,9 @@ inline db_val::operator nano::pending_key () const
 
 inline db_val::operator nano::confirmation_height_info () const
 {
-	nano::bufferstream stream (span_view.data (), span_view.size ());
+	nano::bufferstream stream{ span_view.data (), span_view.size () };
 	nano::confirmation_height_info result;
-	bool error (result.deserialize (stream));
+	bool error{ result.deserialize (stream) };
 	(void)error;
 	debug_assert (!error);
 	return result;
@@ -196,8 +192,8 @@ inline db_val::operator nano::endpoint_key () const
 
 inline db_val::operator std::shared_ptr<nano::block> () const
 {
-	nano::bufferstream stream (span_view.data (), span_view.size ());
-	std::shared_ptr<nano::block> result (nano::deserialize_block (stream));
+	nano::bufferstream stream{ span_view.data (), span_view.size () };
+	std::shared_ptr<nano::block> result{ nano::deserialize_block (stream) };
 	return result;
 }
 
@@ -218,7 +214,7 @@ inline db_val::operator nano::public_key () const
 
 inline db_val::operator std::array<char, 64> () const
 {
-	nano::bufferstream stream (span_view.data (), span_view.size ());
+	nano::bufferstream stream{ span_view.data (), span_view.size () };
 	std::array<char, 64> result;
 	auto error = nano::try_read (stream, result);
 	(void)error;
@@ -228,7 +224,7 @@ inline db_val::operator std::array<char, 64> () const
 
 inline db_val::operator nano::store::block_w_sideband () const
 {
-	nano::bufferstream stream (span_view.data (), span_view.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 ());
@@ -239,9 +235,9 @@ inline db_val::operator nano::store::block_w_sideband () const
 
 inline 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));
+	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;
 }
@@ -257,11 +253,11 @@ inline db_val::operator nano::no_value () const
 }
 
 template <typename Block>
-inline std::shared_ptr<Block> db_val::convert_to_block () const
+inline auto db_val::convert_to_block () const -> std::shared_ptr<Block>
 {
-	nano::bufferstream stream (span_view.data (), span_view.size ());
-	auto error (false);
-	auto result (nano::make_shared<Block> (error, stream));
+	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;
 }
@@ -291,16 +287,18 @@ inline db_val::operator std::shared_ptr<nano::state_block> () const
 	return convert_to_block<nano::state_block> ();
 }
 
-inline void db_val::convert_buffer_to_value ()
+// Member function implementations
+
+inline auto db_val::convert_buffer_to_value () noexcept -> void
 {
 	if (buffer)
 	{
-		span_view = std::span<uint8_t const> (buffer->data (), buffer->size ());
+		span_view = std::span<uint8_t const>{ buffer->data (), buffer->size () };
 	}
 }
 
 template <typename T>
-inline T db_val::convert () const
+inline auto db_val::convert () const -> T
 {
 	T result;
 	debug_assert (span_view.size () == sizeof (result));

From 43d39d7db6e04ce27f2896485e6976df473f42c0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?=
 <3044353+pwojcikdev@users.noreply.github.com>
Date: Sun, 22 Jun 2025 19:22:38 +0200
Subject: [PATCH 6/6] Fix sanitizer warning

---
 nano/store/db_val.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nano/store/db_val.hpp b/nano/store/db_val.hpp
index b97136ce..fe7de26a 100644
--- a/nano/store/db_val.hpp
+++ b/nano/store/db_val.hpp
@@ -38,7 +38,7 @@ public:
 	}
 
 	db_val (std::nullptr_t) noexcept :
-		span_view{}
+		span_view{ reinterpret_cast<uint8_t const *> (""), 0 } // Use empty string literal to provide valid pointer for zero-size memcpy
 	{
 	}