add delegate's Name in 'ioctl node delegate' output 2169 (iotexproject#2174)

* add delegate's Name in 'ioctl node delegate' output 2169

Author: coderbradlee

ioctl/cmd/node/nodedelegate.go

@@ -13,12 +13,15 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/golang/protobuf/proto"
 	"github.com/grpc-ecosystem/go-grpc-middleware/util/metautils"
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 
 	"github.com/iotexproject/iotex-proto/golang/iotexapi"
+	"github.com/iotexproject/iotex-proto/golang/iotextypes"
 
 	"github.com/iotexproject/iotex-core/action/protocol/vote"
 	"github.com/iotexproject/iotex-core/ioctl/cmd/alias"
@@ -29,6 +32,11 @@ import (
 	"github.com/iotexproject/iotex-core/state"
 )
 
+const (
+	protocolID          = "staking"
+	readCandidatesLimit = 20000
+)
+
 // Multi-language support
 var (
 	delegateCmdUses = map[config.Language]string{
@@ -63,19 +71,15 @@ var nodeDelegateCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(0),
 	RunE: func(cmd *cobra.Command, args []string) error {
 		cmd.SilenceUsage = true
-		var err error
-		if nextEpoch {
-			err = nextDelegates()
-		} else {
-			err = delegates()
-		}
+		err := delegates()
 		return output.PrintError(err)
 
 	},
 }
 
 type delegate struct {
 	Address        string `json:"address"`
+	Name           string `json:"string"`
 	Rank           int    `json:"rank"`
 	Alias          string `json:"alias"`
 	Active         bool   `json:"active"`
@@ -101,43 +105,12 @@ func (m *delegatesMessage) String() string {
 		}
 		lines := []string{fmt.Sprintf("Epoch: %d,  Start block height: %d,Total blocks produced in epoch: %d\n",
 			m.Epoch, m.StartBlock, m.TotalBlocks)}
-		formatTitleString := "%-41s   %-4s   %-" + strconv.Itoa(aliasLen) + "s   %-6s   %-6s   %-12s    %s"
-		formatDataString := "%-41s   %4d   %-" + strconv.Itoa(aliasLen) + "s   %-6s   %-6d   %-12s    %s"
+		formatTitleString := "%-41s   %-12s   %-4s   %-" + strconv.Itoa(aliasLen) + "s   %-6s   %-6s   %-12s    %s"
+		formatDataString := "%-41s   %-12s   %4d   %-" + strconv.Itoa(aliasLen) + "s   %-6s   %-6d   %-12s    %s"
 		lines = append(lines, fmt.Sprintf(formatTitleString,
-			"Address", "Rank", "Alias", "Status", "Blocks", "ProbatedStatus", "Votes"))
-		for _, bp := range m.Delegates {
-			lines = append(lines, fmt.Sprintf(formatDataString, bp.Address, bp.Rank,
-				bp.Alias, nodeStatus[bp.Active], bp.Production, probatedStatus[bp.ProbatedStatus], bp.Votes))
-		}
-		return strings.Join(lines, "\n")
-	}
-	return output.FormatString(output.Result, m)
-}
-
-type nextDelegatesMessage struct {
-	Epoch      int        `json:"epoch"`
-	Determined bool       `json:"determined"`
-	Delegates  []delegate `json:"delegates"`
-}
-
-func (m *nextDelegatesMessage) String() string {
-	if output.Format == "" {
-		if !m.Determined {
-			return fmt.Sprintf("delegates of upcoming epoch #%d are not determined", epochNum)
-		}
-		aliasLen := 5
-		for _, bp := range m.Delegates {
-			if len(bp.Alias) > aliasLen {
-				aliasLen = len(bp.Alias)
-			}
-		}
-		lines := []string{fmt.Sprintf("Epoch: %d\n", epochNum)}
-		formatTitleString := "%-41s   %-4s   %-" + strconv.Itoa(aliasLen) + "s   %-6s   %s"
-		formatDataString := "%-41s   %4d   %-" + strconv.Itoa(aliasLen) + "s   %-6s   %s"
-		lines = append(lines, fmt.Sprintf(formatTitleString, "Address", "Rank", "Alias", "Status", "Votes"))
+			"Address", "Name", "Rank", "Alias", "Status", "Blocks", "ProbatedStatus", "Votes"))
 		for _, bp := range m.Delegates {
-			lines = append(lines, fmt.Sprintf(formatDataString, bp.Address, bp.Rank,
-				bp.Alias, nodeStatus[bp.Active], bp.Votes))
+			lines = append(lines, fmt.Sprintf(formatDataString, bp.Address, bp.Name, bp.Rank, bp.Alias, nodeStatus[bp.Active], bp.Production, probatedStatus[bp.ProbatedStatus], bp.Votes))
 		}
 		return strings.Join(lines, "\n")
 	}
