Fix number of inferers considered in the reward cycle

CHANGELOG.md

@@ -75,6 +75,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * [#651](https://github.com/allora-network/allora-chain/pull/651) Refactor: Fuzzer rename invariants test to fuzz test
 * [#653](https://github.com/allora-network/allora-chain/pull/653) Fuzzer Bugfixes, Allow User to Set Fuzzer Transition Probability Distribution
 * [#686](https://github.com/allora-network/allora-chain/pull/686) CLI query commands alignment
+* [#691](https://github.com/allora-network/allora-chain/pull/691/files) Fix number of inferers considered in the reward cycle
 
 ### Deprecated
 

x/emissions/keeper/keeper.go

@@ -1112,19 +1112,13 @@ func (k *Keeper) AppendInference(
 		return errors.New("inference already submitted")
 	}
 
+	// Get active inferers for topic
 	workerAddresses, err := k.GetActiveInferersForTopic(ctx, topic.Id)
 	if err != nil {
 		return errorsmod.Wrap(err, "error getting active inferers for topic")
 	}
-	// If there are less than maxTopInferersToReward, add the current inferer
-	if uint64(len(workerAddresses)) < maxTopInferersToReward {
-		err := k.AddActiveInferer(ctx, topic.Id, inference.Inferer)
-		if err != nil {
-			return errorsmod.Wrap(err, "error adding active inferer")
-		}
-		return k.InsertInference(ctx, topic.Id, *inference)
-	}
 
+	// Get previous EMA score for the current inferer
 	previousEmaScore, err := k.GetInfererScoreEma(ctx, topic.Id, inference.Inferer)
 	if err != nil {
 		return errorsmod.Wrapf(err, "Error getting inferer score ema")
@@ -1134,21 +1128,39 @@ func (k *Keeper) AppendInference(
 		return types.ErrCantUpdateEmaMoreThanOncePerWindow
 	}
 
+	// Get lowest inferer score ema for the topic
 	lowestEmaScore, found, err := k.GetLowestInfererScoreEma(ctx, topic.Id)
 	if err != nil {
 		return errorsmod.Wrap(err, "error getting lowest inferer score ema")
-		// If there are no lowest inferer score ema, calculate it
-	} else if !found {
-		lowestEmaScore, err = GetLowestScoreFromAllInferers(ctx, k, topic.Id, workerAddresses)
-		if err != nil {
-			return errorsmod.Wrap(err, "error getting lowest score from all inferers")
-		}
+	}
+	// If there are no lowest inferer score ema, it means it is the first inference for the topic
+	if !found {
+		lowestEmaScore = previousEmaScore
 		err = k.SetLowestInfererScoreEma(ctx, topic.Id, lowestEmaScore)
 		if err != nil {
 			return errorsmod.Wrap(err, "error setting lowest inferer score ema")
 		}
 	}
 
+	// If there are less than maxTopInferersToReward, add the current inferer, update the lowest inferer score ema if needed, and return
+	if uint64(len(workerAddresses)) < maxTopInferersToReward {
+		// Update lowest inferer score ema if needed
+		if uint64(len(workerAddresses)) == 0 || lowestEmaScore.Score.Gt(previousEmaScore.Score) {
+			err = k.SetLowestInfererScoreEma(ctx, topic.Id, previousEmaScore)
+			if err != nil {
+				return errorsmod.Wrap(err, "error setting lowest inferer score ema")
+			}
+		}
+
+		err = k.AddActiveInferer(ctx, topic.Id, inference.Inferer)
+		if err != nil {
+			return errorsmod.Wrap(err, "error adding active inferer")
+		}
+		return k.InsertInference(ctx, topic.Id, *inference)
+	}
+
+	// Else ...
+	// Checks if the inferer's previous EMA score is greater than the lowest EMA score
 	if previousEmaScore.Score.Gt(lowestEmaScore.Score) {
 		// Update EMA score for the lowest score inferer, who is not the current inferer
 		err = k.CalcAndSaveInfererScoreEmaWithLastSavedTopicQuantile(
@@ -1160,6 +1172,16 @@ func (k *Keeper) AppendInference(
 		if err != nil {
 			return errorsmod.Wrap(err, "error calculating and saving inferer score ema with last saved topic quantile")
 		}
+
+		// Check if the inferer with lowest score is active before removing it, because remove will not fail if the inferer is not active
+		isActive, err := k.IsActiveInferer(ctx, topic.Id, lowestEmaScore.Address)
+		if err != nil {
+			return errorsmod.Wrap(err, "error checking if inferer is active")
+		}
+		if !isActive {
+			return errors.New("inferer with lowest score is not active")
+		}
+
 		// Remove inferer with lowest score
 		err = k.RemoveActiveInferer(ctx, topic.Id, lowestEmaScore.Address)
 		if err != nil {

x/emissions/keeper/keeper_test.go

@@ -3768,6 +3768,119 @@ func (s *KeeperTestSuite) TestAppendInference() {
 	s.Require().Equal(updateAttemptForWorker2.BlockHeight, updatedWorker2Score.BlockHeight, "unchanged height")
 }
 
+func getNewAddress() string {
+	addr := sdk.AccAddress(secp256k1.GenPrivKey().PubKey().Address())
+	return addr.String()
+}
+
+func (s *KeeperTestSuite) TestAppendInferenceWithResetActiveWorkers() {
+	ctx := s.ctx
+	k := s.emissionsKeeper
+	// Topic IDs
+	topicId := s.CreateOneTopic(10801)
+	nonce := types.Nonce{BlockHeight: 10}
+	blockHeightInferences := int64(10)
+
+	// Set previous topic quantile inferer score ema
+	err := k.SetPreviousTopicQuantileInfererScoreEma(ctx, topicId, alloraMath.MustNewDecFromString("1000"))
+	s.Require().NoError(err)
+
+	topic, err := k.GetTopic(ctx, topicId)
+	s.Require().NoError(err)
+
+	worker1 := getNewAddress()
+	worker2 := getNewAddress()
+	worker3 := getNewAddress()
+	worker4 := getNewAddress()
+	worker5 := getNewAddress()
+	worker6 := getNewAddress()
+	score1 := types.Score{TopicId: topicId, BlockHeight: 2, Address: worker1, Score: alloraMath.NewDecFromInt64(91)}
+	score2 := types.Score{TopicId: topicId, BlockHeight: 2, Address: worker2, Score: alloraMath.NewDecFromInt64(92)}
+	score3 := types.Score{TopicId: topicId, BlockHeight: 2, Address: worker3, Score: alloraMath.NewDecFromInt64(93)}
+	score4 := types.Score{TopicId: topicId, BlockHeight: 2, Address: worker4, Score: alloraMath.NewDecFromInt64(94)}
+	score5 := types.Score{TopicId: topicId, BlockHeight: 2, Address: worker5, Score: alloraMath.NewDecFromInt64(95)}
+	score6 := types.Score{TopicId: topicId, BlockHeight: 2, Address: worker6, Score: alloraMath.NewDecFromInt64(96)}
+	err = k.SetInfererScoreEma(ctx, topicId, worker1, score1)
+	s.Require().NoError(err)
+	err = k.SetInfererScoreEma(ctx, topicId, worker2, score2)
+	s.Require().NoError(err)
+	err = k.SetInfererScoreEma(ctx, topicId, worker3, score3)
+	s.Require().NoError(err)
+	err = k.SetInfererScoreEma(ctx, topicId, worker4, score4)
+	s.Require().NoError(err)
+	err = k.SetInfererScoreEma(ctx, topicId, worker5, score5)
+	s.Require().NoError(err)
+	err = k.SetInfererScoreEma(ctx, topicId, worker6, score6)
+	s.Require().NoError(err)
+
+	// Ensure that the number of top inferers is capped at the max top inferers to reward
+	// New high-score entrant should replace earlier low-score entrant
+	params := types.DefaultParams()
+	params.MaxTopInferersToReward = 4
+	err = k.SetParams(ctx, params)
+	s.Require().NoError(err)
+
+	allInferences := types.Inferences{
+		Inferences: []*types.Inference{
+			{TopicId: topicId, BlockHeight: blockHeightInferences, Inferer: worker1, Value: alloraMath.MustNewDecFromString("0.11")},
+			{TopicId: topicId, BlockHeight: blockHeightInferences, Inferer: worker2, Value: alloraMath.MustNewDecFromString("0.12")},
+			{TopicId: topicId, BlockHeight: blockHeightInferences, Inferer: worker3, Value: alloraMath.MustNewDecFromString("0.13")},
+			{TopicId: topicId, BlockHeight: blockHeightInferences, Inferer: worker4, Value: alloraMath.MustNewDecFromString("0.14")},
+			{TopicId: topicId, BlockHeight: blockHeightInferences, Inferer: worker5, Value: alloraMath.MustNewDecFromString("0.15")},
+		},
+	}
+	for _, inference := range allInferences.Inferences {
+		err = k.AppendInference(ctx, topic, nonce.BlockHeight, inference, params.MaxTopInferersToReward)
+		s.Require().NoError(err)
+	}
+
+	activeInferers, err := k.GetActiveInferersForTopic(ctx, topicId)
+	s.Require().NoError(err)
+	s.Require().Equal(params.MaxTopInferersToReward, uint64(len(activeInferers)))
+
+	lowestEmaScore, found, err := k.GetLowestInfererScoreEma(ctx, topicId)
+	s.Require().NoError(err)
+	s.Require().True(found)
+	s.Require().Equal(lowestEmaScore.Address, worker2)
+
+	err = k.ResetActiveWorkersForTopic(ctx, topicId)
+	s.Require().NoError(err)
+
+	activeInferers, err = k.GetActiveInferersForTopic(ctx, topicId)
+	s.Require().NoError(err)
+	s.Require().Equal(0, len(activeInferers))
+
+	lowestEmaScore, found, err = k.GetLowestInfererScoreEma(ctx, topicId)
+	s.Require().NoError(err)
+	s.Require().True(found)
+	s.Require().Equal(lowestEmaScore.Address, worker2)
+
+	blockHeightInferences = blockHeightInferences + topic.EpochLength
+	allInferences = types.Inferences{
+		Inferences: []*types.Inference{
+			{TopicId: topicId, BlockHeight: blockHeightInferences, Inferer: worker2, Value: alloraMath.MustNewDecFromString("0.22")},
+			{TopicId: topicId, BlockHeight: blockHeightInferences, Inferer: worker3, Value: alloraMath.MustNewDecFromString("0.23")},
+			{TopicId: topicId, BlockHeight: blockHeightInferences, Inferer: worker4, Value: alloraMath.MustNewDecFromString("0.24")},
+			{TopicId: topicId, BlockHeight: blockHeightInferences, Inferer: worker5, Value: alloraMath.MustNewDecFromString("0.25")},
+			{TopicId: topicId, BlockHeight: blockHeightInferences, Inferer: worker6, Value: alloraMath.MustNewDecFromString("0.26")},
+		},
+	}
+	nonce.BlockHeight++
+	for _, inference := range allInferences.Inferences {
+		err = k.AppendInference(ctx, topic, nonce.BlockHeight, inference, params.MaxTopInferersToReward)
+		s.Require().NoError(err)
+	}
+
+	activeInferers, err = k.GetActiveInferersForTopic(ctx, topicId)
+	s.Require().NoError(err)
+	s.Require().Equal(params.MaxTopInferersToReward, uint64(len(activeInferers)))
+
+	lowestEmaScore, found, err = k.GetLowestInfererScoreEma(ctx, topicId)
+	s.Require().NoError(err)
+	s.Require().True(found)
+	s.Require().Equal(lowestEmaScore.Address, worker3)
+}
+
 func mockUninitializedParams() types.Params {
 	return types.Params{
 		Version:                             "v2",