[3.4] rpc: add --rpc.logs.maxresults limit on log rpc-API (#19721) (cherry-pick) (#20784)

lupin012 · claude · web-flow · commit 268c57730825 · 2026-04-24T10:15:37.000Z
Provided configuration parameters on logs mgt that, when properly tuned
by the service provider, allow the system to avoid being OOM killed:
- --rpc.blockrange.limit (default changed: 0 → 1000): maximum block
range (end - begin) allowed for range queries. The flag already existed
but defaulted to 0 (unlimited), leaving APIs exposed to unbounded block
scans.
- --rpc.logs.maxresults (default: 20000): new flag — maximum number of
logs returned per call. Previously unbounded.

  APIs affected

  Both limits are enforced consistently across:
  - eth_getLogs
  - erigon_getLogs
  - erigon_getLatestLogs
  - overlay_getLogs
  - trace_filter (block range only)

  Behaviour
- Exceeding --rpc.blockrange.limit with an explicit fromBlock/toBlock
range returns an error (query block range exceeds server limit, narrow
your filter: N).
- Exceeding --rpc.logs.maxresults when a query returns too many results
returns an error (query returns too many logs, narrow your filter: N).
- In erigon_getLatestLogs, when the caller explicitly provides logCount
or blockCount that exceed the configured limits, a distinct error is
returned indicating the requested value and the maximum (requested
logCount/blockCount exceeds server limit: requested N, maximum M).
  - Setting either flag to 0 disables the respective limit (unlimited).
- In erigon_getLatestLogs, when the caller explicitly provides logCount
or blockCount, the block range check on fromBlock/toBlock is skipped —
the count-based limit takes precedence.
- The previous hardcoded constants GetLatestLogMaxLogCount (30000) and
GetLatestLogMaxBlockCount (1000) have been removed in favour of the
global config parameters.

---------

Co-authored-by: Claude Sonnet 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/cmd/rpcdaemon/cli/config.go b/cmd/rpcdaemon/cli/config.go
@@ -179,7 +179,8 @@ func RootCommand() (*cobra.Command, *httpcfg.HttpCfg) {
 	rootCmd.PersistentFlags().IntVar(&cfg.RpcFiltersConfig.RpcSubscriptionFiltersMaxTxs, "rpc.subscription.filters.maxtxs", rpchelper.DefaultFiltersConfig.RpcSubscriptionFiltersMaxTxs, "Maximum number of transactions to store per subscription.")
 	rootCmd.PersistentFlags().IntVar(&cfg.RpcFiltersConfig.RpcSubscriptionFiltersMaxAddresses, "rpc.subscription.filters.maxaddresses", rpchelper.DefaultFiltersConfig.RpcSubscriptionFiltersMaxAddresses, "Maximum number of addresses per subscription to filter logs by.")
 	rootCmd.PersistentFlags().IntVar(&cfg.RpcFiltersConfig.RpcSubscriptionFiltersMaxTopics, "rpc.subscription.filters.maxtopics", rpchelper.DefaultFiltersConfig.RpcSubscriptionFiltersMaxTopics, "Maximum number of topics per subscription to filter logs by.")
-	rootCmd.PersistentFlags().IntVar(&cfg.RangeLimit, utils.RpcBlockRangeLimit.Name, utils.RpcBlockRangeLimit.Value, utils.RpcBlockRangeLimit.Usage)
+	rootCmd.PersistentFlags().IntVar(&cfg.BlockRangeLimit, utils.RpcBlockRangeLimit.Name, utils.RpcBlockRangeLimit.Value, utils.RpcBlockRangeLimit.Usage)
+	rootCmd.PersistentFlags().IntVar(&cfg.GetLogsMaxResults, utils.RpcGetLogsMaxResults.Name, utils.RpcGetLogsMaxResults.Value, utils.RpcGetLogsMaxResults.Usage)
 	rootCmd.PersistentFlags().IntVar(&cfg.BatchLimit, utils.RpcBatchLimit.Name, utils.RpcBatchLimit.Value, utils.RpcBatchLimit.Usage)
 	rootCmd.PersistentFlags().IntVar(&cfg.ReturnDataLimit, utils.RpcReturnDataLimit.Name, utils.RpcReturnDataLimit.Value, utils.RpcReturnDataLimit.Usage)
 	rootCmd.PersistentFlags().BoolVar(&cfg.AllowUnprotectedTxs, utils.AllowUnprotectedTxs.Name, utils.AllowUnprotectedTxs.Value, utils.AllowUnprotectedTxs.Usage)
@@ -721,6 +722,8 @@ func startRegularRpcServer(ctx context.Context, cfg *httpcfg.HttpCfg, rpcAPI []r
 		"grpc", cfg.GRPCServerEnabled,
 		"http", cfg.HttpServerEnabled,
 		"ws", cfg.WebsocketEnabled,
+		"rpc.blockrange.limit", cfg.BlockRangeLimit,
+		"rpc.logs.maxresults", cfg.GetLogsMaxResults,
 	}
 
 	if cfg.SocketServerEnabled {
diff --git a/cmd/rpcdaemon/cli/httpcfg/http_cfg.go b/cmd/rpcdaemon/cli/httpcfg/http_cfg.go
@@ -59,7 +59,8 @@ type HttpCfg struct {
 
 	API                               []string
 	Gascap                            uint64
-	RangeLimit                        int
+	BlockRangeLimit                   int
+	GetLogsMaxResults                 int
 	Feecap                            float64
 	MaxTraces                         uint64
 	WebsocketPort                     int
diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go
@@ -407,7 +407,12 @@ var (
 	RpcBlockRangeLimit = cli.IntFlag{
 		Name:  "rpc.blockrange.limit",
 		Usage: "Maximum block range (end - begin) allowed for range queries (0 = unlimited)",
-		Value: 0,
+		Value: 1_000,
+	}
+	RpcGetLogsMaxResults = cli.IntFlag{
+		Name:  "rpc.logs.maxresults",
+		Usage: "Maximum number of logs returned by eth_getLogs, erigon_getLogs, erigon_getLatestLogs (0 = unlimited)",
+		Value: 20_000,
 	}
 	RpcTraceCompatFlag = cli.BoolFlag{
 		Name:  "trace.compat",
diff --git a/execution/engineapi/engine_server.go b/execution/engineapi/engine_server.go
@@ -140,7 +140,7 @@ func (e *EngineServer) Start(
 			return nil
 		})
 	}
-	base := jsonrpc.NewBaseApi(filters, stateCache, blockReader, httpConfig.WithDatadir, httpConfig.EvmCallTimeout, engineReader, httpConfig.Dirs, nil, httpConfig.RangeLimit)
+	base := jsonrpc.NewBaseApi(filters, stateCache, blockReader, httpConfig.WithDatadir, httpConfig.EvmCallTimeout, engineReader, httpConfig.Dirs, nil, httpConfig.BlockRangeLimit, httpConfig.GetLogsMaxResults)
 	ethImpl := jsonrpc.NewEthAPI(base, db, eth, e.txpool, mining, jsonrpc.NewEthApiConfig(httpConfig), e.logger)
 
 	apiList := []rpc.API{
diff --git a/execution/engineapi/engine_server_test.go b/execution/engineapi/engine_server_test.go
@@ -67,7 +67,7 @@ func oneBlockStep(mockSentry *execmoduletester.ExecModuleTester, require *requir
 
 func newBaseApiForTest(m *execmoduletester.ExecModuleTester) *jsonrpc.BaseAPI {
 	stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
-	return jsonrpc.NewBaseApi(nil, stateCache, m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0)
+	return jsonrpc.NewBaseApi(nil, stateCache, m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0, 0)
 }
 
 func newEthApiForTest(base *jsonrpc.BaseAPI, db kv.TemporalRoDB, txPool txpoolproto.TxpoolClient) *jsonrpc.APIImpl {
diff --git a/node/cli/flags.go b/node/cli/flags.go
@@ -457,7 +457,8 @@ func setEmbeddedRpcDaemon(ctx *cli.Context, cfg *nodecfg.Config, logger log.Logg
 			RpcSubscriptionFiltersMaxTopics:    ctx.Int(RpcSubscriptionFiltersMaxTopicsFlag.Name),
 		},
 		Gascap:              ctx.Uint64(utils.RpcGasCapFlag.Name),
-		RangeLimit:          ctx.Int(utils.RpcBlockRangeLimit.Name),
+		BlockRangeLimit:     ctx.Int(utils.RpcBlockRangeLimit.Name),
+		GetLogsMaxResults:   ctx.Int(utils.RpcGetLogsMaxResults.Name),
 		Feecap:              ctx.Float64(utils.RPCGlobalTxFeeCapFlag.Name),
 		MaxTraces:           ctx.Uint64(utils.TraceMaxtracesFlag.Name),
 		TraceCompatibility:  ctx.Bool(utils.RpcTraceCompatFlag.Name),
diff --git a/node/eth/backend.go b/node/eth/backend.go
@@ -831,7 +831,8 @@ func New(ctx context.Context, stack *node.Node, config *ethconfig.Config, logger
 		backend.engine,
 		httpRpcCfg.Dirs,
 		backend.polygonBridge,
-		httpRpcCfg.RangeLimit,
+		httpRpcCfg.BlockRangeLimit,
+		httpRpcCfg.GetLogsMaxResults,
 	)
 	ethApiConfig := &jsonrpc.EthApiConfig{
 		GasCap:                      httpRpcCfg.Gascap,
diff --git a/rpc/gasprice/feehistory_test.go b/rpc/gasprice/feehistory_test.go
@@ -80,7 +80,7 @@ func TestFeeHistory(t *testing.T) {
 			m := newTestBackend(t) //, big.NewInt(16), c.pending)
 			defer m.Close()
 
-			baseApi := jsonrpc.NewBaseApi(nil, kvcache.NewDummy(), m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0)
+			baseApi := jsonrpc.NewBaseApi(nil, kvcache.NewDummy(), m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0, 0)
 			tx, err := m.DB.BeginTemporalRo(m.Ctx)
 			require.NoError(t, err)
 			defer tx.Rollback()
diff --git a/rpc/gasprice/gasprice_test.go b/rpc/gasprice/gasprice_test.go
@@ -87,7 +87,7 @@ func TestSuggestPrice(t *testing.T) {
 	}
 
 	m := newTestBackend(t) //, big.NewInt(16), c.pending)
-	baseApi := jsonrpc.NewBaseApi(nil, kvcache.NewDummy(), m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0)
+	baseApi := jsonrpc.NewBaseApi(nil, kvcache.NewDummy(), m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0, 0)
 
 	tx, err := m.DB.BeginTemporalRo(m.Ctx)
 	require.NoError(t, err)
diff --git a/rpc/jsonrpc/daemon.go b/rpc/jsonrpc/daemon.go
@@ -49,7 +49,7 @@ func APIList(db kv.TemporalRoDB, eth rpchelper.ApiBackend, txPool txpoolproto.Tx
 	blockReader services.FullBlockReader, cfg *httpcfg.HttpCfg, engine rules.EngineReader,
 	logger log.Logger, bridgeReader bridgeReader, spanProducersReader spanProducersReader,
 ) (list []rpc.API) {
-	base := NewBaseApi(filters, stateCache, blockReader, cfg.WithDatadir, cfg.EvmCallTimeout, engine, cfg.Dirs, bridgeReader, cfg.RangeLimit)
+	base := NewBaseApi(filters, stateCache, blockReader, cfg.WithDatadir, cfg.EvmCallTimeout, engine, cfg.Dirs, bridgeReader, cfg.BlockRangeLimit, cfg.GetLogsMaxResults)
 	ethImpl := NewEthAPI(base, db, eth, txPool, mining, NewEthApiConfig(cfg), logger)
 	erigonImpl := NewErigonAPI(base, db, eth)
 	txpoolImpl := NewTxPoolAPI(base, db, txPool)
diff --git a/rpc/jsonrpc/debug_api_test.go b/rpc/jsonrpc/debug_api_test.go
@@ -77,7 +77,7 @@ func TestTraceBlockByNumber(t *testing.T) {
 	}
 	m, _, _ := rpcdaemontest.CreateTestExecModule(t)
 	stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
-	baseApi := NewBaseApi(nil, stateCache, m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0)
+	baseApi := NewBaseApi(nil, stateCache, m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0, 0)
 	ethApi := newEthApiForTest(baseApi, m.DB, nil, nil)
 	api := NewPrivateDebugAPI(baseApi, m.DB, 0, false)
 	for _, tt := range debugTraceTransactionTests {
diff --git a/rpc/jsonrpc/erigon_receipts.go b/rpc/jsonrpc/erigon_receipts.go
@@ -36,12 +36,6 @@ import (
 	"github.com/erigontech/erigon/rpc/rpchelper"
 )
 
-// erigon_GetLatestLog is the maximum number of log can be retrieved
-const GetLatestLogMaxLogCount = 30000
-
-// erigon_GetLatestLog is the maximum number of block can be retrieved
-const GetLatestLogMaxBlockCount = 1000
-
 // GetLogsByHash implements erigon_getLogsByHash. Returns an array of arrays of logs generated by the transactions in the block given by the block's hash.
 func (api *ErigonImpl) GetLogsByHash(ctx context.Context, hash common.Hash) ([][]*types.Log, error) {
 	receipts, ok := api.getCachedReceipts(ctx, hash)
@@ -141,7 +135,7 @@ func (api *ErigonImpl) GetLogs(ctx context.Context, crit filters.FilterCriteria)
 		return nil, err
 	}
 
-	return api.getLogsV3(ctx, tx, begin, end, crit, api.BaseAPI.rangeLimit)
+	return api.getLogsV3(ctx, tx, begin, end, crit, api.BaseAPI.blockRangeLimit, api.BaseAPI.getLogsMaxResults)
 }
 
 // GetLatestLogs implements erigon_getLatestLogs.
@@ -163,17 +157,17 @@ func (api *ErigonImpl) GetLatestLogs(ctx context.Context, crit filters.FilterCri
 		return nil, errors.New("logs count & block count are ambigious")
 	}
 	ignoreTopicOrder := logOptions.IgnoreTopicsOrder
-	if logOptions.LogCount == 0 && logOptions.BlockCount == 0 {
+	userProvidedCountLimit := logOptions.LogCount != 0 || logOptions.BlockCount != 0
+	if !userProvidedCountLimit {
 		logOptions = filters.DefaultLogFilterOptions()
 		logOptions.IgnoreTopicsOrder = ignoreTopicOrder
 	}
 
-	// Determine how many results we will dump
-	if logOptions.LogCount > GetLatestLogMaxLogCount {
-		logOptions.LogCount = GetLatestLogMaxLogCount
+	if api.getLogsMaxResults != 0 && logOptions.LogCount > uint64(api.getLogsMaxResults) {
+		return nil, &rpc.CustomError{Message: fmt.Sprintf("%s: requested %d, maximum %d", errRequestedLogCountExceedsLimit, logOptions.LogCount, api.getLogsMaxResults), Code: rpc.ErrCodeInvalidParams}
 	}
-	if logOptions.BlockCount > GetLatestLogMaxBlockCount {
-		logOptions.BlockCount = GetLatestLogMaxBlockCount
+	if api.blockRangeLimit != 0 && logOptions.BlockCount > uint64(api.blockRangeLimit) {
+		return nil, &rpc.CustomError{Message: fmt.Sprintf("%s: requested %d, maximum %d", errRequestedBlockCountExceedsLimit, logOptions.BlockCount, api.blockRangeLimit), Code: rpc.ErrCodeInvalidParams}
 	}
 
 	erigonLogs := types.ErigonLogs{}
@@ -224,8 +218,8 @@ func (api *ErigonImpl) GetLatestLogs(ctx context.Context, crit filters.FilterCri
 		return nil, &rpc.CustomError{Message: fmt.Sprintf("invalid block range: end (%d) < begin (%d)", end, begin), Code: rpc.ErrCodeInvalidParams}
 	}
 
-	if api.rangeLimit != 0 && (end-begin) > uint64(api.rangeLimit) {
-		return nil, &rpc.CustomError{Message: fmt.Sprintf("%s: %d", errExceedBlockRange, api.rangeLimit), Code: rpc.ErrCodeInvalidParams}
+	if !userProvidedCountLimit && api.blockRangeLimit != 0 && (end-begin) > uint64(api.blockRangeLimit) {
+		return nil, &rpc.CustomError{Message: fmt.Sprintf("%s: %d", errExceedBlockRange, api.blockRangeLimit), Code: rpc.ErrCodeInvalidParams}
 	}
 
 	err = api.BaseAPI.checkReceiptsAvailable(ctx, tx, begin)
@@ -350,6 +344,9 @@ func (api *ErigonImpl) GetLatestLogs(ctx context.Context, crit filters.FilterCri
 			return nil, fmt.Errorf("block not found %d", blockNum)
 		}
 		for _, log := range filtered {
+			if api.getLogsMaxResults != 0 && len(erigonLogs) >= api.getLogsMaxResults {
+				return nil, &rpc.CustomError{Message: fmt.Sprintf("%s: %d", errExceedLogResults, api.getLogsMaxResults), Code: rpc.ErrCodeInvalidParams}
+			}
 			erigonLog := &types.ErigonLog{}
 			erigonLog.BlockNumber = blockNum
 			erigonLog.BlockHash = blockHash
diff --git a/rpc/jsonrpc/erigon_receipts_test.go b/rpc/jsonrpc/erigon_receipts_test.go
@@ -223,6 +223,115 @@ func TestGetBlockReceiptsByBlockHash(t *testing.T) {
 	require.NoError(t, err)
 }
 
+// TestGetLogs_RangeLimitExceeded verifies that eth_getLogs returns an error when the
+// requested block range exceeds rangeLimit.
+func TestGetLogs_RangeLimitExceeded(t *testing.T) {
+	m, _, _ := rpcdaemontest.CreateTestExecModule(t)
+	ethApi := newEthApiForTest(newBaseApiWithLimits(m, 5, 0), m.DB, nil, nil)
+	_, err := ethApi.GetLogs(context.Background(), filters.FilterCriteria{
+		FromBlock: big.NewInt(0),
+		ToBlock:   big.NewInt(10),
+	})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), errExceedBlockRange)
+}
+
+// TestGetLogs_RangeLimitOk verifies that eth_getLogs succeeds when the requested block
+// range is within rangeLimit.
+func TestGetLogs_RangeLimitOk(t *testing.T) {
+	m, _, _ := rpcdaemontest.CreateTestExecModule(t)
+	ethApi := newEthApiForTest(newBaseApiWithLimits(m, 11, 0), m.DB, nil, nil)
+	logs, err := ethApi.GetLogs(context.Background(), filters.FilterCriteria{
+		FromBlock: big.NewInt(0),
+		ToBlock:   big.NewInt(10),
+	})
+	require.NoError(t, err)
+	assert.NotEmpty(t, logs)
+}
+
+// TestGetLogs_MaxResultsOk verifies that eth_getLogs succeeds when maxResults is
+// unlimited (0).
+func TestGetLogs_MaxResultsOk(t *testing.T) {
+	m, _, _ := rpcdaemontest.CreateTestExecModule(t)
+	ethApi := newEthApiForTest(newBaseApiWithLimits(m, 0, 0), m.DB, nil, nil)
+	logs, err := ethApi.GetLogs(context.Background(), filters.FilterCriteria{
+		FromBlock: big.NewInt(0),
+		ToBlock:   big.NewInt(10),
+	})
+	require.NoError(t, err)
+	assert.NotEmpty(t, logs)
+}
+
+// TestGetLatestLogs_LogCountExceedsMaxResults verifies that erigon_getLatestLogs
+// returns an error when the requested logCount exceeds getLogsMaxResults.
+func TestGetLatestLogs_LogCountExceedsMaxResults(t *testing.T) {
+	m, _, _ := rpcdaemontest.CreateTestExecModule(t)
+	api := NewErigonAPI(newBaseApiWithLimits(m, 0, 5), m.DB, nil)
+	_, err := api.GetLatestLogs(context.Background(), filters.FilterCriteria{}, filters.LogFilterOptions{
+		LogCount: 10,
+	})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), errRequestedLogCountExceedsLimit)
+}
+
+// TestGetLatestLogs_BlockCountExceedsRangeLimit verifies that erigon_getLatestLogs
+// returns an error when the requested blockCount exceeds rangeLimit.
+func TestGetLatestLogs_BlockCountExceedsRangeLimit(t *testing.T) {
+	m, _, _ := rpcdaemontest.CreateTestExecModule(t)
+	api := NewErigonAPI(newBaseApiWithLimits(m, 5, 0), m.DB, nil)
+	_, err := api.GetLatestLogs(context.Background(), filters.FilterCriteria{}, filters.LogFilterOptions{
+		BlockCount: 10,
+	})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), errRequestedBlockCountExceedsLimit)
+}
+
+// TestGetLatestLogs_ExplicitRangeExceedsLimit verifies that erigon_getLatestLogs
+// returns an error when an explicit fromBlock/toBlock range exceeds rangeLimit and
+// no logCount/blockCount is specified.
+func TestGetLatestLogs_ExplicitRangeExceedsLimit(t *testing.T) {
+	m, _, _ := rpcdaemontest.CreateTestExecModule(t)
+	api := NewErigonAPI(newBaseApiWithLimits(m, 5, 0), m.DB, nil)
+	_, err := api.GetLatestLogs(context.Background(), filters.FilterCriteria{
+		FromBlock: big.NewInt(0),
+		ToBlock:   big.NewInt(10),
+	}, filters.LogFilterOptions{})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), errExceedBlockRange)
+}
+
+// TestGetLatestLogs_ExplicitRangeWithLogCount_NoRangeCheck verifies that when
+// logCount is set, the explicit fromBlock/toBlock range check is skipped even if
+// the range exceeds rangeLimit.
+func TestGetLatestLogs_ExplicitRangeWithLogCount_NoRangeCheck(t *testing.T) {
+	m, _, _ := rpcdaemontest.CreateTestExecModule(t)
+	// rangeLimit=5, but logCount is set so the range check should be skipped.
+	api := NewErigonAPI(newBaseApiWithLimits(m, 5, 0), m.DB, nil)
+	_, err := api.GetLatestLogs(context.Background(), filters.FilterCriteria{
+		FromBlock: big.NewInt(0),
+		ToBlock:   big.NewInt(10),
+	}, filters.LogFilterOptions{
+		LogCount: 100,
+	})
+	require.NoError(t, err)
+}
+
+// TestGetLatestLogs_ExplicitRangeWithBlockCount_NoRangeCheck verifies that when
+// blockCount is set (within rangeLimit), the explicit fromBlock/toBlock range check
+// is skipped even if the explicit range exceeds rangeLimit.
+func TestGetLatestLogs_ExplicitRangeWithBlockCount_NoRangeCheck(t *testing.T) {
+	m, _, _ := rpcdaemontest.CreateTestExecModule(t)
+	// rangeLimit=5, blockCount=3 (≤5 so ok), explicit range 0-10 is skipped.
+	api := NewErigonAPI(newBaseApiWithLimits(m, 5, 0), m.DB, nil)
+	_, err := api.GetLatestLogs(context.Background(), filters.FilterCriteria{
+		FromBlock: big.NewInt(0),
+		ToBlock:   big.NewInt(10),
+	}, filters.LogFilterOptions{
+		BlockCount: 3,
+	})
+	require.NoError(t, err)
+}
+
 // newTestBackend creates a chain with a number of explicitly defined blocks and
 // wraps it into a mock backend.
 func mockWithGenerator(t *testing.T, blocks int, generator func(int, *blockgen.BlockGen)) *execmoduletester.ExecModuleTester {
diff --git a/rpc/jsonrpc/eth_api.go b/rpc/jsonrpc/eth_api.go
@@ -146,13 +146,14 @@ type BaseAPI struct {
 	bridgeReader bridgeReader
 
 	evmCallTimeout      time.Duration
-	rangeLimit          int
+	blockRangeLimit     int
+	getLogsMaxResults   int
 	dirs                datadir.Dirs
 	receiptsGenerator   *receipts.Generator
 	borReceiptGenerator *receipts.BorGenerator
 }
 
-func NewBaseApi(f *rpchelper.Filters, stateCache kvcache.Cache, blockReader services.FullBlockReader, singleNodeMode bool, evmCallTimeout time.Duration, engine rules.EngineReader, dirs datadir.Dirs, bridgeReader bridgeReader, rangeLimit int) *BaseAPI {
+func NewBaseApi(f *rpchelper.Filters, stateCache kvcache.Cache, blockReader services.FullBlockReader, singleNodeMode bool, evmCallTimeout time.Duration, engine rules.EngineReader, dirs datadir.Dirs, bridgeReader bridgeReader, rangeLimit int, getLogsMaxResults int) *BaseAPI {
 	var (
 		blocksLRUSize = 128 // ~32Mb
 	)
@@ -178,7 +179,8 @@ func NewBaseApi(f *rpchelper.Filters, stateCache kvcache.Cache, blockReader serv
 		borReceiptGenerator: receipts.NewBorGenerator(blockReader, engine, stateCache),
 		dirs:                dirs,
 		bridgeReader:        bridgeReader,
-		rangeLimit:          rangeLimit,
+		blockRangeLimit:     rangeLimit,
+		getLogsMaxResults:   getLogsMaxResults,
 	}
 }
 
diff --git a/rpc/jsonrpc/eth_api_test.go b/rpc/jsonrpc/eth_api_test.go
@@ -43,7 +43,11 @@ import (
 )
 
 func newBaseApiForTest(m *execmoduletester.ExecModuleTester) *BaseAPI {
-	return NewBaseApi(nil, m.StateCache, m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0)
+	return NewBaseApi(nil, m.StateCache, m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0, 0)
+}
+
+func newBaseApiWithLimits(m *execmoduletester.ExecModuleTester, rangeLimit, maxResults int) *BaseAPI {
+	return NewBaseApi(nil, m.StateCache, m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, rangeLimit, maxResults)
 }
 
 func newEthApiForTest(base *BaseAPI, db kv.TemporalRoDB, txPool txpoolproto.TxpoolClient, mining txpoolproto.MiningClient) *APIImpl {
@@ -85,7 +89,7 @@ func TestGetBalanceChangesInBlock(t *testing.T) {
 func TestGetTransactionReceipt(t *testing.T) {
 	m, _, _ := rpcdaemontest.CreateTestExecModule(t)
 	stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
-	api := newEthApiForTest(NewBaseApi(nil, stateCache, m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0), m.DB, nil, nil)
+	api := newEthApiForTest(NewBaseApi(nil, stateCache, m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0, 0), m.DB, nil, nil)
 	// Call GetTransactionReceipt for transaction which is not in the database
 	if _, err := api.GetTransactionReceipt(context.Background(), common.Hash{}); err != nil {
 		t.Errorf("calling GetTransactionReceipt with empty hash: %v", err)
diff --git a/rpc/jsonrpc/eth_callMany_test.go b/rpc/jsonrpc/eth_callMany_test.go
@@ -97,7 +97,7 @@ func TestCallMany(t *testing.T) {
 
 	db := contractBackend.DB()
 	engine := contractBackend.Engine()
-	api := newEthApiForTest(NewBaseApi(nil, stateCache, contractBackend.BlockReader(), false, rpccfg.DefaultEvmCallTimeout, engine, datadir.New(t.TempDir()), nil, 0), db, nil, nil)
+	api := newEthApiForTest(NewBaseApi(nil, stateCache, contractBackend.BlockReader(), false, rpccfg.DefaultEvmCallTimeout, engine, datadir.New(t.TempDir()), nil, 0, 0), db, nil, nil)
 
 	callArgAddr1 := ethapi.CallArgs{From: &address, To: &tokenAddr, Nonce: &nonce,
 		MaxPriorityFeePerGas: (*hexutil.Big)(big.NewInt(1e9)),
diff --git a/rpc/jsonrpc/eth_filters_test.go b/rpc/jsonrpc/eth_filters_test.go
@@ -37,7 +37,7 @@ import (
 )
 
 func newBaseApiWithFiltersForTest(f *rpchelper.Filters, stateCache *kvcache.Coherent, m *execmoduletester.ExecModuleTester) *BaseAPI {
-	return NewBaseApi(f, stateCache, m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0)
+	return NewBaseApi(f, stateCache, m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0, 0)
 }
 
 func TestNewFilters(t *testing.T) {
diff --git a/rpc/jsonrpc/eth_mining_test.go b/rpc/jsonrpc/eth_mining_test.go
diff --git a/rpc/jsonrpc/eth_receipts.go b/rpc/jsonrpc/eth_receipts.go
diff --git a/rpc/jsonrpc/gen_traces_test.go b/rpc/jsonrpc/gen_traces_test.go
diff --git a/rpc/jsonrpc/otterscan_transaction_by_sender_and_nonce_test.go b/rpc/jsonrpc/otterscan_transaction_by_sender_and_nonce_test.go
diff --git a/rpc/jsonrpc/overlay_api.go b/rpc/jsonrpc/overlay_api.go
diff --git a/rpc/jsonrpc/parity_api_test.go b/rpc/jsonrpc/parity_api_test.go
diff --git a/rpc/jsonrpc/trace_filtering.go b/rpc/jsonrpc/trace_filtering.go
diff --git a/rpc/jsonrpc/txpool_api_test.go b/rpc/jsonrpc/txpool_api_test.go

Original file line number	Diff line number	Diff line change
`@@ -140,7 +140,7 @@ func (e *EngineServer) Start(`
`140`	`140`	`return nil`
`141`	`141`	`})`
`142`	`142`	`}`
`143`		`- base := jsonrpc.NewBaseApi(filters, stateCache, blockReader, httpConfig.WithDatadir, httpConfig.EvmCallTimeout, engineReader, httpConfig.Dirs, nil, httpConfig.RangeLimit)`
	`143`	`+ base := jsonrpc.NewBaseApi(filters, stateCache, blockReader, httpConfig.WithDatadir, httpConfig.EvmCallTimeout, engineReader, httpConfig.Dirs, nil, httpConfig.BlockRangeLimit, httpConfig.GetLogsMaxResults)`
`144`	`144`	`ethImpl := jsonrpc.NewEthAPI(base, db, eth, e.txpool, mining, jsonrpc.NewEthApiConfig(httpConfig), e.logger)`
`145`	`145`
`146`	`146`	`apiList := []rpc.API{`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ func oneBlockStep(mockSentry execmoduletester.ExecModuleTester, require requir`
`67`	`67`
`68`	`68`	`func newBaseApiForTest(m execmoduletester.ExecModuleTester) jsonrpc.BaseAPI {`
`69`	`69`	`stateCache := kvcache.New(kvcache.DefaultCoherentConfig)`
`70`		`- return jsonrpc.NewBaseApi(nil, stateCache, m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0)`
	`70`	`+ return jsonrpc.NewBaseApi(nil, stateCache, m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0, 0)`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`func newEthApiForTest(base jsonrpc.BaseAPI, db kv.TemporalRoDB, txPool txpoolproto.TxpoolClient) jsonrpc.APIImpl {`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ func TestSuggestPrice(t *testing.T) {`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`m := newTestBackend(t) //, big.NewInt(16), c.pending)`
`90`		`- baseApi := jsonrpc.NewBaseApi(nil, kvcache.NewDummy(), m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0)`
	`90`	`+ baseApi := jsonrpc.NewBaseApi(nil, kvcache.NewDummy(), m.BlockReader, false, rpccfg.DefaultEvmCallTimeout, m.Engine, m.Dirs, nil, 0, 0)`
`91`	`91`
`92`	`92`	`tx, err := m.DB.BeginTemporalRo(m.Ctx)`
`93`	`93`	`require.NoError(t, err)`