From 3cc4015d29a77e6bf40d2cc19fe2bf8592f1ebc2 Mon Sep 17 00:00:00 2001 From: zsfelfoldi Date: Tue, 16 Sep 2025 12:46:28 +0200 Subject: [PATCH] cmd/utils, eth/filters: changed flag name to LogQueryLimit --- cmd/geth/main.go | 2 +- cmd/utils/flags.go | 14 +++++++------- eth/ethconfig/config.go | 4 ++-- eth/ethconfig/gen_config.go | 10 +++++----- eth/filters/api.go | 28 ++++++++++++++-------------- eth/filters/filter_system.go | 14 +++++++------- eth/filters/filter_system_test.go | 16 ++++++++-------- 7 files changed, 44 insertions(+), 44 deletions(-) diff --git a/cmd/geth/main.go b/cmd/geth/main.go index b08c1b3809..9e3026bd2e 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -180,7 +180,7 @@ var ( utils.RPCGlobalGasCapFlag, utils.RPCGlobalEVMTimeoutFlag, utils.RPCGlobalTxFeeCapFlag, - utils.EthGetLogMaxAddressFlag, + utils.RPCGlobalLogQueryLimit, utils.AllowUnprotectedTxs, utils.BatchRequestLimit, utils.BatchResponseMaxSize, diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index b2d6e0ebe3..6413c0fa04 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -590,10 +590,10 @@ var ( Value: ethconfig.Defaults.RPCTxFeeCap, Category: flags.APICategory, } - EthGetLogMaxAddressFlag = &cli.IntFlag{ - Name: "rpc.getlogmaxaddrs", - Usage: "Maximum number of addresses allowed in eth_getLogs filter criteria", - Value: ethconfig.Defaults.FilterMaxAddresses, + RPCGlobalLogQueryLimit = &cli.IntFlag{ + Name: "rpc.logquerylimit", + Usage: "Maximum number of alternative addresses or topics allowed per search position in eth_getLogs filter criteria (0 = no cap)", + Value: ethconfig.Defaults.LogQueryLimit, Category: flags.APICategory, } // Authenticated RPC HTTP settings @@ -1695,8 +1695,8 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) { if ctx.IsSet(CacheLogSizeFlag.Name) { cfg.FilterLogCacheSize = ctx.Int(CacheLogSizeFlag.Name) } - if ctx.IsSet(EthGetLogMaxAddressFlag.Name) { - cfg.FilterMaxAddresses = ctx.Int(EthGetLogMaxAddressFlag.Name) + if ctx.IsSet(RPCGlobalLogQueryLimit.Name) { + cfg.LogQueryLimit = ctx.Int(RPCGlobalLogQueryLimit.Name) } if !ctx.Bool(SnapshotFlag.Name) || cfg.SnapshotCache == 0 { // If snap-sync is requested, this flag is also required @@ -2007,7 +2007,7 @@ func RegisterGraphQLService(stack *node.Node, backend ethapi.Backend, filterSyst func RegisterFilterAPI(stack *node.Node, backend ethapi.Backend, ethcfg *ethconfig.Config) *filters.FilterSystem { filterSystem := filters.NewFilterSystem(backend, filters.Config{ LogCacheSize: ethcfg.FilterLogCacheSize, - MaxAddresses: ethcfg.FilterMaxAddresses, + LogQueryLimit: ethcfg.LogQueryLimit, }) stack.RegisterAPIs([]rpc.API{{ Namespace: "eth", diff --git a/eth/ethconfig/config.go b/eth/ethconfig/config.go index c43a11afef..994d968093 100644 --- a/eth/ethconfig/config.go +++ b/eth/ethconfig/config.go @@ -62,7 +62,7 @@ var Defaults = Config{ TrieTimeout: 60 * time.Minute, SnapshotCache: 102, FilterLogCacheSize: 32, - FilterMaxAddresses: 1000, + LogQueryLimit: 1000, Miner: miner.DefaultConfig, TxPool: legacypool.DefaultConfig, BlobPool: blobpool.DefaultConfig, @@ -133,7 +133,7 @@ type Config struct { FilterLogCacheSize int // This is the maximum number of addresses allowed in filter criteria for eth_getLogs. - FilterMaxAddresses int + LogQueryLimit int // Mining options Miner miner.Config diff --git a/eth/ethconfig/gen_config.go b/eth/ethconfig/gen_config.go index 10349ffb97..8f9dffa723 100644 --- a/eth/ethconfig/gen_config.go +++ b/eth/ethconfig/gen_config.go @@ -44,7 +44,7 @@ func (c Config) MarshalTOML() (interface{}, error) { SnapshotCache int Preimages bool FilterLogCacheSize int - FilterMaxAddresses int + LogQueryLimit int Miner miner.Config TxPool legacypool.Config BlobPool blobpool.Config @@ -87,7 +87,7 @@ func (c Config) MarshalTOML() (interface{}, error) { enc.SnapshotCache = c.SnapshotCache enc.Preimages = c.Preimages enc.FilterLogCacheSize = c.FilterLogCacheSize - enc.FilterMaxAddresses = c.FilterMaxAddresses + enc.LogQueryLimit = c.LogQueryLimit enc.Miner = c.Miner enc.TxPool = c.TxPool enc.BlobPool = c.BlobPool @@ -134,7 +134,7 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error { SnapshotCache *int Preimages *bool FilterLogCacheSize *int - FilterMaxAddresses *int + LogQueryLimit *int Miner *miner.Config TxPool *legacypool.Config BlobPool *blobpool.Config @@ -234,8 +234,8 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error { if dec.FilterLogCacheSize != nil { c.FilterLogCacheSize = *dec.FilterLogCacheSize } - if dec.FilterMaxAddresses != nil { - c.FilterMaxAddresses = *dec.FilterMaxAddresses + if dec.LogQueryLimit != nil { + c.LogQueryLimit = *dec.LogQueryLimit } if dec.Miner != nil { c.Miner = *dec.Miner diff --git a/eth/filters/api.go b/eth/filters/api.go index fe5fe1b25e..33c746f084 100644 --- a/eth/filters/api.go +++ b/eth/filters/api.go @@ -42,7 +42,7 @@ var ( errBlockHashWithRange = errors.New("can't specify fromBlock/toBlock with blockHash") errPendingLogsUnsupported = errors.New("pending logs are not supported") errExceedMaxTopics = errors.New("exceed max topics") - errExceedMaxAddresses = errors.New("exceed max addresses") + errExceedLogQueryLimit = errors.New("exceed max addresses or topics per search position") ) const ( @@ -68,22 +68,22 @@ type filter struct { // FilterAPI offers support to create and manage filters. This will allow external clients to retrieve various // information related to the Ethereum protocol such as blocks, transactions and logs. type FilterAPI struct { - sys *FilterSystem - events *EventSystem - filtersMu sync.Mutex - filters map[rpc.ID]*filter - timeout time.Duration - maxAddresses int + sys *FilterSystem + events *EventSystem + filtersMu sync.Mutex + filters map[rpc.ID]*filter + timeout time.Duration + logQueryLimit int } // NewFilterAPI returns a new FilterAPI instance. func NewFilterAPI(system *FilterSystem) *FilterAPI { api := &FilterAPI{ - sys: system, - events: NewEventSystem(system), - filters: make(map[rpc.ID]*filter), - timeout: system.cfg.Timeout, - maxAddresses: system.cfg.MaxAddresses, + sys: system, + events: NewEventSystem(system), + filters: make(map[rpc.ID]*filter), + timeout: system.cfg.Timeout, + logQueryLimit: system.cfg.LogQueryLimit, } go api.timeoutLoop(system.cfg.Timeout) @@ -347,8 +347,8 @@ func (api *FilterAPI) GetLogs(ctx context.Context, crit FilterCriteria) ([]*type if len(crit.Topics) > maxTopics { return nil, errExceedMaxTopics } - if len(crit.Addresses) > api.maxAddresses { - return nil, errExceedMaxAddresses + if len(crit.Addresses) > api.logQueryLimit { + return nil, errExceedLogQueryLimit } var filter *Filter diff --git a/eth/filters/filter_system.go b/eth/filters/filter_system.go index 7f9132f801..01e5f787b0 100644 --- a/eth/filters/filter_system.go +++ b/eth/filters/filter_system.go @@ -41,9 +41,9 @@ import ( // Config represents the configuration of the filter system. type Config struct { - LogCacheSize int // maximum number of cached blocks (default: 32) - Timeout time.Duration // how long filters stay active (default: 5min) - MaxAddresses int // maximum number of addresses allowed in filter criteria (default: 1000) + LogCacheSize int // maximum number of cached blocks (default: 32) + Timeout time.Duration // how long filters stay active (default: 5min) + LogQueryLimit int // maximum number of addresses allowed in filter criteria (default: 1000) } func (cfg Config) withDefaults() Config { @@ -53,8 +53,8 @@ func (cfg Config) withDefaults() Config { if cfg.LogCacheSize == 0 { cfg.LogCacheSize = 32 } - if cfg.MaxAddresses == 0 { - cfg.MaxAddresses = 1000 + if cfg.LogQueryLimit == 0 { + cfg.LogQueryLimit = 1000 } return cfg } @@ -295,8 +295,8 @@ func (es *EventSystem) SubscribeLogs(crit ethereum.FilterQuery, logs chan []*typ if len(crit.Topics) > maxTopics { return nil, errExceedMaxTopics } - if len(crit.Addresses) > es.sys.cfg.MaxAddresses { - return nil, errExceedMaxAddresses + if len(crit.Addresses) > es.sys.cfg.LogQueryLimit { + return nil, errExceedLogQueryLimit } var from, to rpc.BlockNumber if crit.FromBlock == nil { diff --git a/eth/filters/filter_system_test.go b/eth/filters/filter_system_test.go index 121678093a..ae5def7298 100644 --- a/eth/filters/filter_system_test.go +++ b/eth/filters/filter_system_test.go @@ -435,7 +435,7 @@ func TestInvalidLogFilterCreation(t *testing.T) { 1: {FromBlock: big.NewInt(rpc.PendingBlockNumber.Int64()), ToBlock: big.NewInt(100)}, 2: {FromBlock: big.NewInt(rpc.LatestBlockNumber.Int64()), ToBlock: big.NewInt(100)}, 3: {Topics: [][]common.Hash{{}, {}, {}, {}, {}}}, - 4: {Addresses: make([]common.Address, api.maxAddresses+1)}, + 4: {Addresses: make([]common.Address, api.logQueryLimit+1)}, } for i, test := range testCases { @@ -532,10 +532,10 @@ func TestInvalidGetRangeLogsRequest(t *testing.T) { func TestInvalidAddressLengthRequest(t *testing.T) { t.Parallel() - // Test with custom config (MaxAddresses = 5 for easier testing) + // Test with custom config (LogQueryLimit = 5 for easier testing) var ( db = rawdb.NewMemoryDatabase() - _, sys = newTestFilterSystem(db, Config{MaxAddresses: 5}) + _, sys = newTestFilterSystem(db, Config{LogQueryLimit: 5}) api = NewFilterAPI(sys) ) @@ -550,14 +550,14 @@ func TestInvalidAddressLengthRequest(t *testing.T) { FromBlock: big.NewInt(0), ToBlock: big.NewInt(100), Addresses: invalidAddresses, - }); err != errExceedMaxAddresses { - t.Errorf("Expected GetLogs with 6 addresses to return errExceedMaxAddresses, but got: %v", err) + }); err != errExceedLogQueryLimit { + t.Errorf("Expected GetLogs with 6 addresses to return errExceedLogQueryLimit, but got: %v", err) } // Test with default config should reject 1001 addresses var ( db2 = rawdb.NewMemoryDatabase() - _, sys2 = newTestFilterSystem(db2, Config{}) // Uses default MaxAddresses = 1000 + _, sys2 = newTestFilterSystem(db2, Config{}) // Uses default LogQueryLimit = 1000 api2 = NewFilterAPI(sys2) ) @@ -571,8 +571,8 @@ func TestInvalidAddressLengthRequest(t *testing.T) { FromBlock: big.NewInt(0), ToBlock: big.NewInt(100), Addresses: tooManyAddresses, - }); err != errExceedMaxAddresses { - t.Errorf("Expected GetLogs with 1001 addresses to return errExceedMaxAddresses, but got: %v", err) + }); err != errExceedLogQueryLimit { + t.Errorf("Expected GetLogs with 1001 addresses to return errExceedLogQueryLimit, but got: %v", err) } }