Handle report in dispute

proto/layer/oracle/aggregate.proto

@@ -18,6 +18,8 @@ message Aggregate {
   uint64 nonce = 8;
   int64 aggregateReportIndex = 9;
   int64 height = 10;
+  // height of the micro report
+  int64 micro_height = 11;
 }
 
 message AvailableTimestamps {

tests/integration/reporter_keeper_test.go

@@ -222,3 +222,69 @@ func (s *IntegrationTestSuite) TestDelegatorCount() {
 	s.NoError(err)
 	s.Equal(uint64(5), del.DelegationCount)
 }
+
+// add 100 delegators to a reporter and check if the delegator count is 100
+// and what happens when the 101st delegator tries to delegate
+func (s *IntegrationTestSuite) TestMaxDelegatorCount() {
+	valAccs, valAddrs, _ := s.Setup.CreateValidator(1)
+	stakingmsgServer := stakingkeeper.NewMsgServerImpl(s.Setup.Stakingkeeper)
+	valAcc := valAccs[0]
+	valAdd := valAddrs[0]
+	k1 := valAcc
+	var k2 sdk.AccAddress
+	// delegate a 100 delegators
+	for i := 0; i < 100; i++ {
+		delegatorAddr := sample.AccAddressBytes()
+		s.Setup.MintTokens(delegatorAddr, math.NewInt(1000*1e6))
+		msgDelegate := stakingtypes.NewMsgDelegate(
+			delegatorAddr.String(),
+			valAdd.String(),
+			sdk.NewInt64Coin(s.Setup.Denom, 1000*1e6),
+		)
+		if i == 99 {
+			k2 = delegatorAddr
+		}
+		_, err := stakingmsgServer.Delegate(s.Setup.Ctx, msgDelegate)
+		s.NoError(err)
+	}
+
+	// check delegator count
+	rep, err := s.Setup.Reporterkeeper.Reporters.Get(s.Setup.Ctx, valAcc)
+	s.NoError(err)
+	s.Equal(uint64(100), rep.DelegatorsCount)
+	// check how many reporters are there
+	iter, err := s.Setup.Reporterkeeper.Reporters.Iterate(s.Setup.Ctx, nil)
+	s.NoError(err)
+	list, err := iter.Keys()
+	s.NoError(err)
+	s.Equal(2, len(list))
+
+	rep1, err := s.Setup.Reporterkeeper.Reporters.Get(s.Setup.Ctx, k1)
+	s.NoError(err)
+	s.Equal(uint64(100), rep1.DelegatorsCount)
+	rep2, err := s.Setup.Reporterkeeper.Reporters.Get(s.Setup.Ctx, k2)
+	s.NoError(err)
+	s.Equal(uint64(1), rep2.DelegatorsCount)
+
+	// delegate 102nd delegator
+	delegatorAddr := sample.AccAddressBytes()
+	s.Setup.MintTokens(delegatorAddr, math.NewInt(1000*1e6))
+	msgDelegate := stakingtypes.NewMsgDelegate(
+		delegatorAddr.String(),
+		valAdd.String(),
+		sdk.NewInt64Coin(s.Setup.Denom, 1000*1e6),
+	)
+	_, err = stakingmsgServer.Delegate(s.Setup.Ctx, msgDelegate)
+	s.NoError(err)
+
+	// check delegator count
+	iter, err = s.Setup.Reporterkeeper.Reporters.Iterate(s.Setup.Ctx, nil)
+	s.NoError(err)
+	list, err = iter.Keys()
+	s.NoError(err)
+	s.Equal(3, len(list))
+	// delegator should be come a third reporter
+	rep3, err := s.Setup.Reporterkeeper.Reporters.Get(s.Setup.Ctx, delegatorAddr)
+	s.NoError(err)
+	s.Equal(uint64(1), rep3.DelegatorsCount)
+}

tests/setup.go

@@ -395,3 +395,48 @@ func (s *SharedSetup) ConvertToAccAddress(priv []ed25519.PrivKey) []sdk.AccAddre
 	}
 	return testAddrs
 }
+
+func (s *SharedSetup) CreateValidator(numValidators int) ([]sdk.AccAddress, []sdk.ValAddress, []stakingtypes.Validator) {
+	require := s.require
+
+	// create account that will become a validator
+	accountsAddrs := simtestutil.CreateIncrementalAccounts(numValidators)
+	// mint numTrb for each validator
+	initCoins := sdk.NewCoin(s.Denom, math.NewInt(5000*1e6))
+	for _, acc := range accountsAddrs {
+		// mint to module
+		require.NoError(s.Bankkeeper.MintCoins(s.Ctx, authtypes.Minter, sdk.NewCoins(initCoins)))
+		// send from module to account
+		require.NoError(s.Bankkeeper.SendCoinsFromModuleToAccount(s.Ctx, authtypes.Minter, acc, sdk.NewCoins(initCoins)))
+		require.Equal(initCoins, s.Bankkeeper.GetBalance(s.Ctx, acc, s.Denom))
+	}
+
+	// get val address for each account
+	validatorsAddrs := simtestutil.ConvertAddrsToValAddrs(accountsAddrs)
+	// create pub keys for validators
+	pubKeys := simtestutil.CreateTestPubKeys(numValidators)
+	validators := make([]stakingtypes.Validator, numValidators)
+	stakingServer := stakingkeeper.NewMsgServerImpl(s.Stakingkeeper)
+	// set each account with proper keepers
+	for i, pubKey := range pubKeys {
+		s.Accountkeeper.NewAccountWithAddress(s.Ctx, accountsAddrs[i])
+		valMsg, err := stakingtypes.NewMsgCreateValidator(
+			validatorsAddrs[i].String(),
+			pubKey,
+			sdk.NewInt64Coin(s.Denom, 100),
+			stakingtypes.Description{Moniker: strconv.Itoa(i)},
+			stakingtypes.CommissionRates{
+				Rate:          math.LegacyNewDecWithPrec(5, 1),
+				MaxRate:       math.LegacyNewDecWithPrec(5, 1),
+				MaxChangeRate: math.LegacyNewDec(0),
+			},
+			math.OneInt())
+		require.NoError(err)
+
+		_, err = stakingServer.CreateValidator(s.Ctx, valMsg)
+		require.NoError(err)
+	}
+	_, err := s.Stakingkeeper.EndBlocker(s.Ctx)
+	require.NoError(err)
+	return accountsAddrs, validatorsAddrs, validators
+}