@@ -172,16 +145,12 @@ func delegates() error {
 		StartBlock:  int(epochData.Height),
 		TotalBlocks: int(response.TotalBlocks),
 	}
-
-	probationListRes, err := bc.GetProbationList(epochNum)
+	probationList, err := getProbationList(epochNum)
 	if err != nil {
 		return output.NewError(0, "failed to get probation list", err)
 	}
-	probationList := &vote.ProbationList{}
-	if probationListRes != nil {
-		if err := probationList.Deserialize(probationListRes.Data); err != nil {
-			return output.NewError(output.SerializationError, "failed to deserialize probation list", err)
-		}
+	if epochData.Height >= config.ReadConfig.FairBankHeight {
+		return delegatesV2(probationList, response, &message)
 	}
 	for rank, bp := range response.BlockProducersInfo {
 		votes, ok := big.NewInt(0).SetString(bp.Votes, 10)
@@ -208,14 +177,12 @@ func delegates() error {
 	return nil
 }
 
-// deprecated: It won't be able to query next delegate after Easter height, because it will be determined at the end of the epoch.
-func nextDelegates() error {
+func delegatesV2(pb *vote.ProbationList, epochMeta *iotexapi.GetEpochMetaResponse, message *delegatesMessage) error {
 	chainMeta, err := bc.GetChainMeta()
 	if err != nil {
 		return output.NewError(0, "failed to get chain meta", err)
 	}
-	epochNum = chainMeta.Epoch.Num + 1
-	message := nextDelegatesMessage{Epoch: int(epochNum)}
+	epochNum = chainMeta.Epoch.Num
 	conn, err := util.ConnectToEndpoint(config.ReadConfig.SecureConnect && !config.Insecure)
 	if err != nil {
 		return output.NewError(output.NetworkError, "failed to connect to endpoint", err)
@@ -239,15 +206,13 @@ func nextDelegates() error {
 	if err != nil {
 		sta, ok := status.FromError(err)
 		if ok && sta.Code() == codes.NotFound {
-			message.Determined = false
 			fmt.Println(message.String())
 			return nil
 		} else if ok {
 			return output.NewError(output.APIError, sta.Message(), nil)
 		}
 		return output.NewError(output.NetworkError, "failed to invoke ReadState api", err)
 	}
-	message.Determined = true
 	var ABPs state.CandidateList
 	if err := ABPs.Deserialize(abpResponse.Data); err != nil {
 		return output.NewError(output.SerializationError, "failed to deserialize active BPs", err)
@@ -273,17 +238,141 @@ func nextDelegates() error {
 	for _, abp := range ABPs {
 		isActive[abp.Address] = true
 	}
+	production := make(map[string]int)
+	for _, info := range epochMeta.BlockProducersInfo {
+		production[info.Address] = int(info.Production)
+	}
 	aliases := alias.GetAliasMap()
 	for rank, bp := range BPs {
+		isProbated := false
+		if _, ok := pb.ProbationInfo[bp.Address]; ok {
+			isProbated = true
+		}
 		votes := big.NewInt(0).SetBytes(bp.Votes.Bytes())
 		message.Delegates = append(message.Delegates, delegate{
-			Address: bp.Address,
-			Rank:    rank + 1,
-			Alias:   aliases[bp.Address],
-			Active:  isActive[bp.Address],
-			Votes:   util.RauToString(votes, util.IotxDecimalNum),
+			Address:        bp.Address,
+			Rank:           rank + 1,
+			Alias:          aliases[bp.Address],
+			Active:         isActive[bp.Address],
+			Production:     production[bp.Address],
+			Votes:          util.RauToString(votes, util.IotxDecimalNum),
+			ProbatedStatus: isProbated,
 		})
 	}
+	fillMessage(cli, message, aliases, isActive, pb)
 	fmt.Println(message.String())
 	return nil
 }
+
+func getProbationList(epochNum uint64) (*vote.ProbationList, error) {
+	probationListRes, err := bc.GetProbationList(epochNum)
+	if err != nil {
+		return nil, err
+	}
+	probationList := &vote.ProbationList{}
+	if probationListRes != nil {
+		if err := probationList.Deserialize(probationListRes.Data); err != nil {
+			return nil, err
+		}
+	}
+	return probationList, nil
+}
+
+func fillMessage(cli iotexapi.APIServiceClient, message *delegatesMessage, alias map[string]string, active map[string]bool, pb *vote.ProbationList) error {
+	cl, err := getAllStakingCandidates(cli)
+	if err != nil {
+		return err
+	}
+	addressMap := make(map[string]*iotextypes.CandidateV2)
+	for _, candidate := range cl.Candidates {
+		addressMap[candidate.OperatorAddress] = candidate
+	}
+	delegateAddressMap := make(map[string]struct{})
+	for _, m := range message.Delegates {
+		delegateAddressMap[m.Address] = struct{}{}
+	}
+	for i, m := range message.Delegates {
+		if c, ok := addressMap[m.Address]; ok {
+			message.Delegates[i].Name = c.Name
+			continue
+		}
+	}
+	rank := len(message.Delegates) + 1
+	for _, candidate := range cl.Candidates {
+		if _, ok := delegateAddressMap[candidate.OperatorAddress]; ok {
+			continue
+		}
+		isProbated := false
+		if _, ok := pb.ProbationInfo[candidate.OwnerAddress]; ok {
+			isProbated = true
+		}
+		iotx, err := util.StringToIOTX(candidate.TotalWeightedVotes)
+		if err != nil {
+			return err
+		}
+		message.Delegates = append(message.Delegates, delegate{
+			Address:        candidate.OperatorAddress,
+			Name:           candidate.Name,
+			Rank:           rank,
+			Alias:          alias[candidate.OperatorAddress],
+			Active:         active[candidate.OperatorAddress],
+			Votes:          iotx,
+			ProbatedStatus: isProbated,
+		})
+		rank++
+	}
+	return nil
+}
+
+func getAllStakingCandidates(chainClient iotexapi.APIServiceClient) (candidateListAll *iotextypes.CandidateListV2, err error) {
+	candidateListAll = &iotextypes.CandidateListV2{}
+	for i := uint32(0); ; i++ {
+		offset := i * readCandidatesLimit
+		size := uint32(readCandidatesLimit)
+		candidateList, err := getStakingCandidates(chainClient, offset, size)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to get candidates")
+		}
+		candidateListAll.Candidates = append(candidateListAll.Candidates, candidateList.Candidates...)
+		if len(candidateList.Candidates) < readCandidatesLimit {
+			break
+		}
+	}
+	return
+}
+
+func getStakingCandidates(chainClient iotexapi.APIServiceClient, offset, limit uint32) (candidateList *iotextypes.CandidateListV2, err error) {
+	methodName, err := proto.Marshal(&iotexapi.ReadStakingDataMethod{
+		Method: iotexapi.ReadStakingDataMethod_CANDIDATES,
+	})
+	if err != nil {
+		return nil, err
+	}
+	arg, err := proto.Marshal(&iotexapi.ReadStakingDataRequest{
+		Request: &iotexapi.ReadStakingDataRequest_Candidates_{
+			Candidates: &iotexapi.ReadStakingDataRequest_Candidates{
+				Pagination: &iotexapi.PaginationParam{
+					Offset: offset,
+					Limit:  limit,
+				},
+			},
+		},
+	})
+	if err != nil {
+		return nil, err
+	}
+	readStateRequest := &iotexapi.ReadStateRequest{
+		ProtocolID: []byte(protocolID),
+		MethodName: methodName,
+		Arguments:  [][]byte{arg},
+	}
+	readStateRes, err := chainClient.ReadState(context.Background(), readStateRequest)
+	if err != nil {
+		return
+	}
+	candidateList = &iotextypes.CandidateListV2{}
+	if err := proto.Unmarshal(readStateRes.GetData(), candidateList); err != nil {
+		return nil, errors.Wrap(err, "failed to unmarshal VoteBucketList")
+	}
+	return
+}

ioctl/config/config.go

@@ -13,7 +13,8 @@ import (
 
 	"github.com/spf13/cobra"
 	"gopkg.in/yaml.v2"
-
+	
+	"github.com/iotexproject/iotex-core/config"
 	"github.com/iotexproject/iotex-core/ioctl/output"
 	"github.com/iotexproject/iotex-core/pkg/log"
 )
@@ -63,6 +64,7 @@ type Config struct {
 	DefaultAccount Context           `json:"defaultAccount" yaml:"defaultAccount"`
 	Explorer       string            `json:"explorer" yaml:"explorer"`
 	Language       string            `json:"language" yaml:"language"`
+	FairBankHeight uint64            `json:"fairbankHeight" yaml:"fairbankHeight"`
 }
 
 var (
@@ -103,6 +105,9 @@ func init() {
 		ReadConfig.Language = supportedLanguage[0]
 		completeness = false
 	}
+	if ReadConfig.FairBankHeight == 0 {
+		ReadConfig.FairBankHeight = config.Default.Genesis.FairbankBlockHeight
+	}
 	if !completeness {
 		err := writeConfig()
 		if err != nil {