// MaxSnapshotResults is the maximum number of snapshots returned
const MaxSnapshotResults = 500

// PriceSnapshotHistory queries all snapshots
func (qs QueryServer) PriceSnapshotHistory(ctx context.Context, req *types.QueryPriceSnapshotHistoryRequest) (*types.QueryPriceSnapshotHistoryResponse, error) {
	sdkCtx := sdk.UnwrapSDKContext(ctx)

	// Get the snapshots available on the KVStore
	priceSnapshots := []types.PriceSnapshot{}
	count := 0
	err := qs.Keeper.PriceSnapshot.Walk(sdkCtx, nil, func(_ int64, snapshot types.PriceSnapshot) (bool, error) {
		priceSnapshots = append(priceSnapshots, snapshot)
		count++
		// Limit results to prevent memory exhaustion
		return count >= MaxSnapshotResults, nil
	})
	if err != nil {
		return nil, err
	}

	return &types.QueryPriceSnapshotHistoryResponse{PriceSnapshot: priceSnapshots}, nil

// MinimumPrecompileGas is the minimum gas charged for any precompile invocation
// This prevents zero-cost spam attacks with malformed inputs
const MinimumPrecompileGas uint64 = 3000

// RequiredGas returns the required gas for the precompile
func (p Precompile) RequiredGas(input []byte) uint64 {
	// Charge minimum gas for malformed inputs to prevent spam
	if len(input) < 4 {
		return MinimumPrecompileGas
	}

	// Get the method ID from the first 4 bytes
	methodID := input[:4]

	// Get the method from the ABI
	method, err := p.MethodById(methodID)
	if err != nil {
		// Charge minimum gas for invalid method IDs
		return MinimumPrecompileGas
	}

	// Get the gas required for the method
	return p.Precompile.RequiredGas(input, p.IsTransaction(method))
}

// MaxQueryResults is the maximum number of results returned by list queries
// This prevents memory exhaustion from unbounded iteration
const MaxQueryResults = 1000

// ExchangeRates returns all exchange rates
func (qs QueryServer) ExchangeRates(ctx context.Context, req *types.QueryExchangeRatesRequest) (*types.QueryExchangeRatesResponse, error) {
	sdkCtx := sdk.UnwrapSDKContext(ctx)

	exchangeRates := []types.DenomOracleExchangeRate{}
	count := 0
	err := qs.Keeper.ExchangeRate.Walk(sdkCtx, nil, func(denom string, exchangeRate types.OracleExchangeRate) (bool, error) {
		exchangeRates = append(exchangeRates, types.DenomOracleExchangeRate{Denom: denom, OracleExchangeRate: &exchangeRate})
		count++
		// Limit results to prevent memory exhaustion
		return count >= MaxQueryResults, nil
	})
	if err != nil {
		return nil, err
	}

	return &types.QueryExchangeRatesResponse{DenomOracleExchangeRate: exchangeRates}, nil

Verify each finding against the current code and only fix it if needed.

Outside diff comments:
In `@x/oracle/keeper/query_server.go`:
- Around line 110-117: The VoteTargets query currently returns all targets via
qs.Keeper.GetVoteTargets and lacks an iteration bound; replace the unbounded
fetch with a bounded walk over the store (similar to ExchangeRates/Actives) by
iterating via qs.Keeper.VoteTarget.Walk (or the Keeper iterator for vote
targets), appending each denom to a local []string, incrementing a counter and
returning true when count >= MaxQueryResults to stop iteration, check and return
any Walk error, and finally return &types.QueryVoteTargetsResponse{VoteTargets:
voteTargets}, nil (or the actual error) so the result is limited to
MaxQueryResults and matches the other list queries' pattern.

---

Nitpick comments:
In `@precompiles/oracle/types.go`:
- Around line 12-14: The constant MaxDenomLength is set to 256 but should match
the SDK's maximum denom length of 128; change the value of MaxDenomLength in
precompiles/oracle/types.go from 256 to 128 so validation aligns with
x/tokenfactory's constraint and avoids allowing denom lengths that the SDK would
reject (update the const MaxDenomLength declaration accordingly).

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@precompiles/oracle/types.go`:
- Around line 29-32: The denom length check currently only exists in the
precompile parser and can be bypassed; add the same validation to the shared
query boundary by enforcing MaxDenomLength inside QueryServer.ExchangeRate:
validate that denom is non-empty and len(denom) <= MaxDenomLength (use the
existing MaxDenomLength constant) and return an error when exceeded so all
callers (not just precompile paths) receive consistent protection; keep the same
error message format used elsewhere for consistency.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@x/oracle/keeper/query_server_test.go`:
- Around line 341-354: The "valid - denom at max length" test case is marked
expectError:false but no exchange rate is seeded for strings.Repeat("a",
MaxDenomLength), so the loop's assertion (which only checks results for
utils.AtomDenom) never verifies it; update the test setup to seed an exchange
rate for the max-length denom (the same denom string used in that test case) so
querier.ExchangeRate(ctx, &types.QueryExchangeRateRequest{Denom: tc.denom})
returns a non-error and a non-nil response, and/or extend the per-case
assertions in the loop (around the call to querier.ExchangeRate) to explicitly
assert success for tc.denom == strings.Repeat("a", utils.MaxDenomLength) instead
of relying only on utils.AtomDenom.