ACP-77: Current validators API for SoV

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 validator set for the provided subnet at
+  // the current P-chain height.
+  rpc GetCurrentValidatorSet(GetCurrentValidatorSetRequest) returns (GetCurrentValidatorSetResponse);
 }
 
 message GetMinimumHeightResponse {
@@ -40,12 +43,26 @@ 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;
+  bytes public_key = 3; // Uncompressed public key, can be empty
+  uint64 start_time = 4; // can be empty
+  uint64 min_nonce = 5; // can be empty
+  bool is_active = 6; // can be empty
+  bytes validation_id = 7; // can be empty
+  bool is_sov = 8; // can be empty
 }
 
 message GetValidatorSetResponse {
   repeated Validator validators = 1;
 }
+
+message GetCurrentValidatorSetResponse {
+  repeated Validator validators = 1;
+  uint64 current_height = 2;
+}

snow/validators/gvalidators/validator_state_client.go

@@ -94,3 +94,51 @@ 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 {
+			// PublicKeyFromValidUncompressedBytes is used rather than
+			// PublicKeyFromCompressedBytes because it is significantly faster
+			// due to the avoidance of decompression and key re-verification. 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{
+			ValidationID: validationID,
+			NodeID:       nodeID,
+			PublicKey:    publicKey,
+			Weight:       validator.Weight,
+			StartTime:    validator.StartTime,
+			MinNonce:     validator.MinNonce,
+			IsActive:     validator.IsActive,
+			IsSoV:        validator.IsSov,
+		}
+	}
+	return vdrs, resp.GetCurrentHeight(), nil
+}

snow/validators/gvalidators/validator_state_server.go

@@ -80,3 +80,42 @@ 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.Validator, len(vdrs)),
+		CurrentHeight: currentHeight,
+	}
+
+	i := 0
+	for _, vdr := range vdrs {
+		vdrPB := &pb.Validator{
+			NodeId:       vdr.NodeID.Bytes(),
+			StartTime:    vdr.StartTime,
+			IsActive:     vdr.IsActive,
+			ValidationId: vdr.ValidationID[:],
+			Weight:       vdr.Weight,
+			MinNonce:     vdr.MinNonce,
+			IsSov:        vdr.IsSoV,
+		}
+		if vdr.PublicKey != nil {
+			// Passing in the uncompressed bytes is a performance optimization
+			// to avoid the cost of calling PublicKeyFromCompressedBytes on the
+			// client side.
+			vdrPB.PublicKey = bls.PublicKeyToUncompressedBytes(vdr.PublicKey)
+		}
+		resp.Validators[i] = vdrPB
+		i++
+	}
+	return resp, nil
+}

snow/validators/state.go

@@ -32,6 +32,14 @@ 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.
+	GetCurrentValidatorSet(
+		ctx context.Context,
+		subnetID ids.ID,
+	) (map[ids.ID]*GetCurrentValidatorOutput, uint64, error)
 }
 
 type lockedState struct {
@@ -78,6 +86,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 +109,8 @@ func NewNoValidatorsState(state State) State {
 func (*noValidators) GetValidatorSet(context.Context, uint64, ids.ID) (map[ids.NodeID]*GetValidatorOutput, error) {
 	return nil, nil
 }
+
+func (n *noValidators) GetCurrentValidatorSet(ctx context.Context, _ ids.ID) (map[ids.ID]*GetCurrentValidatorOutput, uint64, error) {
+	height, err := n.GetCurrentHeight(ctx)
+	return nil, height, err
+}

snow/validators/traced_state.go

@@ -17,22 +17,24 @@ import (
 var _ State = (*tracedState)(nil)
 
 type tracedState struct {
-	s                   State
-	getMinimumHeightTag string
-	getCurrentHeightTag string
-	getSubnetIDTag      string
-	getValidatorSetTag  string
-	tracer              trace.Tracer
+	s                         State
+	getMinimumHeightTag       string
+	getCurrentHeightTag       string
+	getSubnetIDTag            string
+	getValidatorSetTag        string
+	getCurrentValidatorSetTag string
+	tracer                    trace.Tracer
 }
 
 func Trace(s State, name string, tracer trace.Tracer) State {
 	return &tracedState{
-		s:                   s,
-		getMinimumHeightTag: name + ".GetMinimumHeight",
-		getCurrentHeightTag: name + ".GetCurrentHeight",
-		getSubnetIDTag:      name + ".GetSubnetID",
-		getValidatorSetTag:  name + ".GetValidatorSet",
-		tracer:              tracer,
+		s:                         s,
+		getMinimumHeightTag:       name + ".GetMinimumHeight",
+		getCurrentHeightTag:       name + ".GetCurrentHeight",
+		getSubnetIDTag:            name + ".GetSubnetID",
+		getValidatorSetTag:        name + ".GetValidatorSet",
+		getCurrentValidatorSetTag: name + ".GetCurrentValidatorSet",
+		tracer:                    tracer,
 	}
 }
 
@@ -72,3 +74,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.getCurrentValidatorSetTag, oteltrace.WithAttributes(
+		attribute.Stringer("subnetID", subnetID),
+	))
+	defer span.End()
+
+	return s.s.GetCurrentValidatorSet(ctx, subnetID)
+}

snow/validators/validator.go

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