Test only current validators api

proto/validatorstate/validator_state.proto

@@ -17,6 +17,9 @@ service ValidatorState {
   // GetValidatorSet returns the weights of the nodeIDs for the provided
   // subnet at the requested P-chain height.
   rpc GetValidatorSet(GetValidatorSetRequest) returns (GetValidatorSetResponse);
+  // GetCurrentValidatorSet returns the weights of the nodeIDs for the provided
+  // subnet at the current P-chain height.
+  rpc GetCurrentValidatorSet(GetCurrentValidatorSetRequest) returns (GetCurrentValidatorSetResponse);
 }
 
 message GetMinimumHeightResponse {
@@ -40,12 +43,31 @@ message GetValidatorSetRequest {
   bytes subnet_id = 2;
 }
 
+message GetCurrentValidatorSetRequest {
+  bytes subnet_id = 1;
+}
+
 message Validator {
   bytes node_id = 1;
   uint64 weight = 2;
   bytes public_key = 3;
 }
 
+message CurrentValidator {
+  bytes node_id = 1;
+  uint64 weight = 2;
+  bytes public_key = 3;
+  uint64 start_time = 4;
+  uint64 set_weight_nonce = 5;
+  bool is_active = 6;
+  bytes validation_id = 7;
+}
+
 message GetValidatorSetResponse {
   repeated Validator validators = 1;
 }
+
+message GetCurrentValidatorSetResponse {
+  repeated CurrentValidator validators = 1;
+  uint64 current_height = 2;
+}

snow/validators/gvalidators/validator_state_client.go

@@ -94,3 +94,49 @@ func (c *Client) GetValidatorSet(
 	}
 	return vdrs, nil
 }
+
+func (c *Client) GetCurrentValidatorSet(
+	ctx context.Context,
+	subnetID ids.ID,
+) (map[ids.ID]*validators.GetCurrentValidatorOutput, uint64, error) {
+	resp, err := c.client.GetCurrentValidatorSet(ctx, &pb.GetCurrentValidatorSetRequest{
+		SubnetId: subnetID[:],
+	})
+	if err != nil {
+		return nil, 0, err
+	}
+
+	vdrs := make(map[ids.ID]*validators.GetCurrentValidatorOutput, len(resp.Validators))
+	for _, validator := range resp.Validators {
+		nodeID, err := ids.ToNodeID(validator.NodeId)
+		if err != nil {
+			return nil, 0, err
+		}
+		var publicKey *bls.PublicKey
+		if len(validator.PublicKey) > 0 {
+			// This is a performance optimization to avoid the cost of
+			// compression and key re-verification with
+			// PublicKeyFromCompressedBytes. We can safely assume that the BLS
+			// Public Keys are verified before being added to the P-Chain and
+			// served by the gRPC server.
+			publicKey = bls.PublicKeyFromValidUncompressedBytes(validator.PublicKey)
+			if publicKey == nil {
+				return nil, 0, errFailedPublicKeyDeserialize
+			}
+		}
+		validationID, err := ids.ToID(validator.ValidationId)
+		if err != nil {
+			return nil, 0, err
+		}
+
+		vdrs[validationID] = &validators.GetCurrentValidatorOutput{
+			NodeID:         nodeID,
+			PublicKey:      publicKey,
+			Weight:         validator.Weight,
+			StartTime:      validator.StartTime,
+			SetWeightNonce: validator.SetWeightNonce,
+			IsActive:       validator.IsActive,
+		}
+	}
+	return vdrs, resp.GetCurrentHeight(), nil
+}

snow/validators/gvalidators/validator_state_server.go

@@ -79,3 +79,40 @@ func (s *Server) GetValidatorSet(ctx context.Context, req *pb.GetValidatorSetReq
 	}
 	return resp, nil
 }
+
+func (s *Server) GetCurrentValidatorSet(ctx context.Context, req *pb.GetCurrentValidatorSetRequest) (*pb.GetCurrentValidatorSetResponse, error) {
+	subnetID, err := ids.ToID(req.SubnetId)
+	if err != nil {
+		return nil, err
+	}
+
+	vdrs, currentHeight, err := s.state.GetCurrentValidatorSet(ctx, subnetID)
+	if err != nil {
+		return nil, err
+	}
+
+	resp := &pb.GetCurrentValidatorSetResponse{
+		Validators:    make([]*pb.CurrentValidator, len(vdrs)),
+		CurrentHeight: currentHeight,
+	}
+
+	i := 0
+	for _, vdr := range vdrs {
+		vdrPB := &pb.CurrentValidator{
+			NodeId:         vdr.NodeID.Bytes(),
+			StartTime:      vdr.StartTime,
+			IsActive:       vdr.IsActive,
+			ValidationId:   vdr.ValidationID[:],
+			Weight:         vdr.Weight,
+			SetWeightNonce: vdr.SetWeightNonce,
+		}
+		if vdr.PublicKey != nil {
+			// This is a performance optimization to avoid the cost of compression
+			// from PublicKeyToCompressedBytes.
+			vdrPB.PublicKey = bls.PublicKeyToUncompressedBytes(vdr.PublicKey)
+		}
+		resp.Validators[i] = vdrPB
+		i++
+	}
+	return resp, nil
+}