x/bridge/keeper/withdraw_tokens.go

@@ -82,6 +82,7 @@ func (k Keeper) createWithdrawalAggregate(goCtx context.Context, amount sdk.Coin
 		Nonce:                0,
 		AggregateReportIndex: 0,
 		Height:               ctx.BlockHeight(),
+		MicroHeight:          ctx.BlockHeight(),
 	}
 	return aggregate, nil
 }

x/dispute/keeper/dispute.go

@@ -130,6 +130,11 @@ func (k Keeper) SetNewDispute(ctx sdk.Context, sender sdk.AccAddress, msg types.
 
 // Slash and jail reporter
 func (k Keeper) SlashAndJailReporter(ctx sdk.Context, report oracletypes.MicroReport, category types.DisputeCategory, hashId []byte) error {
+	// flag aggregate report if necessary
+	err := k.oracleKeeper.FlagAggregateReport(ctx, report)
+	if err != nil {
+		return err
+	}
 	reporterAddr := sdk.MustAccAddressFromBech32(report.Reporter)
 
 	slashFactor, jailDuration, err := GetSlashPercentageAndJailDuration(category)

x/dispute/keeper/dispute_test.go

@@ -154,6 +154,7 @@ func (s *KeeperTestSuite) TestSlashAndJailReporter() {
 	reporterAcc := sdk.MustAccAddressFromBech32(report.Reporter)
 	s.reporterKeeper.On("EscrowReporterStake", s.ctx, reporterAcc, report.Power, int64(1), math.NewInt(10000), dispute.HashId).Return(nil)
 	s.reporterKeeper.On("JailReporter", s.ctx, reporterAcc, int64(0)).Return(nil)
+	s.oracleKeeper.On("FlagAggregateReport", s.ctx, report).Return(nil)
 	s.NoError(s.disputeKeeper.SlashAndJailReporter(s.ctx, report, dispute.DisputeCategory, dispute.HashId))
 }
 
@@ -193,6 +194,7 @@ func (s *KeeperTestSuite) TestGetSlashPercentageAndJailDuration() {
 			cat:  4,
 		},
 	}
+	s.oracleKeeper.On("FlagAggregateReport", s.ctx, report()).Return(nil)
 
 	for _, tc := range testCases {
 		tc := tc
@@ -254,6 +256,7 @@ func (s *KeeperTestSuite) TestAddDisputeRound() {
 	fee := sdk.NewCoin("loya", math.NewInt(10))
 	s.bankKeeper.On("HasBalance", s.ctx, sender, fee).Return(true)
 	s.bankKeeper.On("SendCoinsFromAccountToModule", s.ctx, sender, types.ModuleName, sdk.NewCoins(fee)).Return(nil)
+	s.oracleKeeper.On("FlagAggregateReport", s.ctx, report()).Return(nil)
 	s.NoError(s.disputeKeeper.AddDisputeRound(s.ctx, sender, dispute, msg))
 
 	dispute1, err := s.disputeKeeper.Disputes.Get(s.ctx, 1)

x/dispute/keeper/msg_server_add_fee_to_dispute_test.go

@@ -3,6 +3,7 @@ package keeper_test
 import (
 	"time"
 
+	"github.com/stretchr/testify/mock"
 	"github.com/tellor-io/layer/testutil/sample"
 	layer "github.com/tellor-io/layer/types"
 	"github.com/tellor-io/layer/x/dispute/types"
@@ -46,6 +47,7 @@ func (k *KeeperTestSuite) TestMsgServerAddFeeToDispute() {
 	dispute.FeeTotal = math.ZeroInt()
 	k.NoError(k.disputeKeeper.Disputes.Set(k.ctx, dispute.DisputeId, dispute))
 	fee := sdk.NewCoin(layer.BondDenom, math.NewInt(10000))
+	k.oracleKeeper.On("FlagAggregateReport", k.ctx, mock.Anything).Return(nil)
 	k.bankKeeper.On("HasBalance", k.ctx, creator, fee).Return(true)
 	k.bankKeeper.On("SendCoinsFromAccountToModule", k.ctx, creator, types.ModuleName, sdk.NewCoins(fee)).Return(nil)
 	k.reporterKeeper.On("EscrowReporterStake", k.ctx, sdk.MustAccAddressFromBech32(dispute.ReportEvidence.Reporter), dispute.ReportEvidence.Power, int64(1), dispute.SlashAmount, dispute.HashId).Return(nil)