Add platform.getSubnetOnlyValidator API (#3540)

Author: StephenButtolph

RELEASES.md

@@ -2,6 +2,10 @@
 
 ## Pending Release
 
+### APIs
+
+- Added `platform.getSubnetOnlyValidator`
+
 ### Configs
 
 - Added P-chain configs

tests/e2e/p/l1.go

@@ -224,6 +224,7 @@ var _ = e2e.DescribePChain("[L1]", func() {
 			)
 			require.NoError(err)
 		})
+		genesisValidationID := subnetID.Append(0)
 
 		tc.By("verifying the Permissioned Subnet was converted to an L1", func() {
 			expectedConversionID, err := warpmessage.SubnetConversionID(warpmessage.SubnetConversionData{
@@ -267,6 +268,31 @@ var _ = e2e.DescribePChain("[L1]", func() {
 					},
 				})
 			})
+
+			tc.By("verifying the SoV can be fetched", func() {
+				sov, _, err := pClient.GetSubnetOnlyValidator(tc.DefaultContext(), genesisValidationID)
+				require.NoError(err)
+				require.LessOrEqual(sov.Balance, genesisBalance)
+
+				sov.StartTime = 0
+				sov.Balance = 0
+				require.Equal(
+					platformvm.SubnetOnlyValidator{
+						SubnetID:  subnetID,
+						NodeID:    subnetGenesisNode.NodeID,
+						PublicKey: genesisNodePK,
+						RemainingBalanceOwner: &secp256k1fx.OutputOwners{
+							Addrs: []ids.ShortID{},
+						},
+						DeactivationOwner: &secp256k1fx.OutputOwners{
+							Addrs: []ids.ShortID{},
+						},
+						Weight:   genesisWeight,
+						MinNonce: 0,
+					},
+					sov,
+				)
+			})
 		})
 
 		advanceProposerVMPChainHeight := func() {
@@ -284,6 +310,9 @@ var _ = e2e.DescribePChain("[L1]", func() {
 		registerNodePoP, err := subnetRegisterNode.GetProofOfPossession()
 		require.NoError(err)
 
+		registerNodePK, err := bls.PublicKeyFromCompressedBytes(registerNodePoP.PublicKey[:])
+		require.NoError(err)
+
 		tc.By("ensuring the subnet nodes are healthy", func() {
 			e2e.WaitForHealthy(tc, subnetGenesisNode)
 			e2e.WaitForHealthy(tc, subnetRegisterNode)
@@ -365,6 +394,30 @@ var _ = e2e.DescribePChain("[L1]", func() {
 					},
 				})
 			})
+
+			tc.By("verifying the SoV can be fetched", func() {
+				sov, _, err := pClient.GetSubnetOnlyValidator(tc.DefaultContext(), registerValidationID)
+				require.NoError(err)
+
+				sov.StartTime = 0
+				require.Equal(
+					platformvm.SubnetOnlyValidator{
+						SubnetID:  subnetID,
+						NodeID:    subnetRegisterNode.NodeID,
+						PublicKey: registerNodePK,
+						RemainingBalanceOwner: &secp256k1fx.OutputOwners{
+							Addrs: []ids.ShortID{},
+						},
+						DeactivationOwner: &secp256k1fx.OutputOwners{
+							Addrs: []ids.ShortID{},
+						},
+						Weight:   registerWeight,
+						MinNonce: 0,
+						Balance:  0,
+					},
+					sov,
+				)
+			})
 		})
 
 		var nextNonce uint64
@@ -438,6 +491,30 @@ var _ = e2e.DescribePChain("[L1]", func() {
 					},
 				})
 			})
+
+			tc.By("verifying the SoV can be fetched", func() {
+				sov, _, err := pClient.GetSubnetOnlyValidator(tc.DefaultContext(), registerValidationID)
+				require.NoError(err)
+
+				sov.StartTime = 0
+				require.Equal(
+					platformvm.SubnetOnlyValidator{
+						SubnetID:  subnetID,
+						NodeID:    subnetRegisterNode.NodeID,
+						PublicKey: registerNodePK,
+						RemainingBalanceOwner: &secp256k1fx.OutputOwners{
+							Addrs: []ids.ShortID{},
+						},
+						DeactivationOwner: &secp256k1fx.OutputOwners{
+							Addrs: []ids.ShortID{},
+						},
+						Weight:   updatedWeight,
+						MinNonce: nextNonce,
+						Balance:  0,
+					},
+					sov,
+				)
+			})
 		})
 
 		tc.By("advancing the proposervm P-chain height", advanceProposerVMPChainHeight)

vms/platformvm/client.go

