Add GetAllValidatorsAt endpoint (#4394)

Co-authored-by: Stephen Buttolph <stephen@avalabs.org>

Author: geoff-vball

snow/validators/warp.go

@@ -5,13 +5,17 @@ package validators
 
 import (
 	"bytes"
+	"encoding/json"
 
 	"golang.org/x/exp/maps"
 
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/utils"
 	"github.com/ava-labs/avalanchego/utils/crypto/bls"
+	"github.com/ava-labs/avalanchego/utils/formatting"
 	"github.com/ava-labs/avalanchego/utils/math"
+
+	avajson "github.com/ava-labs/avalanchego/utils/json"
 )
 
 var _ utils.Sortable[*Warp] = (*Warp)(nil)
@@ -24,6 +28,28 @@ type WarpSet struct {
 	TotalWeight uint64
 }
 
+type jsonWarpSet struct {
+	Validators  []*Warp        `json:"validators"`
+	TotalWeight avajson.Uint64 `json:"totalWeight"`
+}
+
+func (w WarpSet) MarshalJSON() ([]byte, error) {
+	return json.Marshal(jsonWarpSet{
+		Validators:  w.Validators,
+		TotalWeight: avajson.Uint64(w.TotalWeight),
+	})
+}
+
+func (w *WarpSet) UnmarshalJSON(b []byte) error {
+	var j jsonWarpSet
+	if err := json.Unmarshal(b, &j); err != nil {
+		return err
+	}
+	w.TotalWeight = uint64(j.TotalWeight)
+	w.Validators = j.Validators
+	return nil
+}
+
 type Warp struct {
 	PublicKey *bls.PublicKey
 	// PublicKeyBytes is expected to be in the uncompressed form.
@@ -36,6 +62,48 @@ func (w *Warp) Compare(o *Warp) int {
 	return bytes.Compare(w.PublicKeyBytes, o.PublicKeyBytes)
 }
 
+type jsonWarp struct {
+	PublicKey string         `json:"publicKey"`
+	Weight    avajson.Uint64 `json:"weight"`
+	NodeIDs   []ids.NodeID   `json:"nodeIDs"`
+}
+
+func (w Warp) MarshalJSON() ([]byte, error) {
+	pkBytes := bls.PublicKeyToCompressedBytes(w.PublicKey)
+	pk, err := formatting.Encode(formatting.HexNC, pkBytes)
+	if err != nil {
+		return nil, err
+	}
+	return json.Marshal(jsonWarp{
+		PublicKey: pk,
+		Weight:    avajson.Uint64(w.Weight),
+		NodeIDs:   w.NodeIDs,
+	})
+}
+
+func (w *Warp) UnmarshalJSON(b []byte) error {
+	var j jsonWarp
+	if err := json.Unmarshal(b, &j); err != nil {
+		return err
+	}
+
+	pkBytes, err := formatting.Decode(formatting.HexNC, j.PublicKey)
+	if err != nil {
+		return err
+	}
+	pk, err := bls.PublicKeyFromCompressedBytes(pkBytes)
+	if err != nil {
+		return err
+	}
+	*w = Warp{
+		PublicKey:      pk,
+		PublicKeyBytes: bls.PublicKeyToUncompressedBytes(pk),
+		Weight:         uint64(j.Weight),
+		NodeIDs:        j.NodeIDs,
+	}
+	return nil
+}
+
 // FlattenValidatorSet converts the provided vdrSet into a canonical ordering.
 func FlattenValidatorSet(vdrSet map[ids.NodeID]*GetValidatorOutput) (WarpSet, error) {
 	var (

snow/validators/warp_test.go

@@ -4,6 +4,8 @@
 package validators_test
 
 import (
+	"encoding/hex"
+	"encoding/json"
 	"math"
 	"strconv"
 	"testing"
@@ -12,13 +14,92 @@ import (
 
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/snow/validators/validatorstest"
+	"github.com/ava-labs/avalanchego/utils/crypto/bls"
 	"github.com/ava-labs/avalanchego/utils/crypto/bls/signer/localsigner"
 
 	safemath "github.com/ava-labs/avalanchego/utils/math"
 
 	. "github.com/ava-labs/avalanchego/snow/validators"
 )
 
+func TestWarpJSON(t *testing.T) {
+	const pkStr = "88c4760201a451619475ff7d3782d02381826bad5bef306d1ff6b22d3fb2e137bc004d867054efc241463fe4b21c61af"
+	pkBytes, err := hex.DecodeString(pkStr)
+	require.NoError(t, err)
+	pk, err := bls.PublicKeyFromCompressedBytes(pkBytes)
+	require.NoError(t, err)
+
+	w := Warp{
+		PublicKey:      pk,
+		PublicKeyBytes: bls.PublicKeyToUncompressedBytes(pk),
+		Weight:         12345,
+		NodeIDs: []ids.NodeID{
+			{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07},
+			{0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f},
+		},
+	}
+	wJSON, err := json.MarshalIndent(w, "", "\t")
+	require.NoError(t, err)
+
+	const expectedJSON = `{
+	"publicKey": "0x88c4760201a451619475ff7d3782d02381826bad5bef306d1ff6b22d3fb2e137bc004d867054efc241463fe4b21c61af",
+	"weight": "12345",
+	"nodeIDs": [
+		"NodeID-12D2adLM3UJyWgFWD2VXv5vkMT8MoMbg",
+		"NodeID-jVEbJZmHxdPnxBthD7v8dC96qyUrPMxg"
+	]
+}`
+	require.JSONEq(t, expectedJSON, string(wJSON))
+
+	var parsedW Warp
+	require.NoError(t, json.Unmarshal(wJSON, &parsedW))
+	require.Equal(t, w, parsedW)
+}
+
+func TestWarpSetJSON(t *testing.T) {
+	const pkStr = "88c4760201a451619475ff7d3782d02381826bad5bef306d1ff6b22d3fb2e137bc004d867054efc241463fe4b21c61af"
+	pkBytes, err := hex.DecodeString(pkStr)
+	require.NoError(t, err)
+	pk, err := bls.PublicKeyFromCompressedBytes(pkBytes)
+	require.NoError(t, err)
+
+	ws := WarpSet{
+		Validators: []*Warp{
+			{
+				PublicKey:      pk,
+				PublicKeyBytes: bls.PublicKeyToUncompressedBytes(pk),
+				Weight:         12345,
+				NodeIDs: []ids.NodeID{
+					{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07},
+					{0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f},
+				},
+			},
+		},
+		TotalWeight: 54321,
+	}
+	wsJSON, err := json.MarshalIndent(ws, "", "\t")
+	require.NoError(t, err)
+
+	const expectedJSON = `{
+	"validators": [
+		{
+			"publicKey": "0x88c4760201a451619475ff7d3782d02381826bad5bef306d1ff6b22d3fb2e137bc004d867054efc241463fe4b21c61af",
+			"weight": "12345",
+			"nodeIDs": [
+				"NodeID-12D2adLM3UJyWgFWD2VXv5vkMT8MoMbg",
+				"NodeID-jVEbJZmHxdPnxBthD7v8dC96qyUrPMxg"
+			]
+		}
+	],
+	"totalWeight": "54321"
+}`
+	require.JSONEq(t, expectedJSON, string(wsJSON))
+
+	var parsedWS WarpSet
+	require.NoError(t, json.Unmarshal(wsJSON, &parsedWS))
+	require.Equal(t, ws, parsedWS)
+}
+
 func TestFlattenValidatorSet(t *testing.T) {
 	var (
 		vdrs    = validatorstest.NewWarpSet(t, 3)

tests/e2e/p/l1.go

@@ -155,6 +155,20 @@ var _ = e2e.DescribePChain("[L1]", func() {
 			subnetValidators, err := pClient.GetValidatorsAt(tc.DefaultContext(), subnetID, platformapi.Height(height))
 			require.NoError(err)
 			require.Equal(expectedValidators, subnetValidators)
+
+			// Test GetAllValidatorsAt too, for coverage
+			flattenedExpectedValidators, err := snowvalidators.FlattenValidatorSet(expectedValidators) // for coverage
+			require.NoError(err)
+
+			// require.Equal will complain if one has a nil slice and the other
+			// has an empty slice. This avoids that issue.
+			if len(flattenedExpectedValidators.Validators) == 0 {
+				flattenedExpectedValidators.Validators = nil
+			}
+
+			allValidators, err := pClient.GetAllValidatorsAt(tc.DefaultContext(), platformapi.Height(height))
+			require.NoError(err)
+			require.Equal(flattenedExpectedValidators, allValidators[subnetID])
 		}
 		tc.By("verifying the Permissioned Subnet is configured as expected", func() {
 			tc.By("verifying the subnet reports as permissioned", func() {

vms/platformvm/client.go

@@ -491,6 +491,21 @@ func (c *Client) GetTimestamp(ctx context.Context, options ...rpc.Option) (time.
 	return res.Timestamp, err
 }
 
+// GetAllValidatorsAt returns the canonical validator sets of
+// all chains with at least one active validator at the specified
+// height or at proposerVM height if set to [platformapi.ProposedHeight].
+func (c *Client) GetAllValidatorsAt(
+	ctx context.Context,
+	height platformapi.Height,
+	options ...rpc.Option,
+) (map[ids.ID]validators.WarpSet, error) {
+	res := &GetAllValidatorsAtReply{}
+	err := c.Requester.SendRequest(ctx, "platform.getAllValidatorsAt", &GetAllValidatorsAtArgs{
+		Height: height,
+	}, res, options...)
+	return res.ValidatorSets, err
+}
+
 // GetValidatorsAt returns the weights of the validator set of a provided subnet
 // at the specified height or at proposerVM height if set to
 // [platformapi.ProposedHeight].

vms/platformvm/service.go

@@ -1782,6 +1782,57 @@ func (s *Service) GetTimestamp(_ *http.Request, _ *struct{}, reply *GetTimestamp
 	return nil
 }
 
+// GetAllValidatorsAtArgs are the arguments for GetAllValidatorsAt
+type GetAllValidatorsAtArgs struct {
+	Height platformapi.Height `json:"height"`
+}
+
+// GetAllValidatorsAtReply is the response from GetAllValidatorsAt
+type GetAllValidatorsAtReply struct {
+	ValidatorSets map[ids.ID]validators.WarpSet `json:"validatorSets"`
+}
+
+// GetAllValidatorsAt returns the canonical validator sets of
+// all chains with at least one active validator at the specified
+// height or at proposerVM height if set to [platformapi.ProposedHeight].
+func (s *Service) GetAllValidatorsAt(r *http.Request, args *GetAllValidatorsAtArgs, reply *GetAllValidatorsAtReply) error {
+	s.vm.ctx.Log.Debug("API called",
+		zap.String("service", "platform"),
+		zap.String("method", "getAllValidatorsAt"),
+		zap.Uint64("height", uint64(args.Height)),
+		zap.Bool("isProposed", args.Height.IsProposed()),
+	)
+
+	s.vm.ctx.Lock.Lock()
+	defer s.vm.ctx.Lock.Unlock()
+
+	ctx := r.Context()
+	height, err := s.getQueryHeight(ctx, args.Height)
+	if err != nil {
+		return err
+	}
+
+	reply.ValidatorSets, err = s.vm.GetWarpValidatorSets(ctx, height)
+	if err != nil {
+		return fmt.Errorf("failed to get validator sets at %d: %w", height, err)
+	}
+	return nil
+}
+
+// If args.Height is the sentinel value for proposed height, gets the proposed height and return it,
+// else returns the input height.
+func (s *Service) getQueryHeight(ctx context.Context, heightArg platformapi.Height) (uint64, error) {
+	if !heightArg.IsProposed() {
+		return uint64(heightArg), nil
+	}
+
+	height, err := s.vm.GetMinimumHeight(ctx)
+	if err != nil {
+		return 0, fmt.Errorf("failed to get proposed height: %w", err)
+	}
+	return height, nil
+}
+
 // GetValidatorsAtArgs is the response from GetValidatorsAt
 type GetValidatorsAtArgs struct {
 	Height   platformapi.Height `json:"height"`
@@ -1867,18 +1918,14 @@ func (s *Service) GetValidatorsAt(r *http.Request, args *GetValidatorsAtArgs, re
 	defer s.vm.ctx.Lock.Unlock()
 
 	ctx := r.Context()
-	var err error
-	height := uint64(args.Height)
-	if args.Height.IsProposed() {
-		height, err = s.vm.GetMinimumHeight(ctx)
-		if err != nil {
-			return fmt.Errorf("failed to get proposed height: %w", err)
-		}
+	height, err := s.getQueryHeight(ctx, args.Height)
+	if err != nil {
+		return err
 	}
 
 	reply.Validators, err = s.vm.GetValidatorSet(ctx, height, args.SubnetID)
 	if err != nil {
-		return fmt.Errorf("failed to get validator set: %w", err)
+		return fmt.Errorf("failed to get validator set at %d: %w", height, err)
 	}
 	return nil
 }