fix from comments

Author: colmazia

x/feeds/README.md

@@ -28,7 +28,7 @@ This module is used in the BandChain.
     - [CurrentFeeds](#currentfeeds)
     - [ValidatorPriceList](#validatorpricelist)
     - [Price](#price-1)
-    - [DelegatorSignal](#delegatorsignal)
+    - [DelegatorSignals](#delegatorsignals)
     - [SignalTotalPower](#signaltotalpower)
       - [SignalTotalPowerByPowerIndex](#signaltotalpowerbypowerindex)
     - [Params](#params)
@@ -132,11 +132,11 @@ The Price is a space for holding the current price information of signals.
 
 * Price: `0x02 -> ProtocolBuffer(Price)`
 
-### DelegatorSignal
+### DelegatorSignals
 
-The DelegatorSignal is a space for holding current Delegator Signals information of delegators.
+The DelegatorSignals is a space for holding current Delegator Signals information of delegators.
 
-* DelegatorSignal: `0x03 -> ProtocolBuffer(DelegatorSignals)`
+* DelegatorSignals: `0x03 -> ProtocolBuffer(DelegatorSignals)`
 
 ### SignalTotalPower
 

x/feeds/client/cli/query.go

@@ -25,21 +25,23 @@ func GetQueryCmd() *cobra.Command {
 		GetQueryCmdPrices(),
 		GetQueryCmdPrice(),
 		GetQueryCmdValidatorPrices(),
+		GetQueryCmdValidValidator(),
 		GetQueryCmdSignalTotalPowers(),
 		GetQueryCmdParams(),
-		GetQueryCmdDelegatorSignal(),
+		GetQueryCmdReferenceSourceConfig(),
+		GetQueryCmdDelegatorSignals(),
 		GetQueryCmdCurrentFeeds(),
 		GetQueryCmdIsFeeder(),
 	)
 
 	return queryCmd
 }
 
-// GetQueryCmdDelegatorSignal implements the query delegator signal command.
-func GetQueryCmdDelegatorSignal() *cobra.Command {
+// GetQueryCmdDelegatorSignals implements the query delegator signal command.
+func GetQueryCmdDelegatorSignals() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "delegator-signal [delegator-addr]",
-		Short: "Shows delegator's currently active signal",
+		Use:   "delegator-signals [delegator-addr]",
+		Short: "Shows delegator's currently active signals",
 		Args:  cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			clientCtx := client.GetClientContextFromCmd(cmd)
@@ -175,6 +177,33 @@ func GetQueryCmdValidatorPrices() *cobra.Command {
 	return cmd
 }
 
+// GetQueryCmdValidValidator implements the query valid validator command.
+func GetQueryCmdValidValidator() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "valid-validator [validator-address]",
+		Short: "Shows if the given address is a valid validator",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx := client.GetClientContextFromCmd(cmd)
+			queryClient := types.NewQueryClient(clientCtx)
+
+			res, err := queryClient.ValidValidator(
+				context.Background(),
+				&types.QueryValidValidatorRequest{Validator: args[0]},
+			)
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}
+
 // GetQueryCmdSignalTotalPowers implements the query signal-total-powers command.
 func GetQueryCmdSignalTotalPowers() *cobra.Command {
 	cmd := &cobra.Command{

x/feeds/keeper/calculate.go

@@ -14,10 +14,7 @@ func (k Keeper) InitGenesis(ctx sdk.Context, genState types.GenesisState) {
 
 	k.SetAllDelegatorSignals(ctx, genState.DelegatorSignals)
 
-	signalTotalPowers, err := k.CalculateNewSignalTotalPowers(ctx)
-	if err != nil {
-		panic(err)
-	}
+	signalTotalPowers := k.CalculateNewSignalTotalPowers(ctx)
 	k.SetSignalTotalPowers(ctx, signalTotalPowers)
 
 	feeds := k.CalculateNewCurrentFeeds(ctx)

x/feeds/keeper/genesis.go

@@ -137,7 +137,8 @@ func (q queryServer) ValidatorPrices(
 	}
 
 	for _, valPrice := range valPricesList.ValidatorPrices {
-		if _, exists := signalIDSet[valPrice.SignalID]; exists {
+		if _, exists := signalIDSet[valPrice.SignalID]; exists &&
+			valPrice.PriceStatus != types.PriceStatusUnspecified {
 			filteredPrices = append(filteredPrices, valPrice)
 		}
 	}
@@ -161,13 +162,8 @@ func (q queryServer) ValidValidator(
 	isValid := true
 
 	// check if it's bonded validators.
-	isBonded := q.keeper.IsBondedValidator(ctx, val)
-	if !isBonded {
-		isValid = false
-	}
-
-	validatorStatus := q.keeper.oracleKeeper.GetValidatorStatus(ctx, val)
-	if !validatorStatus.IsActive {
+	err = q.keeper.ValidateValidatorRequiredToSend(ctx, val)
+	if err != nil {
 		isValid = false
 	}
 
@@ -230,8 +226,14 @@ func (q queryServer) CurrentFeeds(
 
 	currentFeeds := q.keeper.GetCurrentFeeds(ctx)
 	feedWithDeviations := make([]types.FeedWithDeviation, 0, len(currentFeeds.Feeds))
+	params := q.keeper.GetParams(ctx)
 	for _, feed := range currentFeeds.Feeds {
-		deviation := CalculateDeviation(feed.Power, q.keeper.GetParams(ctx))
+		deviation := types.CalculateDeviation(
+			feed.Power,
+			params.PowerStepThreshold,
+			params.MinDeviationBasisPoint,
+			params.MaxDeviationBasisPoint,
+		)
 		feedWithDeviations = append(
 			feedWithDeviations,
 			types.FeedWithDeviation{

x/feeds/keeper/grpc_query.go

@@ -203,7 +203,7 @@ func (suite *KeeperTestSuite) TestQueryValidatorPrices() {
 	})
 	suite.Require().NoError(err)
 	suite.Require().Equal(&types.QueryValidatorPricesResponse{
-		ValidatorPrices: []types.ValidatorPrice{valPrices[0]},
+		ValidatorPrices: []types.ValidatorPrice(nil),
 	}, res)
 
 	// query with invalid validator

x/feeds/keeper/grpc_query_test.go

@@ -32,6 +32,9 @@ func NewKeeper(
 	authzKeeper types.AuthzKeeper,
 	authority string,
 ) Keeper {
+	if _, err := sdk.AccAddressFromBech32(authority); err != nil {
+		panic(fmt.Errorf("invalid authority address: %w", err))
+	}
 	return Keeper{
 		cdc:           cdc,
 		storeKey:      storeKey,

x/feeds/keeper/keeper.go

@@ -34,8 +34,14 @@ func (k Keeper) SetCurrentFeeds(ctx sdk.Context, feeds []types.Feed) {
 func (k Keeper) CalculateNewCurrentFeeds(ctx sdk.Context) []types.Feed {
 	signalTotalPowers := k.GetSignalTotalPowersByPower(ctx, k.GetParams(ctx).MaxCurrentFeeds)
 	feeds := make([]types.Feed, 0, len(signalTotalPowers))
+	params := k.GetParams(ctx)
 	for _, signalTotalPower := range signalTotalPowers {
-		interval := CalculateInterval(signalTotalPower.Power, k.GetParams(ctx))
+		interval := types.CalculateInterval(
+			signalTotalPower.Power,
+			params.PowerStepThreshold,
+			params.MinInterval,
+			params.MaxInterval,
+		)
 		if interval > 0 {
 			feed := types.Feed{
 				SignalID: signalTotalPower.ID,

x/feeds/keeper/keeper_feed.go

@@ -54,23 +54,22 @@ func (k Keeper) SetPrice(ctx sdk.Context, price types.Price) {
 	ctx.KVStore(k.storeKey).Set(types.PriceStoreKey(price.SignalID), k.cdc.MustMarshal(&price))
 }
 
-// DeletePrice deletes a price by signal id.
-func (k Keeper) DeletePrice(ctx sdk.Context, signalID string) {
-	ctx.KVStore(k.storeKey).Delete(types.PriceStoreKey(signalID))
-}
-
 // CalculatePrices calculates final prices for all supported feeds.
 func (k Keeper) CalculatePrices(ctx sdk.Context) {
+	// get the current feeds
 	currentFeeds := k.GetCurrentFeeds(ctx)
 
 	var validatorsByPower []types.ValidatorInfo
+	// iterate over bonded validators sorted by power
 	k.stakingKeeper.IterateBondedValidatorsByPower(
 		ctx,
 		func(idx int64, val stakingtypes.ValidatorI) (stop bool) {
+			// get the status of the validator
 			status := k.oracleKeeper.GetValidatorStatus(ctx, val.GetOperator())
 			if !status.IsActive {
 				return false
 			}
+			// collect validator information
 			validatorInfo := types.ValidatorInfo{
 				Index:   idx,
 				Address: val.GetOperator(),
@@ -81,6 +80,7 @@ func (k Keeper) CalculatePrices(ctx sdk.Context) {
 			return false
 		})
 
+	// collect all validator prices
 	allValidatorPrices := make(map[string]map[string]types.ValidatorPrice)
 	for _, val := range validatorsByPower {
 		valPricesList, err := k.GetValidatorPriceList(ctx, val.Address)
@@ -90,20 +90,22 @@ func (k Keeper) CalculatePrices(ctx sdk.Context) {
 
 		valPricesMap := make(map[string]types.ValidatorPrice)
 		for _, valPrice := range valPricesList.ValidatorPrices {
-			if valPrice.SignalID != "" {
+			if valPrice.PriceStatus != types.PriceStatusUnspecified {
 				valPricesMap[valPrice.SignalID] = valPrice
 			}
 		}
 
 		allValidatorPrices[val.Address.String()] = valPricesMap
 	}
 
+	// calculate prices for each feed
 	for _, feed := range currentFeeds.Feeds {
 		var priceFeedInfos []types.PriceFeedInfo
 		for _, valInfo := range validatorsByPower {
 			valPrice := allValidatorPrices[valInfo.Address.String()][feed.SignalID]
 
-			missReport, havePrice := CheckMissReport(
+			// check for miss report
+			missReport := CheckMissReport(
 				feed,
 				currentFeeds.LastUpdateTimestamp,
 				currentFeeds.LastUpdateBlock,
@@ -117,6 +119,8 @@ func (k Keeper) CalculatePrices(ctx sdk.Context) {
 				k.oracleKeeper.MissReport(ctx, valInfo.Address, ctx.BlockTime())
 			}
 
+			// check if the price is available
+			havePrice := CheckHavePrice(feed, valPrice, ctx.BlockTime())
 			if havePrice {
 				priceFeedInfos = append(
 					priceFeedInfos, types.PriceFeedInfo{
@@ -130,8 +134,10 @@ func (k Keeper) CalculatePrices(ctx sdk.Context) {
 			}
 		}
 
+		// calculate the final price for the feed
 		price, err := k.CalculatePrice(ctx, feed, priceFeedInfos)
 		if err != nil {
+			// emit event for failed price calculation
 			ctx.EventManager().EmitEvent(
 				sdk.NewEvent(
 					types.EventTypeCalculatePriceFailed,
@@ -142,8 +148,10 @@ func (k Keeper) CalculatePrices(ctx sdk.Context) {
 			continue
 		}
 
+		// set the calculated price in the store
 		k.SetPrice(ctx, price)
 
+		// emit event for updated price
 		ctx.EventManager().EmitEvent(
 			sdk.NewEvent(
 				types.EventTypeUpdatePrice,
@@ -213,35 +221,42 @@ func CheckMissReport(
 	blockTime time.Time,
 	blockHeight int64,
 	gracePeriod int64,
-) (missReport bool, havePrice bool) {
-	// During the grace period, if the block time exceeds MaximumGuaranteeBlockTime, it will be capped at MaximumGuaranteeBlockTime.
+) bool {
+	// During the grace period, if the block time exceeds MaxGuaranteeBlockTime, it will be capped at MaxGuaranteeBlockTime.
 	// This means that in cases of slow block time, the validator will not be deactivated
-	// as long as the block height does not exceed the equivalent of assumed MaximumGuaranteeBlockTime of block time.
+	// as long as the block height does not exceed the equivalent of assumed MaxGuaranteeBlockTime of block time.
 	lastTime := lastUpdateTimestamp + gracePeriod
-	lastBlock := lastUpdateBlock + gracePeriod/types.MaximumGuaranteeBlockTime
+	lastBlock := lastUpdateBlock + gracePeriod/types.MaxGuaranteeBlockTime
 
 	if valInfo.Status.Since.Unix()+gracePeriod > lastTime {
 		lastTime = valInfo.Status.Since.Unix() + gracePeriod
 	}
 
-	if valPrice.SignalID != "" {
-		// Append valid price feed info if within the acceptance period
-		if valPrice.Timestamp >= blockTime.Unix()-feed.Interval {
-			havePrice = true
-		}
-
+	if valPrice.PriceStatus != types.PriceStatusUnspecified {
 		if valPrice.Timestamp+feed.Interval > lastTime {
 			lastTime = valPrice.Timestamp + feed.Interval
 		}
 
-		if valPrice.BlockHeight+feed.Interval/types.MaximumGuaranteeBlockTime > lastBlock {
-			lastBlock = valPrice.BlockHeight + feed.Interval/types.MaximumGuaranteeBlockTime
+		if valPrice.BlockHeight+feed.Interval/types.MaxGuaranteeBlockTime > lastBlock {
+			lastBlock = valPrice.BlockHeight + feed.Interval/types.MaxGuaranteeBlockTime
 		}
 	}
 
 	// Determine if the last action is too old, indicating a missed report
-	missReport = lastTime < blockTime.Unix() && lastBlock < blockHeight
-	return
+	return lastTime < blockTime.Unix() && lastBlock < blockHeight
+}
+
+// CheckHavePrice checks if a validator has a price feed within interval range.
+func CheckHavePrice(
+	feed types.Feed,
+	valPrice types.ValidatorPrice,
+	blockTime time.Time,
+) bool {
+	if valPrice.PriceStatus != types.PriceStatusUnspecified && valPrice.Timestamp >= blockTime.Unix()-feed.Interval {
+		return true
+	}
+
+	return false
 }
 
 // GetValidatorPriceList gets a validator price by validator address.
@@ -275,3 +290,21 @@ func (k Keeper) SetValidatorPriceList(
 
 	return nil
 }
+
+// ValidateValidatorRequiredToSend validates validator is required for price submission.
+func (k Keeper) ValidateValidatorRequiredToSend(
+	ctx sdk.Context,
+	val sdk.ValAddress,
+) error {
+	isValid := k.IsBondedValidator(ctx, val)
+	if !isValid {
+		return types.ErrNotBondedValidator
+	}
+
+	status := k.oracleKeeper.GetValidatorStatus(ctx, val)
+	if !status.IsActive {
+		return types.ErrOracleStatusNotActive.Wrapf("val: %s", val.String())
+	}
+
+	return nil
+}