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

     1  package keeper
     2  
     3  import (
     4  	"testing"
     5  	"time"
     6  
     7  	sdk "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"
     8  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/staking/types"
     9  
    10  	"github.com/stretchr/testify/assert"
    11  	"github.com/stretchr/testify/require"
    12  )
    13  
    14  // tests GetDelegation, GetDelegatorDelegations, SetDelegation, RemoveDelegation, GetDelegatorDelegations
    15  func TestDelegation(t *testing.T) {
    16  	ctx, _, keeper, _ := CreateTestInput(t, false, 10)
    17  
    18  	//construct the validators
    19  	amts := []sdk.Int{sdk.NewInt(9), sdk.NewInt(8), sdk.NewInt(7)}
    20  	var validators [3]types.Validator
    21  	for i, amt := range amts {
    22  		validators[i] = types.NewValidator(addrVals[i], PKs[i], types.Description{})
    23  		validators[i], _ = validators[i].AddTokensFromDel(amt)
    24  	}
    25  
    26  	validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true)
    27  	validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], true)
    28  	validators[2] = TestingUpdateValidator(keeper, ctx, validators[2], true)
    29  
    30  	// first add a validators[0] to delegate too
    31  
    32  	bond1to1 := types.NewDelegation(addrDels[0], addrVals[0], sdk.NewDec(9))
    33  
    34  	// check the empty keeper first
    35  	_, found := keeper.GetDelegation(ctx, addrDels[0], addrVals[0])
    36  	require.False(t, found)
    37  
    38  	// set and retrieve a record
    39  	keeper.SetDelegation(ctx, bond1to1)
    40  	resBond, found := keeper.GetDelegation(ctx, addrDels[0], addrVals[0])
    41  	require.True(t, found)
    42  	require.True(t, bond1to1.Equal(resBond))
    43  
    44  	// modify a records, save, and retrieve
    45  	bond1to1.Shares = sdk.NewDec(99)
    46  	keeper.SetDelegation(ctx, bond1to1)
    47  	resBond, found = keeper.GetDelegation(ctx, addrDels[0], addrVals[0])
    48  	require.True(t, found)
    49  	require.True(t, bond1to1.Equal(resBond))
    50  
    51  	// add some more records
    52  	bond1to2 := types.NewDelegation(addrDels[0], addrVals[1], sdk.NewDec(9))
    53  	bond1to3 := types.NewDelegation(addrDels[0], addrVals[2], sdk.NewDec(9))
    54  	bond2to1 := types.NewDelegation(addrDels[1], addrVals[0], sdk.NewDec(9))
    55  	bond2to2 := types.NewDelegation(addrDels[1], addrVals[1], sdk.NewDec(9))
    56  	bond2to3 := types.NewDelegation(addrDels[1], addrVals[2], sdk.NewDec(9))
    57  	keeper.SetDelegation(ctx, bond1to2)
    58  	keeper.SetDelegation(ctx, bond1to3)
    59  	keeper.SetDelegation(ctx, bond2to1)
    60  	keeper.SetDelegation(ctx, bond2to2)
    61  	keeper.SetDelegation(ctx, bond2to3)
    62  
    63  	// test all bond retrieve capabilities
    64  	resBonds := keeper.GetDelegatorDelegations(ctx, addrDels[0], 5)
    65  	require.Equal(t, 3, len(resBonds))
    66  	require.True(t, bond1to1.Equal(resBonds[0]))
    67  	require.True(t, bond1to2.Equal(resBonds[1]))
    68  	require.True(t, bond1to3.Equal(resBonds[2]))
    69  	resBonds = keeper.GetAllDelegatorDelegations(ctx, addrDels[0])
    70  	require.Equal(t, 3, len(resBonds))
    71  	resBonds = keeper.GetDelegatorDelegations(ctx, addrDels[0], 2)
    72  	require.Equal(t, 2, len(resBonds))
    73  	resBonds = keeper.GetDelegatorDelegations(ctx, addrDels[1], 5)
    74  	require.Equal(t, 3, len(resBonds))
    75  	require.True(t, bond2to1.Equal(resBonds[0]))
    76  	require.True(t, bond2to2.Equal(resBonds[1]))
    77  	require.True(t, bond2to3.Equal(resBonds[2]))
    78  	allBonds := keeper.GetAllDelegations(ctx)
    79  	require.Equal(t, 6, len(allBonds))
    80  	require.True(t, bond1to1.Equal(allBonds[0]))
    81  	require.True(t, bond1to2.Equal(allBonds[1]))
    82  	require.True(t, bond1to3.Equal(allBonds[2]))
    83  	require.True(t, bond2to1.Equal(allBonds[3]))
    84  	require.True(t, bond2to2.Equal(allBonds[4]))
    85  	require.True(t, bond2to3.Equal(allBonds[5]))
    86  
    87  	resVals := keeper.GetDelegatorValidators(ctx, addrDels[0], 3)
    88  	require.Equal(t, 3, len(resVals))
    89  	resVals = keeper.GetDelegatorValidators(ctx, addrDels[1], 4)
    90  	require.Equal(t, 3, len(resVals))
    91  
    92  	for i := 0; i < 3; i++ {
    93  
    94  		resVal, err := keeper.GetDelegatorValidator(ctx, addrDels[0], addrVals[i])
    95  		require.Nil(t, err)
    96  		require.Equal(t, addrVals[i], resVal.GetOperator())
    97  
    98  		resVal, err = keeper.GetDelegatorValidator(ctx, addrDels[1], addrVals[i])
    99  		require.Nil(t, err)
   100  		require.Equal(t, addrVals[i], resVal.GetOperator())
   101  
   102  		resDels := keeper.GetValidatorDelegations(ctx, addrVals[i])
   103  		require.Len(t, resDels, 2)
   104  	}
   105  
   106  	// delete a record
   107  	keeper.RemoveDelegation(ctx, bond2to3)
   108  	_, found = keeper.GetDelegation(ctx, addrDels[1], addrVals[2])
   109  	require.False(t, found)
   110  	resBonds = keeper.GetDelegatorDelegations(ctx, addrDels[1], 5)
   111  	require.Equal(t, 2, len(resBonds))
   112  	require.True(t, bond2to1.Equal(resBonds[0]))
   113  	require.True(t, bond2to2.Equal(resBonds[1]))
   114  
   115  	resBonds = keeper.GetAllDelegatorDelegations(ctx, addrDels[1])
   116  	require.Equal(t, 2, len(resBonds))
   117  
   118  	// delete all the records from delegator 2
   119  	keeper.RemoveDelegation(ctx, bond2to1)
   120  	keeper.RemoveDelegation(ctx, bond2to2)
   121  	_, found = keeper.GetDelegation(ctx, addrDels[1], addrVals[0])
   122  	require.False(t, found)
   123  	_, found = keeper.GetDelegation(ctx, addrDels[1], addrVals[1])
   124  	require.False(t, found)
   125  	resBonds = keeper.GetDelegatorDelegations(ctx, addrDels[1], 5)
   126  	require.Equal(t, 0, len(resBonds))
   127  }
   128  
   129  // tests Get/Set/Remove UnbondingDelegation
   130  func TestUnbondingDelegation(t *testing.T) {
   131  	ctx, _, keeper, _ := CreateTestInput(t, false, 0)
   132  
   133  	ubd := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 0,
   134  		time.Unix(0, 0), sdk.NewInt(5))
   135  
   136  	// set and retrieve a record
   137  	keeper.SetUnbondingDelegation(ctx, ubd)
   138  	resUnbond, found := keeper.GetUnbondingDelegation(ctx, addrDels[0], addrVals[0])
   139  	require.True(t, found)
   140  	require.True(t, ubd.Equal(resUnbond))
   141  
   142  	// modify a records, save, and retrieve
   143  	ubd.Entries[0].Balance = sdk.NewInt(21)
   144  	keeper.SetUnbondingDelegation(ctx, ubd)
   145  
   146  	resUnbonds := keeper.GetUnbondingDelegations(ctx, addrDels[0], 5)
   147  	require.Equal(t, 1, len(resUnbonds))
   148  
   149  	resUnbonds = keeper.GetAllUnbondingDelegations(ctx, addrDels[0])
   150  	require.Equal(t, 1, len(resUnbonds))
   151  
   152  	resUnbond, found = keeper.GetUnbondingDelegation(ctx, addrDels[0], addrVals[0])
   153  	require.True(t, found)
   154  	require.True(t, ubd.Equal(resUnbond))
   155  
   156  	// delete a record
   157  	keeper.RemoveUnbondingDelegation(ctx, ubd)
   158  	_, found = keeper.GetUnbondingDelegation(ctx, addrDels[0], addrVals[0])
   159  	require.False(t, found)
   160  
   161  	resUnbonds = keeper.GetUnbondingDelegations(ctx, addrDels[0], 5)
   162  	require.Equal(t, 0, len(resUnbonds))
   163  
   164  	resUnbonds = keeper.GetAllUnbondingDelegations(ctx, addrDels[0])
   165  	require.Equal(t, 0, len(resUnbonds))
   166  
   167  }
   168  
   169  func TestUnbondDelegation(t *testing.T) {
   170  	ctx, _, keeper, _ := CreateTestInput(t, false, 0)
   171  
   172  	startTokens := sdk.TokensFromConsensusPower(10)
   173  
   174  	notBondedPool := keeper.GetNotBondedPool(ctx)
   175  	err := notBondedPool.SetCoins(sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), startTokens)))
   176  	require.NoError(t, err)
   177  	keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool)
   178  
   179  	// create a validator and a delegator to that validator
   180  	// note this validator starts not-bonded
   181  	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
   182  
   183  	validator, issuedShares := validator.AddTokensFromDel(startTokens)
   184  	require.Equal(t, startTokens, issuedShares.RoundInt())
   185  
   186  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   187  
   188  	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
   189  	keeper.SetDelegation(ctx, delegation)
   190  
   191  	bondTokens := sdk.TokensFromConsensusPower(6)
   192  	amount, err := keeper.unbond(ctx, addrDels[0], addrVals[0], bondTokens.ToDec())
   193  	require.NoError(t, err)
   194  	require.Equal(t, bondTokens, amount) // shares to be added to an unbonding delegation
   195  
   196  	delegation, found := keeper.GetDelegation(ctx, addrDels[0], addrVals[0])
   197  	require.True(t, found)
   198  	validator, found = keeper.GetValidator(ctx, addrVals[0])
   199  	require.True(t, found)
   200  
   201  	remainingTokens := startTokens.Sub(bondTokens)
   202  	require.Equal(t, remainingTokens, delegation.Shares.RoundInt())
   203  	require.Equal(t, remainingTokens, validator.BondedTokens())
   204  }
   205  
   206  func TestUnbondingDelegationsMaxEntries(t *testing.T) {
   207  	ctx, _, keeper, _ := CreateTestInput(t, false, 1)
   208  	startTokens := sdk.TokensFromConsensusPower(10)
   209  	bondDenom := keeper.BondDenom(ctx)
   210  
   211  	notBondedPool := keeper.GetNotBondedPool(ctx)
   212  	err := notBondedPool.SetCoins(sdk.NewCoins(sdk.NewCoin(bondDenom, startTokens)))
   213  	require.NoError(t, err)
   214  	keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool)
   215  
   216  	// create a validator and a delegator to that validator
   217  	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
   218  
   219  	validator, issuedShares := validator.AddTokensFromDel(startTokens)
   220  	require.Equal(t, startTokens, issuedShares.RoundInt())
   221  
   222  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   223  	require.True(sdk.IntEq(t, startTokens, validator.BondedTokens()))
   224  	require.True(t, validator.IsBonded())
   225  
   226  	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
   227  	keeper.SetDelegation(ctx, delegation)
   228  
   229  	maxEntries := keeper.MaxEntries(ctx)
   230  
   231  	oldBonded := keeper.GetBondedPool(ctx).GetCoins().AmountOf(bondDenom)
   232  	oldNotBonded := keeper.GetNotBondedPool(ctx).GetCoins().AmountOf(bondDenom)
   233  
   234  	// should all pass
   235  	var completionTime time.Time
   236  	for i := uint16(0); i < maxEntries; i++ {
   237  		var err error
   238  		completionTime, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDec(1))
   239  		require.NoError(t, err)
   240  	}
   241  
   242  	bondedPool := keeper.GetBondedPool(ctx)
   243  	notBondedPool = keeper.GetNotBondedPool(ctx)
   244  	require.True(sdk.DecEq(t, bondedPool.GetCoins().AmountOf(bondDenom), oldBonded.Sub(sdk.NewDec(int64(maxEntries)))))
   245  	require.True(sdk.DecEq(t, notBondedPool.GetCoins().AmountOf(bondDenom), oldNotBonded.Add(sdk.NewDec(int64(maxEntries)))))
   246  
   247  	oldBonded = bondedPool.GetCoins().AmountOf(bondDenom)
   248  	oldNotBonded = notBondedPool.GetCoins().AmountOf(bondDenom)
   249  
   250  	// an additional unbond should fail due to max entries
   251  	_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDec(1))
   252  	require.Error(t, err)
   253  
   254  	bondedPool = keeper.GetBondedPool(ctx)
   255  	notBondedPool = keeper.GetNotBondedPool(ctx)
   256  	require.True(sdk.DecEq(t, bondedPool.GetCoins().AmountOf(bondDenom), oldBonded))
   257  	require.True(sdk.DecEq(t, notBondedPool.GetCoins().AmountOf(bondDenom), oldNotBonded))
   258  
   259  	// mature unbonding delegations
   260  	ctx.SetBlockTime(completionTime)
   261  	err = keeper.CompleteUnbonding(ctx, addrDels[0], addrVals[0])
   262  	require.NoError(t, err)
   263  
   264  	bondedPool = keeper.GetBondedPool(ctx)
   265  	notBondedPool = keeper.GetNotBondedPool(ctx)
   266  	require.True(sdk.DecEq(t, bondedPool.GetCoins().AmountOf(bondDenom), oldBonded))
   267  	require.True(sdk.DecEq(t, notBondedPool.GetCoins().AmountOf(bondDenom), oldNotBonded.Sub(sdk.NewDec(int64(maxEntries)))))
   268  
   269  	oldNotBonded = notBondedPool.GetCoins().AmountOf(bondDenom)
   270  
   271  	// unbonding  should work again
   272  	_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDec(1))
   273  	require.NoError(t, err)
   274  
   275  	bondedPool = keeper.GetBondedPool(ctx)
   276  
   277  	notBondedPool = keeper.GetNotBondedPool(ctx)
   278  	require.True(sdk.DecEq(t, bondedPool.GetCoins().AmountOf(bondDenom), oldBonded.Sub(sdk.NewDec(int64(1)))))
   279  	require.True(sdk.DecEq(t, notBondedPool.GetCoins().AmountOf(bondDenom), oldNotBonded.Add(sdk.NewDec(int64(1)))))
   280  }
   281  
   282  // test undelegating self delegation from a validator pushing it below MinSelfDelegation
   283  // shift it from the bonded to unbonding state and jailed
   284  func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) {
   285  
   286  	ctx, _, keeper, _ := CreateTestInput(t, false, 0)
   287  	delTokens := sdk.TokensFromConsensusPower(10)
   288  	delCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), delTokens))
   289  
   290  	//create a validator with a self-delegation
   291  	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
   292  
   293  	validator.MinSelfDelegation = delTokens
   294  	validator, issuedShares := validator.AddTokensFromDel(delTokens)
   295  	require.Equal(t, delTokens, issuedShares.RoundInt())
   296  
   297  	// add bonded tokens to pool for delegations
   298  	notBondedPool := keeper.GetNotBondedPool(ctx)
   299  	err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(delCoins...))
   300  	require.NoError(t, err)
   301  	keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool)
   302  
   303  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   304  	require.True(t, validator.IsBonded())
   305  
   306  	selfDelegation := types.NewDelegation(sdk.AccAddress(addrVals[0].Bytes()), addrVals[0], issuedShares)
   307  	keeper.SetDelegation(ctx, selfDelegation)
   308  
   309  	// add bonded tokens to pool for delegations
   310  	bondedPool := keeper.GetBondedPool(ctx)
   311  	err = bondedPool.SetCoins(bondedPool.GetCoins().Add(delCoins...))
   312  	require.NoError(t, err)
   313  	keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool)
   314  
   315  	// create a second delegation to this validator
   316  	keeper.DeleteValidatorByPowerIndex(ctx, validator)
   317  	validator, issuedShares = validator.AddTokensFromDel(delTokens)
   318  	require.True(t, validator.IsBonded())
   319  	require.Equal(t, delTokens, issuedShares.RoundInt())
   320  
   321  	// add bonded tokens to pool for delegations
   322  	bondedPool = keeper.GetBondedPool(ctx)
   323  	err = bondedPool.SetCoins(bondedPool.GetCoins().Add(delCoins...))
   324  	require.NoError(t, err)
   325  	keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool)
   326  
   327  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   328  	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
   329  	keeper.SetDelegation(ctx, delegation)
   330  
   331  	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
   332  	_, err = keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.TokensFromConsensusPower(6).ToDec())
   333  	require.NoError(t, err)
   334  
   335  	// end block
   336  	updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx)
   337  	require.Equal(t, 1, len(updates))
   338  
   339  	validator, found := keeper.GetValidator(ctx, addrVals[0])
   340  	require.True(t, found)
   341  	require.Equal(t, sdk.TokensFromConsensusPower(14), validator.Tokens)
   342  	require.Equal(t, sdk.Unbonding, validator.Status)
   343  	require.True(t, validator.Jailed)
   344  }
   345  
   346  func TestUndelegateFromUnbondingValidator(t *testing.T) {
   347  	ctx, _, keeper, _ := CreateTestInput(t, false, 0)
   348  	delTokens := sdk.TokensFromConsensusPower(10)
   349  	delCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), delTokens))
   350  
   351  	//create a validator with a self-delegation
   352  	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
   353  
   354  	validator, issuedShares := validator.AddTokensFromDel(delTokens)
   355  	require.Equal(t, delTokens, issuedShares.RoundInt())
   356  
   357  	// add bonded tokens to pool for delegations
   358  	notBondedPool := keeper.GetNotBondedPool(ctx)
   359  	err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(delCoins...))
   360  	require.NoError(t, err)
   361  	keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool)
   362  
   363  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   364  	require.True(t, validator.IsBonded())
   365  
   366  	selfDelegation := types.NewDelegation(sdk.AccAddress(addrVals[0].Bytes()), addrVals[0], issuedShares)
   367  	keeper.SetDelegation(ctx, selfDelegation)
   368  
   369  	bondedPool := keeper.GetBondedPool(ctx)
   370  	err = bondedPool.SetCoins(bondedPool.GetCoins().Add(delCoins...))
   371  	require.NoError(t, err)
   372  	keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool)
   373  
   374  	// create a second delegation to this validator
   375  	keeper.DeleteValidatorByPowerIndex(ctx, validator)
   376  
   377  	validator, issuedShares = validator.AddTokensFromDel(delTokens)
   378  	require.Equal(t, delTokens, issuedShares.RoundInt())
   379  
   380  	bondedPool = keeper.GetBondedPool(ctx)
   381  	err = bondedPool.SetCoins(bondedPool.GetCoins().Add(delCoins...))
   382  	require.NoError(t, err)
   383  	keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool)
   384  
   385  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   386  	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
   387  	keeper.SetDelegation(ctx, delegation)
   388  
   389  	bondedPool = keeper.GetBondedPool(ctx)
   390  	err = bondedPool.SetCoins(bondedPool.GetCoins().Add(delCoins...))
   391  	require.NoError(t, err)
   392  	keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool)
   393  
   394  	header := ctx.BlockHeader()
   395  	blockHeight := int64(10)
   396  	header.Height = blockHeight
   397  	blockTime := time.Unix(333, 0)
   398  	header.Time = blockTime
   399  	ctx.SetBlockHeader(header)
   400  
   401  	// unbond the all self-delegation to put validator in unbonding state
   402  	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
   403  	_, err = keeper.Undelegate(ctx, val0AccAddr, addrVals[0], delTokens.ToDec())
   404  	require.NoError(t, err)
   405  
   406  	// end block
   407  	updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx)
   408  	require.Equal(t, 1, len(updates))
   409  
   410  	validator, found := keeper.GetValidator(ctx, addrVals[0])
   411  	require.True(t, found)
   412  	require.Equal(t, blockHeight, validator.UnbondingHeight)
   413  	params := keeper.GetParams(ctx)
   414  	require.True(t, blockTime.Add(params.UnbondingTime).Equal(validator.UnbondingCompletionTime))
   415  
   416  	blockHeight2 := int64(20)
   417  	blockTime2 := time.Unix(444, 0).UTC()
   418  	ctx.SetBlockHeight(blockHeight2)
   419  	ctx.SetBlockTime(blockTime2)
   420  
   421  	// unbond some of the other delegation's shares
   422  	_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDec(6))
   423  	require.NoError(t, err)
   424  
   425  	// retrieve the unbonding delegation
   426  	ubd, found := keeper.GetUnbondingDelegation(ctx, addrDels[0], addrVals[0])
   427  	require.True(t, found)
   428  	require.Len(t, ubd.Entries, 1)
   429  	require.True(t, ubd.Entries[0].Balance.Equal(sdk.NewInt(6)))
   430  	assert.Equal(t, blockHeight2, ubd.Entries[0].CreationHeight)
   431  	assert.True(t, blockTime2.Add(params.UnbondingTime).Equal(ubd.Entries[0].CompletionTime))
   432  }
   433  
   434  func TestUndelegateFromUnbondedValidator(t *testing.T) {
   435  	ctx, _, keeper, _ := CreateTestInput(t, false, 1)
   436  	delTokens := sdk.TokensFromConsensusPower(10)
   437  	delCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), delTokens))
   438  
   439  	// add bonded tokens to pool for delegations
   440  	notBondedPool := keeper.GetNotBondedPool(ctx)
   441  	err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(delCoins...))
   442  	require.NoError(t, err)
   443  	keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool)
   444  
   445  	// create a validator with a self-delegation
   446  	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
   447  
   448  	valTokens := sdk.TokensFromConsensusPower(10)
   449  	validator, issuedShares := validator.AddTokensFromDel(valTokens)
   450  	require.Equal(t, valTokens, issuedShares.RoundInt())
   451  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   452  	require.True(t, validator.IsBonded())
   453  
   454  	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
   455  	selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
   456  	keeper.SetDelegation(ctx, selfDelegation)
   457  
   458  	bondedPool := keeper.GetBondedPool(ctx)
   459  	err = bondedPool.SetCoins(bondedPool.GetCoins().Add(delCoins...))
   460  	require.NoError(t, err)
   461  	keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool)
   462  
   463  	// create a second delegation to this validator
   464  	keeper.DeleteValidatorByPowerIndex(ctx, validator)
   465  	validator, issuedShares = validator.AddTokensFromDel(delTokens)
   466  	require.Equal(t, delTokens, issuedShares.RoundInt())
   467  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   468  	require.True(t, validator.IsBonded())
   469  	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
   470  	keeper.SetDelegation(ctx, delegation)
   471  
   472  	ctx.SetBlockHeight(10)
   473  	ctx.SetBlockTime(time.Unix(333, 0))
   474  
   475  	// unbond the all self-delegation to put validator in unbonding state
   476  	_, err = keeper.Undelegate(ctx, val0AccAddr, addrVals[0], valTokens.ToDec())
   477  	require.NoError(t, err)
   478  
   479  	// end block
   480  	updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx)
   481  	require.Equal(t, 1, len(updates))
   482  
   483  	validator, found := keeper.GetValidator(ctx, addrVals[0])
   484  	require.True(t, found)
   485  	require.Equal(t, ctx.BlockHeight(), validator.UnbondingHeight)
   486  	params := keeper.GetParams(ctx)
   487  	require.True(t, ctx.BlockHeader().Time.Add(params.UnbondingTime).Equal(validator.UnbondingCompletionTime))
   488  
   489  	// unbond the validator
   490  	ctx.SetBlockTime(validator.UnbondingCompletionTime)
   491  	keeper.UnbondAllMatureValidatorQueue(ctx)
   492  
   493  	// Make sure validator is still in state because there is still an outstanding delegation
   494  	validator, found = keeper.GetValidator(ctx, addrVals[0])
   495  	require.True(t, found)
   496  	require.Equal(t, validator.Status, sdk.Unbonded)
   497  
   498  	// unbond some of the other delegation's shares
   499  	unbondTokens := sdk.TokensFromConsensusPower(6)
   500  	_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], unbondTokens.ToDec())
   501  	require.NoError(t, err)
   502  
   503  	// unbond rest of the other delegation's shares
   504  	remainingTokens := delTokens.Sub(unbondTokens)
   505  	_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], remainingTokens.ToDec())
   506  	require.NoError(t, err)
   507  
   508  	//  now validator should now be deleted from state
   509  	validator, found = keeper.GetValidator(ctx, addrVals[0])
   510  	require.False(t, found, "%v", validator)
   511  }
   512  
   513  func TestUnbondingAllDelegationFromValidator(t *testing.T) {
   514  	ctx, _, keeper, _ := CreateTestInput(t, false, 0)
   515  	delTokens := sdk.TokensFromConsensusPower(10)
   516  	delCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), delTokens))
   517  
   518  	// add bonded tokens to pool for delegations
   519  	notBondedPool := keeper.GetNotBondedPool(ctx)
   520  	err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(delCoins...))
   521  	require.NoError(t, err)
   522  	keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool)
   523  
   524  	//create a validator with a self-delegation
   525  	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
   526  
   527  	valTokens := sdk.TokensFromConsensusPower(10)
   528  	validator, issuedShares := validator.AddTokensFromDel(valTokens)
   529  	require.Equal(t, valTokens, issuedShares.RoundInt())
   530  
   531  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   532  	require.True(t, validator.IsBonded())
   533  	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
   534  
   535  	selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
   536  	keeper.SetDelegation(ctx, selfDelegation)
   537  
   538  	// create a second delegation to this validator
   539  	keeper.DeleteValidatorByPowerIndex(ctx, validator)
   540  	validator, issuedShares = validator.AddTokensFromDel(delTokens)
   541  	require.Equal(t, delTokens, issuedShares.RoundInt())
   542  
   543  	bondedPool := keeper.GetBondedPool(ctx)
   544  	err = bondedPool.SetCoins(bondedPool.GetCoins().Add(delCoins...))
   545  	require.NoError(t, err)
   546  	keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool)
   547  
   548  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   549  	require.True(t, validator.IsBonded())
   550  
   551  	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
   552  	keeper.SetDelegation(ctx, delegation)
   553  
   554  	ctx.SetBlockHeight(10)
   555  	ctx.SetBlockTime(time.Unix(333, 0))
   556  
   557  	// unbond the all self-delegation to put validator in unbonding state
   558  	_, err = keeper.Undelegate(ctx, val0AccAddr, addrVals[0], valTokens.ToDec())
   559  	require.NoError(t, err)
   560  
   561  	// end block
   562  	updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx)
   563  	require.Equal(t, 1, len(updates))
   564  
   565  	// unbond all the remaining delegation
   566  	_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], delTokens.ToDec())
   567  	require.NoError(t, err)
   568  
   569  	// validator should still be in state and still be in unbonding state
   570  	validator, found := keeper.GetValidator(ctx, addrVals[0])
   571  	require.True(t, found)
   572  	require.Equal(t, validator.Status, sdk.Unbonding)
   573  
   574  	// unbond the validator
   575  	ctx.SetBlockTime(validator.UnbondingCompletionTime)
   576  	keeper.UnbondAllMatureValidatorQueue(ctx)
   577  
   578  	// validator should now be deleted from state
   579  	_, found = keeper.GetValidator(ctx, addrVals[0])
   580  	require.False(t, found)
   581  }
   582  
   583  // Make sure that that the retrieving the delegations doesn't affect the state
   584  func TestGetRedelegationsFromSrcValidator(t *testing.T) {
   585  	ctx, _, keeper, _ := CreateTestInput(t, false, 0)
   586  
   587  	rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 0,
   588  		time.Unix(0, 0), sdk.NewInt(5),
   589  		sdk.NewDec(5))
   590  
   591  	// set and retrieve a record
   592  	keeper.SetRedelegation(ctx, rd)
   593  	resBond, found := keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1])
   594  	require.True(t, found)
   595  
   596  	// get the redelegations one time
   597  	redelegations := keeper.GetRedelegationsFromSrcValidator(ctx, addrVals[0])
   598  	require.Equal(t, 1, len(redelegations))
   599  	require.True(t, redelegations[0].Equal(resBond))
   600  
   601  	// get the redelegations a second time, should be exactly the same
   602  	redelegations = keeper.GetRedelegationsFromSrcValidator(ctx, addrVals[0])
   603  	require.Equal(t, 1, len(redelegations))
   604  	require.True(t, redelegations[0].Equal(resBond))
   605  }
   606  
   607  // tests Get/Set/Remove/Has UnbondingDelegation
   608  func TestRedelegation(t *testing.T) {
   609  	ctx, _, keeper, _ := CreateTestInput(t, false, 0)
   610  
   611  	rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 0,
   612  		time.Unix(0, 0), sdk.NewInt(5),
   613  		sdk.NewDec(5))
   614  
   615  	// test shouldn't have and redelegations
   616  	has := keeper.HasReceivingRedelegation(ctx, addrDels[0], addrVals[1])
   617  	require.False(t, has)
   618  
   619  	// set and retrieve a record
   620  	keeper.SetRedelegation(ctx, rd)
   621  	resRed, found := keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1])
   622  	require.True(t, found)
   623  
   624  	redelegations := keeper.GetRedelegationsFromSrcValidator(ctx, addrVals[0])
   625  	require.Equal(t, 1, len(redelegations))
   626  	require.True(t, redelegations[0].Equal(resRed))
   627  
   628  	redelegations = keeper.GetRedelegations(ctx, addrDels[0], 5)
   629  	require.Equal(t, 1, len(redelegations))
   630  	require.True(t, redelegations[0].Equal(resRed))
   631  
   632  	redelegations = keeper.GetAllRedelegations(ctx, addrDels[0], nil, nil)
   633  	require.Equal(t, 1, len(redelegations))
   634  	require.True(t, redelegations[0].Equal(resRed))
   635  
   636  	// check if has the redelegation
   637  	has = keeper.HasReceivingRedelegation(ctx, addrDels[0], addrVals[1])
   638  	require.True(t, has)
   639  
   640  	// modify a records, save, and retrieve
   641  	rd.Entries[0].SharesDst = sdk.NewDec(21)
   642  	keeper.SetRedelegation(ctx, rd)
   643  
   644  	resRed, found = keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1])
   645  	require.True(t, found)
   646  	require.True(t, rd.Equal(resRed))
   647  
   648  	redelegations = keeper.GetRedelegationsFromSrcValidator(ctx, addrVals[0])
   649  	require.Equal(t, 1, len(redelegations))
   650  	require.True(t, redelegations[0].Equal(resRed))
   651  
   652  	redelegations = keeper.GetRedelegations(ctx, addrDels[0], 5)
   653  	require.Equal(t, 1, len(redelegations))
   654  	require.True(t, redelegations[0].Equal(resRed))
   655  
   656  	// delete a record
   657  	keeper.RemoveRedelegation(ctx, rd)
   658  	_, found = keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1])
   659  	require.False(t, found)
   660  
   661  	redelegations = keeper.GetRedelegations(ctx, addrDels[0], 5)
   662  	require.Equal(t, 0, len(redelegations))
   663  
   664  	redelegations = keeper.GetAllRedelegations(ctx, addrDels[0], nil, nil)
   665  	require.Equal(t, 0, len(redelegations))
   666  }
   667  
   668  func TestRedelegateToSameValidator(t *testing.T) {
   669  	ctx, _, keeper, _ := CreateTestInput(t, false, 0)
   670  	valTokens := sdk.TokensFromConsensusPower(10)
   671  	startCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), valTokens))
   672  
   673  	// add bonded tokens to pool for delegations
   674  	notBondedPool := keeper.GetNotBondedPool(ctx)
   675  	err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(startCoins...))
   676  	require.NoError(t, err)
   677  	keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool)
   678  
   679  	// create a validator with a self-delegation
   680  	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
   681  	validator, issuedShares := validator.AddTokensFromDel(valTokens)
   682  	require.Equal(t, valTokens, issuedShares.RoundInt())
   683  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   684  	require.True(t, validator.IsBonded())
   685  
   686  	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
   687  	selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
   688  	keeper.SetDelegation(ctx, selfDelegation)
   689  
   690  	_, err = keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[0], sdk.NewDec(5))
   691  	require.Error(t, err)
   692  
   693  }
   694  
   695  func TestRedelegationMaxEntries(t *testing.T) {
   696  	ctx, _, keeper, _ := CreateTestInput(t, false, 0)
   697  	startTokens := sdk.TokensFromConsensusPower(20)
   698  	startCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), startTokens))
   699  
   700  	// add bonded tokens to pool for delegations
   701  	notBondedPool := keeper.GetNotBondedPool(ctx)
   702  	err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(startCoins...))
   703  	require.NoError(t, err)
   704  	keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool)
   705  
   706  	// create a validator with a self-delegation
   707  	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
   708  	valTokens := sdk.TokensFromConsensusPower(10)
   709  	validator, issuedShares := validator.AddTokensFromDel(valTokens)
   710  	require.Equal(t, valTokens, issuedShares.RoundInt())
   711  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   712  	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
   713  	selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
   714  	keeper.SetDelegation(ctx, selfDelegation)
   715  
   716  	// create a second validator
   717  	validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{})
   718  	validator2, issuedShares = validator2.AddTokensFromDel(valTokens)
   719  	require.Equal(t, valTokens, issuedShares.RoundInt())
   720  
   721  	validator2 = TestingUpdateValidator(keeper, ctx, validator2, true)
   722  	require.Equal(t, sdk.Bonded, validator2.Status)
   723  
   724  	maxEntries := keeper.MaxEntries(ctx)
   725  
   726  	// redelegations should pass
   727  	var completionTime time.Time
   728  	for i := uint16(0); i < maxEntries; i++ {
   729  		var err error
   730  		completionTime, err = keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], sdk.NewDec(1))
   731  		require.NoError(t, err)
   732  	}
   733  
   734  	// an additional redelegation should fail due to max entries
   735  	_, err = keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], sdk.NewDec(1))
   736  	require.Error(t, err)
   737  
   738  	// mature redelegations
   739  	ctx.SetBlockTime(completionTime)
   740  	err = keeper.CompleteRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1])
   741  	require.NoError(t, err)
   742  
   743  	// redelegation should work again
   744  	_, err = keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], sdk.NewDec(1))
   745  	require.NoError(t, err)
   746  }
   747  
   748  func TestRedelegateSelfDelegation(t *testing.T) {
   749  	ctx, _, keeper, _ := CreateTestInput(t, false, 0)
   750  	startTokens := sdk.TokensFromConsensusPower(30)
   751  	startCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), startTokens))
   752  
   753  	// add bonded tokens to pool for delegations
   754  	notBondedPool := keeper.GetNotBondedPool(ctx)
   755  	err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(startCoins...))
   756  	require.NoError(t, err)
   757  	keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool)
   758  
   759  	//create a validator with a self-delegation
   760  	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
   761  	valTokens := sdk.TokensFromConsensusPower(10)
   762  	validator, issuedShares := validator.AddTokensFromDel(valTokens)
   763  	require.Equal(t, valTokens, issuedShares.RoundInt())
   764  
   765  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   766  
   767  	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
   768  	selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
   769  	keeper.SetDelegation(ctx, selfDelegation)
   770  
   771  	// create a second validator
   772  	validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{})
   773  	validator2, issuedShares = validator2.AddTokensFromDel(valTokens)
   774  	require.Equal(t, valTokens, issuedShares.RoundInt())
   775  	validator2 = TestingUpdateValidator(keeper, ctx, validator2, true)
   776  	require.Equal(t, sdk.Bonded, validator2.Status)
   777  
   778  	// create a second delegation to validator 1
   779  	delTokens := sdk.TokensFromConsensusPower(10)
   780  	validator, issuedShares = validator.AddTokensFromDel(delTokens)
   781  	require.Equal(t, delTokens, issuedShares.RoundInt())
   782  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   783  
   784  	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
   785  	keeper.SetDelegation(ctx, delegation)
   786  
   787  	_, err = keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], delTokens.ToDec())
   788  	require.NoError(t, err)
   789  
   790  	// end block
   791  	updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx)
   792  	require.Equal(t, 2, len(updates))
   793  
   794  	validator, found := keeper.GetValidator(ctx, addrVals[0])
   795  	require.True(t, found)
   796  	require.Equal(t, valTokens, validator.Tokens)
   797  	require.Equal(t, sdk.Unbonding, validator.Status)
   798  }
   799  
   800  func TestRedelegateFromUnbondingValidator(t *testing.T) {
   801  	ctx, _, keeper, _ := CreateTestInput(t, false, 0)
   802  	startTokens := sdk.TokensFromConsensusPower(30)
   803  	startCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), startTokens))
   804  
   805  	// add bonded tokens to pool for delegations
   806  	notBondedPool := keeper.GetNotBondedPool(ctx)
   807  	err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(startCoins...))
   808  	require.NoError(t, err)
   809  	keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool)
   810  
   811  	//create a validator with a self-delegation
   812  	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
   813  
   814  	valTokens := sdk.TokensFromConsensusPower(10)
   815  	validator, issuedShares := validator.AddTokensFromDel(valTokens)
   816  	require.Equal(t, valTokens, issuedShares.RoundInt())
   817  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   818  	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
   819  	selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
   820  	keeper.SetDelegation(ctx, selfDelegation)
   821  
   822  	// create a second delegation to this validator
   823  	keeper.DeleteValidatorByPowerIndex(ctx, validator)
   824  	delTokens := sdk.TokensFromConsensusPower(10)
   825  	validator, issuedShares = validator.AddTokensFromDel(delTokens)
   826  	require.Equal(t, delTokens, issuedShares.RoundInt())
   827  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   828  	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
   829  	keeper.SetDelegation(ctx, delegation)
   830  
   831  	// create a second validator
   832  	validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{})
   833  	validator2, issuedShares = validator2.AddTokensFromDel(valTokens)
   834  	require.Equal(t, valTokens, issuedShares.RoundInt())
   835  	validator2 = TestingUpdateValidator(keeper, ctx, validator2, true)
   836  
   837  	header := ctx.BlockHeader()
   838  	blockHeight := int64(10)
   839  	header.Height = blockHeight
   840  	blockTime := time.Unix(333, 0)
   841  	header.Time = blockTime
   842  	ctx.SetBlockHeader(header)
   843  
   844  	// unbond the all self-delegation to put validator in unbonding state
   845  	_, err = keeper.Undelegate(ctx, val0AccAddr, addrVals[0], delTokens.ToDec())
   846  	require.NoError(t, err)
   847  
   848  	// end block
   849  	updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx)
   850  	require.Equal(t, 1, len(updates))
   851  
   852  	validator, found := keeper.GetValidator(ctx, addrVals[0])
   853  	require.True(t, found)
   854  	require.Equal(t, blockHeight, validator.UnbondingHeight)
   855  	params := keeper.GetParams(ctx)
   856  	require.True(t, blockTime.Add(params.UnbondingTime).Equal(validator.UnbondingCompletionTime))
   857  
   858  	//change the context
   859  	header = ctx.BlockHeader()
   860  	blockHeight2 := int64(20)
   861  	header.Height = blockHeight2
   862  	blockTime2 := time.Unix(444, 0)
   863  	header.Time = blockTime2
   864  	ctx.SetBlockHeader(header)
   865  
   866  	// unbond some of the other delegation's shares
   867  	redelegateTokens := sdk.TokensFromConsensusPower(6)
   868  	_, err = keeper.BeginRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1], redelegateTokens.ToDec())
   869  	require.NoError(t, err)
   870  
   871  	// retrieve the unbonding delegation
   872  	ubd, found := keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1])
   873  	require.True(t, found)
   874  	require.Len(t, ubd.Entries, 1)
   875  	assert.Equal(t, blockHeight, ubd.Entries[0].CreationHeight)
   876  	assert.True(t, blockTime.Add(params.UnbondingTime).Equal(ubd.Entries[0].CompletionTime))
   877  }
   878  
   879  func TestRedelegateFromUnbondedValidator(t *testing.T) {
   880  	ctx, _, keeper, _ := CreateTestInput(t, false, 0)
   881  	startTokens := sdk.TokensFromConsensusPower(30)
   882  	startCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), startTokens))
   883  
   884  	// add bonded tokens to pool for delegations
   885  	notBondedPool := keeper.GetNotBondedPool(ctx)
   886  	err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(startCoins...))
   887  	require.NoError(t, err)
   888  	keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool)
   889  
   890  	//create a validator with a self-delegation
   891  	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
   892  
   893  	valTokens := sdk.TokensFromConsensusPower(10)
   894  	validator, issuedShares := validator.AddTokensFromDel(valTokens)
   895  	require.Equal(t, valTokens, issuedShares.RoundInt())
   896  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   897  	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
   898  	selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
   899  	keeper.SetDelegation(ctx, selfDelegation)
   900  
   901  	// create a second delegation to this validator
   902  	keeper.DeleteValidatorByPowerIndex(ctx, validator)
   903  	delTokens := sdk.TokensFromConsensusPower(10)
   904  	validator, issuedShares = validator.AddTokensFromDel(delTokens)
   905  	require.Equal(t, delTokens, issuedShares.RoundInt())
   906  	validator = TestingUpdateValidator(keeper, ctx, validator, true)
   907  	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
   908  	keeper.SetDelegation(ctx, delegation)
   909  
   910  	// create a second validator
   911  	validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{})
   912  	validator2, issuedShares = validator2.AddTokensFromDel(valTokens)
   913  	require.Equal(t, valTokens, issuedShares.RoundInt())
   914  	validator2 = TestingUpdateValidator(keeper, ctx, validator2, true)
   915  	require.Equal(t, sdk.Bonded, validator2.Status)
   916  
   917  	ctx.SetBlockHeight(10)
   918  	ctx.SetBlockTime(time.Unix(333, 0))
   919  
   920  	// unbond the all self-delegation to put validator in unbonding state
   921  	_, err = keeper.Undelegate(ctx, val0AccAddr, addrVals[0], delTokens.ToDec())
   922  	require.NoError(t, err)
   923  
   924  	// end block
   925  	updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx)
   926  	require.Equal(t, 1, len(updates))
   927  
   928  	validator, found := keeper.GetValidator(ctx, addrVals[0])
   929  	require.True(t, found)
   930  	require.Equal(t, ctx.BlockHeight(), validator.UnbondingHeight)
   931  	params := keeper.GetParams(ctx)
   932  	require.True(t, ctx.BlockHeader().Time.Add(params.UnbondingTime).Equal(validator.UnbondingCompletionTime))
   933  
   934  	// unbond the validator
   935  	keeper.unbondingToUnbonded(ctx, validator)
   936  
   937  	// redelegate some of the delegation's shares
   938  	redelegationTokens := sdk.TokensFromConsensusPower(6)
   939  	_, err = keeper.BeginRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1], redelegationTokens.ToDec())
   940  	require.NoError(t, err)
   941  
   942  	// no red should have been found
   943  	red, found := keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1])
   944  	require.False(t, found, "%v", red)
   945  }