@@ -11,6 +11,7 @@ import (
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/snow/validators"
 	"github.com/ava-labs/avalanchego/utils/constants"
+	"github.com/ava-labs/avalanchego/utils/crypto/bls"
 	"github.com/ava-labs/avalanchego/utils/crypto/secp256k1"
 	"github.com/ava-labs/avalanchego/utils/formatting"
 	"github.com/ava-labs/avalanchego/utils/formatting/address"
@@ -71,6 +72,9 @@ type Client interface {
 	GetStakingAssetID(ctx context.Context, subnetID ids.ID, options ...rpc.Option) (ids.ID, error)
 	// GetCurrentValidators returns the list of current validators for subnet with ID [subnetID]
 	GetCurrentValidators(ctx context.Context, subnetID ids.ID, nodeIDs []ids.NodeID, options ...rpc.Option) ([]ClientPermissionlessValidator, error)
+	// GetSubnetOnlyValidator returns the requested SoV with [validationID] and
+	// the height at which it was calculated.
+	GetSubnetOnlyValidator(ctx context.Context, validationID ids.ID, options ...rpc.Option) (SubnetOnlyValidator, uint64, error)
 	// GetCurrentSupply returns an upper bound on the supply of AVAX in the system along with the P-chain height
 	GetCurrentSupply(ctx context.Context, subnetID ids.ID, options ...rpc.Option) (uint64, uint64, error)
 	// SampleValidators returns the nodeIDs of a sample of [sampleSize] validators from the current validator set for subnet with ID [subnetID]
@@ -326,6 +330,72 @@ func (c *client) GetCurrentValidators(
 	return getClientPermissionlessValidators(res.Validators)
 }
 
+// SubnetOnlyValidator is the response from calling GetSubnetOnlyValidator on
+// the API client.
+type SubnetOnlyValidator struct {
+	SubnetID              ids.ID
+	NodeID                ids.NodeID
+	PublicKey             *bls.PublicKey
+	RemainingBalanceOwner *secp256k1fx.OutputOwners
+	DeactivationOwner     *secp256k1fx.OutputOwners
+	StartTime             uint64
+	Weight                uint64
+	MinNonce              uint64
+	// Balance is the remaining amount of AVAX this SoV has for paying the
+	// continuous fee.
+	Balance uint64
+}
+
+func (c *client) GetSubnetOnlyValidator(
+	ctx context.Context,
+	validationID ids.ID,
+	options ...rpc.Option,
+) (SubnetOnlyValidator, uint64, error) {
+	res := &GetSubnetOnlyValidatorReply{}
+	err := c.requester.SendRequest(ctx, "platform.getSubnetOnlyValidator",
+		&GetSubnetOnlyValidatorArgs{
+			ValidationID: validationID,
+		},
+		res, options...,
+	)
+	if err != nil {
+		return SubnetOnlyValidator{}, 0, err
+	}
+
+	pk, err := bls.PublicKeyFromCompressedBytes(res.PublicKey)
+	if err != nil {
+		return SubnetOnlyValidator{}, 0, err
+	}
+	remainingBalanceOwnerAddrs, err := address.ParseToIDs(res.RemainingBalanceOwner.Addresses)
+	if err != nil {
+		return SubnetOnlyValidator{}, 0, err
+	}
+	deactivationOwnerAddrs, err := address.ParseToIDs(res.DeactivationOwner.Addresses)
+	if err != nil {
+		return SubnetOnlyValidator{}, 0, err
+	}
+
+	return SubnetOnlyValidator{
+		SubnetID:  res.SubnetID,
+		NodeID:    res.NodeID,
+		PublicKey: pk,
+		RemainingBalanceOwner: &secp256k1fx.OutputOwners{
+			Locktime:  uint64(res.RemainingBalanceOwner.Locktime),
+			Threshold: uint32(res.RemainingBalanceOwner.Threshold),
+			Addrs:     remainingBalanceOwnerAddrs,
+		},
+		DeactivationOwner: &secp256k1fx.OutputOwners{
+			Locktime:  uint64(res.DeactivationOwner.Locktime),
+			Threshold: uint32(res.DeactivationOwner.Threshold),
+			Addrs:     deactivationOwnerAddrs,
+		},
+		StartTime: uint64(res.StartTime),
+		Weight:    uint64(res.Weight),
+		MinNonce:  uint64(res.MinNonce),
+		Balance:   uint64(res.Balance),
+	}, uint64(res.Height), err
+}
+
 func (c *client) GetCurrentSupply(ctx context.Context, subnetID ids.ID, options ...rpc.Option) (uint64, uint64, error) {
 	res := &GetCurrentSupplyReply{}
 	err := c.requester.SendRequest(ctx, "platform.getCurrentSupply", &GetCurrentSupplyArgs{

vms/platformvm/service.go

@@ -37,6 +37,7 @@ import (
 	"github.com/ava-labs/avalanchego/vms/platformvm/state"
 	"github.com/ava-labs/avalanchego/vms/platformvm/status"
 	"github.com/ava-labs/avalanchego/vms/platformvm/txs"
+	"github.com/ava-labs/avalanchego/vms/platformvm/warp/message"
 	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
 	"github.com/ava-labs/avalanchego/vms/types"
 
@@ -969,6 +970,93 @@ func (s *Service) GetCurrentValidators(_ *http.Request, args *GetCurrentValidato
 	return nil
 }
 
+type GetSubnetOnlyValidatorArgs struct {
+	ValidationID ids.ID `json:"validationID"`
+}
+
+type GetSubnetOnlyValidatorReply struct {
+	SubnetID ids.ID     `json:"subnetID"`
+	NodeID   ids.NodeID `json:"nodeID"`
+	// PublicKey is the compressed BLS public key of the validator
+	PublicKey             types.JSONByteSlice `json:"publicKey"`
+	RemainingBalanceOwner platformapi.Owner   `json:"remainingBalanceOwner"`
+	DeactivationOwner     platformapi.Owner   `json:"deactivationOwner"`
+	StartTime             avajson.Uint64      `json:"startTime"`
+	Weight                avajson.Uint64      `json:"weight"`
+	MinNonce              avajson.Uint64      `json:"minNonce"`
+	// Balance is the remaining amount of AVAX this SoV has for paying the
+	// continuous fee, according to the last accepted state. If the validator is
+	// inactive, the balance will be 0.
+	Balance avajson.Uint64 `json:"balance"`
+	// Height is the height of the last accepted block
+	Height avajson.Uint64 `json:"height"`
+}
+
+// GetSubnetOnlyValidator returns the SoV if it exists
+func (s *Service) GetSubnetOnlyValidator(r *http.Request, args *GetSubnetOnlyValidatorArgs, reply *GetSubnetOnlyValidatorReply) error {
+	s.vm.ctx.Log.Debug("API called",
+		zap.String("service", "platform"),
+		zap.String("method", "getSubnetOnlyValidator"),
+		zap.Stringer("validationID", args.ValidationID),
+	)
+
+	s.vm.ctx.Lock.Lock()
+	defer s.vm.ctx.Lock.Unlock()
+
+	sov, err := s.vm.state.GetSubnetOnlyValidator(args.ValidationID)
+	if err != nil {
+		return fmt.Errorf("fetching SoV %q failed: %w", args.ValidationID, err)
+	}
+
+	var remainingBalanceOwner message.PChainOwner
+	if _, err := txs.Codec.Unmarshal(sov.RemainingBalanceOwner, &remainingBalanceOwner); err != nil {
+		return fmt.Errorf("failed unmarshalling remaining balance owner: %w", err)
+	}
+	remainingBalanceAPIOwner, err := s.getAPIOwner(&secp256k1fx.OutputOwners{
+		Threshold: remainingBalanceOwner.Threshold,
+		Addrs:     remainingBalanceOwner.Addresses,
+	})
+	if err != nil {
+		return fmt.Errorf("failed formatting remaining balance owner: %w", err)
+	}
+
+	var deactivationOwner message.PChainOwner
+	if _, err := txs.Codec.Unmarshal(sov.DeactivationOwner, &deactivationOwner); err != nil {
+		return fmt.Errorf("failed unmarshalling deactivation owner: %w", err)
+	}
+	deactivationAPIOwner, err := s.getAPIOwner(&secp256k1fx.OutputOwners{
+		Threshold: deactivationOwner.Threshold,
+		Addrs:     deactivationOwner.Addresses,
+	})
+	if err != nil {
+		return fmt.Errorf("failed formatting deactivation owner: %w", err)
+	}
+
+	ctx := r.Context()
+	height, err := s.vm.GetCurrentHeight(ctx)
+	if err != nil {
+		return fmt.Errorf("failed getting current height: %w", err)
+	}
+
+	reply.SubnetID = sov.SubnetID
+	reply.NodeID = sov.NodeID
+	reply.PublicKey = bls.PublicKeyToCompressedBytes(
+		bls.PublicKeyFromValidUncompressedBytes(sov.PublicKey),
+	)
+	reply.RemainingBalanceOwner = *remainingBalanceAPIOwner
+	reply.DeactivationOwner = *deactivationAPIOwner
+	reply.StartTime = avajson.Uint64(sov.StartTime)
+	reply.Weight = avajson.Uint64(sov.Weight)
+	reply.MinNonce = avajson.Uint64(sov.MinNonce)
+	if sov.EndAccumulatedFee != 0 {
+		accruedFees := s.vm.state.GetAccruedFees()
+		reply.Balance = avajson.Uint64(sov.EndAccumulatedFee - accruedFees)
+	}
+	reply.Height = avajson.Uint64(height)
+
+	return nil
+}
+
 // GetCurrentSupplyArgs are the arguments for calling GetCurrentSupply
 type GetCurrentSupplyArgs struct {
 	SubnetID ids.ID `json:"subnetID"`