snow/validators/state.go

@@ -32,6 +32,15 @@ type State interface {
 		height uint64,
 		subnetID ids.ID,
 	) (map[ids.NodeID]*GetValidatorOutput, error)
+
+	// GetCurrentValidatorSet returns the current validators of the provided subnet
+	// and the current P-Chain height.
+	// Map is keyed by ValidationID.
+	// The returned map should not be modified.
+	GetCurrentValidatorSet(
+		ctx context.Context,
+		subnetID ids.ID,
+	) (map[ids.ID]*GetCurrentValidatorOutput, uint64, error)
 }
 
 type lockedState struct {
@@ -78,6 +87,16 @@ func (s *lockedState) GetValidatorSet(
 	return s.s.GetValidatorSet(ctx, height, subnetID)
 }
 
+func (s *lockedState) GetCurrentValidatorSet(
+	ctx context.Context,
+	subnetID ids.ID,
+) (map[ids.ID]*GetCurrentValidatorOutput, uint64, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	return s.s.GetCurrentValidatorSet(ctx, subnetID)
+}
+
 type noValidators struct {
 	State
 }
@@ -91,3 +110,8 @@ func NewNoValidatorsState(state State) State {
 func (*noValidators) GetValidatorSet(context.Context, uint64, ids.ID) (map[ids.NodeID]*GetValidatorOutput, error) {
 	return nil, nil
 }
+
+func (*noValidators) GetCurrentValidatorSet(context.Context, ids.ID) (map[ids.ID]*GetCurrentValidatorOutput, uint64, error) {
+	// TODO: should we return the actual height?
+	return nil, 0, nil
+}

snow/validators/traced_state.go

@@ -72,3 +72,15 @@ func (s *tracedState) GetValidatorSet(
 
 	return s.s.GetValidatorSet(ctx, height, subnetID)
 }
+
+func (s *tracedState) GetCurrentValidatorSet(
+	ctx context.Context,
+	subnetID ids.ID,
+) (map[ids.ID]*GetCurrentValidatorOutput, uint64, error) {
+	ctx, span := s.tracer.Start(ctx, s.getValidatorSetTag, oteltrace.WithAttributes(
+		attribute.Stringer("subnetID", subnetID),
+	))
+	defer span.End()
+
+	return s.s.GetCurrentValidatorSet(ctx, subnetID)
+}

snow/validators/validator.go

@@ -29,3 +29,13 @@ type GetValidatorOutput struct {
 	PublicKey *bls.PublicKey
 	Weight    uint64
 }
+
+type GetCurrentValidatorOutput struct {
+	ValidationID   ids.ID
+	NodeID         ids.NodeID
+	PublicKey      *bls.PublicKey
+	Weight         uint64
+	StartTime      uint64
+	SetWeightNonce uint64
+	IsActive       bool
+}

snow/validators/validatorstest/state.go

@@ -30,11 +30,13 @@ type State struct {
 	CantGetCurrentHeight,
 	CantGetSubnetID,
 	CantGetValidatorSet bool
+	CantGetCurrentValidatorSet bool
 
-	GetMinimumHeightF func(ctx context.Context) (uint64, error)
-	GetCurrentHeightF func(ctx context.Context) (uint64, error)
-	GetSubnetIDF      func(ctx context.Context, chainID ids.ID) (ids.ID, error)
-	GetValidatorSetF  func(ctx context.Context, height uint64, subnetID ids.ID) (map[ids.NodeID]*validators.GetValidatorOutput, error)
+	GetMinimumHeightF       func(ctx context.Context) (uint64, error)
+	GetCurrentHeightF       func(ctx context.Context) (uint64, error)
+	GetSubnetIDF            func(ctx context.Context, chainID ids.ID) (ids.ID, error)
+	GetValidatorSetF        func(ctx context.Context, height uint64, subnetID ids.ID) (map[ids.NodeID]*validators.GetValidatorOutput, error)
+	GetCurrentValidatorSetF func(ctx context.Context, subnetID ids.ID) (map[ids.ID]*validators.GetCurrentValidatorOutput, uint64, error)
 }
 
 func (vm *State) GetMinimumHeight(ctx context.Context) (uint64, error) {
@@ -80,3 +82,16 @@ func (vm *State) GetValidatorSet(
 	}
 	return nil, errGetValidatorSet
 }
+
+func (vm *State) GetCurrentValidatorSet(
+	ctx context.Context,
+	subnetID ids.ID,
+) (map[ids.ID]*validators.GetCurrentValidatorOutput, uint64, error) {
+	if vm.GetCurrentValidatorSetF != nil {
+		return vm.GetCurrentValidatorSetF(ctx, subnetID)
+	}
+	if vm.CantGetCurrentValidatorSet && vm.T != nil {
+		require.FailNow(vm.T, "unexpectedly called GetCurrentValidatorSet")
+	}
+	return nil, 0, nil
+}