fix(x/auth/tx): honor deprecated Pagination field in GetTxsEvent

GetTxsEvent only consumed the top-level Page/Limit/OrderBy fields and
silently ignored req.Pagination. REST clients hitting the gRPC-gateway
endpoint with pagination.limit / pagination.offset / pagination.reverse
got DefaultLimit-sized ascending pages no matter what they passed,
which is what made paginated transfer.recipient queries appear to drop
matching txs.

Treat the deprecated fields as a fallback when the top-level fields are
unset: limit -> req.Pagination.Limit, page -> Offset/Limit + 1 (with an
InvalidArgument when Offset is not a multiple of Limit), and Reverse
maps to OrderBy_DESC. Top-level fields still win when both are set.

Adds a service_test.go with a recording TxSearch client covering each
fallback path plus the precedence rule.

Closes #25886

Author: ozpool

x/auth/tx/service.go

@@ -48,9 +48,39 @@ func (s txServer) GetTxsEvent(_ context.Context, req *txtypes.GetTxsEventRequest
 		return nil, status.Error(codes.InvalidArgument, "request cannot be nil")
 	}
 
-	orderBy := parseOrderBy(req.OrderBy)
+	page, limit, orderBy := req.Page, req.Limit, parseOrderBy(req.OrderBy)
 
-	result, err := QueryTxsByEvents(s.clientCtx, int(req.Page), int(req.Limit), req.Query, orderBy)
+	// Backwards-compatibility: the top-level page/limit/order_by fields supersede
+	// the deprecated Pagination message, but if a caller only set the deprecated
+	// fields (common when consuming the gRPC-gateway REST endpoint with
+	// pagination.limit / pagination.offset / pagination.reverse query params),
+	// fall back to those values rather than silently ignoring them. See #25886.
+	if req.Pagination != nil {
+		if limit == 0 && req.Pagination.Limit > 0 {
+			limit = req.Pagination.Limit
+		}
+		if page == 0 {
+			effectiveLimit := limit
+			if effectiveLimit == 0 {
+				effectiveLimit = query.DefaultLimit
+			}
+			if req.Pagination.Offset > 0 {
+				if req.Pagination.Offset%effectiveLimit != 0 {
+					return nil, status.Errorf(
+						codes.InvalidArgument,
+						"pagination.offset (%d) must be a multiple of pagination.limit (%d)",
+						req.Pagination.Offset, effectiveLimit,
+					)
+				}
+				page = req.Pagination.Offset/effectiveLimit + 1
+			}
+		}
+		if orderBy == "" && req.Pagination.Reverse {
+			orderBy = "desc"
+		}
+	}
+
+	result, err := QueryTxsByEvents(s.clientCtx, int(page), int(limit), req.Query, orderBy)
 	if err != nil {
 		return nil, status.Error(codes.Internal, err.Error())
 	}

x/auth/tx/service_test.go

@@ -0,0 +1,136 @@
+package tx_test
+
+import (
+	"context"
+	"testing"
+
+	coretypes "github.com/cometbft/cometbft/rpc/core/types"
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	"github.com/cosmos/cosmos-sdk/types/query"
+	txtypes "github.com/cosmos/cosmos-sdk/types/tx"
+	"github.com/cosmos/cosmos-sdk/x/auth/tx"
+)
+
+// recordingTxSearchClient captures the page/limit/orderBy passed to TxSearch
+// so tests can assert how GetTxsEvent translated the request.
+type recordingTxSearchClient struct {
+	client.MockClient
+
+	page    *int
+	limit   *int
+	orderBy string
+}
+
+func (c *recordingTxSearchClient) TxSearch(
+	_ context.Context,
+	_ string,
+	_ bool,
+	page, limit *int,
+	orderBy string,
+) (*coretypes.ResultTxSearch, error) {
+	if page != nil {
+		v := *page
+		c.page = &v
+	}
+	if limit != nil {
+		v := *limit
+		c.limit = &v
+	}
+	c.orderBy = orderBy
+	return &coretypes.ResultTxSearch{Txs: nil, TotalCount: 0}, nil
+}
+
+func newRecordingCtx() (*recordingTxSearchClient, client.Context) {
+	rc := &recordingTxSearchClient{}
+	ctx := client.Context{}.
+		WithClient(rc).
+		WithCmdContext(context.Background()).
+		WithInterfaceRegistry(codectypes.NewInterfaceRegistry())
+	return rc, ctx
+}
+
+// TestGetTxsEvent_HonorsDeprecatedPagination ensures that when callers only
+// populate the deprecated Pagination field (e.g. REST clients passing
+// pagination.limit / pagination.offset / pagination.reverse), the values are
+// forwarded to TxSearch instead of being silently dropped. Regression for
+// https://github.com/cosmos/cosmos-sdk/issues/25886.
+func TestGetTxsEvent_HonorsDeprecatedPagination(t *testing.T) {
+	cases := []struct {
+		name       string
+		req        *txtypes.GetTxsEventRequest
+		wantPage   int
+		wantLimit  int
+		wantOrder  string
+		wantErrMsg string
+	}{
+		{
+			name: "deprecated limit honored when top-level limit is zero",
+			req: &txtypes.GetTxsEventRequest{
+				Query:      "tx.height=1",
+				Pagination: &query.PageRequest{Limit: 250},
+			},
+			wantPage:  1,
+			wantLimit: 250,
+		},
+		{
+			name: "deprecated offset translates to page",
+			req: &txtypes.GetTxsEventRequest{
+				Query:      "tx.height=1",
+				Pagination: &query.PageRequest{Limit: 100, Offset: 200},
+			},
+			wantPage:  3,
+			wantLimit: 100,
+		},
+		{
+			name: "deprecated reverse maps to desc order",
+			req: &txtypes.GetTxsEventRequest{
+				Query:      "tx.height=1",
+				Pagination: &query.PageRequest{Limit: 50, Reverse: true},
+			},
+			wantPage:  1,
+			wantLimit: 50,
+			wantOrder: "desc",
+		},
+		{
+			name: "top-level page/limit win over deprecated fields",
+			req: &txtypes.GetTxsEventRequest{
+				Query:      "tx.height=1",
+				Page:       2,
+				Limit:      25,
+				Pagination: &query.PageRequest{Limit: 999, Offset: 9000},
+			},
+			wantPage:  2,
+			wantLimit: 25,
+		},
+		{
+			name: "non-multiple offset rejected",
+			req: &txtypes.GetTxsEventRequest{
+				Query:      "tx.height=1",
+				Pagination: &query.PageRequest{Limit: 100, Offset: 150},
+			},
+			wantErrMsg: "must be a multiple of",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			rc, ctx := newRecordingCtx()
+			srv := tx.NewTxServer(ctx, nil, codectypes.NewInterfaceRegistry())
+			_, err := srv.GetTxsEvent(context.Background(), tc.req)
+			if tc.wantErrMsg != "" {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), tc.wantErrMsg)
+				return
+			}
+			require.NoError(t, err)
+			require.NotNil(t, rc.page, "page not forwarded to TxSearch")
+			require.NotNil(t, rc.limit, "limit not forwarded to TxSearch")
+			require.Equal(t, tc.wantPage, *rc.page)
+			require.Equal(t, tc.wantLimit, *rc.limit)
+			require.Equal(t, tc.wantOrder, rc.orderBy)
+		})
+	}
+}