rpcdaemon: fix eth_feeHistory (#2115)

Author: lupin012

silkworm/core/chain/config.cpp

@@ -181,9 +181,12 @@ std::optional<ChainConfig> ChainConfig::from_json(const nlohmann::json& json) no
     return config;
 }
 
-[[nodiscard]] bool ChainConfig::withdrawals_activated(uint64_t block_time) const noexcept {
+[[nodiscard]] bool ChainConfig::withdrawals_activated(BlockTime block_time) const noexcept {
     return shanghai_time && block_time >= shanghai_time;
 }
+[[nodiscard]] bool ChainConfig::is_london(BlockNum block_number) const noexcept {
+    return (london_block && block_number >= london_block);
+}
 
 evmc_revision ChainConfig::revision(uint64_t block_number, uint64_t block_time) const noexcept {
     if (cancun_time && block_time >= cancun_time) return EVMC_CANCUN;

silkworm/core/chain/config.hpp

@@ -95,7 +95,8 @@ struct ChainConfig {
     protocol::PreMergeRuleSetConfig rule_set_config{protocol::NoPreMergeConfig{}};
 
     // The Shanghai hard fork has withdrawals, but Agra does not
-    [[nodiscard]] bool withdrawals_activated(uint64_t block_time) const noexcept;
+    [[nodiscard]] bool withdrawals_activated(BlockTime block_time) const noexcept;
+    [[nodiscard]] bool is_london(BlockNum block_number) const noexcept;
 
     //! \brief Returns the revision level at given block number
     //! \details In other words, on behalf of Json chain config data

silkworm/rpc/commands/eth_api.cpp

@@ -2086,6 +2086,9 @@ Task<void> EthereumRpcApi::handle_fee_history(const nlohmann::json& request, nlo
     try {
         const auto chain_storage{tx->create_storage()};
 
+        rpc::fee_history::BlockHeaderProvider block_header_provider = [&chain_storage](BlockNum block_number) {
+            return chain_storage->read_canonical_header(block_number);
+        };
         rpc::fee_history::BlockProvider block_provider = [this, &chain_storage](BlockNum block_number) {
             return core::read_block_by_number(*block_cache_, *chain_storage, block_number);
         };
@@ -2100,7 +2103,7 @@ Task<void> EthereumRpcApi::handle_fee_history(const nlohmann::json& request, nlo
         auto chain_config = co_await chain_storage->read_chain_config();
         ensure(chain_config.has_value(), "cannot read chain config");
 
-        rpc::fee_history::FeeHistoryOracle oracle{*chain_config, block_provider, receipts_provider, latest_block_provider};
+        rpc::fee_history::FeeHistoryOracle oracle{*chain_config, block_header_provider, block_provider, receipts_provider, latest_block_provider};
 
         const auto block_number = co_await core::get_block_number(newest_block, *tx);
         const auto fee_history = co_await oracle.fee_history(block_number, block_count, reward_percentiles);

silkworm/rpc/core/fee_history_oracle.cpp

@@ -109,24 +109,34 @@ Task<FeeHistory> FeeHistoryOracle::fee_history(BlockNum newest_block,
         }
 
         BlockFees block_fees{block_number};
-        if (block_number >= block_range.last_block->block.header.number) {
-            block_fees.block = block_range.last_block;
-            block_fees.receipts = co_await receipts_provider_(*block_fees.block);
+
+        if (!reward_percentiles.empty()) {
+            if (block_number >= block_range.last_block->block.header.number) {
+                block_fees.block = block_range.last_block;
+                block_fees.receipts = co_await receipts_provider_(*block_fees.block);
+            } else {
+                const auto block_with_hash = co_await block_provider_(block_number);
+                if (!block_with_hash) {
+                    continue;
+                }
+                block_fees.block = block_with_hash;
+                if (!reward_percentiles.empty()) {
+                    block_fees.receipts = co_await receipts_provider_(*block_fees.block);
+                }
+            }
+            block_fees.block_header = block_fees.block->block.header;
         } else {
-            const auto block_with_hash = co_await block_provider_(block_number);
-            if (!block_with_hash) {
+            const auto block_header = co_await block_header_provider_(block_number);
+            if (!block_header) {
                 continue;
             }
-            block_fees.block = block_with_hash;
-            if (!reward_percentiles.empty()) {
-                block_fees.receipts = co_await receipts_provider_(*block_fees.block);
-            }
+            block_fees.block_header = block_header;
         }
         co_await process_block(block_fees, reward_percentiles);
 
         ensure(block_fees.block_number >= oldest_block_number, "fee_history: block_number lower than oldest");
         const auto index = block_fees.block_number - oldest_block_number;
-        if (block_fees.block) {
+        if (block_fees.block_header) {
             fee_history.rewards[index] = block_fees.rewards;
             fee_history.base_fees_per_gas[index] = block_fees.base_fee;
             fee_history.base_fees_per_gas[index + 1] = block_fees.next_base_fee;
@@ -188,23 +198,20 @@ bool sort_by_reward(std::pair<intx::uint256, uint64_t>& p1, const std::pair<intx
 }
 
 Task<void> FeeHistoryOracle::process_block(BlockFees& block_fees, const std::vector<int8_t>& reward_percentiles) {
-    auto& header = block_fees.block->block.header;
+    auto& header = *(block_fees.block_header);
+    auto next_block_number = header.number + 1;
     block_fees.base_fee = header.base_fee_per_gas.value_or(0);
 
     block_fees.gas_used_ratio = static_cast<double>(header.gas_used) / static_cast<double>(header.gas_limit);
 
-    const auto parent_block = co_await block_provider_(header.number + 1);
-    if (!parent_block) {
-        co_return;
-    }
-    const auto evmc_revision = config_.revision(parent_block->block.header.number, parent_block->block.header.timestamp);
-    block_fees.next_base_fee = 0;
-    if (evmc_revision >= EVMC_LONDON) {
+    if (config_.is_london(next_block_number)) {
         block_fees.next_base_fee = protocol::expected_base_fee_per_gas(header);
+    } else {
+        block_fees.next_base_fee = 0;
     }
 
     if (reward_percentiles.empty()) {
-        co_return;
+        co_return;  // rewards were not requested, return
     }
     if (block_fees.receipts.size() != block_fees.block->block.transactions.size()) {
         co_return;

silkworm/rpc/core/fee_history_oracle.hpp

@@ -31,6 +31,7 @@
 
 namespace silkworm::rpc::fee_history {
 
+using BlockHeaderProvider = std::function<Task<std::optional<silkworm::BlockHeader>>(BlockNum)>;
 using BlockProvider = std::function<Task<std::shared_ptr<silkworm::BlockWithHash>>(BlockNum)>;
 using ReceiptsProvider = std::function<Task<rpc::Receipts>(const BlockWithHash&)>;
 using LatestBlockProvider = std::function<Task<uint64_t>()>;
@@ -56,7 +57,8 @@ struct BlockRange {
 
 struct BlockFees {
     BlockNum block_number{0};
-    std::shared_ptr<BlockWithHash> block;
+    std::optional<BlockHeader> block_header;
+    std::shared_ptr<BlockWithHash> block;  // only set if reward percentiles are requested
     rpc::Receipts receipts;
     Rewards rewards;
     intx::uint256 base_fee;
@@ -66,9 +68,9 @@ struct BlockFees {
 
 class FeeHistoryOracle {
   public:
-    explicit FeeHistoryOracle(const silkworm::ChainConfig& config, const BlockProvider& block_provider, ReceiptsProvider& receipts_provider,
+    explicit FeeHistoryOracle(const silkworm::ChainConfig& config, const BlockHeaderProvider& header_provider, const BlockProvider& block_provider, ReceiptsProvider& receipts_provider,
                               LatestBlockProvider& latest_block_provider)
-        : config_{config}, block_provider_(block_provider), receipts_provider_(receipts_provider), latest_block_provider_{latest_block_provider} {}
+        : config_{config}, block_header_provider_(header_provider), block_provider_(block_provider), receipts_provider_(receipts_provider), latest_block_provider_{latest_block_provider} {}
     virtual ~FeeHistoryOracle() = default;
 
     FeeHistoryOracle(const FeeHistoryOracle&) = delete;
@@ -85,6 +87,7 @@ class FeeHistoryOracle {
     Task<void> process_block(BlockFees& block_fees, const std::vector<int8_t>& reward_percentiles);
 
     const silkworm::ChainConfig& config_;
+    const BlockHeaderProvider& block_header_provider_;
     const BlockProvider& block_provider_;
     const ReceiptsProvider& receipts_provider_;
     const LatestBlockProvider& latest_block_provider_;