cosmos-sdk/x/staking/keeper/delegation_test.go

849 lines
34 KiB
Go

package keeper_test
import (
"time"
"cosmossdk.io/math"
"github.com/golang/mock/gomock"
simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
sdk "github.com/cosmos/cosmos-sdk/types"
stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
"github.com/cosmos/cosmos-sdk/x/staking/testutil"
stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
)
func createValAddrs(count int) ([]sdk.AccAddress, []sdk.ValAddress) {
addrs := simtestutil.CreateIncrementalAccounts(count)
valAddrs := simtestutil.ConvertAddrsToValAddrs(addrs)
return addrs, valAddrs
}
// tests GetDelegation, GetDelegatorDelegations, SetDelegation, RemoveDelegation, GetDelegatorDelegations
func (s *KeeperTestSuite) TestDelegation() {
ctx, keeper := s.ctx, s.stakingKeeper
require := s.Require()
addrDels, valAddrs := createValAddrs(3)
// construct the validators
amts := []math.Int{sdk.NewInt(9), sdk.NewInt(8), sdk.NewInt(7)}
var validators [3]stakingtypes.Validator
for i, amt := range amts {
validators[i] = testutil.NewValidator(s.T(), valAddrs[i], PKs[i])
validators[i], _ = validators[i].AddTokensFromDel(amt)
validators[i] = stakingkeeper.TestingUpdateValidator(keeper, ctx, validators[i], true)
}
// first add a validators[0] to delegate too
bond1to1 := stakingtypes.NewDelegation(addrDels[0], valAddrs[0], math.LegacyNewDec(9))
// check the empty keeper first
_, found := keeper.GetDelegation(ctx, addrDels[0], valAddrs[0])
require.False(found)
// set and retrieve a record
keeper.SetDelegation(ctx, bond1to1)
resBond, found := keeper.GetDelegation(ctx, addrDels[0], valAddrs[0])
require.True(found)
require.Equal(bond1to1, resBond)
// modify a records, save, and retrieve
bond1to1.Shares = math.LegacyNewDec(99)
keeper.SetDelegation(ctx, bond1to1)
resBond, found = keeper.GetDelegation(ctx, addrDels[0], valAddrs[0])
require.True(found)
require.Equal(bond1to1, resBond)
// add some more records
bond1to2 := stakingtypes.NewDelegation(addrDels[0], valAddrs[1], math.LegacyNewDec(9))
bond1to3 := stakingtypes.NewDelegation(addrDels[0], valAddrs[2], math.LegacyNewDec(9))
bond2to1 := stakingtypes.NewDelegation(addrDels[1], valAddrs[0], math.LegacyNewDec(9))
bond2to2 := stakingtypes.NewDelegation(addrDels[1], valAddrs[1], math.LegacyNewDec(9))
bond2to3 := stakingtypes.NewDelegation(addrDels[1], valAddrs[2], math.LegacyNewDec(9))
keeper.SetDelegation(ctx, bond1to2)
keeper.SetDelegation(ctx, bond1to3)
keeper.SetDelegation(ctx, bond2to1)
keeper.SetDelegation(ctx, bond2to2)
keeper.SetDelegation(ctx, bond2to3)
// test all bond retrieve capabilities
resBonds := keeper.GetDelegatorDelegations(ctx, addrDels[0], 5)
require.Equal(3, len(resBonds))
require.Equal(bond1to1, resBonds[0])
require.Equal(bond1to2, resBonds[1])
require.Equal(bond1to3, resBonds[2])
resBonds = keeper.GetAllDelegatorDelegations(ctx, addrDels[0])
require.Equal(3, len(resBonds))
resBonds = keeper.GetDelegatorDelegations(ctx, addrDels[0], 2)
require.Equal(2, len(resBonds))
resBonds = keeper.GetDelegatorDelegations(ctx, addrDels[1], 5)
require.Equal(3, len(resBonds))
require.Equal(bond2to1, resBonds[0])
require.Equal(bond2to2, resBonds[1])
require.Equal(bond2to3, resBonds[2])
allBonds := keeper.GetAllDelegations(ctx)
require.Equal(6, len(allBonds))
require.Equal(bond1to1, allBonds[0])
require.Equal(bond1to2, allBonds[1])
require.Equal(bond1to3, allBonds[2])
require.Equal(bond2to1, allBonds[3])
require.Equal(bond2to2, allBonds[4])
require.Equal(bond2to3, allBonds[5])
resVals := keeper.GetDelegatorValidators(ctx, addrDels[0], 3)
require.Equal(3, len(resVals))
resVals = keeper.GetDelegatorValidators(ctx, addrDels[1], 4)
require.Equal(3, len(resVals))
for i := 0; i < 3; i++ {
resVal, err := keeper.GetDelegatorValidator(ctx, addrDels[0], valAddrs[i])
require.Nil(err)
require.Equal(valAddrs[i], resVal.GetOperator())
resVal, err = keeper.GetDelegatorValidator(ctx, addrDels[1], valAddrs[i])
require.Nil(err)
require.Equal(valAddrs[i], resVal.GetOperator())
resDels := keeper.GetValidatorDelegations(ctx, valAddrs[i])
require.Len(resDels, 2)
}
// test total bonded for single delegator
expBonded := bond1to1.Shares.Add(bond2to1.Shares).Add(bond1to3.Shares)
resDelBond := keeper.GetDelegatorBonded(ctx, addrDels[0])
require.Equal(expBonded, sdk.NewDecFromInt(resDelBond))
// delete a record
keeper.RemoveDelegation(ctx, bond2to3)
_, found = keeper.GetDelegation(ctx, addrDels[1], valAddrs[2])
require.False(found)
resBonds = keeper.GetDelegatorDelegations(ctx, addrDels[1], 5)
require.Equal(2, len(resBonds))
require.Equal(bond2to1, resBonds[0])
require.Equal(bond2to2, resBonds[1])
resBonds = keeper.GetAllDelegatorDelegations(ctx, addrDels[1])
require.Equal(2, len(resBonds))
// delete all the records from delegator 2
keeper.RemoveDelegation(ctx, bond2to1)
keeper.RemoveDelegation(ctx, bond2to2)
_, found = keeper.GetDelegation(ctx, addrDels[1], valAddrs[0])
require.False(found)
_, found = keeper.GetDelegation(ctx, addrDels[1], valAddrs[1])
require.False(found)
resBonds = keeper.GetDelegatorDelegations(ctx, addrDels[1], 5)
require.Equal(0, len(resBonds))
}
// tests Get/Set/Remove UnbondingDelegation
func (s *KeeperTestSuite) TestUnbondingDelegation() {
ctx, keeper := s.ctx, s.stakingKeeper
require := s.Require()
delAddrs, valAddrs := createValAddrs(2)
ubd := stakingtypes.NewUnbondingDelegation(
delAddrs[0],
valAddrs[0],
0,
time.Unix(0, 0).UTC(),
sdk.NewInt(5),
0,
)
// set and retrieve a record
keeper.SetUnbondingDelegation(ctx, ubd)
resUnbond, found := keeper.GetUnbondingDelegation(ctx, delAddrs[0], valAddrs[0])
require.True(found)
require.Equal(ubd, resUnbond)
// modify a records, save, and retrieve
expUnbond := sdk.NewInt(21)
ubd.Entries[0].Balance = expUnbond
keeper.SetUnbondingDelegation(ctx, ubd)
resUnbonds := keeper.GetUnbondingDelegations(ctx, delAddrs[0], 5)
require.Equal(1, len(resUnbonds))
resUnbonds = keeper.GetAllUnbondingDelegations(ctx, delAddrs[0])
require.Equal(1, len(resUnbonds))
resUnbond, found = keeper.GetUnbondingDelegation(ctx, delAddrs[0], valAddrs[0])
require.True(found)
require.Equal(ubd, resUnbond)
resDelUnbond := keeper.GetDelegatorUnbonding(ctx, delAddrs[0])
require.Equal(expUnbond, resDelUnbond)
// delete a record
keeper.RemoveUnbondingDelegation(ctx, ubd)
_, found = keeper.GetUnbondingDelegation(ctx, delAddrs[0], valAddrs[0])
require.False(found)
resUnbonds = keeper.GetUnbondingDelegations(ctx, delAddrs[0], 5)
require.Equal(0, len(resUnbonds))
resUnbonds = keeper.GetAllUnbondingDelegations(ctx, delAddrs[0])
require.Equal(0, len(resUnbonds))
}
func (s *KeeperTestSuite) TestUnbondDelegation() {
ctx, keeper := s.ctx, s.stakingKeeper
require := s.Require()
delAddrs, valAddrs := createValAddrs(1)
startTokens := keeper.TokensFromConsensusPower(ctx, 10)
validator := testutil.NewValidator(s.T(), valAddrs[0], PKs[0])
validator, issuedShares := validator.AddTokensFromDel(startTokens)
require.Equal(startTokens, issuedShares.RoundInt())
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
_ = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
delegation := stakingtypes.NewDelegation(delAddrs[0], valAddrs[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
bondTokens := keeper.TokensFromConsensusPower(ctx, 6)
amount, err := keeper.Unbond(ctx, delAddrs[0], valAddrs[0], sdk.NewDecFromInt(bondTokens))
require.NoError(err)
require.Equal(bondTokens, amount) // shares to be added to an unbonding delegation
delegation, found := keeper.GetDelegation(ctx, delAddrs[0], valAddrs[0])
require.True(found)
validator, found = keeper.GetValidator(ctx, valAddrs[0])
require.True(found)
remainingTokens := startTokens.Sub(bondTokens)
require.Equal(remainingTokens, delegation.Shares.RoundInt())
require.Equal(remainingTokens, validator.BondedTokens())
}
// // test undelegating self delegation from a validator pushing it below MinSelfDelegation
// // shift it from the bonded to unbonding state and jailed
func (s *KeeperTestSuite) TestUndelegateSelfDelegationBelowMinSelfDelegation() {
ctx, keeper := s.ctx, s.stakingKeeper
require := s.Require()
addrDels, addrVals := createValAddrs(1)
delTokens := keeper.TokensFromConsensusPower(ctx, 10)
// create a validator with a self-delegation
validator := testutil.NewValidator(s.T(), addrVals[0], PKs[0])
validator.MinSelfDelegation = delTokens
validator, issuedShares := validator.AddTokensFromDel(delTokens)
require.Equal(delTokens, issuedShares.RoundInt())
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
keeper.SetValidatorByConsAddr(ctx, validator)
require.True(validator.IsBonded())
selfDelegation := stakingtypes.NewDelegation(sdk.AccAddress(addrVals[0].Bytes()), addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second delegation to this validator
keeper.DeleteValidatorByPowerIndex(ctx, validator)
validator, issuedShares = validator.AddTokensFromDel(delTokens)
require.True(validator.IsBonded())
require.Equal(delTokens, issuedShares.RoundInt())
validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
delegation := stakingtypes.NewDelegation(addrDels[0], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any())
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(keeper.TokensFromConsensusPower(ctx, 6)))
require.NoError(err)
// end block
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any())
s.applyValidatorSetUpdates(ctx, keeper, 1)
validator, found := keeper.GetValidator(ctx, addrVals[0])
require.True(found)
require.Equal(keeper.TokensFromConsensusPower(ctx, 14), validator.Tokens)
require.Equal(stakingtypes.Unbonding, validator.Status)
require.True(validator.Jailed)
}
func (s *KeeperTestSuite) TestUndelegateFromUnbondingValidator() {
ctx, keeper := s.ctx, s.stakingKeeper
require := s.Require()
delTokens := keeper.TokensFromConsensusPower(ctx, 10)
addrDels, addrVals := createValAddrs(2)
// create a validator with a self-delegation
validator := testutil.NewValidator(s.T(), addrVals[0], PKs[0])
keeper.SetValidatorByConsAddr(ctx, validator)
validator, issuedShares := validator.AddTokensFromDel(delTokens)
require.Equal(delTokens, issuedShares.RoundInt())
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
require.True(validator.IsBonded())
selfDelegation := stakingtypes.NewDelegation(addrVals[0].Bytes(), addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second delegation to this validator
keeper.DeleteValidatorByPowerIndex(ctx, validator)
validator, issuedShares = validator.AddTokensFromDel(delTokens)
require.Equal(delTokens, issuedShares.RoundInt())
validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
delegation := stakingtypes.NewDelegation(addrDels[1], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
header := ctx.BlockHeader()
blockHeight := int64(10)
header.Height = blockHeight
blockTime := time.Unix(333, 0)
header.Time = blockTime
ctx = ctx.WithBlockHeader(header)
// unbond the all self-delegation to put validator in unbonding state
val0AccAddr := sdk.AccAddress(addrVals[0])
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any())
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(delTokens))
require.NoError(err)
// end block
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any())
s.applyValidatorSetUpdates(ctx, keeper, 1)
validator, found := keeper.GetValidator(ctx, addrVals[0])
require.True(found)
require.Equal(blockHeight, validator.UnbondingHeight)
params := keeper.GetParams(ctx)
require.True(blockTime.Add(params.UnbondingTime).Equal(validator.UnbondingTime))
blockHeight2 := int64(20)
blockTime2 := time.Unix(444, 0).UTC()
ctx = ctx.WithBlockHeight(blockHeight2)
ctx = ctx.WithBlockTime(blockTime2)
// unbond some of the other delegation's shares
_, err = keeper.Undelegate(ctx, addrDels[1], addrVals[0], math.LegacyNewDec(6))
require.NoError(err)
// retrieve the unbonding delegation
ubd, found := keeper.GetUnbondingDelegation(ctx, addrDels[1], addrVals[0])
require.True(found)
require.Len(ubd.Entries, 1)
require.True(ubd.Entries[0].Balance.Equal(sdk.NewInt(6)))
require.Equal(blockHeight2, ubd.Entries[0].CreationHeight)
require.True(blockTime2.Add(params.UnbondingTime).Equal(ubd.Entries[0].CompletionTime))
}
func (s *KeeperTestSuite) TestUndelegateFromUnbondedValidator() {
ctx, keeper := s.ctx, s.stakingKeeper
require := s.Require()
delTokens := keeper.TokensFromConsensusPower(ctx, 10)
addrDels, addrVals := createValAddrs(2)
// create a validator with a self-delegation
validator := testutil.NewValidator(s.T(), addrVals[0], PKs[0])
keeper.SetValidatorByConsAddr(ctx, validator)
valTokens := keeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(valTokens, issuedShares.RoundInt())
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
require.True(validator.IsBonded())
val0AccAddr := sdk.AccAddress(addrVals[0])
selfDelegation := stakingtypes.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second delegation to this validator
keeper.DeleteValidatorByPowerIndex(ctx, validator)
validator, issuedShares = validator.AddTokensFromDel(delTokens)
require.Equal(delTokens, issuedShares.RoundInt())
validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
require.True(validator.IsBonded())
delegation := stakingtypes.NewDelegation(addrDels[1], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
ctx = ctx.WithBlockHeight(10)
ctx = ctx.WithBlockTime(time.Unix(333, 0))
// unbond the all self-delegation to put validator in unbonding state
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any())
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(valTokens))
require.NoError(err)
// end block
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any())
s.applyValidatorSetUpdates(ctx, keeper, 1)
validator, found := keeper.GetValidator(ctx, addrVals[0])
require.True(found)
require.Equal(ctx.BlockHeight(), validator.UnbondingHeight)
params := keeper.GetParams(ctx)
require.True(ctx.BlockHeader().Time.Add(params.UnbondingTime).Equal(validator.UnbondingTime))
// unbond the validator
ctx = ctx.WithBlockTime(validator.UnbondingTime)
keeper.UnbondAllMatureValidators(ctx)
// Make sure validator is still in state because there is still an outstanding delegation
validator, found = keeper.GetValidator(ctx, addrVals[0])
require.True(found)
require.Equal(validator.Status, stakingtypes.Unbonded)
// unbond some of the other delegation's shares
unbondTokens := keeper.TokensFromConsensusPower(ctx, 6)
_, err = keeper.Undelegate(ctx, addrDels[1], addrVals[0], sdk.NewDecFromInt(unbondTokens))
require.NoError(err)
// unbond rest of the other delegation's shares
remainingTokens := delTokens.Sub(unbondTokens)
_, err = keeper.Undelegate(ctx, addrDels[1], addrVals[0], sdk.NewDecFromInt(remainingTokens))
require.NoError(err)
// now validator should be deleted from state
validator, found = keeper.GetValidator(ctx, addrVals[0])
require.False(found, "%v", validator)
}
func (s *KeeperTestSuite) TestUnbondingAllDelegationFromValidator() {
ctx, keeper := s.ctx, s.stakingKeeper
require := s.Require()
delTokens := keeper.TokensFromConsensusPower(ctx, 10)
addrDels, addrVals := createValAddrs(2)
// create a validator with a self-delegation
validator := testutil.NewValidator(s.T(), addrVals[0], PKs[0])
keeper.SetValidatorByConsAddr(ctx, validator)
valTokens := keeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(valTokens, issuedShares.RoundInt())
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
require.True(validator.IsBonded())
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
selfDelegation := stakingtypes.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second delegation to this validator
keeper.DeleteValidatorByPowerIndex(ctx, validator)
validator, issuedShares = validator.AddTokensFromDel(delTokens)
require.Equal(delTokens, issuedShares.RoundInt())
validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
require.True(validator.IsBonded())
delegation := stakingtypes.NewDelegation(addrDels[1], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
ctx = ctx.WithBlockHeight(10)
ctx = ctx.WithBlockTime(time.Unix(333, 0))
// unbond the all self-delegation to put validator in unbonding state
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any())
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(valTokens))
require.NoError(err)
// end block
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any())
s.applyValidatorSetUpdates(ctx, keeper, 1)
// unbond all the remaining delegation
_, err = keeper.Undelegate(ctx, addrDels[1], addrVals[0], sdk.NewDecFromInt(delTokens))
require.NoError(err)
// validator should still be in state and still be in unbonding state
validator, found := keeper.GetValidator(ctx, addrVals[0])
require.True(found)
require.Equal(validator.Status, stakingtypes.Unbonding)
// unbond the validator
ctx = ctx.WithBlockTime(validator.UnbondingTime)
keeper.UnbondAllMatureValidators(ctx)
// validator should now be deleted from state
_, found = keeper.GetValidator(ctx, addrVals[0])
require.False(found)
}
// Make sure that that the retrieving the delegations doesn't affect the state
func (s *KeeperTestSuite) TestGetRedelegationsFromSrcValidator() {
ctx, keeper := s.ctx, s.stakingKeeper
require := s.Require()
addrDels, addrVals := createValAddrs(2)
rd := stakingtypes.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 0,
time.Unix(0, 0), sdk.NewInt(5),
math.LegacyNewDec(5), 0)
// set and retrieve a record
keeper.SetRedelegation(ctx, rd)
resBond, found := keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1])
require.True(found)
// get the redelegations one time
redelegations := keeper.GetRedelegationsFromSrcValidator(ctx, addrVals[0])
require.Equal(1, len(redelegations))
require.Equal(redelegations[0], resBond)
// get the redelegations a second time, should be exactly the same
redelegations = keeper.GetRedelegationsFromSrcValidator(ctx, addrVals[0])
require.Equal(1, len(redelegations))
require.Equal(redelegations[0], resBond)
}
// tests Get/Set/Remove/Has UnbondingDelegation
func (s *KeeperTestSuite) TestRedelegation() {
ctx, keeper := s.ctx, s.stakingKeeper
require := s.Require()
addrDels, addrVals := createValAddrs(2)
rd := stakingtypes.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 0,
time.Unix(0, 0).UTC(), sdk.NewInt(5),
math.LegacyNewDec(5), 0)
// test shouldn't have and redelegations
has := keeper.HasReceivingRedelegation(ctx, addrDels[0], addrVals[1])
require.False(has)
// set and retrieve a record
keeper.SetRedelegation(ctx, rd)
resRed, found := keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1])
require.True(found)
redelegations := keeper.GetRedelegationsFromSrcValidator(ctx, addrVals[0])
require.Equal(1, len(redelegations))
require.Equal(redelegations[0], resRed)
redelegations = keeper.GetRedelegations(ctx, addrDels[0], 5)
require.Equal(1, len(redelegations))
require.Equal(redelegations[0], resRed)
redelegations = keeper.GetAllRedelegations(ctx, addrDels[0], nil, nil)
require.Equal(1, len(redelegations))
require.Equal(redelegations[0], resRed)
// check if has the redelegation
has = keeper.HasReceivingRedelegation(ctx, addrDels[0], addrVals[1])
require.True(has)
// modify a records, save, and retrieve
rd.Entries[0].SharesDst = math.LegacyNewDec(21)
keeper.SetRedelegation(ctx, rd)
resRed, found = keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1])
require.True(found)
require.Equal(rd, resRed)
redelegations = keeper.GetRedelegationsFromSrcValidator(ctx, addrVals[0])
require.Equal(1, len(redelegations))
require.Equal(redelegations[0], resRed)
redelegations = keeper.GetRedelegations(ctx, addrDels[0], 5)
require.Equal(1, len(redelegations))
require.Equal(redelegations[0], resRed)
// delete a record
keeper.RemoveRedelegation(ctx, rd)
_, found = keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1])
require.False(found)
redelegations = keeper.GetRedelegations(ctx, addrDels[0], 5)
require.Equal(0, len(redelegations))
redelegations = keeper.GetAllRedelegations(ctx, addrDels[0], nil, nil)
require.Equal(0, len(redelegations))
}
func (s *KeeperTestSuite) TestRedelegateToSameValidator() {
ctx, keeper := s.ctx, s.stakingKeeper
require := s.Require()
_, addrVals := createValAddrs(1)
valTokens := keeper.TokensFromConsensusPower(ctx, 10)
// create a validator with a self-delegation
validator := testutil.NewValidator(s.T(), addrVals[0], PKs[0])
validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(valTokens, issuedShares.RoundInt())
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
require.True(validator.IsBonded())
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
selfDelegation := stakingtypes.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
_, err := keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[0], math.LegacyNewDec(5))
require.Error(err)
}
func (s *KeeperTestSuite) TestRedelegationMaxEntries() {
ctx, keeper := s.ctx, s.stakingKeeper
require := s.Require()
_, addrVals := createValAddrs(2)
// create a validator with a self-delegation
validator := testutil.NewValidator(s.T(), addrVals[0], PKs[0])
valTokens := keeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(valTokens, issuedShares.RoundInt())
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
_ = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
selfDelegation := stakingtypes.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second validator
validator2 := testutil.NewValidator(s.T(), addrVals[1], PKs[1])
validator2, issuedShares = validator2.AddTokensFromDel(valTokens)
require.Equal(valTokens, issuedShares.RoundInt())
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
validator2 = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator2, true)
require.Equal(stakingtypes.Bonded, validator2.Status)
maxEntries := keeper.MaxEntries(ctx)
// redelegations should pass
var completionTime time.Time
for i := uint32(0); i < maxEntries; i++ {
var err error
completionTime, err = keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], math.LegacyNewDec(1))
require.NoError(err)
}
// an additional redelegation should fail due to max entries
_, err := keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], math.LegacyNewDec(1))
require.Error(err)
// mature redelegations
ctx = ctx.WithBlockTime(completionTime)
_, err = keeper.CompleteRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1])
require.NoError(err)
// redelegation should work again
_, err = keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], math.LegacyNewDec(1))
require.NoError(err)
}
func (s *KeeperTestSuite) TestRedelegateSelfDelegation() {
ctx, keeper := s.ctx, s.stakingKeeper
require := s.Require()
addrDels, addrVals := createValAddrs(2)
// create a validator with a self-delegation
validator := testutil.NewValidator(s.T(), addrVals[0], PKs[0])
keeper.SetValidatorByConsAddr(ctx, validator)
valTokens := keeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(valTokens, issuedShares.RoundInt())
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
val0AccAddr := sdk.AccAddress(addrVals[0])
selfDelegation := stakingtypes.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second validator
validator2 := testutil.NewValidator(s.T(), addrVals[1], PKs[1])
validator2, issuedShares = validator2.AddTokensFromDel(valTokens)
require.Equal(valTokens, issuedShares.RoundInt())
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
validator2 = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator2, true)
require.Equal(stakingtypes.Bonded, validator2.Status)
// create a second delegation to validator 1
delTokens := keeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares = validator.AddTokensFromDel(delTokens)
require.Equal(delTokens, issuedShares.RoundInt())
validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
delegation := stakingtypes.NewDelegation(addrDels[0], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
_, err := keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], sdk.NewDecFromInt(delTokens))
require.NoError(err)
// end block
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any())
s.applyValidatorSetUpdates(ctx, keeper, 2)
validator, found := keeper.GetValidator(ctx, addrVals[0])
require.True(found)
require.Equal(valTokens, validator.Tokens)
require.Equal(stakingtypes.Unbonding, validator.Status)
}
func (s *KeeperTestSuite) TestRedelegateFromUnbondingValidator() {
ctx, keeper := s.ctx, s.stakingKeeper
require := s.Require()
addrDels, addrVals := createValAddrs(2)
// create a validator with a self-delegation
validator := testutil.NewValidator(s.T(), addrVals[0], PKs[0])
keeper.SetValidatorByConsAddr(ctx, validator)
valTokens := keeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(valTokens, issuedShares.RoundInt())
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
selfDelegation := stakingtypes.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second delegation to this validator
keeper.DeleteValidatorByPowerIndex(ctx, validator)
delTokens := keeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares = validator.AddTokensFromDel(delTokens)
require.Equal(delTokens, issuedShares.RoundInt())
validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
delegation := stakingtypes.NewDelegation(addrDels[1], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
// create a second validator
validator2 := testutil.NewValidator(s.T(), addrVals[1], PKs[1])
validator2, issuedShares = validator2.AddTokensFromDel(valTokens)
require.Equal(valTokens, issuedShares.RoundInt())
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
_ = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator2, true)
header := ctx.BlockHeader()
blockHeight := int64(10)
header.Height = blockHeight
blockTime := time.Unix(333, 0)
header.Time = blockTime
ctx = ctx.WithBlockHeader(header)
// unbond the all self-delegation to put validator in unbonding state
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any())
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(delTokens))
require.NoError(err)
// end block
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any())
s.applyValidatorSetUpdates(ctx, keeper, 1)
validator, found := keeper.GetValidator(ctx, addrVals[0])
require.True(found)
require.Equal(blockHeight, validator.UnbondingHeight)
params := keeper.GetParams(ctx)
require.True(blockTime.Add(params.UnbondingTime).Equal(validator.UnbondingTime))
// change the context
header = ctx.BlockHeader()
blockHeight2 := int64(20)
header.Height = blockHeight2
blockTime2 := time.Unix(444, 0)
header.Time = blockTime2
ctx = ctx.WithBlockHeader(header)
// unbond some of the other delegation's shares
redelegateTokens := keeper.TokensFromConsensusPower(ctx, 6)
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
_, err = keeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], sdk.NewDecFromInt(redelegateTokens))
require.NoError(err)
// retrieve the unbonding delegation
ubd, found := keeper.GetRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1])
require.True(found)
require.Len(ubd.Entries, 1)
require.Equal(blockHeight, ubd.Entries[0].CreationHeight)
require.True(blockTime.Add(params.UnbondingTime).Equal(ubd.Entries[0].CompletionTime))
}
func (s *KeeperTestSuite) TestRedelegateFromUnbondedValidator() {
ctx, keeper := s.ctx, s.stakingKeeper
require := s.Require()
addrDels, addrVals := createValAddrs(2)
// create a validator with a self-delegation
validator := testutil.NewValidator(s.T(), addrVals[0], PKs[0])
keeper.SetValidatorByConsAddr(ctx, validator)
valTokens := keeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(valTokens, issuedShares.RoundInt())
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
selfDelegation := stakingtypes.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second delegation to this validator
keeper.DeleteValidatorByPowerIndex(ctx, validator)
delTokens := keeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares = validator.AddTokensFromDel(delTokens)
require.Equal(delTokens, issuedShares.RoundInt())
validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true)
delegation := stakingtypes.NewDelegation(addrDels[1], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
// create a second validator
validator2 := testutil.NewValidator(s.T(), addrVals[1], PKs[1])
validator2, issuedShares = validator2.AddTokensFromDel(valTokens)
require.Equal(valTokens, issuedShares.RoundInt())
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
validator2 = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator2, true)
require.Equal(stakingtypes.Bonded, validator2.Status)
ctx = ctx.WithBlockHeight(10)
ctx = ctx.WithBlockTime(time.Unix(333, 0))
// unbond the all self-delegation to put validator in unbonding state
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any())
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(delTokens))
require.NoError(err)
// end block
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any())
s.applyValidatorSetUpdates(ctx, keeper, 1)
validator, found := keeper.GetValidator(ctx, addrVals[0])
require.True(found)
require.Equal(ctx.BlockHeight(), validator.UnbondingHeight)
params := keeper.GetParams(ctx)
require.True(ctx.BlockHeader().Time.Add(params.UnbondingTime).Equal(validator.UnbondingTime))
// unbond the validator
keeper.UnbondingToUnbonded(ctx, validator)
// redelegate some of the delegation's shares
redelegationTokens := keeper.TokensFromConsensusPower(ctx, 6)
s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any())
_, err = keeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], sdk.NewDecFromInt(redelegationTokens))
require.NoError(err)
// no red should have been found
red, found := keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1])
require.False(found, "%v", red)
}