feat: allow querying each signing info (#17)

* feat: allow querying each signing info

* chore: gofumpt

* chore: return also validators count

Author: freak12techno

config.example.toml

@@ -16,6 +16,14 @@ include-validators = ["cosmosvaloperxxx"]
 # List of validators to exclude from monitoring, with it specified, all validators except mentioned
 # will be monitored. Cannot be used together with include-validators.
 exclude-validators = ["cosmosvaloperyyy"]
+# Some chains, likely cosmos-sdk, return signing-info without an address, making it impossible
+# to match some validators with their signing info, as a result, the validators list returned
+# by Telegram bot and the list of monitored validators isn't full. This flag, instead of querying
+# all signing infos with a single request, does a query for each validator asking for its signing info.
+# This is super ugly and resource consuming, but probably is the only solution. If you face
+# the issue of not validators appearing in the list, try switching it to true.
+# Defaults to false.
+query-each-signing-info = false
 
 # Node config.
 [node]

config.go

@@ -55,7 +55,8 @@ type AppConfig struct {
 	ChainInfoConfig ChainInfoConfig `toml:"chain-info"`
 	NodeConfig      NodeConfig      `toml:"node"`
 
-	Interval int `toml:"interval" default:"120"`
+	QueryEachSigningInfo bool `toml:"query-each-signing-info"`
+	Interval             int  `toml:"interval" default:"120"`
 
 	Prefix                    string `toml:"bech-prefix"`
 	ValidatorPrefix           string `toml:"bech-validator-prefix"`

grpc.go

@@ -14,16 +14,18 @@ import (
 )
 
 type TendermintGRPC struct {
-	NodeConfig NodeConfig
-	Limit      uint64
-	Client     *grpc.ClientConn
-	Logger     zerolog.Logger
-	Registry   codectypes.InterfaceRegistry
+	NodeConfig           NodeConfig
+	Limit                uint64
+	Client               *grpc.ClientConn
+	Logger               zerolog.Logger
+	Registry             codectypes.InterfaceRegistry
+	QueryEachSigningInfo bool
 }
 
 func NewTendermintGRPC(
 	nodeConfig NodeConfig,
 	registry codectypes.InterfaceRegistry,
+	queryEachSigningInfo bool,
 	logger *zerolog.Logger,
 ) *TendermintGRPC {
 	grpcConn, err := grpc.Dial(
@@ -35,11 +37,12 @@ func NewTendermintGRPC(
 	}
 
 	return &TendermintGRPC{
-		NodeConfig: nodeConfig,
-		Limit:      1000,
-		Logger:     logger.With().Str("component", "grpc").Logger(),
-		Client:     grpcConn,
-		Registry:   registry,
+		NodeConfig:           nodeConfig,
+		Limit:                1000,
+		Logger:               logger.With().Str("component", "grpc").Logger(),
+		Client:               grpcConn,
+		Registry:             registry,
+		QueryEachSigningInfo: queryEachSigningInfo,
 	}
 }
 
@@ -75,6 +78,10 @@ func (grpc *TendermintGRPC) GetSlashingParams() SlashingParams {
 }
 
 func (grpc *TendermintGRPC) GetValidatorsState() (ValidatorsState, error) {
+	if grpc.QueryEachSigningInfo {
+		return grpc.GetValidatorsStateWithEachSigningInfo()
+	}
+
 	slashingClient := slashingtypes.NewQueryClient(grpc.Client)
 	signingInfos, err := slashingClient.SigningInfos(
 		context.Background(),
@@ -135,6 +142,53 @@ func (grpc *TendermintGRPC) GetValidatorsState() (ValidatorsState, error) {
 	return newState, nil
 }
 
+func (grpc *TendermintGRPC) GetValidatorsStateWithEachSigningInfo() (ValidatorsState, error) {
+	slashingClient := slashingtypes.NewQueryClient(grpc.Client)
+	stakingClient := stakingtypes.NewQueryClient(grpc.Client)
+	validatorsResult, err := stakingClient.Validators(
+		context.Background(),
+		&stakingtypes.QueryValidatorsRequest{
+			Pagination: &querytypes.PageRequest{
+				Limit: grpc.Limit,
+			},
+		},
+	)
+	if err != nil {
+		grpc.Logger.Error().Err(err).Msg("Could not query for validators")
+		return nil, err
+	}
+
+	newState := make(ValidatorsState, len(validatorsResult.Validators))
+	for _, validator := range validatorsResult.Validators {
+		err := validator.UnpackInterfaces(grpc.Registry)
+		if err != nil {
+			grpc.Logger.Error().Err(err).Msg("Could not unpack interface")
+			return nil, err
+		}
+
+		pubKey, err := validator.GetConsAddr()
+		if err != nil {
+			grpc.Logger.Error().Err(err).Msg("Could not get cons addr")
+			return nil, err
+		}
+
+		info, err := slashingClient.SigningInfo(
+			context.Background(),
+			&slashingtypes.QuerySigningInfoRequest{
+				ConsAddress: pubKey.String(),
+			},
+		)
+		if err != nil {
+			grpc.Logger.Error().Err(err).Msg("Could not query for signing info")
+			continue
+		}
+
+		newState[pubKey.String()] = NewValidatorState(validator, info.ValSigningInfo)
+	}
+
+	return newState, nil
+}
+
 func (grpc *TendermintGRPC) GetValidator(address string) (stakingtypes.Validator, error) {
 	stakingClient := stakingtypes.NewQueryClient(grpc.Client)
 

main.go

@@ -43,7 +43,7 @@ func Execute(configPath string) {
 	interfaceRegistry := encCfg.InterfaceRegistry
 
 	rpc := NewTendermintRPC(appConfig.NodeConfig, log)
-	grpc := NewTendermintGRPC(appConfig.NodeConfig, interfaceRegistry, log)
+	grpc := NewTendermintGRPC(appConfig.NodeConfig, interfaceRegistry, appConfig.QueryEachSigningInfo, log)
 	slashingParams := grpc.GetSlashingParams()
 
 	params := Params{

telegram.go

@@ -407,6 +407,7 @@ func (r *TelegramReporter) getValidatorWithMissedBlocksSerialized(state Validato
 
 func (r *TelegramReporter) getValidatorsWithMissedBlocksSerialized(state []ValidatorState) (string, error) {
 	var sb strings.Builder
+	sb.WriteString(fmt.Sprintf("<strong>Total validators:</strong> %d\n", len(state)))
 
 	for _, validator := range state {
 		group, err := r.AppConfig.MissedBlocksGroups.GetGroup(validator.MissedBlocks)