diff --git a/cmd/dev/grpc_toolbox.cpp b/cmd/dev/grpc_toolbox.cpp
index 0dae7a379f..06faa7fb0d 100644
--- a/cmd/dev/grpc_toolbox.cpp
+++ b/cmd/dev/grpc_toolbox.cpp
@@ -990,10 +990,7 @@ int execute_temporal_kv_query(const std::string& target, KVQueryFunc<Q> query_fu
         db::kv::grpc::client::RemoteClient client{channel_factory,
                                                   *grpc_context,
                                                   &state_cache,
-                                                  rpc::ethdb::kv::block_provider(&eth_backend),
-                                                  rpc::ethdb::kv::block_number_from_txn_hash_provider(&eth_backend),
-                                                  rpc::ethdb::kv::block_number_from_block_hash_provider(&eth_backend),
-                                                  rpc::ethdb::kv::block_hash_from_block_number_provider(&eth_backend)};
+                                                  ethdb::kv::make_backend_providers(&eth_backend)};
         auto kv_service = client.service();
 
         // NOLINTNEXTLINE(performance-unnecessary-value-param)
diff --git a/silkworm/db/chain/remote_chain_storage.cpp b/silkworm/db/chain/remote_chain_storage.cpp
index 95ec8be2b2..2ea5a557b9 100644
--- a/silkworm/db/chain/remote_chain_storage.cpp
+++ b/silkworm/db/chain/remote_chain_storage.cpp
@@ -28,16 +28,8 @@
 
 namespace silkworm::db::chain {
 
-RemoteChainStorage::RemoteChainStorage(kv::api::Transaction& tx,
-                                       BlockProvider block_provider,
-                                       BlockNumberFromTxnHashProvider block_number_from_txn_hash_provider,
-                                       BlockNumberFromBlockHashProvider block_number_from_block_hash_provider,
-                                       BlockHashFromBlockNumberProvider block_hash_from_number_provider)
-    : tx_{tx},
-      block_provider_{std::move(block_provider)},
-      block_number_from_txn_hash_provider_{std::move(block_number_from_txn_hash_provider)},
-      block_number_from_block_hash_provider_{std::move(block_number_from_block_hash_provider)},
-      block_hash_from_number_provider_{std::move(block_hash_from_number_provider)} {}
+RemoteChainStorage::RemoteChainStorage(kv::api::Transaction& tx, Providers providers)
+    : tx_{tx}, providers_{std::move(providers)} {}
 
 Task<ChainConfig> RemoteChainStorage::read_chain_config() const {
     const auto genesis_block_hash{co_await read_canonical_block_hash(tx_, kEarliestBlockNumber)};
@@ -67,26 +59,26 @@ Task<std::optional<BlockNum>> RemoteChainStorage::read_block_number(const Hash&
 }
 
 Task<bool> RemoteChainStorage::read_block(HashAsSpan hash, BlockNum number, bool read_senders, Block& block) const {
-    co_return co_await block_provider_(number, hash, read_senders, block);
+    co_return co_await providers_.block(number, hash, read_senders, block);
 }
 
 Task<bool> RemoteChainStorage::read_block(const Hash& hash, BlockNum number, Block& block) const {
-    co_return co_await block_provider_(number, hash.bytes, /*.read_senders=*/false, block);
+    co_return co_await providers_.block(number, hash.bytes, /*.read_senders=*/false, block);
 }
 
 Task<bool> RemoteChainStorage::read_block(const Hash& hash, Block& block) const {
     const BlockNum block_number = co_await read_header_number(tx_, hash);
-    co_return co_await block_provider_(block_number, hash.bytes, /*.read_senders=*/false, block);
+    co_return co_await providers_.block(block_number, hash.bytes, /*.read_senders=*/false, block);
 }
 
 Task<bool> RemoteChainStorage::read_block(BlockNum number, bool read_senders, Block& block) const {
     const auto hash = co_await read_canonical_block_hash(tx_, number);
-    co_return co_await block_provider_(number, hash.bytes, read_senders, block);
+    co_return co_await providers_.block(number, hash.bytes, read_senders, block);
 }
 
 Task<std::optional<BlockHeader>> RemoteChainStorage::read_header(BlockNum number, HashAsArray hash) const {
     Block block;
-    const bool success = co_await block_provider_(number, hash, /*.read_senders=*/false, block);
+    const bool success = co_await providers_.block(number, hash, /*.read_senders=*/false, block);
     std::optional<BlockHeader> header;
     if (success) {
         header = std::move(block.header);
@@ -109,7 +101,7 @@ Task<std::vector<BlockHeader>> RemoteChainStorage::read_sibling_headers(BlockNum
 
 Task<bool> RemoteChainStorage::read_body(BlockNum number, HashAsArray hash, bool read_senders, BlockBody& body) const {
     Block block;
-    const bool success = co_await block_provider_(number, hash, read_senders, block);
+    const bool success = co_await providers_.block(number, hash, read_senders, block);
     if (!success) {
         co_return false;
     }
@@ -140,7 +132,7 @@ Task<std::optional<BlockHeader>> RemoteChainStorage::read_canonical_header(Block
 Task<bool> RemoteChainStorage::read_canonical_body(BlockNum number, BlockBody& body) const {
     Block block;
     const auto hash = co_await read_canonical_block_hash(tx_, number);
-    const bool success = co_await block_provider_(number, hash.bytes, /*.read_senders=*/false, block);
+    const bool success = co_await providers_.block(number, hash.bytes, /*.read_senders=*/false, block);
     if (!success) {
         co_return false;
     }
@@ -152,7 +144,7 @@ Task<bool> RemoteChainStorage::read_canonical_body(BlockNum number, BlockBody& b
 
 Task<bool> RemoteChainStorage::read_canonical_block(BlockNum number, Block& block) const {
     const auto hash = co_await read_canonical_block_hash(tx_, number);
-    const bool success = co_await block_provider_(number, hash.bytes, /*.read_senders=*/false, block);
+    const bool success = co_await providers_.block(number, hash.bytes, /*.read_senders=*/false, block);
     if (!success) {
         co_return false;
     }
@@ -171,7 +163,7 @@ Task<bool> RemoteChainStorage::has_body(BlockNum number, const Hash& hash) const
 
 Task<bool> RemoteChainStorage::read_rlp_transactions(BlockNum number, const evmc::bytes32& hash, std::vector<Bytes>& rlp_txs) const {
     Block block;
-    const bool success = co_await block_provider_(number, hash.bytes, /*.read_senders=*/false, block);
+    const bool success = co_await providers_.block(number, hash.bytes, /*.read_senders=*/false, block);
     if (!success) {
         co_return false;
     }
@@ -191,7 +183,7 @@ Task<std::optional<intx::uint256>> RemoteChainStorage::read_total_difficulty(con
 }
 
 Task<std::optional<BlockNum>> RemoteChainStorage::read_block_number_by_transaction_hash(const evmc::bytes32& transaction_hash) const {
-    co_return co_await block_number_from_txn_hash_provider_(transaction_hash.bytes);
+    co_return co_await providers_.block_number_from_txn_hash(transaction_hash.bytes);
 }
 
 }  // namespace silkworm::db::chain
diff --git a/silkworm/db/chain/remote_chain_storage.hpp b/silkworm/db/chain/remote_chain_storage.hpp
index 63844898fe..078f477ea8 100644
--- a/silkworm/db/chain/remote_chain_storage.hpp
+++ b/silkworm/db/chain/remote_chain_storage.hpp
@@ -29,17 +29,20 @@ namespace silkworm::db::chain {
 using BlockProvider = std::function<Task<bool>(BlockNum, HashAsSpan, bool, Block&)>;
 using BlockNumberFromTxnHashProvider = std::function<Task<BlockNum>(HashAsSpan)>;
 using BlockNumberFromBlockHashProvider = std::function<Task<BlockNum>(HashAsSpan)>;
-using BlockHashFromBlockNumberProvider = std::function<Task<evmc::bytes32>(BlockNum)>;
+using CanonicalBlockHashFromNumberProvider = std::function<Task<evmc::bytes32>(BlockNum)>;
+
+struct Providers {
+    BlockProvider block;
+    BlockNumberFromTxnHashProvider block_number_from_txn_hash;
+    BlockNumberFromBlockHashProvider block_number_from_hash;
+    CanonicalBlockHashFromNumberProvider canonical_block_hash_from_number;
+};
 
 //! RemoteChainStorage must be used when blockchain data is remote with respect to the running component, i.e. it is
 //! in remote database (accessed via gRPC KV I/F) or remote snapshot files (accessed via gRPC ETHBACKEND I/F)
 class RemoteChainStorage : public ChainStorage {
   public:
-    RemoteChainStorage(kv::api::Transaction& tx,
-                       BlockProvider block_provider,
-                       BlockNumberFromTxnHashProvider block_number_from_txn_hash_provider,
-                       BlockNumberFromBlockHashProvider block_number_from_block_hash_provider,
-                       BlockHashFromBlockNumberProvider block_hash_from_number_provider);
+    RemoteChainStorage(kv::api::Transaction& tx, Providers providers);
     ~RemoteChainStorage() override = default;
 
     [[nodiscard]] Task<ChainConfig> read_chain_config() const override;
@@ -82,10 +85,7 @@ class RemoteChainStorage : public ChainStorage {
 
   private:
     kv::api::Transaction& tx_;
-    BlockProvider block_provider_;
-    BlockNumberFromTxnHashProvider block_number_from_txn_hash_provider_;
-    BlockNumberFromBlockHashProvider block_number_from_block_hash_provider_;
-    BlockHashFromBlockNumberProvider block_hash_from_number_provider_;
+    Providers providers_;
 };
 
 }  // namespace silkworm::db::chain
diff --git a/silkworm/db/chain/remote_chain_storage_test.cpp b/silkworm/db/chain/remote_chain_storage_test.cpp
index 65948f9276..d2806b3950 100644
--- a/silkworm/db/chain/remote_chain_storage_test.cpp
+++ b/silkworm/db/chain/remote_chain_storage_test.cpp
@@ -48,7 +48,7 @@ static Bytes kChainConfig{*from_hex(
 
 struct RemoteChainStorageTest : public silkworm::test_util::ContextTestBase {
     test_util::MockTransaction transaction;
-    RemoteChainStorage storage{transaction, {}, {}, {}, {}};
+    RemoteChainStorage storage{transaction, Providers{}};
 };
 
 TEST_CASE_METHOD(RemoteChainStorageTest, "read_chain_config") {
diff --git a/silkworm/db/kv/grpc/client/remote_client.cpp b/silkworm/db/kv/grpc/client/remote_client.cpp
index 0c160a1740..4b2edc6c3e 100644
--- a/silkworm/db/kv/grpc/client/remote_client.cpp
+++ b/silkworm/db/kv/grpc/client/remote_client.cpp
@@ -41,35 +41,23 @@ class RemoteClientImpl final : public api::Service {
     RemoteClientImpl(const rpc::ChannelFactory& create_channel,
                      agrpc::GrpcContext& grpc_context,
                      api::StateCache* state_cache,
-                     chain::BlockProvider block_provider,
-                     chain::BlockNumberFromTxnHashProvider block_number_from_txn_hash_provider,
-                     chain::BlockNumberFromBlockHashProvider block_number_from_block_hash_provider,
-                     chain::BlockHashFromBlockNumberProvider block_hash_from_number_provider,
+                     chain::Providers providers,
                      rpc::DisconnectHook on_disconnect)
         : channel_{create_channel()},
           stub_{proto::KV::NewStub(channel_)},
           grpc_context_{grpc_context},
           state_cache_{state_cache},
-          block_provider_{std::move(block_provider)},
-          block_number_from_txn_hash_provider_{std::move(block_number_from_txn_hash_provider)},
-          block_number_from_block_hash_provider_{std::move(block_number_from_block_hash_provider)},
-          block_hash_from_number_provider_{std::move(block_hash_from_number_provider)},
+          providers_{std::move(providers)},
           on_disconnect_{std::move(on_disconnect)} {}
     RemoteClientImpl(std::unique_ptr<Stub> stub,
                      agrpc::GrpcContext& grpc_context,
                      api::StateCache* state_cache,
-                     chain::BlockProvider block_provider,
-                     chain::BlockNumberFromTxnHashProvider block_number_from_txn_hash_provider,
-                     chain::BlockNumberFromBlockHashProvider block_number_from_block_hash_provider,
-                     chain::BlockHashFromBlockNumberProvider block_hash_from_number_provider,
+                     chain::Providers providers,
                      rpc::DisconnectHook on_disconnect)
         : stub_{std::move(stub)},
           grpc_context_{grpc_context},
           state_cache_{state_cache},
-          block_provider_{std::move(block_provider)},
-          block_number_from_txn_hash_provider_{std::move(block_number_from_txn_hash_provider)},
-          block_number_from_block_hash_provider_{std::move(block_number_from_block_hash_provider)},
-          block_hash_from_number_provider_{std::move(block_hash_from_number_provider)},
+          providers_{std::move(providers)},
           on_disconnect_{std::move(on_disconnect)} {}
 
     ~RemoteClientImpl() override = default;
@@ -87,10 +75,7 @@ class RemoteClientImpl final : public api::Service {
         auto tx = std::make_unique<RemoteTransaction>(*stub_,
                                                       grpc_context_,
                                                       state_cache_,
-                                                      block_provider_,
-                                                      block_number_from_txn_hash_provider_,
-                                                      block_number_from_block_hash_provider_,
-                                                      block_hash_from_number_provider_);
+                                                      providers_);
         co_await tx->open();
         co_return tx;
     }
@@ -159,10 +144,7 @@ class RemoteClientImpl final : public api::Service {
     std::unique_ptr<Stub> stub_;
     agrpc::GrpcContext& grpc_context_;
     api::StateCache* state_cache_;
-    chain::BlockProvider block_provider_;
-    chain::BlockNumberFromTxnHashProvider block_number_from_txn_hash_provider_;
-    chain::BlockNumberFromBlockHashProvider block_number_from_block_hash_provider_;
-    chain::BlockHashFromBlockNumberProvider block_hash_from_number_provider_;
+    chain::Providers providers_;
     rpc::DisconnectHook on_disconnect_;
     std::chrono::milliseconds min_backoff_timeout_{rpc::kDefaultMinBackoffReconnectTimeout};
     std::chrono::milliseconds max_backoff_timeout_{rpc::kDefaultMaxBackoffReconnectTimeout};
@@ -171,35 +153,23 @@ class RemoteClientImpl final : public api::Service {
 RemoteClient::RemoteClient(const rpc::ChannelFactory& create_channel,
                            agrpc::GrpcContext& grpc_context,
                            api::StateCache* state_cache,
-                           chain::BlockProvider block_provider,
-                           chain::BlockNumberFromTxnHashProvider block_number_from_txn_hash_provider,
-                           chain::BlockNumberFromBlockHashProvider block_number_from_block_hash_provider,
-                           chain::BlockHashFromBlockNumberProvider block_hash_from_number_provider,
+                           chain::Providers providers,
                            rpc::DisconnectHook on_disconnect)
     : p_impl_{std::make_shared<RemoteClientImpl>(create_channel,
                                                  grpc_context,
                                                  state_cache,
-                                                 std::move(block_provider),
-                                                 std::move(block_number_from_txn_hash_provider),
-                                                 std::move(block_number_from_block_hash_provider),
-                                                 std::move(block_hash_from_number_provider),
+                                                 std::move(providers),
                                                  std::move(on_disconnect))} {}
 
 RemoteClient::RemoteClient(std::unique_ptr<Stub> stub,
                            agrpc::GrpcContext& grpc_context,
                            api::StateCache* state_cache,
-                           chain::BlockProvider block_provider,
-                           chain::BlockNumberFromTxnHashProvider block_number_from_txn_hash_provider,
-                           chain::BlockNumberFromBlockHashProvider block_number_from_block_hash_provider,
-                           chain::BlockHashFromBlockNumberProvider block_hash_from_number_provider,
+                           chain::Providers providers,
                            rpc::DisconnectHook on_disconnect)
     : p_impl_{std::make_shared<RemoteClientImpl>(std::move(stub),
                                                  grpc_context,
                                                  state_cache,
-                                                 std::move(block_provider),
-                                                 std::move(block_number_from_txn_hash_provider),
-                                                 std::move(block_number_from_block_hash_provider),
-                                                 std::move(block_hash_from_number_provider),
+                                                 std::move(providers),
                                                  std::move(on_disconnect))} {}
 
 // Must be here (not in header) because RemoteClientImpl size is necessary for std::unique_ptr in PIMPL idiom
diff --git a/silkworm/db/kv/grpc/client/remote_client.hpp b/silkworm/db/kv/grpc/client/remote_client.hpp
index 4dc2bcba7f..4c0efac1a6 100644
--- a/silkworm/db/kv/grpc/client/remote_client.hpp
+++ b/silkworm/db/kv/grpc/client/remote_client.hpp
@@ -38,19 +38,13 @@ struct RemoteClient : public api::Client {
         const rpc::ChannelFactory& create_channel,
         agrpc::GrpcContext& grpc_context,
         api::StateCache* state_cache,
-        chain::BlockProvider block_provider,
-        chain::BlockNumberFromTxnHashProvider block_number_from_txn_hash_provider,
-        chain::BlockNumberFromBlockHashProvider block_number_from_block_hash_provider,
-        chain::BlockHashFromBlockNumberProvider block_hash_from_number_provider,
+        chain::Providers providers,
         std::function<Task<void>()> on_disconnect = []() -> Task<void> { co_return; });
     RemoteClient(
         std::unique_ptr<::remote::KV::StubInterface> stub,
         agrpc::GrpcContext& grpc_context,
         api::StateCache* state_cache,
-        chain::BlockProvider block_provider,
-        chain::BlockNumberFromTxnHashProvider block_number_from_txn_hash_provider,
-        chain::BlockNumberFromBlockHashProvider block_number_from_block_hash_provider,
-        chain::BlockHashFromBlockNumberProvider block_hash_from_number_provider,
+        chain::Providers providers,
         std::function<Task<void>()> on_disconnect = []() -> Task<void> { co_return; });
     ~RemoteClient() override;
 
diff --git a/silkworm/db/kv/grpc/client/remote_client_test.cpp b/silkworm/db/kv/grpc/client/remote_client_test.cpp
index 578ee5013e..1e52bcc8ed 100644
--- a/silkworm/db/kv/grpc/client/remote_client_test.cpp
+++ b/silkworm/db/kv/grpc/client/remote_client_test.cpp
@@ -47,7 +47,7 @@ struct RemoteClientTestRunner : public TestRunner<RemoteClient, StrictMockKVStub
         [](HashAsSpan) -> Task<BlockNum> { co_return 0; }};
     chain::BlockNumberFromBlockHashProvider block_number_from_block_hash_provider{
         [](HashAsSpan) -> Task<BlockNum> { co_return 0; }};
-    chain::BlockHashFromBlockNumberProvider block_hash_from_block_number_provider{
+    chain::CanonicalBlockHashFromNumberProvider canonical_block_hash_from_number_provider{
         [](BlockNum) -> Task<evmc::bytes32> { co_return 0; }};
 
   protected:
@@ -55,10 +55,10 @@ struct RemoteClientTestRunner : public TestRunner<RemoteClient, StrictMockKVStub
         return RemoteClient{std::move(stub_),
                             grpc_context_,
                             state_cache.get(),
-                            block_provider,
-                            block_number_from_txn_hash_provider,
-                            block_number_from_block_hash_provider,
-                            block_hash_from_block_number_provider};
+                            {block_provider,
+                             block_number_from_txn_hash_provider,
+                             block_number_from_block_hash_provider,
+                             canonical_block_hash_from_number_provider}};
     }
 };
 
diff --git a/silkworm/db/kv/grpc/client/remote_transaction.cpp b/silkworm/db/kv/grpc/client/remote_transaction.cpp
index f22d6bab7a..83bb816301 100644
--- a/silkworm/db/kv/grpc/client/remote_transaction.cpp
+++ b/silkworm/db/kv/grpc/client/remote_transaction.cpp
@@ -33,15 +33,9 @@ RemoteTransaction::RemoteTransaction(
     Stub& stub,
     agrpc::GrpcContext& grpc_context,
     api::StateCache* state_cache,
-    chain::BlockProvider block_provider,
-    chain::BlockNumberFromTxnHashProvider block_number_from_txn_hash_provider,
-    chain::BlockNumberFromBlockHashProvider block_number_from_block_hash_provider,
-    chain::BlockHashFromBlockNumberProvider block_hash_from_number_provider)
+    chain::Providers providers)
     : BaseTransaction(state_cache),
-      block_provider_{std::move(block_provider)},
-      block_number_from_txn_hash_provider_{std::move(block_number_from_txn_hash_provider)},
-      block_number_from_block_hash_provider_{std::move(block_number_from_block_hash_provider)},
-      block_hash_from_number_provider_{std::move(block_hash_from_number_provider)},
+      providers_{std::move(providers)},
       stub_{stub},
       grpc_context_{grpc_context},
       tx_rpc_{grpc_context_} {}
@@ -118,7 +112,7 @@ std::shared_ptr<silkworm::State> RemoteTransaction::create_state(boost::asio::an
 }
 
 std::shared_ptr<chain::ChainStorage> RemoteTransaction::create_storage() {
-    return std::make_shared<chain::RemoteChainStorage>(*this, block_provider_, block_number_from_txn_hash_provider_, block_number_from_block_hash_provider_, block_hash_from_number_provider_);
+    return std::make_shared<chain::RemoteChainStorage>(*this, providers_);
 }
 
 Task<api::DomainPointResult> RemoteTransaction::domain_get(api::DomainPointQuery&& query) {  // NOLINT(*-rvalue-reference-param-not-moved)
diff --git a/silkworm/db/kv/grpc/client/remote_transaction.hpp b/silkworm/db/kv/grpc/client/remote_transaction.hpp
index db5c2b89bc..2ae6c2e3b9 100644
--- a/silkworm/db/kv/grpc/client/remote_transaction.hpp
+++ b/silkworm/db/kv/grpc/client/remote_transaction.hpp
@@ -42,10 +42,7 @@ class RemoteTransaction : public api::BaseTransaction {
     RemoteTransaction(::remote::KV::StubInterface& stub,
                       agrpc::GrpcContext& grpc_context,
                       api::StateCache* state_cache,
-                      chain::BlockProvider block_provider,
-                      chain::BlockNumberFromTxnHashProvider block_number_from_txn_hash_provider,
-                      chain::BlockNumberFromBlockHashProvider block_number_from_block_hash_provider,
-                      chain::BlockHashFromBlockNumberProvider block_hash_from_number_provider);
+                      chain::Providers providers);
     ~RemoteTransaction() override = default;
 
     uint64_t tx_id() const override { return tx_id_; }
@@ -81,10 +78,7 @@ class RemoteTransaction : public api::BaseTransaction {
   private:
     Task<std::shared_ptr<api::CursorDupSort>> get_cursor(const std::string& table, bool is_cursor_dup_sort);
 
-    chain::BlockProvider block_provider_;
-    chain::BlockNumberFromTxnHashProvider block_number_from_txn_hash_provider_;
-    chain::BlockNumberFromBlockHashProvider block_number_from_block_hash_provider_;
-    chain::BlockHashFromBlockNumberProvider block_hash_from_number_provider_;
+    chain::Providers providers_;
     std::map<std::string, std::shared_ptr<api::CursorDupSort>> cursors_;
     std::map<std::string, std::shared_ptr<api::CursorDupSort>> dup_cursors_;
     ::remote::KV::StubInterface& stub_;
diff --git a/silkworm/db/kv/grpc/client/remote_transaction_test.cpp b/silkworm/db/kv/grpc/client/remote_transaction_test.cpp
index 5ec6f93c13..755a2f03a6 100644
--- a/silkworm/db/kv/grpc/client/remote_transaction_test.cpp
+++ b/silkworm/db/kv/grpc/client/remote_transaction_test.cpp
@@ -39,10 +39,7 @@ class RemoteTransactionTest : public db::test_util::KVTestBase {
     RemoteTransaction remote_tx_{*stub_,
                                  grpc_context_,
                                  &state_cache_,
-                                 {},
-                                 {},
-                                 {},
-                                 {}};
+                                 chain::Providers{}};
 
   private:
     api::CoherentStateCache state_cache_;
diff --git a/silkworm/db/kv/state_changes_stream_test.cpp b/silkworm/db/kv/state_changes_stream_test.cpp
index fdf73bc85a..7c6d3fd877 100644
--- a/silkworm/db/kv/state_changes_stream_test.cpp
+++ b/silkworm/db/kv/state_changes_stream_test.cpp
@@ -87,7 +87,7 @@ struct RemoteStateChangesStreamTest : public StateChangesStreamTest {
         [](HashAsSpan) -> Task<BlockNum> { co_return 0; }};
     chain::BlockNumberFromBlockHashProvider block_number_from_block_hash_provider{
         [](HashAsSpan) -> Task<BlockNum> { co_return 0; }};
-    chain::BlockHashFromBlockNumberProvider block_hash_from_block_number_provider{
+    chain::CanonicalBlockHashFromNumberProvider canonical_block_hash_from_number_provider{
         [](BlockNum) -> Task<evmc::bytes32> { co_return 0; }};
 
     RemoteClient make_remote_client(auto&& channel_or_stub) {
@@ -95,10 +95,10 @@ struct RemoteStateChangesStreamTest : public StateChangesStreamTest {
             std::forward<decltype(channel_or_stub)>(channel_or_stub),
             grpc_context_,
             state_cache.get(),
-            block_provider,
-            block_number_from_txn_hash_provider,
-            block_number_from_block_hash_provider,
-            block_hash_from_block_number_provider};
+            {block_provider,
+             block_number_from_txn_hash_provider,
+             block_number_from_block_hash_provider,
+             canonical_block_hash_from_number_provider}};
     }
 };
 
diff --git a/silkworm/rpc/core/estimate_gas_oracle_test.cpp b/silkworm/rpc/core/estimate_gas_oracle_test.cpp
index a9e92c3032..dbe135e223 100644
--- a/silkworm/rpc/core/estimate_gas_oracle_test.cpp
+++ b/silkworm/rpc/core/estimate_gas_oracle_test.cpp
@@ -34,7 +34,6 @@
 #include <silkworm/db/test_util/kv_test_base.hpp>
 #include <silkworm/infra/test_util/log.hpp>
 #include <silkworm/rpc/ethdb/kv/backend_providers.hpp>
-#include <silkworm/rpc/ethdb/kv/remote_database.hpp>
 #include <silkworm/rpc/test_util/mock_back_end.hpp>
 #include <silkworm/rpc/test_util/mock_estimate_gas_oracle.hpp>
 #include <silkworm/rpc/types/block.hpp>
@@ -97,20 +96,12 @@ TEST_CASE("estimate gas") {
     const silkworm::ChainConfig& config{kMainnetConfig};
     RemoteDatabaseTest remote_db_test;
     test::BackEndMock backend;
+    db::chain::Providers providers = ethdb::kv::make_backend_providers(&backend);
     auto tx = std::make_unique<db::kv::grpc::client::RemoteTransaction>(remote_db_test.stub(),
                                                                         remote_db_test.grpc_context(),
                                                                         &remote_db_test.state_cache,
-                                                                        ethdb::kv::block_provider(&backend),
-                                                                        ethdb::kv::block_number_from_txn_hash_provider(&backend),
-                                                                        ethdb::kv::block_number_from_block_hash_provider(&backend),
-                                                                        ethdb::kv::block_hash_from_block_number_provider(&backend));
-    const db::chain::RemoteChainStorage storage{
-        *tx,
-        ethdb::kv::block_provider(&backend),
-        ethdb::kv::block_number_from_txn_hash_provider(&backend),
-        ethdb::kv::block_number_from_block_hash_provider(&backend),
-        ethdb::kv::block_hash_from_block_number_provider(&backend),
-    };
+                                                                        providers);
+    const db::chain::RemoteChainStorage storage{*tx, std::move(providers)};
     MockEstimateGasOracle estimate_gas_oracle{block_header_provider, account_reader, config, workers, *tx, storage};
 
     SECTION("Call empty, always fails but success in last step") {
diff --git a/silkworm/rpc/core/evm_debug_test.cpp b/silkworm/rpc/core/evm_debug_test.cpp
index 1c9f3e9fa9..14c22f3ab9 100644
--- a/silkworm/rpc/core/evm_debug_test.cpp
+++ b/silkworm/rpc/core/evm_debug_test.cpp
@@ -57,7 +57,7 @@ struct DebugExecutorTest : public test_util::ServiceContextTestBase {
     boost::asio::any_io_executor io_executor{io_context_.get_executor()};
     json::Stream stream{io_executor, writer};
     test::BackEndMock backend;
-    RemoteChainStorage chain_storage{transaction, ethdb::kv::block_provider(&backend), ethdb::kv::block_number_from_txn_hash_provider(&backend), ethdb::kv::block_number_from_block_hash_provider(&backend), ethdb::kv::block_hash_from_block_number_provider(&backend)};
+    RemoteChainStorage chain_storage{transaction, ethdb::kv::make_backend_providers(&backend)};
 };
 
 class TestDebugExecutor : DebugExecutor {
diff --git a/silkworm/rpc/core/evm_executor_test.cpp b/silkworm/rpc/core/evm_executor_test.cpp
index 6d37d14172..a026773684 100644
--- a/silkworm/rpc/core/evm_executor_test.cpp
+++ b/silkworm/rpc/core/evm_executor_test.cpp
@@ -56,11 +56,7 @@ struct EVMExecutorTest : public test_util::ServiceContextTestBase {
     ClientContextPool pool{1};
     boost::asio::any_io_executor io_executor{pool.next_io_context().get_executor()};
     test::BackEndMock backend;
-    RemoteChainStorage storage{transaction,
-                               ethdb::kv::block_provider(&backend),
-                               ethdb::kv::block_number_from_txn_hash_provider(&backend),
-                               ethdb::kv::block_number_from_block_hash_provider(&backend),
-                               ethdb::kv::block_hash_from_block_number_provider(&backend)};
+    RemoteChainStorage storage{transaction, ethdb::kv::make_backend_providers(&backend)};
     const uint64_t chain_id{11155111};
     const ChainConfig* chain_config_ptr{lookup_chain_config(chain_id)};
     BlockNum block_number{6'000'000};
diff --git a/silkworm/rpc/core/evm_trace_test.cpp b/silkworm/rpc/core/evm_trace_test.cpp
index 7d47358393..d0935f0e60 100644
--- a/silkworm/rpc/core/evm_trace_test.cpp
+++ b/silkworm/rpc/core/evm_trace_test.cpp
@@ -60,7 +60,7 @@ struct TraceCallExecutorTest : public test_util::ServiceContextTestBase {
     StringWriter writer{4096};
     boost::asio::any_io_executor io_executor{io_context_.get_executor()};
     std::unique_ptr<ethbackend::BackEnd> backend = std::make_unique<test::BackEndMock>();
-    RemoteChainStorage chain_storage{transaction, ethdb::kv::block_provider(backend.get()), ethdb::kv::block_number_from_txn_hash_provider(backend.get()), ethdb::kv::block_number_from_block_hash_provider(backend.get()), ethdb::kv::block_hash_from_block_number_provider(backend.get())};
+    RemoteChainStorage chain_storage{transaction, ethdb::kv::make_backend_providers(backend.get())};
 };
 
 #ifndef SILKWORM_SANITIZE
diff --git a/silkworm/rpc/core/receipts_test.cpp b/silkworm/rpc/core/receipts_test.cpp
index a7a83f1f5a..cf0d1a5121 100644
--- a/silkworm/rpc/core/receipts_test.cpp
+++ b/silkworm/rpc/core/receipts_test.cpp
@@ -227,7 +227,7 @@ TEST_CASE("get_receipts") {
     WorkerPool pool{1};
     db::test_util::MockTransaction transaction;
     std::unique_ptr<ethbackend::BackEnd> backend = std::make_unique<test::BackEndMock>();
-    silkworm::db::chain::RemoteChainStorage chain_storage{transaction, ethdb::kv::block_provider(backend.get()), ethdb::kv::block_number_from_txn_hash_provider(backend.get()), ethdb::kv::block_number_from_block_hash_provider(backend.get()), ethdb::kv::block_hash_from_block_number_provider(backend.get())};
+    silkworm::db::chain::RemoteChainStorage chain_storage{transaction, ethdb::kv::make_backend_providers(backend.get())};
 
     SECTION("null receipts without data") {
         const silkworm::BlockWithHash block_with_hash{};
diff --git a/silkworm/rpc/daemon.cpp b/silkworm/rpc/daemon.cpp
index 11e0200e7f..102e3cb1e6 100644
--- a/silkworm/rpc/daemon.cpp
+++ b/silkworm/rpc/daemon.cpp
@@ -81,10 +81,10 @@ static std::string get_library_versions() {
     return library_versions;
 }
 
-using ethdb::kv::block_hash_from_block_number_provider;
 using ethdb::kv::block_number_from_block_hash_provider;
 using ethdb::kv::block_number_from_txn_hash_provider;
 using ethdb::kv::block_provider;
+using ethdb::kv::canonical_block_hash_from_number_provider;
 
 int Daemon::run(const DaemonSettings& settings) {
     const bool are_settings_valid{validate_settings(settings)};
@@ -319,7 +319,7 @@ std::unique_ptr<db::kv::api::Client> Daemon::make_kv_client(rpc::ClientContext&
     auto* backend{must_use_private_service<rpc::ethbackend::BackEnd>(io_context)};
     if (settings_.standalone) {
         return std::make_unique<db::kv::grpc::client::RemoteClient>(
-            create_channel_, grpc_context, state_cache, block_provider(backend), block_number_from_txn_hash_provider(backend), block_number_from_block_hash_provider(backend), block_hash_from_block_number_provider(backend));
+            create_channel_, grpc_context, state_cache, ethdb::kv::make_backend_providers(backend));
     }
     // TODO(canepat) finish implementation and clean-up composition of objects here
     db::kv::api::StateChangeRunner runner{io_context.get_executor()};
diff --git a/silkworm/rpc/ethdb/kv/backend_providers.hpp b/silkworm/rpc/ethdb/kv/backend_providers.hpp
index 4a49407943..38a031c782 100644
--- a/silkworm/rpc/ethdb/kv/backend_providers.hpp
+++ b/silkworm/rpc/ethdb/kv/backend_providers.hpp
@@ -39,10 +39,18 @@ inline db::chain::BlockNumberFromBlockHashProvider block_number_from_block_hash_
     };
 }
 
-inline db::chain::BlockHashFromBlockNumberProvider block_hash_from_block_number_provider(ethbackend::BackEnd* backend) {
+inline db::chain::CanonicalBlockHashFromNumberProvider canonical_block_hash_from_number_provider(ethbackend::BackEnd* backend) {
     return [backend](BlockNum number) -> Task<evmc::bytes32> {
         co_return co_await backend->get_block_hash_from_block_number(number);
     };
 }
 
+inline db::chain::Providers make_backend_providers(ethbackend::BackEnd* backend) {
+    return {
+        ethdb::kv::block_provider(backend),
+        ethdb::kv::block_number_from_txn_hash_provider(backend),
+        ethdb::kv::block_number_from_block_hash_provider(backend),
+        ethdb::kv::canonical_block_hash_from_number_provider(backend)};
+}
+
 }  // namespace silkworm::rpc::ethdb::kv
diff --git a/silkworm/rpc/ethdb/kv/remote_database.cpp b/silkworm/rpc/ethdb/kv/remote_database.cpp
index 253016681e..f7eec9fdd3 100644
--- a/silkworm/rpc/ethdb/kv/remote_database.cpp
+++ b/silkworm/rpc/ethdb/kv/remote_database.cpp
@@ -51,10 +51,7 @@ Task<std::unique_ptr<db::kv::api::Transaction>> RemoteDatabase::begin() {
     auto txn = std::make_unique<RemoteTransaction>(*stub_,
                                                    grpc_context_,
                                                    state_cache_,
-                                                   block_provider(backend_),
-                                                   block_number_from_txn_hash_provider(backend_),
-                                                   block_number_from_block_hash_provider(backend_),
-                                                   block_hash_from_block_number_provider(backend_));
+                                                   ethdb::kv::make_backend_providers(backend_));
     co_await txn->open();
     SILK_TRACE << "RemoteDatabase::begin " << this << " txn: " << txn.get() << " end";
     co_return txn;
diff --git a/silkworm/rpc/test_util/dummy_transaction.hpp b/silkworm/rpc/test_util/dummy_transaction.hpp
index 32d30edd35..859fc0c533 100644
--- a/silkworm/rpc/test_util/dummy_transaction.hpp
+++ b/silkworm/rpc/test_util/dummy_transaction.hpp
@@ -75,7 +75,7 @@ class DummyTransaction : public db::kv::api::BaseTransaction {
     }
 
     std::shared_ptr<db::chain::ChainStorage> create_storage() override {
-        return std::make_shared<db::chain::RemoteChainStorage>(*this, ethdb::kv::block_provider(&backend_), ethdb::kv::block_number_from_txn_hash_provider(&backend_), ethdb::kv::block_number_from_block_hash_provider(&backend_), ethdb::kv::block_hash_from_block_number_provider(&backend_));
+        return std::make_shared<db::chain::RemoteChainStorage>(*this, ethdb::kv::make_backend_providers(&backend_));
     }
 
     Task<void> close() override { co_return; }