support from, to and order in IdentitityStates API (#6718)

* support from, to and order in IdentitityStates API

* bump 'api' and rename 'Id' to 'Smesher'

* add filtering by smesher

Author: poszu

api/grpcserver/v2beta1/interface.go

@@ -4,18 +4,10 @@ import (
 	"context"
 
 	"github.com/spacemeshos/go-spacemesh/common/types"
-	"github.com/spacemeshos/go-spacemesh/identity"
-	"github.com/spacemeshos/go-spacemesh/sql/builder"
 )
 
 //go:generate mockgen -typed -package=v2beta1 -destination=./mocks.go -source=./interface.go
 
 type malfeasanceInfo interface {
 	Info(ctx context.Context, nodeID types.NodeID) (map[string]string, error)
 }
-
-type identityState interface {
-	All(ops builder.Operations) map[types.NodeID][]identity.StateInfo
-	AllProposals() map[types.NodeID][]*types.Proposal
-	AllEligibilities() map[types.NodeID]map[types.LayerID][]types.VotingEligibility
-}

api/grpcserver/v2beta1/mocks.go

@@ -2,6 +2,7 @@ package v2beta1
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	pb "github.com/spacemeshos/api/release/go/spacemesh/v2beta1"
@@ -13,11 +14,18 @@ import (
 
 	"github.com/spacemeshos/go-spacemesh/activation"
 	"github.com/spacemeshos/go-spacemesh/common/types"
+	identity "github.com/spacemeshos/go-spacemesh/identity"
 	"github.com/spacemeshos/go-spacemesh/sql/builder"
 )
 
 const SmeshingIdentities = "smeshing_identities_v2beta1"
 
+type identityState interface {
+	All(ops builder.Operations) ([]identity.IdStateInfo, error)
+	AllProposals() map[types.NodeID][]*types.Proposal
+	AllEligibilities() map[types.NodeID]map[types.LayerID][]types.VotingEligibility
+}
+
 type SmeshingIdentitiesService struct {
 	states      identityState
 	poetClients []activation.PoetService
@@ -59,31 +67,31 @@ func (s *SmeshingIdentitiesService) States(
 		return nil, status.Error(codes.InvalidArgument, "limit must be set to <= 100")
 	}
 
-	ops := toEventOperations(request)
-
-	pbIdentities := make(map[string]*pb.Identity, request.Limit)
-	for nodeId, history := range s.states.All(ops) {
-		pbIdentities[nodeId.String()] = &pb.Identity{
-			History: []*pb.IdentityStateInfo{},
-		}
-
-		for i := len(history) - 1; i >= 0; i-- {
-			info := history[i]
+	ops, err := toEventOperations(request)
+	if err != nil {
+		return nil, status.Error(codes.InvalidArgument, err.Error())
+	}
 
-			identityStateInfo := info.State.APIStateInfo()
-			identityStateInfo.Time = timestamppb.New(info.Time)
+	var states []*pb.IdentityStateInfo
+	events, err := s.states.All(ops)
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
+	for _, info := range events {
+		identityStateInfo := info.State.APIStateInfo()
+		identityStateInfo.Time = timestamppb.New(info.Time)
+		identityStateInfo.Smesher = info.ID.Bytes()
 
-			pbIdentities[nodeId.String()].History = append(pbIdentities[nodeId.String()].History, identityStateInfo)
-		}
+		states = append(states, identityStateInfo)
 	}
 
-	return &pb.IdentityStatesResponse{Identities: pbIdentities}, nil
+	return &pb.IdentityStatesResponse{States: states}, nil
 }
 
-func toEventOperations(filter *pb.IdentityStatesRequest) builder.Operations {
+func toEventOperations(filter *pb.IdentityStatesRequest) (builder.Operations, error) {
 	ops := builder.Operations{}
 	if filter == nil {
-		return ops
+		return ops, nil
 	}
 
 	if len(filter.States) > 0 {
@@ -98,21 +106,58 @@ func toEventOperations(filter *pb.IdentityStatesRequest) builder.Operations {
 			Value: states,
 		})
 	}
+	if len(filter.Smeshers) > 0 {
+		ops.Filter = append(ops.Filter, builder.Op{
+			Field: "id",
+			Token: builder.In,
+			Value: filter.Smeshers,
+		})
+	}
 
 	if filter.Limit != 0 {
 		ops.Modifiers = append(ops.Modifiers, builder.Modifier{
 			Key:   builder.Limit,
 			Value: int64(filter.Limit),
 		})
 	}
-	if filter.Offset != 0 {
+
+	if filter.From != nil {
+		if err := filter.From.CheckValid(); err != nil {
+			return ops, fmt.Errorf("'from' is invalid: %w", err)
+		}
+		ops.Filter = append(ops.Filter, builder.Op{
+			Field: "timestamp",
+			Token: builder.Gte,
+			Value: filter.From.AsTime().UnixMicro(),
+		})
+	}
+	if filter.To != nil {
+		if err := filter.To.CheckValid(); err != nil {
+			return ops, fmt.Errorf("'to' is invalid: %w", err)
+		}
+		ops.Filter = append(ops.Filter, builder.Op{
+			Field: "timestamp",
+			Token: builder.Lt,
+			Value: filter.To.AsTime().UnixMicro(),
+		})
+	}
+
+	switch filter.Order {
+	case pb.SortOrder_ASC:
+		ops.Modifiers = append(ops.Modifiers, builder.Modifier{
+			Key:   builder.OrderBy,
+			Value: "timestamp asc",
+		})
+	case pb.SortOrder_DESC:
 		ops.Modifiers = append(ops.Modifiers, builder.Modifier{
-			Key:   builder.Offset,
-			Value: int64(filter.Offset),
+			Key:   builder.OrderBy,
+			Value: "timestamp desc",
 		})
+	default:
+		return ops, fmt.Errorf("unknown sort order: %d", filter.Order)
 	}
 
-	return ops
+	return ops, nil
 }
 
 func (s *SmeshingIdentitiesService) PoetInfo(