rpc: eth_feeHistory optimisation (#19526)

This PR introduces two major optimizations inspired by the Geth/Netmind
client architectures to decrease latency:

* Parallel Block Processing: Switched from sequential to concurrent
block fetching using 4 workers, matching Geth's maxBlockFetchers
architecture.

* FeeHistory Cache: Added a 2048-entry LRU cache for eth_feeHistory
results. This avoids repetitive fee/percentile computations by caching
the final processedFees struct instead of raw block data.

<details>
<summary><b>📊 Click to view detailed Benchmark results</b></summary>

| Scenario | Before | After | Speedup |
| :--- | :--- | :--- | :--- |
| **full/200** (sequential cold) | 451 ms | 93 ms | **4.9×** |
| **full/1024** (sequential cold) | 2,230 ms | 118 ms | **18.9×** |
| **full/1024** (sequential warm) | 2,346 ms | 95 ms | **24.7×** |
| **full/1024** (concurrent warm) | 1 req/s | 40 req/s | **40.0×** |

</details>

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: lupin012

rpc/gasprice/feehistory.go

@@ -21,15 +21,20 @@ package gasprice
 
 import (
 	"context"
+	"encoding/binary"
 	"errors"
 	"fmt"
+	"math"
 	"math/big"
 	"sort"
 	"sync/atomic"
 
 	"github.com/holiman/uint256"
+	"golang.org/x/sync/errgroup"
 
 	"github.com/erigontech/erigon/common"
+	commonlru "github.com/erigontech/erigon/common/lru"
+	"github.com/erigontech/erigon/execution/chain"
 	"github.com/erigontech/erigon/execution/protocol/misc"
 	"github.com/erigontech/erigon/execution/types"
 	"github.com/erigontech/erigon/rpc"
@@ -46,8 +51,59 @@ const (
 	maxFeeHistory = 1024
 	// maxQueryLimit is the max number of requested percentiles.
 	maxQueryLimit = 100
+	// feeHistoryCacheSize is the number of processed block results to keep in LRU cache.
+	feeHistoryCacheSize = 2048
+	// maxBlockFetchers is the number of goroutines used in the parallel block fetch loop.
+	maxBlockFetchers = 4
 )
 
+// cacheKey identifies a processed block in the fee history cache.
+// The percentiles string is a binary encoding of the requested percentile slice,
+// so identical percentile arrays produce the same key.
+type cacheKey struct {
+	number      uint64
+	percentiles string
+}
+
+// processedFees holds the computed fee data for a single block.
+// This is what gets stored in the LRU cache.
+type processedFees struct {
+	reward                       []*big.Int
+	baseFee, nextBaseFee         *uint256.Int
+	blobBaseFee, nextBlobBaseFee *uint256.Int
+	gasUsedRatio                 float64
+	blobGasUsedRatio             float64
+}
+
+// FeeHistoryCache is an opaque LRU cache for fee history block data.
+// It is safe for concurrent use.
+type FeeHistoryCache struct {
+	c *commonlru.Cache[cacheKey, processedFees]
+}
+
+// NewFeeHistoryCache creates a new fee history cache.
+func NewFeeHistoryCache() *FeeHistoryCache {
+	return &FeeHistoryCache{c: commonlru.NewCache[cacheKey, processedFees](feeHistoryCacheSize)}
+}
+
+func (fc *FeeHistoryCache) get(k cacheKey) (processedFees, bool) {
+	return fc.c.Get(k)
+}
+
+func (fc *FeeHistoryCache) add(k cacheKey, v processedFees) {
+	fc.c.Add(k, v)
+}
+
+// encodePercentiles serializes a slice of float64 percentile values into a
+// binary string suitable for use as a cache key component.
+func encodePercentiles(percentiles []float64) string {
+	b := make([]byte, 8*len(percentiles))
+	for i, p := range percentiles {
+		binary.LittleEndian.PutUint64(b[i*8:], math.Float64bits(p))
+	}
+	return string(b)
+}
+
 // blockFees represents a single block for processing
 type blockFees struct {
 	// set by the caller
@@ -56,12 +112,8 @@ type blockFees struct {
 	block       *types.Block // only set if reward percentiles are requested
 	receipts    types.Receipts
 	// filled by processBlock
-	reward                       []*big.Int
-	baseFee, nextBaseFee         *uint256.Int
-	blobBaseFee, nextBlobBaseFee *uint256.Int
-	gasUsedRatio                 float64
-	blobGasUsedRatio             float64
-	err                          error
+	results processedFees
+	err     error
 }
 
 // txGasAndReward is sorted in ascending order based on reward
@@ -84,15 +136,14 @@ func (s sortGasAndReward) Less(i, j int) bool {
 // processBlock takes a blockFees structure with the blockNumber, the header and optionally
 // the block field filled in, retrieves the block from the backend if not present yet and
 // fills in the rest of the fields.
-func (oracle *Oracle) processBlock(bf *blockFees, percentiles []float64) {
-	chainconfig := oracle.backend.ChainConfig()
-	if bf.baseFee = bf.header.BaseFee; bf.baseFee == nil {
-		bf.baseFee = new(uint256.Int)
+func (oracle *Oracle) processBlock(bf *blockFees, percentiles []float64, chainconfig *chain.Config) {
+	if bf.results.baseFee = bf.header.BaseFee; bf.results.baseFee == nil {
+		bf.results.baseFee = new(uint256.Int)
 	}
 	if chainconfig.IsLondon(bf.blockNumber + 1) {
-		bf.nextBaseFee = misc.CalcBaseFee(chainconfig, bf.header)
+		bf.results.nextBaseFee = misc.CalcBaseFee(chainconfig, bf.header)
 	} else {
-		bf.nextBaseFee = new(uint256.Int)
+		bf.results.nextBaseFee = new(uint256.Int)
 	}
 
 	// Fill in blob base fee and next blob base fee.
@@ -108,17 +159,17 @@ func (oracle *Oracle) processBlock(bf *blockFees, percentiles []float64) {
 			bf.err = err
 			return
 		}
-		bf.blobBaseFee = &blobBaseFee256
-		bf.nextBlobBaseFee = &nextBlobBaseFee256
+		bf.results.blobBaseFee = &blobBaseFee256
+		bf.results.nextBlobBaseFee = &nextBlobBaseFee256
 
 	} else {
-		bf.blobBaseFee = new(uint256.Int)
-		bf.nextBlobBaseFee = new(uint256.Int)
+		bf.results.blobBaseFee = new(uint256.Int)
+		bf.results.nextBlobBaseFee = new(uint256.Int)
 	}
-	bf.gasUsedRatio = float64(bf.header.GasUsed) / float64(bf.header.GasLimit)
+	bf.results.gasUsedRatio = float64(bf.header.GasUsed) / float64(bf.header.GasLimit)
 
 	if blobGasUsed := bf.header.BlobGasUsed; blobGasUsed != nil && chainconfig.GetMaxBlobGasPerBlock(bf.header.Time) != 0 {
-		bf.blobGasUsedRatio = float64(*blobGasUsed) / float64(chainconfig.GetMaxBlobGasPerBlock(bf.header.Time))
+		bf.results.blobGasUsedRatio = float64(*blobGasUsed) / float64(chainconfig.GetMaxBlobGasPerBlock(bf.header.Time))
 	}
 
 	if len(percentiles) == 0 {
@@ -131,11 +182,11 @@ func (oracle *Oracle) processBlock(bf *blockFees, percentiles []float64) {
 		return
 	}
 
-	bf.reward = make([]*big.Int, len(percentiles))
+	bf.results.reward = make([]*big.Int, len(percentiles))
 	if len(bf.block.Transactions()) == 0 {
 		// return an all zero row if there are no transactions to gather data from
-		for i := range bf.reward {
-			bf.reward[i] = new(big.Int)
+		for i := range bf.results.reward {
+			bf.results.reward[i] = new(big.Int)
 		}
 		return
 	}
@@ -160,7 +211,7 @@ func (oracle *Oracle) processBlock(bf *blockFees, percentiles []float64) {
 			txIndex++
 			sumGasUsed += sorter[txIndex].gasUsed
 		}
-		bf.reward[i] = sorter[txIndex].reward
+		bf.results.reward[i] = sorter[txIndex].reward
 	}
 }
 
@@ -273,61 +324,126 @@ func (oracle *Oracle) FeeHistory(ctx context.Context, blocks int, unresolvedLast
 	}
 	oldestBlock := lastBlock + 1 - uint64(blocks)
 
+	// percentileKey is the binary-encoded percentile slice used as part of the cache key.
+	percentileKey := encodePercentiles(rewardPercentiles)
+
+	// blockResult holds the computed data for a single block slot.
+	type blockResult struct {
+		processed processedFees
+		hasResult bool
+		missing   bool
+	}
+
 	var (
-		next = oldestBlock
-	)
-	var (
-		reward           = make([][]*big.Int, blocks)
-		baseFee          = make([]*uint256.Int, blocks+1)
-		gasUsedRatio     = make([]float64, blocks)
-		blobGasUsedRatio = make([]float64, blocks)
-		blobBaseFee      = make([]*uint256.Int, blocks+1)
-		firstMissing     = blocks
+		next         = oldestBlock
+		blockResults = make([]blockResult, blocks)
+		reward       = make([][]*big.Int, blocks)
+		baseFee      = make([]*uint256.Int, blocks+1)
+		gasUsedRatio = make([]float64, blocks)
+		blobBaseFee  = make([]*uint256.Int, blocks+1)
 	)
-	for ; blocks > 0; blocks-- {
-		if err = common.Stopped(ctx.Done()); err != nil {
-			return common.Big0, nil, nil, nil, nil, nil, err
-		}
-		// Retrieve the next block number to fetch with this goroutine
-		blockNumber := atomic.AddUint64(&next, 1) - 1
-		if blockNumber > lastBlock {
-			continue
-		}
 
-		fees := &blockFees{blockNumber: blockNumber}
-		if pendingBlock != nil && blockNumber >= pendingBlock.NumberU64() {
-			fees.block, fees.receipts = pendingBlock, pendingReceipts
-		} else {
-			if len(rewardPercentiles) != 0 {
-				fees.block, fees.err = oracle.backend.BlockByNumber(ctx, rpc.BlockNumber(blockNumber))
-				if fees.block != nil && fees.err == nil {
-					fees.receipts, fees.err = oracle.backend.GetReceiptsGasUsed(ctx, fees.block)
+	// Pre-fetch chain config once using the main backend (safe: single goroutine).
+	chainconfig := oracle.backend.ChainConfig()
+
+	// Launch up to maxBlockFetchers goroutines. Each goroutine opens its own
+	// TemporalTx via Fork so MDBX transactions are never shared across goroutines.
+	// If Fork returns nil (not supported), we fall back to using the main backend
+	// sequentially (only one goroutine will do real work in that case because they
+	// all share the same backend, but correctness is preserved).
+	g, fetchCtx := errgroup.WithContext(ctx)
+	for range maxBlockFetchers {
+		g.Go(func() error {
+			localBackend, cleanup, forkErr := oracle.backend.Fork(fetchCtx)
+			if forkErr != nil {
+				return forkErr
+			}
+			if cleanup != nil {
+				defer cleanup()
+			}
+			if localBackend == nil {
+				localBackend = oracle.backend
+			}
+
+			for {
+				if fetchCtx.Err() != nil {
+					return nil
+				}
+				blockNumber := atomic.AddUint64(&next, 1) - 1
+				if blockNumber > lastBlock {
+					return nil
+				}
+				idx := int(blockNumber - oldestBlock)
+
+				// Try the LRU cache first (skip for pending blocks — they are ephemeral).
+				isPending := pendingBlock != nil && blockNumber >= pendingBlock.NumberU64()
+				if !isPending && oracle.historyCache != nil {
+					if cached, ok := oracle.historyCache.get(cacheKey{blockNumber, percentileKey}); ok {
+						blockResults[idx] = blockResult{processed: cached, hasResult: true}
+						continue
+					}
+				}
+
+				fees := &blockFees{blockNumber: blockNumber}
+				if isPending {
+					fees.block, fees.receipts = pendingBlock, pendingReceipts
+				} else if len(rewardPercentiles) != 0 {
+					fees.block, fees.err = localBackend.BlockByNumber(fetchCtx, rpc.BlockNumber(blockNumber))
+					if fees.block != nil && fees.err == nil {
+						fees.receipts, fees.err = localBackend.GetReceiptsGasUsed(fetchCtx, fees.block)
+					}
+				} else {
+					fees.header, fees.err = localBackend.HeaderByNumber(fetchCtx, rpc.BlockNumber(blockNumber))
+				}
+				if fees.block != nil {
+					fees.header = fees.block.Header()
+				}
+				if fees.err != nil {
+					return fees.err
+				}
+
+				if fees.header == nil {
+					// No block and no error: requesting into the future (possible reorg).
+					blockResults[idx].missing = true
+					continue
+				}
+
+				oracle.processBlock(fees, rewardPercentiles, chainconfig)
+				if fees.err != nil {
+					return fees.err
+				}
+
+				blockResults[idx] = blockResult{processed: fees.results, hasResult: true}
+				if !isPending && oracle.historyCache != nil {
+					oracle.historyCache.add(cacheKey{blockNumber, percentileKey}, fees.results)
 				}
-			} else {
-				fees.header, fees.err = oracle.backend.HeaderByNumber(ctx, rpc.BlockNumber(blockNumber))
 			}
-		}
-		if fees.block != nil {
-			fees.header = fees.block.Header()
-		}
-		if fees.header != nil {
-			oracle.processBlock(fees, rewardPercentiles)
-		}
+		})
+	}
+	if err = g.Wait(); err != nil {
+		return common.Big0, nil, nil, nil, nil, nil, err
+	}
 
-		if fees.err != nil {
-			return common.Big0, nil, nil, nil, nil, nil, fees.err
-		}
-		i := int(fees.blockNumber - oldestBlock)
-		if fees.header != nil {
-			reward[i], baseFee[i], baseFee[i+1], gasUsedRatio[i] = fees.reward, fees.baseFee, fees.nextBaseFee, fees.gasUsedRatio
-			blobGasUsedRatio[i], blobBaseFee[i], blobBaseFee[i+1] = fees.blobGasUsedRatio, fees.blobBaseFee, fees.nextBlobBaseFee
-		} else {
-			// getting no block and no error means we are requesting into the future (might happen because of a reorg)
+	// Post-processing is serial: all goroutines have finished, no races.
+	firstMissing := len(blockResults)
+	blobGasUsedRatio := make([]float64, len(blockResults))
+	for i, r := range blockResults {
+		if r.missing || !r.hasResult {
 			if i < firstMissing {
 				firstMissing = i
 			}
+			continue
 		}
+		p := &r.processed
+		reward[i] = p.reward
+		baseFee[i] = p.baseFee
+		baseFee[i+1] = p.nextBaseFee
+		gasUsedRatio[i] = p.gasUsedRatio
+		blobGasUsedRatio[i] = p.blobGasUsedRatio
+		blobBaseFee[i] = p.blobBaseFee
+		blobBaseFee[i+1] = p.nextBlobBaseFee
 	}
+
 	if firstMissing == 0 {
 		return common.Big0, nil, nil, nil, nil, nil, nil
 	}

rpc/gasprice/feehistory_test.go

@@ -86,7 +86,7 @@ func TestFeeHistory(t *testing.T) {
 			defer tx.Rollback()
 
 			cache := jsonrpc.NewGasPriceCache()
-			oracle := gasprice.NewOracle(jsonrpc.NewGasPriceOracleBackend(tx, baseApi), config, cache, log.New())
+			oracle := gasprice.NewOracle(jsonrpc.NewGasPriceOracleBackend(m.DB, tx, baseApi), config, cache, gasprice.NewFeeHistoryCache(), log.New())
 
 			first, reward, baseFee, ratio, blobBaseFee, blobBaseFeeRatio, err := oracle.FeeHistory(context.Background(), c.count, c.last, c.percent)
 

rpc/gasprice/gasprice.go

@@ -45,6 +45,12 @@ type OracleBackend interface {
 
 	GetReceiptsGasUsed(ctx context.Context, block *types.Block) (types.Receipts, error)
 	PendingBlockAndReceipts() (*types.Block, types.Receipts)
+
+	// Fork opens a new TemporalTx and returns a goroutine-local backend together
+	// with a cleanup function (call via defer cleanup()).
+	// If the backend does not support forking, it returns (nil, nil, nil) and
+	// the caller should fall back to using the main backend sequentially.
+	Fork(ctx context.Context) (OracleBackend, func(), error)
 }
 
 type Cache interface {
@@ -55,10 +61,11 @@ type Cache interface {
 // Oracle recommends gas prices based on the content of recent
 // blocks. Suitable for both light and full clients.
 type Oracle struct {
-	backend     OracleBackend
-	maxPrice    *uint256.Int
-	ignorePrice *uint256.Int
-	cache       Cache
+	backend      OracleBackend
+	maxPrice     *uint256.Int
+	ignorePrice  *uint256.Int
+	cache        Cache
+	historyCache *FeeHistoryCache
 
 	checkBlocks                       int
 	percentile                        int
@@ -69,7 +76,7 @@ type Oracle struct {
 
 // NewOracle returns a new gasprice oracle which can recommend suitable
 // gasprice for newly created transaction.
-func NewOracle(backend OracleBackend, params gaspricecfg.Config, cache Cache, log log.Logger) *Oracle {
+func NewOracle(backend OracleBackend, params gaspricecfg.Config, cache Cache, historyCache *FeeHistoryCache, log log.Logger) *Oracle {
 	blocks := params.Blocks
 	if blocks < 1 {
 		blocks = 1
@@ -104,6 +111,7 @@ func NewOracle(backend OracleBackend, params gaspricecfg.Config, cache Cache, lo
 		checkBlocks:      blocks,
 		percentile:       percent,
 		cache:            cache,
+		historyCache:     historyCache,
 		maxHeaderHistory: params.MaxHeaderHistory,
 		maxBlockHistory:  params.MaxBlockHistory,
 		log:              log,

rpc/gasprice/gasprice_test.go

@@ -94,7 +94,7 @@ func TestSuggestPrice(t *testing.T) {
 	defer tx.Rollback()
 
 	cache := jsonrpc.NewGasPriceCache()
-	oracle := gasprice.NewOracle(jsonrpc.NewGasPriceOracleBackend(tx, baseApi), config, cache, log.New())
+	oracle := gasprice.NewOracle(jsonrpc.NewGasPriceOracleBackend(nil, tx, baseApi), config, cache, nil, log.New())
 
 	// The gas price sampled is: 32G, 31G, 30G, 29G, 28G, 27G
 	got, err := oracle.SuggestTipCap(context.Background())