github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/libs/cosmos-sdk/x/distribution/keeper/delegation_test.go (about)

     1  package keeper
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/require"
     7  
     8  	sdk "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"
     9  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/staking"
    10  )
    11  
    12  func TestCalculateRewardsBasic(t *testing.T) {
    13  	ctx, _, k, sk, _ := CreateTestInputDefault(t, false, 1000)
    14  	sh := staking.NewHandler(sk)
    15  
    16  	// create validator with 50% commission
    17  	commission := staking.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
    18  	msg := staking.NewMsgCreateValidator(
    19  		valOpAddr1, valConsPk1, sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100)), staking.Description{}, commission, sdk.OneInt(),
    20  	)
    21  
    22  	res, err := sh(ctx, msg)
    23  	require.NoError(t, err)
    24  	require.NotNil(t, res)
    25  
    26  	// end block to bond validator
    27  	staking.EndBlocker(ctx, sk)
    28  
    29  	// next block
    30  	ctx.SetBlockHeight(ctx.BlockHeight() + 1)
    31  
    32  	// fetch validator and delegation
    33  	val := sk.Validator(ctx, valOpAddr1)
    34  	del := sk.Delegation(ctx, sdk.AccAddress(valOpAddr1), valOpAddr1)
    35  
    36  	// historical count should be 2 (once for validator init, once for delegation init)
    37  	require.Equal(t, uint64(2), k.GetValidatorHistoricalReferenceCount(ctx))
    38  
    39  	// end period
    40  	endingPeriod := k.incrementValidatorPeriod(ctx, val)
    41  
    42  	// historical count should be 2 still
    43  	require.Equal(t, uint64(2), k.GetValidatorHistoricalReferenceCount(ctx))
    44  
    45  	// calculate delegation rewards
    46  	rewards := k.calculateDelegationRewards(ctx, val, del, endingPeriod)
    47  
    48  	// rewards should be zero
    49  	require.True(t, rewards.IsZero())
    50  
    51  	// allocate some rewards
    52  	initial := int64(10)
    53  	tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDec(initial)}}
    54  	k.AllocateTokensToValidator(ctx, val, tokens)
    55  
    56  	// end period
    57  	endingPeriod = k.incrementValidatorPeriod(ctx, val)
    58  
    59  	// calculate delegation rewards
    60  	rewards = k.calculateDelegationRewards(ctx, val, del, endingPeriod)
    61  
    62  	// rewards should be half the tokens
    63  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDec(initial / 2)}}, rewards)
    64  
    65  	// commission should be the other half
    66  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDec(initial / 2)}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
    67  }
    68  
    69  func TestCalculateRewardsAfterSlash(t *testing.T) {
    70  	ctx, _, k, sk, _ := CreateTestInputDefault(t, false, 1000)
    71  	sh := staking.NewHandler(sk)
    72  
    73  	// create validator with 50% commission
    74  	commission := staking.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
    75  	valPower := int64(100)
    76  	valTokens := sdk.TokensFromConsensusPower(valPower)
    77  	msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
    78  		sdk.NewCoin(sdk.DefaultBondDenom, valTokens), staking.Description{}, commission, sdk.OneInt())
    79  
    80  	res, err := sh(ctx, msg)
    81  	require.NoError(t, err)
    82  	require.NotNil(t, res)
    83  
    84  	// end block to bond validator
    85  	staking.EndBlocker(ctx, sk)
    86  
    87  	// next block
    88  	ctx.SetBlockHeight(ctx.BlockHeight() + 1)
    89  
    90  	// fetch validator and delegation
    91  	val := sk.Validator(ctx, valOpAddr1)
    92  	del := sk.Delegation(ctx, sdk.AccAddress(valOpAddr1), valOpAddr1)
    93  
    94  	// end period
    95  	endingPeriod := k.incrementValidatorPeriod(ctx, val)
    96  
    97  	// calculate delegation rewards
    98  	rewards := k.calculateDelegationRewards(ctx, val, del, endingPeriod)
    99  
   100  	// rewards should be zero
   101  	require.True(t, rewards.IsZero())
   102  
   103  	// start out block height
   104  	ctx.SetBlockHeight(ctx.BlockHeight() + 3)
   105  
   106  	// slash the validator by 50%
   107  	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), valPower, sdk.NewDecWithPrec(5, 1))
   108  
   109  	// retrieve validator
   110  	val = sk.Validator(ctx, valOpAddr1)
   111  
   112  	// increase block height
   113  	ctx.SetBlockHeight(ctx.BlockHeight() + 3)
   114  
   115  	// allocate some rewards
   116  	initial := sdk.TokensFromConsensusPower(10)
   117  	tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.ToDec()}}
   118  	k.AllocateTokensToValidator(ctx, val, tokens)
   119  
   120  	// end period
   121  	endingPeriod = k.incrementValidatorPeriod(ctx, val)
   122  
   123  	// calculate delegation rewards
   124  	rewards = k.calculateDelegationRewards(ctx, val, del, endingPeriod)
   125  
   126  	// rewards should be half the tokens
   127  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.QuoRaw(2).ToDec()}}, rewards)
   128  
   129  	// commission should be the other half
   130  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.QuoRaw(2).ToDec()}},
   131  		k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
   132  }
   133  
   134  func TestCalculateRewardsAfterManySlashes(t *testing.T) {
   135  	ctx, _, k, sk, _ := CreateTestInputDefault(t, false, 1000)
   136  	sh := staking.NewHandler(sk)
   137  
   138  	// create validator with 50% commission
   139  	power := int64(100)
   140  	valTokens := sdk.TokensFromConsensusPower(power)
   141  	commission := staking.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
   142  	msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
   143  		sdk.NewCoin(sdk.DefaultBondDenom, valTokens), staking.Description{}, commission, sdk.OneInt())
   144  
   145  	res, err := sh(ctx, msg)
   146  	require.NoError(t, err)
   147  	require.NotNil(t, res)
   148  
   149  	// end block to bond validator
   150  	staking.EndBlocker(ctx, sk)
   151  
   152  	// next block
   153  	ctx.SetBlockHeight(ctx.BlockHeight() + 1)
   154  
   155  	// fetch validator and delegation
   156  	val := sk.Validator(ctx, valOpAddr1)
   157  	del := sk.Delegation(ctx, sdk.AccAddress(valOpAddr1), valOpAddr1)
   158  
   159  	// end period
   160  	endingPeriod := k.incrementValidatorPeriod(ctx, val)
   161  
   162  	// calculate delegation rewards
   163  	rewards := k.calculateDelegationRewards(ctx, val, del, endingPeriod)
   164  
   165  	// rewards should be zero
   166  	require.True(t, rewards.IsZero())
   167  
   168  	// start out block height
   169  	ctx.SetBlockHeight(ctx.BlockHeight() + 3)
   170  
   171  	// slash the validator by 50%
   172  	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power, sdk.NewDecWithPrec(5, 1))
   173  
   174  	// fetch the validator again
   175  	val = sk.Validator(ctx, valOpAddr1)
   176  
   177  	// increase block height
   178  	ctx.SetBlockHeight(ctx.BlockHeight() + 3)
   179  
   180  	// allocate some rewards
   181  	initial := sdk.TokensFromConsensusPower(10)
   182  	tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.ToDec()}}
   183  	k.AllocateTokensToValidator(ctx, val, tokens)
   184  
   185  	// slash the validator by 50% again
   186  	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power/2, sdk.NewDecWithPrec(5, 1))
   187  
   188  	// fetch the validator again
   189  	val = sk.Validator(ctx, valOpAddr1)
   190  
   191  	// increase block height
   192  	ctx.SetBlockHeight(ctx.BlockHeight() + 3)
   193  
   194  	// allocate some more rewards
   195  	k.AllocateTokensToValidator(ctx, val, tokens)
   196  
   197  	// end period
   198  	endingPeriod = k.incrementValidatorPeriod(ctx, val)
   199  
   200  	// calculate delegation rewards
   201  	rewards = k.calculateDelegationRewards(ctx, val, del, endingPeriod)
   202  
   203  	// rewards should be half the tokens
   204  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.ToDec()}}, rewards)
   205  
   206  	// commission should be the other half
   207  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.ToDec()}},
   208  		k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
   209  }
   210  
   211  func TestCalculateRewardsMultiDelegator(t *testing.T) {
   212  	ctx, _, k, sk, _ := CreateTestInputDefault(t, false, 1000)
   213  	sh := staking.NewHandler(sk)
   214  
   215  	// create validator with 50% commission
   216  	commission := staking.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
   217  	msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
   218  		sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100)), staking.Description{}, commission, sdk.OneInt())
   219  
   220  	res, err := sh(ctx, msg)
   221  	require.NoError(t, err)
   222  	require.NotNil(t, res)
   223  
   224  	// end block to bond validator
   225  	staking.EndBlocker(ctx, sk)
   226  
   227  	// next block
   228  	ctx.SetBlockHeight(ctx.BlockHeight() + 1)
   229  
   230  	// fetch validator and delegation
   231  	val := sk.Validator(ctx, valOpAddr1)
   232  	del1 := sk.Delegation(ctx, sdk.AccAddress(valOpAddr1), valOpAddr1)
   233  
   234  	// allocate some rewards
   235  	initial := int64(20)
   236  	tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDec(initial)}}
   237  	k.AllocateTokensToValidator(ctx, val, tokens)
   238  
   239  	// second delegation
   240  	msg2 := staking.NewMsgDelegate(sdk.AccAddress(valOpAddr2), valOpAddr1, sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100)))
   241  
   242  	res, err = sh(ctx, msg2)
   243  	require.NoError(t, err)
   244  	require.NotNil(t, res)
   245  
   246  	del2 := sk.Delegation(ctx, sdk.AccAddress(valOpAddr2), valOpAddr1)
   247  
   248  	// fetch updated validator
   249  	val = sk.Validator(ctx, valOpAddr1)
   250  
   251  	// end block
   252  	staking.EndBlocker(ctx, sk)
   253  
   254  	// next block
   255  	ctx.SetBlockHeight(ctx.BlockHeight() + 1)
   256  
   257  	// allocate some more rewards
   258  	k.AllocateTokensToValidator(ctx, val, tokens)
   259  
   260  	// end period
   261  	endingPeriod := k.incrementValidatorPeriod(ctx, val)
   262  
   263  	// calculate delegation rewards for del1
   264  	rewards := k.calculateDelegationRewards(ctx, val, del1, endingPeriod)
   265  
   266  	// rewards for del1 should be 3/4 initial
   267  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDec(initial * 3 / 4)}}, rewards)
   268  
   269  	// calculate delegation rewards for del2
   270  	rewards = k.calculateDelegationRewards(ctx, val, del2, endingPeriod)
   271  
   272  	// rewards for del2 should be 1/4 initial
   273  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDec(initial * 1 / 4)}}, rewards)
   274  
   275  	// commission should be equal to initial (50% twice)
   276  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDec(initial)}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
   277  }
   278  
   279  func TestWithdrawDelegationRewardsBasic(t *testing.T) {
   280  	balancePower := int64(1000)
   281  	balanceTokens := sdk.TokensFromConsensusPower(balancePower)
   282  	ctx, ak, k, sk, _ := CreateTestInputDefault(t, false, balancePower)
   283  	sh := staking.NewHandler(sk)
   284  
   285  	// set module account coins
   286  	distrAcc := k.GetDistributionAccount(ctx)
   287  	distrAcc.SetCoins(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, balanceTokens)))
   288  	k.supplyKeeper.SetModuleAccount(ctx, distrAcc)
   289  
   290  	// create validator with 50% commission
   291  	power := int64(100)
   292  	valTokens := sdk.TokensFromConsensusPower(power)
   293  	commission := staking.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
   294  	msg := staking.NewMsgCreateValidator(
   295  		valOpAddr1, valConsPk1,
   296  		sdk.NewCoin(sdk.DefaultBondDenom, valTokens),
   297  		staking.Description{}, commission, sdk.OneInt(),
   298  	)
   299  
   300  	res, err := sh(ctx, msg)
   301  	require.NoError(t, err)
   302  	require.NotNil(t, res)
   303  
   304  	// assert correct initial balance
   305  	expTokens := balanceTokens.Sub(valTokens)
   306  	require.Equal(t,
   307  		sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, expTokens)},
   308  		ak.GetAccount(ctx, sdk.AccAddress(valOpAddr1)).GetCoins(),
   309  	)
   310  
   311  	// end block to bond validator
   312  	staking.EndBlocker(ctx, sk)
   313  
   314  	// next block
   315  	ctx.SetBlockHeight(ctx.BlockHeight() + 1)
   316  
   317  	// fetch validator and delegation
   318  	val := sk.Validator(ctx, valOpAddr1)
   319  
   320  	// allocate some rewards
   321  	initial := sdk.TokensFromConsensusPower(10)
   322  	tokens := sdk.DecCoins{sdk.NewDecCoin(sdk.DefaultBondDenom, initial)}
   323  
   324  	k.AllocateTokensToValidator(ctx, val, tokens)
   325  
   326  	// historical count should be 2 (initial + latest for delegation)
   327  	require.Equal(t, uint64(2), k.GetValidatorHistoricalReferenceCount(ctx))
   328  
   329  	// withdraw rewards
   330  	_, err = k.WithdrawDelegationRewards(ctx, sdk.AccAddress(valOpAddr1), valOpAddr1)
   331  	require.Nil(t, err)
   332  
   333  	// historical count should still be 2 (added one record, cleared one)
   334  	require.Equal(t, uint64(2), k.GetValidatorHistoricalReferenceCount(ctx))
   335  
   336  	// assert correct balance
   337  	exp := balanceTokens.Sub(valTokens).Add(initial.QuoRaw(2))
   338  	require.Equal(t,
   339  		sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, exp)},
   340  		ak.GetAccount(ctx, sdk.AccAddress(valOpAddr1)).GetCoins(),
   341  	)
   342  
   343  	// withdraw commission
   344  	_, err = k.WithdrawValidatorCommission(ctx, valOpAddr1)
   345  	require.Nil(t, err)
   346  
   347  	// assert correct balance
   348  	exp = balanceTokens.Sub(valTokens).Add(initial)
   349  	require.Equal(t,
   350  		sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, exp)},
   351  		ak.GetAccount(ctx, sdk.AccAddress(valOpAddr1)).GetCoins(),
   352  	)
   353  }
   354  
   355  func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) {
   356  	ctx, _, k, sk, _ := CreateTestInputDefault(t, false, 1000)
   357  	sh := staking.NewHandler(sk)
   358  
   359  	// create validator with 50% commission
   360  	power := int64(100)
   361  	valTokens := sdk.TokensFromConsensusPower(power)
   362  	commission := staking.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
   363  	msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
   364  		sdk.NewCoin(sdk.DefaultBondDenom, valTokens), staking.Description{}, commission, sdk.OneInt())
   365  
   366  	res, err := sh(ctx, msg)
   367  	require.NoError(t, err)
   368  	require.NotNil(t, res)
   369  
   370  	// end block to bond validator
   371  	staking.EndBlocker(ctx, sk)
   372  
   373  	// next block
   374  	ctx.SetBlockHeight(ctx.BlockHeight() + 1)
   375  
   376  	// fetch validator and delegation
   377  	val := sk.Validator(ctx, valOpAddr1)
   378  	del := sk.Delegation(ctx, sdk.AccAddress(valOpAddr1), valOpAddr1)
   379  
   380  	// end period
   381  	endingPeriod := k.incrementValidatorPeriod(ctx, val)
   382  
   383  	// calculate delegation rewards
   384  	rewards := k.calculateDelegationRewards(ctx, val, del, endingPeriod)
   385  
   386  	// rewards should be zero
   387  	require.True(t, rewards.IsZero())
   388  
   389  	// start out block height
   390  	ctx.SetBlockHeight(ctx.BlockHeight() + 3)
   391  
   392  	// allocate some rewards
   393  	initial := sdk.TokensFromConsensusPower(10).ToDec()
   394  	tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}
   395  	k.AllocateTokensToValidator(ctx, val, tokens)
   396  
   397  	// slash the validator by 50%
   398  	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power, sdk.NewDecWithPrec(5, 1))
   399  
   400  	// slash the validator by 50% again
   401  	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power/2, sdk.NewDecWithPrec(5, 1))
   402  
   403  	// fetch the validator again
   404  	val = sk.Validator(ctx, valOpAddr1)
   405  
   406  	// increase block height
   407  	ctx.SetBlockHeight(ctx.BlockHeight() + 3)
   408  
   409  	// allocate some more rewards
   410  	k.AllocateTokensToValidator(ctx, val, tokens)
   411  
   412  	// end period
   413  	endingPeriod = k.incrementValidatorPeriod(ctx, val)
   414  
   415  	// calculate delegation rewards
   416  	rewards = k.calculateDelegationRewards(ctx, val, del, endingPeriod)
   417  
   418  	// rewards should be half the tokens
   419  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}, rewards)
   420  
   421  	// commission should be the other half
   422  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
   423  }
   424  
   425  func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
   426  	ctx, _, k, sk, _ := CreateTestInputDefault(t, false, 1000)
   427  	sh := staking.NewHandler(sk)
   428  
   429  	// create validator with 50% commission
   430  	commission := staking.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
   431  	power := int64(100)
   432  	valTokens := sdk.TokensFromConsensusPower(power)
   433  	msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
   434  		sdk.NewCoin(sdk.DefaultBondDenom, valTokens), staking.Description{}, commission, sdk.OneInt())
   435  
   436  	res, err := sh(ctx, msg)
   437  	require.NoError(t, err)
   438  	require.NotNil(t, res)
   439  
   440  	// end block to bond validator
   441  	staking.EndBlocker(ctx, sk)
   442  
   443  	// next block
   444  	ctx.SetBlockHeight(ctx.BlockHeight() + 1)
   445  
   446  	// fetch validator and delegation
   447  	val := sk.Validator(ctx, valOpAddr1)
   448  	del1 := sk.Delegation(ctx, sdk.AccAddress(valOpAddr1), valOpAddr1)
   449  
   450  	// allocate some rewards
   451  	initial := sdk.TokensFromConsensusPower(30).ToDec()
   452  	tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}
   453  	k.AllocateTokensToValidator(ctx, val, tokens)
   454  
   455  	// slash the validator
   456  	ctx.SetBlockHeight(ctx.BlockHeight() + 3)
   457  	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power, sdk.NewDecWithPrec(5, 1))
   458  	ctx.SetBlockHeight(ctx.BlockHeight() + 3)
   459  
   460  	// second delegation
   461  	delTokens := sdk.TokensFromConsensusPower(100)
   462  	msg2 := staking.NewMsgDelegate(sdk.AccAddress(valOpAddr2), valOpAddr1,
   463  		sdk.NewCoin(sdk.DefaultBondDenom, delTokens))
   464  
   465  	res, err = sh(ctx, msg2)
   466  	require.NoError(t, err)
   467  	require.NotNil(t, res)
   468  
   469  	del2 := sk.Delegation(ctx, sdk.AccAddress(valOpAddr2), valOpAddr1)
   470  
   471  	// end block
   472  	staking.EndBlocker(ctx, sk)
   473  
   474  	// next block
   475  	ctx.SetBlockHeight(ctx.BlockHeight() + 1)
   476  
   477  	// allocate some more rewards
   478  	k.AllocateTokensToValidator(ctx, val, tokens)
   479  
   480  	// slash the validator again
   481  	ctx.SetBlockHeight(ctx.BlockHeight() + 3)
   482  	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power, sdk.NewDecWithPrec(5, 1))
   483  	ctx.SetBlockHeight(ctx.BlockHeight() + 3)
   484  
   485  	// fetch updated validator
   486  	val = sk.Validator(ctx, valOpAddr1)
   487  
   488  	// end period
   489  	endingPeriod := k.incrementValidatorPeriod(ctx, val)
   490  
   491  	// calculate delegation rewards for del1
   492  	rewards := k.calculateDelegationRewards(ctx, val, del1, endingPeriod)
   493  
   494  	// rewards for del1 should be 2/3 initial (half initial first period, 1/6 initial second period)
   495  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.QuoInt64(2).Add(initial.QuoInt64(6))}}, rewards)
   496  
   497  	// calculate delegation rewards for del2
   498  	rewards = k.calculateDelegationRewards(ctx, val, del2, endingPeriod)
   499  
   500  	// rewards for del2 should be initial / 3
   501  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.QuoInt64(3)}}, rewards)
   502  
   503  	// commission should be equal to initial (twice 50% commission, unaffected by slashing)
   504  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
   505  }
   506  
   507  func TestCalculateRewardsMultiDelegatorMultWithdraw(t *testing.T) {
   508  	ctx, _, k, sk, _ := CreateTestInputDefault(t, false, 1000)
   509  	sh := staking.NewHandler(sk)
   510  	initial := int64(20)
   511  
   512  	// set module account coins
   513  	distrAcc := k.GetDistributionAccount(ctx)
   514  	distrAcc.SetCoins(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1000))))
   515  	k.supplyKeeper.SetModuleAccount(ctx, distrAcc)
   516  
   517  	tokens := sdk.DecCoins{sdk.NewDecCoinFromDec(sdk.DefaultBondDenom, sdk.NewDec(initial))}
   518  
   519  	// create validator with 50% commission
   520  	commission := staking.NewCommissionRates(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
   521  	msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
   522  		sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100)), staking.Description{}, commission, sdk.OneInt())
   523  
   524  	res, err := sh(ctx, msg)
   525  	require.NoError(t, err)
   526  	require.NotNil(t, res)
   527  
   528  	// end block to bond validator
   529  	staking.EndBlocker(ctx, sk)
   530  
   531  	// next block
   532  	ctx.SetBlockHeight(ctx.BlockHeight() + 1)
   533  
   534  	// fetch validator and delegation
   535  	val := sk.Validator(ctx, valOpAddr1)
   536  	del1 := sk.Delegation(ctx, sdk.AccAddress(valOpAddr1), valOpAddr1)
   537  
   538  	// allocate some rewards
   539  	k.AllocateTokensToValidator(ctx, val, tokens)
   540  
   541  	// historical count should be 2 (validator init, delegation init)
   542  	require.Equal(t, uint64(2), k.GetValidatorHistoricalReferenceCount(ctx))
   543  
   544  	// second delegation
   545  	msg2 := staking.NewMsgDelegate(sdk.AccAddress(valOpAddr2), valOpAddr1, sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100)))
   546  	res, err = sh(ctx, msg2)
   547  	require.NoError(t, err)
   548  	require.NotNil(t, res)
   549  
   550  	// historical count should be 3 (second delegation init)
   551  	require.Equal(t, uint64(3), k.GetValidatorHistoricalReferenceCount(ctx))
   552  
   553  	// fetch updated validator
   554  	val = sk.Validator(ctx, valOpAddr1)
   555  	del2 := sk.Delegation(ctx, sdk.AccAddress(valOpAddr2), valOpAddr1)
   556  
   557  	// end block
   558  	staking.EndBlocker(ctx, sk)
   559  
   560  	// next block
   561  	ctx.SetBlockHeight(ctx.BlockHeight() + 1)
   562  
   563  	// allocate some more rewards
   564  	k.AllocateTokensToValidator(ctx, val, tokens)
   565  
   566  	// first delegator withdraws
   567  	k.WithdrawDelegationRewards(ctx, sdk.AccAddress(valOpAddr1), valOpAddr1)
   568  
   569  	// second delegator withdraws
   570  	k.WithdrawDelegationRewards(ctx, sdk.AccAddress(valOpAddr2), valOpAddr1)
   571  
   572  	// historical count should be 3 (validator init + two delegations)
   573  	require.Equal(t, uint64(3), k.GetValidatorHistoricalReferenceCount(ctx))
   574  
   575  	// validator withdraws commission
   576  	k.WithdrawValidatorCommission(ctx, valOpAddr1)
   577  
   578  	// end period
   579  	endingPeriod := k.incrementValidatorPeriod(ctx, val)
   580  
   581  	// calculate delegation rewards for del1
   582  	rewards := k.calculateDelegationRewards(ctx, val, del1, endingPeriod)
   583  
   584  	// rewards for del1 should be zero
   585  	require.True(t, rewards.IsZero())
   586  
   587  	// calculate delegation rewards for del2
   588  	rewards = k.calculateDelegationRewards(ctx, val, del2, endingPeriod)
   589  
   590  	// rewards for del2 should be zero
   591  	require.True(t, rewards.IsZero())
   592  
   593  	// commission should be zero
   594  	require.True(t, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1).IsZero())
   595  
   596  	// next block
   597  	ctx.SetBlockHeight(ctx.BlockHeight() + 1)
   598  
   599  	// allocate some more rewards
   600  	k.AllocateTokensToValidator(ctx, val, tokens)
   601  
   602  	// first delegator withdraws again
   603  	k.WithdrawDelegationRewards(ctx, sdk.AccAddress(valOpAddr1), valOpAddr1)
   604  
   605  	// end period
   606  	endingPeriod = k.incrementValidatorPeriod(ctx, val)
   607  
   608  	// calculate delegation rewards for del1
   609  	rewards = k.calculateDelegationRewards(ctx, val, del1, endingPeriod)
   610  
   611  	// rewards for del1 should be zero
   612  	require.True(t, rewards.IsZero())
   613  
   614  	// calculate delegation rewards for del2
   615  	rewards = k.calculateDelegationRewards(ctx, val, del2, endingPeriod)
   616  
   617  	// rewards for del2 should be 1/4 initial
   618  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDec(initial / 4)}}, rewards)
   619  
   620  	// commission should be half initial
   621  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDec(initial / 2)}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
   622  
   623  	// next block
   624  	ctx.SetBlockHeight(ctx.BlockHeight() + 1)
   625  
   626  	// allocate some more rewards
   627  	k.AllocateTokensToValidator(ctx, val, tokens)
   628  
   629  	// withdraw commission
   630  	k.WithdrawValidatorCommission(ctx, valOpAddr1)
   631  
   632  	// end period
   633  	endingPeriod = k.incrementValidatorPeriod(ctx, val)
   634  
   635  	// calculate delegation rewards for del1
   636  	rewards = k.calculateDelegationRewards(ctx, val, del1, endingPeriod)
   637  
   638  	// rewards for del1 should be 1/4 initial
   639  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDec(initial / 4)}}, rewards)
   640  
   641  	// calculate delegation rewards for del2
   642  	rewards = k.calculateDelegationRewards(ctx, val, del2, endingPeriod)
   643  
   644  	// rewards for del2 should be 1/2 initial
   645  	require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDec(initial / 2)}}, rewards)
   646  
   647  	// commission should be zero
   648  	require.True(t, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1).IsZero())
   649  }