substitute read_block...(9 withread_header

Author: lupin012

silkworm/rpc/commands/debug_api.cpp

@@ -76,7 +76,7 @@ Task<void> DebugRpcApi::handle_debug_account_range(const nlohmann::json& request
     try {
         auto start = std::chrono::system_clock::now();
         core::AccountDumper dumper{*tx};
-        DumpAccounts dump_accounts = co_await dumper.dump_accounts(*block_cache_, block_num_or_hash, start_address, max_result, exclude_code, exclude_storage);
+        DumpAccounts dump_accounts = co_await dumper.dump_accounts(block_num_or_hash, start_address, max_result, exclude_code, exclude_storage);
         auto end = std::chrono::system_clock::now();
         std::chrono::duration<double> elapsed_seconds = end - start;
         SILK_DEBUG << "dump_accounts: elapsed " << elapsed_seconds.count() << " sec";
@@ -216,8 +216,8 @@ Task<void> DebugRpcApi::handle_debug_storage_range_at(const nlohmann::json& requ
     try {
         const auto chain_storage = tx->make_storage();
         const BlockReader reader{*chain_storage, *tx};
-        const auto block_with_hash = co_await reader.read_block_by_hash(*block_cache_, block_hash);
-        if (!block_with_hash) {
+        const auto header_optional = co_await chain_storage->read_header(block_hash);
+        if (!header_optional) {
             SILK_WARN << "debug_storage_range_at: block not found, hash: " << evmc::hex(block_hash);
             nlohmann::json result = {{"storage", nullptr}, {"nextKey", nullptr}};
             reply = make_json_content(request, result);
@@ -246,7 +246,7 @@ Task<void> DebugRpcApi::handle_debug_storage_range_at(const nlohmann::json& requ
             return count++ < max_result;
         };
 
-        const auto min_tx_num = co_await tx->first_txn_num_in_block(block_with_hash->block.header.number);
+        const auto min_tx_num = co_await tx->first_txn_num_in_block(header_optional->number);
         const auto from_tx_num = min_tx_num + tx_index + 1;  // for system txn in the beginning of block
 
         StorageWalker storage_walker{*tx};

silkworm/rpc/core/account_dumper.cpp

@@ -22,7 +22,6 @@
 namespace silkworm::rpc::core {
 
 Task<DumpAccounts> AccountDumper::dump_accounts(
-    BlockCache& cache,
     const BlockNumOrHash& block_num_or_hash,
     const evmc::address& start_address,
     int16_t max_result,
@@ -32,15 +31,15 @@ Task<DumpAccounts> AccountDumper::dump_accounts(
     const auto chain_storage = transaction_.make_storage();
 
     const BlockReader block_reader{*chain_storage, transaction_};
-    const auto block_with_hash = co_await block_reader.read_block_by_block_num_or_hash(cache, block_num_or_hash);
-    if (!block_with_hash) {
+    const auto header_optional = co_await block_reader.read_header_by_block_num_or_hash(block_num_or_hash);
+    if (!header_optional) {
         throw std::invalid_argument("dump_accounts: block not found");
     }
 
-    dump_accounts.root = block_with_hash->block.header.state_root;
+    dump_accounts.root = header_optional->state_root;
 
     auto key = db::code_domain_key(start_address);
-    const auto block_num = block_with_hash->block.header.number + 1;
+    const auto block_num = header_optional->number + 1;
     const auto start_txn_number = co_await transaction_.first_txn_num_in_block(block_num);
 
     db::kv::api::DomainRangeRequest query{

silkworm/rpc/core/account_dumper.hpp

@@ -24,7 +24,6 @@ class AccountDumper {
     AccountDumper& operator=(const AccountDumper&) = delete;
 
     Task<DumpAccounts> dump_accounts(
-        BlockCache& cache,
         const BlockNumOrHash& block_num_or_hash,
         const evmc::address& start_address,
         int16_t max_result,

silkworm/rpc/core/block_reader.cpp

@@ -93,6 +93,20 @@ Task<std::shared_ptr<BlockWithHash>> BlockReader::read_block_by_block_num_or_has
     throw std::runtime_error{"invalid block_num_or_hash value"};
 }
 
+Task<std::optional<BlockHeader>> BlockReader::read_header_by_block_num_or_hash(const BlockNumOrHash& block_num_or_hash) const {
+    if (block_num_or_hash.is_number()) {  // NOLINT(bugprone-branch-clone)
+        co_return co_await chain_storage_.read_canonical_header(block_num_or_hash.number());
+    }
+    if (block_num_or_hash.is_hash()) {
+        co_return co_await chain_storage_.read_header(block_num_or_hash.hash());
+    }
+    if (block_num_or_hash.is_tag()) {
+        auto [block_num, ignore] = co_await get_block_num(block_num_or_hash.tag(), /*latest_required=*/false);
+        co_return co_await chain_storage_.read_canonical_header(block_num);
+    }
+    throw std::runtime_error{"invalid block_num_or_hash value"};
+}
+
 Task<std::optional<TransactionWithBlock>> BlockReader::read_transaction_by_hash(BlockCache& cache, const evmc::bytes32& transaction_hash) const {
     const auto result = co_await chain_storage_.read_block_num_by_transaction_hash(transaction_hash);
     if (!result) {

silkworm/rpc/core/block_reader.hpp

@@ -76,6 +76,8 @@ class BlockReader {
 
     Task<std::optional<BlockHeader>> read_header(BlockNum block_num) { co_return co_await chain_storage_.read_canonical_header(block_num); }
 
+    Task<std::optional<BlockHeader>> read_header_by_block_num_or_hash(const BlockNumOrHash& block_num_or_hash) const;
+
   private:
     Task<BlockNum> get_forkchoice_block_num(std::string_view block_hash_tag) const;
     const db::chain::ChainStorage& chain_storage_;