certusone
/
cosmos-sdk
mirror of https://github.com/certusone/cosmos-sdk.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

use on-chain params on tests + fix tests + add new tests for power reduction change

This commit is contained in:
psaradev 2021-01-28 23:54:39 +10:00
parent 4f476d6890
commit cb17feddc0
38 changed files with 322 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
client/flags/flags.go
View File

@ -15,7 +15,7 @@ const (
// failures due to state changes that might occur between the tx simulation // failures due to state changes that might occur between the tx simulation
// and the actual run. // and the actual run.
DefaultGasAdjustment = 1.0 DefaultGasAdjustment = 1.0
DefaultGasLimit = 200000 DefaultGasLimit = 300000
GasFlagAuto = "auto" GasFlagAuto = "auto"
// DefaultKeyringBackend // DefaultKeyringBackend

6
x/authz/simulation/operations_test.go
View File

@ -72,7 +72,7 @@ func (suite *SimTestSuite) TestWeightedOperations() {
func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account { func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
accounts := simtypes.RandomAccounts(r, n) accounts := simtypes.RandomAccounts(r, n)
initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction) initAmt := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 200000)
initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt)) initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt))
// add coins to the accounts // add coins to the accounts
@ -132,7 +132,7 @@ func (suite *SimTestSuite) TestSimulateRevokeAuthorization() {
AppHash: suite.app.LastCommitID().Hash, AppHash: suite.app.LastCommitID().Hash,
}}) }})
initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction) initAmt := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 200000)
initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt)) initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt))
granter := accounts[0] granter := accounts[0]
@ -167,7 +167,7 @@ func (suite *SimTestSuite) TestSimulateExecAuthorization() {
// begin a new block // begin a new block
suite.app.BeginBlock(abci.RequestBeginBlock{Header: tmproto.Header{Height: suite.app.LastBlockHeight() + 1, AppHash: suite.app.LastCommitID().Hash}}) suite.app.BeginBlock(abci.RequestBeginBlock{Header: tmproto.Header{Height: suite.app.LastBlockHeight() + 1, AppHash: suite.app.LastCommitID().Hash}})
initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction) initAmt := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 200000)
initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt)) initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt))
granter := accounts[0] granter := accounts[0]

2
x/bank/keeper/keeper_test.go
View File

@ -86,7 +86,7 @@ func (suite *IntegrationTestSuite) TestSupply() {
app, ctx := suite.app, suite.ctx app, ctx := suite.app, suite.ctx
initialPower := int64(100) initialPower := int64(100)
initTokens := sdk.TokensFromConsensusPower(initialPower, sdk.DefaultPowerReduction) initTokens := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, initialPower)
totalSupply := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens)) totalSupply := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))
app.BankKeeper.SetSupply(ctx, types.NewSupply(totalSupply)) app.BankKeeper.SetSupply(ctx, types.NewSupply(totalSupply))

2
x/bank/simulation/operations_test.go
View File

@ -124,7 +124,7 @@ func (suite *SimTestSuite) TestSimulateMsgMultiSend() {
func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account { func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
accounts := simtypes.RandomAccounts(r, n) accounts := simtypes.RandomAccounts(r, n)
initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction) initAmt := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 200)
initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt)) initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
// add coins to the accounts // add coins to the accounts

14
x/distribution/keeper/delegation_test.go
View File

@ -112,7 +112,7 @@ func TestCalculateRewardsAfterSlash(t *testing.T) {
ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
// allocate some rewards // allocate some rewards
initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) initial := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.ToDec()}} tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.ToDec()}}
app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens) app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)
@ -175,7 +175,7 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
// allocate some rewards // allocate some rewards
initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) initial := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.ToDec()}} tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.ToDec()}}
app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens) app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)
@ -269,11 +269,11 @@ func TestCalculateRewardsMultiDelegator(t *testing.T) {
} }
func TestWithdrawDelegationRewardsBasic(t *testing.T) { func TestWithdrawDelegationRewardsBasic(t *testing.T) {
balancePower := int64(1000)
balanceTokens := sdk.TokensFromConsensusPower(balancePower, sdk.DefaultPowerReduction)
app := simapp.Setup(false) app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, tmproto.Header{}) ctx := app.BaseApp.NewContext(false, tmproto.Header{})
balancePower := int64(1000)
balanceTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, balancePower)
addr := simapp.AddTestAddrs(app, ctx, 1, sdk.NewInt(1000000000)) addr := simapp.AddTestAddrs(app, ctx, 1, sdk.NewInt(1000000000))
valAddrs := simapp.ConvertAddrsToValAddrs(addr) valAddrs := simapp.ConvertAddrsToValAddrs(addr)
tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
@ -305,7 +305,7 @@ func TestWithdrawDelegationRewardsBasic(t *testing.T) {
val := app.StakingKeeper.Validator(ctx, valAddrs[0]) val := app.StakingKeeper.Validator(ctx, valAddrs[0])
// allocate some rewards // allocate some rewards
initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) initial := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
tokens := sdk.DecCoins{sdk.NewDecCoin(sdk.DefaultBondDenom, initial)} tokens := sdk.DecCoins{sdk.NewDecCoin(sdk.DefaultBondDenom, initial)}
app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens) app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)
@ -375,7 +375,7 @@ func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) {
ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
// allocate some rewards // allocate some rewards
initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec() initial := app.StakingKeeper.TokensFromConsensusPower(ctx, 10).ToDec()
tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}} tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}
app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens) app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)
@ -431,7 +431,7 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
del1 := app.StakingKeeper.Delegation(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0]) del1 := app.StakingKeeper.Delegation(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0])
// allocate some rewards // allocate some rewards
initial := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction).ToDec() initial := app.StakingKeeper.TokensFromConsensusPower(ctx, 30).ToDec()
tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}} tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}
app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens) app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)

2
x/distribution/keeper/keeper_test.go
View File

@ -57,7 +57,7 @@ func TestWithdrawValidatorCommission(t *testing.T) {
// check initial balance // check initial balance
balance := app.BankKeeper.GetAllBalances(ctx, sdk.AccAddress(valAddrs[0])) balance := app.BankKeeper.GetAllBalances(ctx, sdk.AccAddress(valAddrs[0]))
expTokens := sdk.TokensFromConsensusPower(1000, sdk.DefaultPowerReduction) expTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 1000)
expCoins := sdk.NewCoins(sdk.NewCoin("stake", expTokens)) expCoins := sdk.NewCoins(sdk.NewCoin("stake", expTokens))
require.Equal(t, expCoins, balance) require.Equal(t, expCoins, balance)

4
x/distribution/simulation/operations_test.go
View File

@ -95,7 +95,7 @@ func (suite *SimTestSuite) TestSimulateMsgWithdrawDelegatorReward() {
validator0 := suite.getTestingValidator0(accounts) validator0 := suite.getTestingValidator0(accounts)
// setup delegation // setup delegation
delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) delTokens := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 2)
validator0, issuedShares := validator0.AddTokensFromDel(delTokens) validator0, issuedShares := validator0.AddTokensFromDel(delTokens)
delegator := accounts[1] delegator := accounts[1]
delegation := stakingtypes.NewDelegation(delegator.Address, validator0.GetOperator(), issuedShares) delegation := stakingtypes.NewDelegation(delegator.Address, validator0.GetOperator(), issuedShares)
@ -223,7 +223,7 @@ func (suite *SimTestSuite) SetupTest() {
func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account { func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
accounts := simtypes.RandomAccounts(r, n) accounts := simtypes.RandomAccounts(r, n)
initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction) initAmt := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 200)
initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt)) initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
// add coins to the accounts // add coins to the accounts

6
x/gov/abci_test.go
View File

@ -221,7 +221,7 @@ func TestTickPassedVotingPeriod(t *testing.T) {
require.False(t, activeQueue.Valid()) require.False(t, activeQueue.Valid())
activeQueue.Close() activeQueue.Close()
proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction))} proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 5))}
newProposalMsg, err := types.NewMsgSubmitProposal(TestProposal, proposalCoins, addrs[0]) newProposalMsg, err := types.NewMsgSubmitProposal(TestProposal, proposalCoins, addrs[0])
require.NoError(t, err) require.NoError(t, err)
@ -295,7 +295,7 @@ func TestProposalPassedEndblocker(t *testing.T) {
proposal, err := app.GovKeeper.SubmitProposal(ctx, TestProposal) proposal, err := app.GovKeeper.SubmitProposal(ctx, TestProposal)
require.NoError(t, err) require.NoError(t, err)
proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction))} proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 10))}
newDepositMsg := types.NewMsgDeposit(addrs[0], proposal.ProposalId, proposalCoins) newDepositMsg := types.NewMsgDeposit(addrs[0], proposal.ProposalId, proposalCoins)
handleAndCheck(t, handler, ctx, newDepositMsg) handleAndCheck(t, handler, ctx, newDepositMsg)
@ -343,7 +343,7 @@ func TestEndBlockerProposalHandlerFailed(t *testing.T) {
proposal, err := app.GovKeeper.SubmitProposal(ctx, TestProposal) proposal, err := app.GovKeeper.SubmitProposal(ctx, TestProposal)
require.NoError(t, err) require.NoError(t, err)
proposalCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction))) proposalCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 10)))
newDepositMsg := types.NewMsgDeposit(addrs[0], proposal.ProposalId, proposalCoins) newDepositMsg := types.NewMsgDeposit(addrs[0], proposal.ProposalId, proposalCoins)
handleAndCheck(t, gov.NewHandler(app.GovKeeper), ctx, newDepositMsg) handleAndCheck(t, gov.NewHandler(app.GovKeeper), ctx, newDepositMsg)

6
x/gov/keeper/common_test.go
View File

@ -48,9 +48,9 @@ func createValidators(t *testing.T, ctx sdk.Context, app *simapp.SimApp, powers
app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val2) app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val2)
app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val3) app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val3)
_, _ = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0], sdk.DefaultPowerReduction), stakingtypes.Unbonded, val1, true) _, _ = app.StakingKeeper.Delegate(ctx, addrs[0], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[0]), stakingtypes.Unbonded, val1, true)
_, _ = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1], sdk.DefaultPowerReduction), stakingtypes.Unbonded, val2, true) _, _ = app.StakingKeeper.Delegate(ctx, addrs[1], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[1]), stakingtypes.Unbonded, val2, true)
_, _ = app.StakingKeeper.Delegate(ctx, addrs[2], sdk.TokensFromConsensusPower(powers[2], sdk.DefaultPowerReduction), stakingtypes.Unbonded, val3, true) _, _ = app.StakingKeeper.Delegate(ctx, addrs[2], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[2]), stakingtypes.Unbonded, val3, true)
_ = staking.EndBlocker(ctx, app.StakingKeeper) _ = staking.EndBlocker(ctx, app.StakingKeeper)

4
x/gov/keeper/deposit_test.go
View File

@ -22,8 +22,8 @@ func TestDeposits(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
proposalID := proposal.ProposalId proposalID := proposal.ProposalId
fourStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction))) fourStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 4)))
fiveStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction))) fiveStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 5)))
addr0Initial := app.BankKeeper.GetAllBalances(ctx, TestAddrs[0]) addr0Initial := app.BankKeeper.GetAllBalances(ctx, TestAddrs[0])
addr1Initial := app.BankKeeper.GetAllBalances(ctx, TestAddrs[1]) addr1Initial := app.BankKeeper.GetAllBalances(ctx, TestAddrs[1])

8
x/gov/keeper/grpc_query_test.go
View File

@ -164,7 +164,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryProposals() {
{ {
"request with filter of deposit address", "request with filter of deposit address",
func() { func() {
depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction))) depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 20)))
deposit := types.NewDeposit(testProposals[0].ProposalId, addrs[0], depositCoins) deposit := types.NewDeposit(testProposals[0].ProposalId, addrs[0], depositCoins)
app.GovKeeper.SetDeposit(ctx, deposit) app.GovKeeper.SetDeposit(ctx, deposit)
@ -584,7 +584,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryDeposit() {
{ {
"valid request", "valid request",
func() { func() {
depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction))) depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 20)))
deposit := types.NewDeposit(proposal.ProposalId, addrs[0], depositCoins) deposit := types.NewDeposit(proposal.ProposalId, addrs[0], depositCoins)
app.GovKeeper.SetDeposit(ctx, deposit) app.GovKeeper.SetDeposit(ctx, deposit)
@ -671,11 +671,11 @@ func (suite *KeeperTestSuite) TestGRPCQueryDeposits() {
{ {
"get deposits with default limit", "get deposits with default limit",
func() { func() {
depositAmount1 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction))) depositAmount1 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 20)))
deposit1 := types.NewDeposit(proposal.ProposalId, addrs[0], depositAmount1) deposit1 := types.NewDeposit(proposal.ProposalId, addrs[0], depositAmount1)
app.GovKeeper.SetDeposit(ctx, deposit1) app.GovKeeper.SetDeposit(ctx, deposit1)
depositAmount2 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction))) depositAmount2 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 30)))
deposit2 := types.NewDeposit(proposal.ProposalId, addrs[1], depositAmount2) deposit2 := types.NewDeposit(proposal.ProposalId, addrs[1], depositAmount2)
app.GovKeeper.SetDeposit(ctx, deposit2) app.GovKeeper.SetDeposit(ctx, deposit2)

2
x/gov/keeper/querier_test.go
View File

@ -153,7 +153,7 @@ func TestQueries(t *testing.T) {
TestAddrs := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(20000001)) TestAddrs := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(20000001))
oneCoins := sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 1)) oneCoins := sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 1))
consCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction))) consCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 10)))
tp := TestProposal tp := TestProposal

20
x/gov/keeper/tally_test.go
View File

@ -245,7 +245,7 @@ func TestTallyDelgatorOverride(t *testing.T) {
addrs, valAddrs := createValidators(t, ctx, app, []int64{5, 6, 7}) addrs, valAddrs := createValidators(t, ctx, app, []int64{5, 6, 7})
delTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
val1, found := app.StakingKeeper.GetValidator(ctx, valAddrs[0]) val1, found := app.StakingKeeper.GetValidator(ctx, valAddrs[0])
require.True(t, found) require.True(t, found)
@ -281,7 +281,7 @@ func TestTallyDelgatorInherit(t *testing.T) {
addrs, vals := createValidators(t, ctx, app, []int64{5, 6, 7}) addrs, vals := createValidators(t, ctx, app, []int64{5, 6, 7})
delTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
val3, found := app.StakingKeeper.GetValidator(ctx, vals[2]) val3, found := app.StakingKeeper.GetValidator(ctx, vals[2])
require.True(t, found) require.True(t, found)
@ -316,7 +316,7 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) {
addrs, vals := createValidators(t, ctx, app, []int64{5, 6, 7}) addrs, vals := createValidators(t, ctx, app, []int64{5, 6, 7})
delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
val1, found := app.StakingKeeper.GetValidator(ctx, vals[0]) val1, found := app.StakingKeeper.GetValidator(ctx, vals[0])
require.True(t, found) require.True(t, found)
val2, found := app.StakingKeeper.GetValidator(ctx, vals[1]) val2, found := app.StakingKeeper.GetValidator(ctx, vals[1])
@ -358,7 +358,7 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) {
addrs, vals := createValidators(t, ctx, app, []int64{5, 6, 7}) addrs, vals := createValidators(t, ctx, app, []int64{5, 6, 7})
delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
val2, found := app.StakingKeeper.GetValidator(ctx, vals[1]) val2, found := app.StakingKeeper.GetValidator(ctx, vals[1])
require.True(t, found) require.True(t, found)
val3, found := app.StakingKeeper.GetValidator(ctx, vals[2]) val3, found := app.StakingKeeper.GetValidator(ctx, vals[2])
@ -397,7 +397,7 @@ func TestTallyJailedValidator(t *testing.T) {
addrs, valAddrs := createValidators(t, ctx, app, []int64{25, 6, 7}) addrs, valAddrs := createValidators(t, ctx, app, []int64{25, 6, 7})
delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
val2, found := app.StakingKeeper.GetValidator(ctx, valAddrs[1]) val2, found := app.StakingKeeper.GetValidator(ctx, valAddrs[1])
require.True(t, found) require.True(t, found)
val3, found := app.StakingKeeper.GetValidator(ctx, valAddrs[2]) val3, found := app.StakingKeeper.GetValidator(ctx, valAddrs[2])
@ -440,7 +440,7 @@ func TestTallyValidatorMultipleDelegations(t *testing.T) {
addrs, valAddrs := createValidators(t, ctx, app, []int64{10, 10, 10}) addrs, valAddrs := createValidators(t, ctx, app, []int64{10, 10, 10})
delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
val2, found := app.StakingKeeper.GetValidator(ctx, valAddrs[1]) val2, found := app.StakingKeeper.GetValidator(ctx, valAddrs[1])
require.True(t, found) require.True(t, found)
@ -465,10 +465,10 @@ func TestTallyValidatorMultipleDelegations(t *testing.T) {
require.True(t, passes) require.True(t, passes)
require.False(t, burnDeposits) require.False(t, burnDeposits)
expectedYes := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction) expectedYes := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
expectedAbstain := sdk.TokensFromConsensusPower(0, sdk.DefaultPowerReduction) expectedAbstain := app.StakingKeeper.TokensFromConsensusPower(ctx, 0)
expectedNo := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) expectedNo := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
expectedNoWithVeto := sdk.TokensFromConsensusPower(0, sdk.DefaultPowerReduction) expectedNoWithVeto := app.StakingKeeper.TokensFromConsensusPower(ctx, 0)
expectedTallyResult := types.NewTallyResult(expectedYes, expectedAbstain, expectedNo, expectedNoWithVeto) expectedTallyResult := types.NewTallyResult(expectedYes, expectedAbstain, expectedNo, expectedNoWithVeto)
require.True(t, tallyResults.Equals(expectedTallyResult)) require.True(t, tallyResults.Equals(expectedTallyResult))

2
x/gov/simulation/operations_test.go
View File

@ -222,7 +222,7 @@ func createTestApp(isCheckTx bool) (*simapp.SimApp, sdk.Context) {
func getTestingAccounts(t *testing.T, r *rand.Rand, app *simapp.SimApp, ctx sdk.Context, n int) []simtypes.Account { func getTestingAccounts(t *testing.T, r *rand.Rand, app *simapp.SimApp, ctx sdk.Context, n int) []simtypes.Account {
accounts := simtypes.RandomAccounts(r, n) accounts := simtypes.RandomAccounts(r, n)
initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction) initAmt := app.StakingKeeper.TokensFromConsensusPower(ctx, 200)
initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt)) initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
// add coins to the accounts // add coins to the accounts

2
x/ibc/core/02-client/keeper/keeper_test.go
View File

@ -111,7 +111,7 @@ func (suite *KeeperTestSuite) SetupTest() {
val.Tokens = sdk.NewInt(rand.Int63()) val.Tokens = sdk.NewInt(rand.Int63())
validators = append(validators, val) validators = append(validators, val)
hi := stakingtypes.NewHistoricalInfo(suite.ctx.BlockHeader(), validators, sdk.DefaultPowerReduction) hi := stakingtypes.NewHistoricalInfo(suite.ctx.BlockHeader(), validators, app.StakingKeeper.PowerReduction(suite.ctx))
app.StakingKeeper.SetHistoricalInfo(suite.ctx, int64(i), &hi) app.StakingKeeper.SetHistoricalInfo(suite.ctx, int64(i), &hi)
} }

2
x/slashing/abci_test.go
View File

@ -21,7 +21,7 @@ func TestBeginBlocker(t *testing.T) {
ctx := app.BaseApp.NewContext(false, tmproto.Header{}) ctx := app.BaseApp.NewContext(false, tmproto.Header{})
pks := simapp.CreateTestPubKeys(1) pks := simapp.CreateTestPubKeys(1)
simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) simapp.AddTestAddrsFromPubKeys(app, ctx, pks, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
addr, pk := sdk.ValAddress(pks[0].Address()), pks[0] addr, pk := sdk.ValAddress(pks[0].Address()), pks[0]
tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)

2
x/slashing/genesis_test.go
View File

@ -20,7 +20,7 @@ func TestExportAndInitGenesis(t *testing.T) {
app.SlashingKeeper.SetParams(ctx, testslashing.TestParams()) app.SlashingKeeper.SetParams(ctx, testslashing.TestParams())
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
info1 := types.NewValidatorSigningInfo(sdk.ConsAddress(addrDels[0]), int64(4), int64(3), info1 := types.NewValidatorSigningInfo(sdk.ConsAddress(addrDels[0]), int64(4), int64(3),
time.Now().UTC().Add(100000000000), false, int64(10)) time.Now().UTC().Add(100000000000), false, int64(10))

10
x/slashing/handler_test.go
View File

@ -26,7 +26,7 @@ func TestCannotUnjailUnlessJailed(t *testing.T) {
app := simapp.Setup(false) app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, tmproto.Header{}) ctx := app.BaseApp.NewContext(false, tmproto.Header{})
pks := simapp.CreateTestPubKeys(1) pks := simapp.CreateTestPubKeys(1)
simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) simapp.AddTestAddrsFromPubKeys(app, ctx, pks, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
slh := slashing.NewHandler(app.SlashingKeeper) slh := slashing.NewHandler(app.SlashingKeeper)
@ -52,12 +52,12 @@ func TestCannotUnjailUnlessMeetMinSelfDelegation(t *testing.T) {
app := simapp.Setup(false) app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, tmproto.Header{}) ctx := app.BaseApp.NewContext(false, tmproto.Header{})
pks := simapp.CreateTestPubKeys(1) pks := simapp.CreateTestPubKeys(1)
simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) simapp.AddTestAddrsFromPubKeys(app, ctx, pks, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
slh := slashing.NewHandler(app.SlashingKeeper) slh := slashing.NewHandler(app.SlashingKeeper)
addr, val := sdk.ValAddress(pks[0].Address()), pks[0] addr, val := sdk.ValAddress(pks[0].Address()), pks[0]
amt := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) amt := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
msg := tstaking.CreateValidatorMsg(addr, val, amt) msg := tstaking.CreateValidatorMsg(addr, val, amt)
msg.MinSelfDelegation = amt msg.MinSelfDelegation = amt
tstaking.Handle(msg, true) tstaking.Handle(msg, true)
@ -84,7 +84,7 @@ func TestJailedValidatorDelegations(t *testing.T) {
ctx := app.BaseApp.NewContext(false, tmproto.Header{Time: time.Unix(0, 0)}) ctx := app.BaseApp.NewContext(false, tmproto.Header{Time: time.Unix(0, 0)})
pks := simapp.CreateTestPubKeys(3) pks := simapp.CreateTestPubKeys(3)
simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)) simapp.AddTestAddrsFromPubKeys(app, ctx, pks, app.StakingKeeper.TokensFromConsensusPower(ctx, 20))
app.SlashingKeeper.SetParams(ctx, testslashing.TestParams()) app.SlashingKeeper.SetParams(ctx, testslashing.TestParams())
tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
@ -145,7 +145,7 @@ func TestHandleAbsentValidator(t *testing.T) {
app := simapp.Setup(false) app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, tmproto.Header{Time: time.Unix(0, 0)}) ctx := app.BaseApp.NewContext(false, tmproto.Header{Time: time.Unix(0, 0)})
pks := simapp.CreateTestPubKeys(1) pks := simapp.CreateTestPubKeys(1)
simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) simapp.AddTestAddrsFromPubKeys(app, ctx, pks, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
app.SlashingKeeper.SetParams(ctx, testslashing.TestParams()) app.SlashingKeeper.SetParams(ctx, testslashing.TestParams())
power := int64(100) power := int64(100)

2
x/slashing/keeper/grpc_query_test.go
View File

@ -35,7 +35,7 @@ func (suite *SlashingTestSuite) SetupTest() {
app.BankKeeper.SetParams(ctx, banktypes.DefaultParams()) app.BankKeeper.SetParams(ctx, banktypes.DefaultParams())
app.SlashingKeeper.SetParams(ctx, testslashing.TestParams()) app.SlashingKeeper.SetParams(ctx, testslashing.TestParams())
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
info1 := types.NewValidatorSigningInfo(sdk.ConsAddress(addrDels[0]), int64(4), int64(3), info1 := types.NewValidatorSigningInfo(sdk.ConsAddress(addrDels[0]), int64(4), int64(3),
time.Unix(2, 0), false, int64(10)) time.Unix(2, 0), false, int64(10))

16
x/slashing/keeper/keeper_test.go
View File

@ -23,7 +23,7 @@ func TestUnJailNotBonded(t *testing.T) {
p.MaxValidators = 5 p.MaxValidators = 5
app.StakingKeeper.SetParams(ctx, p) app.StakingKeeper.SetParams(ctx, p)
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 6, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 6, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
valAddrs := simapp.ConvertAddrsToValAddrs(addrDels) valAddrs := simapp.ConvertAddrsToValAddrs(addrDels)
pks := simapp.CreateTestPubKeys(6) pks := simapp.CreateTestPubKeys(6)
tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
@ -39,7 +39,7 @@ func TestUnJailNotBonded(t *testing.T) {
// create a 6th validator with less power than the cliff validator (won't be bonded) // create a 6th validator with less power than the cliff validator (won't be bonded)
addr, val := valAddrs[5], pks[5] addr, val := valAddrs[5], pks[5]
amt := sdk.TokensFromConsensusPower(50, sdk.DefaultPowerReduction) amt := app.StakingKeeper.TokensFromConsensusPower(ctx, 50)
msg := tstaking.CreateValidatorMsg(addr, val, amt) msg := tstaking.CreateValidatorMsg(addr, val, amt)
msg.MinSelfDelegation = amt msg.MinSelfDelegation = amt
tstaking.Handle(msg, true) tstaking.Handle(msg, true)
@ -51,7 +51,7 @@ func TestUnJailNotBonded(t *testing.T) {
// unbond below minimum self-delegation // unbond below minimum self-delegation
require.Equal(t, p.BondDenom, tstaking.Denom) require.Equal(t, p.BondDenom, tstaking.Denom)
tstaking.Undelegate(sdk.AccAddress(addr), addr, sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction), true) tstaking.Undelegate(sdk.AccAddress(addr), addr, app.StakingKeeper.TokensFromConsensusPower(ctx, 1), true)
staking.EndBlocker(ctx, app.StakingKeeper) staking.EndBlocker(ctx, app.StakingKeeper)
ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1)
@ -83,7 +83,7 @@ func TestHandleNewValidator(t *testing.T) {
app := simapp.Setup(false) app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, tmproto.Header{}) ctx := app.BaseApp.NewContext(false, tmproto.Header{})
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
valAddrs := simapp.ConvertAddrsToValAddrs(addrDels) valAddrs := simapp.ConvertAddrsToValAddrs(addrDels)
pks := simapp.CreateTestPubKeys(1) pks := simapp.CreateTestPubKeys(1)
addr, val := valAddrs[0], pks[0] addr, val := valAddrs[0], pks[0]
@ -116,7 +116,7 @@ func TestHandleNewValidator(t *testing.T) {
validator, _ := app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val)) validator, _ := app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
require.Equal(t, stakingtypes.Bonded, validator.GetStatus()) require.Equal(t, stakingtypes.Bonded, validator.GetStatus())
bondPool := app.StakingKeeper.GetBondedPool(ctx) bondPool := app.StakingKeeper.GetBondedPool(ctx)
expTokens := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) expTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
require.True(t, expTokens.Equal(app.BankKeeper.GetBalance(ctx, bondPool.GetAddress(), app.StakingKeeper.BondDenom(ctx)).Amount)) require.True(t, expTokens.Equal(app.BankKeeper.GetBalance(ctx, bondPool.GetAddress(), app.StakingKeeper.BondDenom(ctx)).Amount))
} }
@ -127,7 +127,7 @@ func TestHandleAlreadyJailed(t *testing.T) {
app := simapp.Setup(false) app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, tmproto.Header{}) ctx := app.BaseApp.NewContext(false, tmproto.Header{})
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
valAddrs := simapp.ConvertAddrsToValAddrs(addrDels) valAddrs := simapp.ConvertAddrsToValAddrs(addrDels)
pks := simapp.CreateTestPubKeys(1) pks := simapp.CreateTestPubKeys(1)
addr, val := valAddrs[0], pks[0] addr, val := valAddrs[0], pks[0]
@ -159,7 +159,7 @@ func TestHandleAlreadyJailed(t *testing.T) {
require.Equal(t, stakingtypes.Unbonding, validator.GetStatus()) require.Equal(t, stakingtypes.Unbonding, validator.GetStatus())
// validator should have been slashed // validator should have been slashed
resultingTokens := amt.Sub(sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)) resultingTokens := amt.Sub(app.StakingKeeper.TokensFromConsensusPower(ctx, 1))
require.Equal(t, resultingTokens, validator.GetTokens()) require.Equal(t, resultingTokens, validator.GetTokens())
// another block missed // another block missed
@ -188,7 +188,7 @@ func TestValidatorDippingInAndOut(t *testing.T) {
power := int64(100) power := int64(100)
pks := simapp.CreateTestPubKeys(3) pks := simapp.CreateTestPubKeys(3)
simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) simapp.AddTestAddrsFromPubKeys(app, ctx, pks, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
addr, val := pks[0].Address(), pks[0] addr, val := pks[0].Address(), pks[0]
consAddr := sdk.ConsAddress(addr) consAddr := sdk.ConsAddress(addr)

8
x/slashing/keeper/signing_info_test.go
View File

@ -15,7 +15,7 @@ import (
func TestGetSetValidatorSigningInfo(t *testing.T) { func TestGetSetValidatorSigningInfo(t *testing.T) {
app := simapp.Setup(false) app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, tmproto.Header{}) ctx := app.BaseApp.NewContext(false, tmproto.Header{})
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
info, found := app.SlashingKeeper.GetValidatorSigningInfo(ctx, sdk.ConsAddress(addrDels[0])) info, found := app.SlashingKeeper.GetValidatorSigningInfo(ctx, sdk.ConsAddress(addrDels[0]))
require.False(t, found) require.False(t, found)
@ -39,7 +39,7 @@ func TestGetSetValidatorSigningInfo(t *testing.T) {
func TestGetSetValidatorMissedBlockBitArray(t *testing.T) { func TestGetSetValidatorMissedBlockBitArray(t *testing.T) {
app := simapp.Setup(false) app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, tmproto.Header{}) ctx := app.BaseApp.NewContext(false, tmproto.Header{})
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
missed := app.SlashingKeeper.GetValidatorMissedBlockBitArray(ctx, sdk.ConsAddress(addrDels[0]), 0) missed := app.SlashingKeeper.GetValidatorMissedBlockBitArray(ctx, sdk.ConsAddress(addrDels[0]), 0)
require.False(t, missed) // treat empty key as not missed require.False(t, missed) // treat empty key as not missed
@ -51,7 +51,7 @@ func TestGetSetValidatorMissedBlockBitArray(t *testing.T) {
func TestTombstoned(t *testing.T) { func TestTombstoned(t *testing.T) {
app := simapp.Setup(false) app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, tmproto.Header{}) ctx := app.BaseApp.NewContext(false, tmproto.Header{})
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
require.Panics(t, func() { app.SlashingKeeper.Tombstone(ctx, sdk.ConsAddress(addrDels[0])) }) require.Panics(t, func() { app.SlashingKeeper.Tombstone(ctx, sdk.ConsAddress(addrDels[0])) })
require.False(t, app.SlashingKeeper.IsTombstoned(ctx, sdk.ConsAddress(addrDels[0]))) require.False(t, app.SlashingKeeper.IsTombstoned(ctx, sdk.ConsAddress(addrDels[0])))
@ -75,7 +75,7 @@ func TestTombstoned(t *testing.T) {
func TestJailUntil(t *testing.T) { func TestJailUntil(t *testing.T) {
app := simapp.Setup(false) app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, tmproto.Header{}) ctx := app.BaseApp.NewContext(false, tmproto.Header{})
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
require.Panics(t, func() { app.SlashingKeeper.JailUntil(ctx, sdk.ConsAddress(addrDels[0]), time.Now()) }) require.Panics(t, func() { app.SlashingKeeper.JailUntil(ctx, sdk.ConsAddress(addrDels[0]), time.Now()) })

4
x/slashing/simulation/operations_test.go
View File

@ -77,7 +77,7 @@ func TestSimulateMsgUnjail(t *testing.T) {
app.StakingKeeper.Jail(ctx, val0ConsAddress) app.StakingKeeper.Jail(ctx, val0ConsAddress)
// setup self delegation // setup self delegation
delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
validator0, issuedShares := validator0.AddTokensFromDel(delTokens) validator0, issuedShares := validator0.AddTokensFromDel(delTokens)
val0AccAddress, err := sdk.ValAddressFromBech32(validator0.OperatorAddress) val0AccAddress, err := sdk.ValAddressFromBech32(validator0.OperatorAddress)
require.NoError(t, err) require.NoError(t, err)
@ -116,7 +116,7 @@ func createTestApp(isCheckTx bool) (*simapp.SimApp, sdk.Context) {
func getTestingAccounts(t *testing.T, r *rand.Rand, app *simapp.SimApp, ctx sdk.Context, n int) []simtypes.Account { func getTestingAccounts(t *testing.T, r *rand.Rand, app *simapp.SimApp, ctx sdk.Context, n int) []simtypes.Account {
accounts := simtypes.RandomAccounts(r, n) accounts := simtypes.RandomAccounts(r, n)
initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction) initAmt := app.StakingKeeper.TokensFromConsensusPower(ctx, 200)
initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt)) initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
// add coins to the accounts // add coins to the accounts

3
x/staking/client/cli/cli_test.go
View File

@ -861,12 +861,13 @@ func (s *IntegrationTestSuite) TestGetCmdQueryParams() {
historical_entries: 10000 historical_entries: 10000
max_entries: 7 max_entries: 7
max_validators: 100 max_validators: 100
power_reduction: "1000000"
unbonding_time: 1814400s`, unbonding_time: 1814400s`,
}, },
{ {
"with json output", "with json output",
[]string{fmt.Sprintf("--%s=json", tmcli.OutputFlag)}, []string{fmt.Sprintf("--%s=json", tmcli.OutputFlag)},
`{"unbonding_time":"1814400s","max_validators":100,"max_entries":7,"historical_entries":10000,"bond_denom":"stake"}`, `{"unbonding_time":"1814400s","max_validators":100,"max_entries":7,"historical_entries":10000,"bond_denom":"stake","power_reduction":"1000000"}`,
}, },
} }
for _, tc := range testCases { for _, tc := range testCases {

12
x/staking/genesis_test.go
View File

@ -23,7 +23,7 @@ func bootstrapGenesisTest(t *testing.T, power int64, numAddrs int) (*simapp.SimA
addrDels, _ := generateAddresses(app, ctx, numAddrs, sdk.NewInt(10000)) addrDels, _ := generateAddresses(app, ctx, numAddrs, sdk.NewInt(10000))
amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) amt := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels))))) totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@ -39,7 +39,7 @@ func bootstrapGenesisTest(t *testing.T, power int64, numAddrs int) (*simapp.SimA
func TestInitGenesis(t *testing.T) { func TestInitGenesis(t *testing.T) {
app, ctx, addrs := bootstrapGenesisTest(t, 1000, 10) app, ctx, addrs := bootstrapGenesisTest(t, 1000, 10)
valTokens := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction) valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 1)
params := app.StakingKeeper.GetParams(ctx) params := app.StakingKeeper.GetParams(ctx)
validators := make([]types.Validator, 2) validators := make([]types.Validator, 2)
@ -91,7 +91,7 @@ func TestInitGenesis(t *testing.T) {
abcivals := make([]abci.ValidatorUpdate, len(vals)) abcivals := make([]abci.ValidatorUpdate, len(vals))
for i, val := range validators { for i, val := range validators {
abcivals[i] = val.ABCIValidatorUpdate(sdk.DefaultPowerReduction) abcivals[i] = val.ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx))
} }
require.Equal(t, abcivals, vals) require.Equal(t, abcivals, vals)
@ -113,9 +113,9 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
validators[i].Status = types.Bonded validators[i].Status = types.Bonded
tokens := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 1)
if i < 100 { if i < 100 {
tokens = sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
} }
validators[i].Tokens = tokens validators[i].Tokens = tokens
validators[i].DelegatorShares = tokens.ToDec() validators[i].DelegatorShares = tokens.ToDec()
@ -126,7 +126,7 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) {
abcivals := make([]abci.ValidatorUpdate, 100) abcivals := make([]abci.ValidatorUpdate, 100)
for i, val := range validators[:100] { for i, val := range validators[:100] {
abcivals[i] = val.ABCIValidatorUpdate(sdk.DefaultPowerReduction) abcivals[i] = val.ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx))
} }
require.Equal(t, abcivals, vals) require.Equal(t, abcivals, vals)

65
x/staking/handler_test.go
View File

@ -32,7 +32,7 @@ func bootstrapHandlerGenesisTest(t *testing.T, power int64, numAddrs int, accAmo
addrDels, addrVals := generateAddresses(app, ctx, numAddrs, accAmount) addrDels, addrVals := generateAddresses(app, ctx, numAddrs, accAmount)
amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) amt := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels))))) totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@ -45,6 +45,51 @@ func bootstrapHandlerGenesisTest(t *testing.T, power int64, numAddrs int, accAmo
return app, ctx, addrDels, addrVals return app, ctx, addrDels, addrVals
} }
func TestPowerReductionChangeValidatorSetUpdates(t *testing.T) {
initPower := int64(1000000)
app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 10, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
validatorAddr, validatorAddr3 := valAddrs[0], valAddrs[1]
tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
// create validator
tstaking.CreateValidatorWithValPower(validatorAddr, PKs[0], initPower, true)
// must end-block
updates, err := app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
require.NoError(t, err)
require.Equal(t, 1, len(updates))
// create a second validator keep it bonded
tstaking.CreateValidatorWithValPower(validatorAddr3, PKs[2], initPower, true)
// must end-block
updates, err = app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
require.NoError(t, err)
require.Equal(t, 1, len(updates))
// modify power reduction to 10 times bigger one
params := app.StakingKeeper.GetParams(ctx)
params.PowerReduction = sdk.DefaultPowerReduction.Mul(sdk.NewInt(10))
app.StakingKeeper.SetParams(ctx, params)
// validator updates for tendermint power
updates, err = app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
require.NoError(t, err)
require.Equal(t, 2, len(updates))
require.Equal(t, updates[0].Power, initPower/10)
require.Equal(t, updates[1].Power, initPower/10)
// power reduction back to default
params = app.StakingKeeper.GetParams(ctx)
params.PowerReduction = sdk.DefaultPowerReduction
app.StakingKeeper.SetParams(ctx, params)
// power reduction change for all validators
updates, err = app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
require.NoError(t, err)
require.Equal(t, 2, len(updates))
}
func TestValidatorByPowerIndex(t *testing.T) { func TestValidatorByPowerIndex(t *testing.T) {
initPower := int64(1000000) initPower := int64(1000000)
app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 10, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 10, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
@ -68,7 +113,7 @@ func TestValidatorByPowerIndex(t *testing.T) {
// verify that the by power index exists // verify that the by power index exists
validator, found := app.StakingKeeper.GetValidator(ctx, validatorAddr) validator, found := app.StakingKeeper.GetValidator(ctx, validatorAddr)
require.True(t, found) require.True(t, found)
power := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction) power := types.GetValidatorsByPowerIndexKey(validator, app.StakingKeeper.PowerReduction(ctx))
require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power)) require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power))
// create a second validator keep it bonded // create a second validator keep it bonded
@ -97,11 +142,11 @@ func TestValidatorByPowerIndex(t *testing.T) {
// but the new power record should have been created // but the new power record should have been created
validator, found = app.StakingKeeper.GetValidator(ctx, validatorAddr) validator, found = app.StakingKeeper.GetValidator(ctx, validatorAddr)
require.True(t, found) require.True(t, found)
power2 := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction) power2 := types.GetValidatorsByPowerIndexKey(validator, app.StakingKeeper.PowerReduction(ctx))
require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power2)) require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power2))
// now the new record power index should be the same as the original record // now the new record power index should be the same as the original record
power3 := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction) power3 := types.GetValidatorsByPowerIndexKey(validator, app.StakingKeeper.PowerReduction(ctx))
require.Equal(t, power2, power3) require.Equal(t, power2, power3)
// unbond self-delegation // unbond self-delegation
@ -491,8 +536,8 @@ func TestIncrementsMsgUnbond(t *testing.T) {
errorCases := []sdk.Int{ errorCases := []sdk.Int{
//1<<64 - 1, // more than int64 power //1<<64 - 1, // more than int64 power
//1<<63 + 1, // more than int64 power //1<<63 + 1, // more than int64 power
sdk.TokensFromConsensusPower(1<<63-1, sdk.DefaultPowerReduction), app.StakingKeeper.TokensFromConsensusPower(ctx, 1<<63-1),
sdk.TokensFromConsensusPower(1<<31, sdk.DefaultPowerReduction), app.StakingKeeper.TokensFromConsensusPower(ctx, 1<<31),
initBond, initBond,
} }
@ -527,7 +572,7 @@ func TestMultipleMsgCreateValidator(t *testing.T) {
} }
// bond them all // bond them all
amt := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) amt := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
for i, validatorAddr := range validatorAddrs { for i, validatorAddr := range validatorAddrs {
tstaking.CreateValidator(validatorAddr, PKs[i], amt, true) tstaking.CreateValidator(validatorAddr, PKs[i], amt, true)
// verify that the account is bonded // verify that the account is bonded
@ -1094,11 +1139,11 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
tstaking.Ctx = ctx tstaking.Ctx = ctx
// begin unbonding 4 stake // begin unbonding 4 stake
unbondAmt := sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction) unbondAmt := app.StakingKeeper.TokensFromConsensusPower(ctx, 4)
tstaking.Undelegate(del, valA, unbondAmt, true) tstaking.Undelegate(del, valA, unbondAmt, true)
// begin redelegate 6 stake // begin redelegate 6 stake
redAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction)) redAmt := sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 6))
msgBeginRedelegate := types.NewMsgBeginRedelegate(del, valA, valB, redAmt) msgBeginRedelegate := types.NewMsgBeginRedelegate(del, valA, valB, redAmt)
tstaking.Handle(msgBeginRedelegate, true) tstaking.Handle(msgBeginRedelegate, true)
@ -1182,7 +1227,7 @@ func TestInvalidCoinDenom(t *testing.T) {
valA, valB, delAddr := valAddrs[0], valAddrs[1], delAddrs[2] valA, valB, delAddr := valAddrs[0], valAddrs[1], delAddrs[2]
tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
valTokens := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
invalidCoin := sdk.NewCoin("churros", valTokens) invalidCoin := sdk.NewCoin("churros", valTokens)
validCoin := sdk.NewCoin(sdk.DefaultBondDenom, valTokens) validCoin := sdk.NewCoin(sdk.DefaultBondDenom, valTokens)
oneCoin := sdk.NewCoin(sdk.DefaultBondDenom, sdk.OneInt()) oneCoin := sdk.NewCoin(sdk.DefaultBondDenom, sdk.OneInt())

52
x/staking/keeper/delegation_test.go
View File

@ -183,7 +183,7 @@ func TestUnbondDelegation(t *testing.T) {
delAddrs := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000)) delAddrs := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000))
valAddrs := simapp.ConvertAddrsToValAddrs(delAddrs) valAddrs := simapp.ConvertAddrsToValAddrs(delAddrs)
startTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
require.NoError(t, require.NoError(t,
@ -207,7 +207,7 @@ func TestUnbondDelegation(t *testing.T) {
delegation := types.NewDelegation(delAddrs[0], valAddrs[0], issuedShares) delegation := types.NewDelegation(delAddrs[0], valAddrs[0], issuedShares)
app.StakingKeeper.SetDelegation(ctx, delegation) app.StakingKeeper.SetDelegation(ctx, delegation)
bondTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction) bondTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
amount, err := app.StakingKeeper.Unbond(ctx, delAddrs[0], valAddrs[0], bondTokens.ToDec()) amount, err := app.StakingKeeper.Unbond(ctx, delAddrs[0], valAddrs[0], bondTokens.ToDec())
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, bondTokens, amount) // shares to be added to an unbonding delegation require.Equal(t, bondTokens, amount) // shares to be added to an unbonding delegation
@ -228,7 +228,7 @@ func TestUnbondingDelegationsMaxEntries(t *testing.T) {
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000))
addrVals := simapp.ConvertAddrsToValAddrs(addrDels) addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
startTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
bondDenom := app.StakingKeeper.BondDenom(ctx) bondDenom := app.StakingKeeper.BondDenom(ctx)
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@ -310,7 +310,7 @@ func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) {
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000))
addrVals := simapp.ConvertAddrsToValAddrs(addrDels) addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens)) delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
//create a validator with a self-delegation //create a validator with a self-delegation
@ -358,7 +358,7 @@ func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) {
app.StakingKeeper.SetDelegation(ctx, delegation) app.StakingKeeper.SetDelegation(ctx, delegation)
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes()) val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
_, err = app.StakingKeeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction).ToDec()) _, err = app.StakingKeeper.Undelegate(ctx, val0AccAddr, addrVals[0], app.StakingKeeper.TokensFromConsensusPower(ctx, 6).ToDec())
require.NoError(t, err) require.NoError(t, err)
// end block // end block
@ -366,14 +366,14 @@ func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) {
validator, found := app.StakingKeeper.GetValidator(ctx, addrVals[0]) validator, found := app.StakingKeeper.GetValidator(ctx, addrVals[0])
require.True(t, found) require.True(t, found)
require.Equal(t, sdk.TokensFromConsensusPower(14, sdk.DefaultPowerReduction), validator.Tokens) require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 14), validator.Tokens)
require.Equal(t, types.Unbonding, validator.Status) require.Equal(t, types.Unbonding, validator.Status)
require.True(t, validator.Jailed) require.True(t, validator.Jailed)
} }
func TestUndelegateFromUnbondingValidator(t *testing.T) { func TestUndelegateFromUnbondingValidator(t *testing.T) {
_, app, ctx := createTestInput() _, app, ctx := createTestInput()
delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens)) delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
@ -466,7 +466,7 @@ func TestUndelegateFromUnbondingValidator(t *testing.T) {
func TestUndelegateFromUnbondedValidator(t *testing.T) { func TestUndelegateFromUnbondedValidator(t *testing.T) {
_, app, ctx := createTestInput() _, app, ctx := createTestInput()
delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens)) delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
@ -483,7 +483,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
validator := teststaking.NewValidator(t, addrVals[0], PKs[0]) validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
app.StakingKeeper.SetValidatorByConsAddr(ctx, validator) app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens) validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt()) require.Equal(t, valTokens, issuedShares.RoundInt())
validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@ -534,7 +534,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
require.Equal(t, validator.Status, types.Unbonded) require.Equal(t, validator.Status, types.Unbonded)
// unbond some of the other delegation's shares // unbond some of the other delegation's shares
unbondTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction) unbondTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
_, err = app.StakingKeeper.Undelegate(ctx, addrDels[1], addrVals[0], unbondTokens.ToDec()) _, err = app.StakingKeeper.Undelegate(ctx, addrDels[1], addrVals[0], unbondTokens.ToDec())
require.NoError(t, err) require.NoError(t, err)
@ -550,7 +550,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
func TestUnbondingAllDelegationFromValidator(t *testing.T) { func TestUnbondingAllDelegationFromValidator(t *testing.T) {
_, app, ctx := createTestInput() _, app, ctx := createTestInput()
delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens)) delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
@ -567,7 +567,7 @@ func TestUnbondingAllDelegationFromValidator(t *testing.T) {
validator := teststaking.NewValidator(t, addrVals[0], PKs[0]) validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
app.StakingKeeper.SetValidatorByConsAddr(ctx, validator) app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens) validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt()) require.Equal(t, valTokens, issuedShares.RoundInt())
@ -720,7 +720,7 @@ func TestRedelegateToSameValidator(t *testing.T) {
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(0)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(0))
addrVals := simapp.ConvertAddrsToValAddrs(addrDels) addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), valTokens)) startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), valTokens))
// add bonded tokens to pool for delegations // add bonded tokens to pool for delegations
@ -751,7 +751,7 @@ func TestRedelegationMaxEntries(t *testing.T) {
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
addrVals := simapp.ConvertAddrsToValAddrs(addrDels) addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
startTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction) startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens)) startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
// add bonded tokens to pool for delegations // add bonded tokens to pool for delegations
@ -763,7 +763,7 @@ func TestRedelegationMaxEntries(t *testing.T) {
// create a validator with a self-delegation // create a validator with a self-delegation
validator := teststaking.NewValidator(t, addrVals[0], PKs[0]) validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens) validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt()) require.Equal(t, valTokens, issuedShares.RoundInt())
validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@ -809,7 +809,7 @@ func TestRedelegateSelfDelegation(t *testing.T) {
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
addrVals := simapp.ConvertAddrsToValAddrs(addrDels) addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
startTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction) startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens)) startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
// add bonded tokens to pool for delegations // add bonded tokens to pool for delegations
@ -823,7 +823,7 @@ func TestRedelegateSelfDelegation(t *testing.T) {
validator := teststaking.NewValidator(t, addrVals[0], PKs[0]) validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
app.StakingKeeper.SetValidatorByConsAddr(ctx, validator) app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens) validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt()) require.Equal(t, valTokens, issuedShares.RoundInt())
@ -841,7 +841,7 @@ func TestRedelegateSelfDelegation(t *testing.T) {
require.Equal(t, types.Bonded, validator2.Status) require.Equal(t, types.Bonded, validator2.Status)
// create a second delegation to validator 1 // create a second delegation to validator 1
delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares = validator.AddTokensFromDel(delTokens) validator, issuedShares = validator.AddTokensFromDel(delTokens)
require.Equal(t, delTokens, issuedShares.RoundInt()) require.Equal(t, delTokens, issuedShares.RoundInt())
validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@ -867,7 +867,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
addrVals := simapp.ConvertAddrsToValAddrs(addrDels) addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
startTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction) startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens)) startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
// add bonded tokens to pool for delegations // add bonded tokens to pool for delegations
@ -881,7 +881,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
validator := teststaking.NewValidator(t, addrVals[0], PKs[0]) validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
app.StakingKeeper.SetValidatorByConsAddr(ctx, validator) app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens) validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt()) require.Equal(t, valTokens, issuedShares.RoundInt())
validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@ -891,7 +891,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
// create a second delegation to this validator // create a second delegation to this validator
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator)
delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares = validator.AddTokensFromDel(delTokens) validator, issuedShares = validator.AddTokensFromDel(delTokens)
require.Equal(t, delTokens, issuedShares.RoundInt()) require.Equal(t, delTokens, issuedShares.RoundInt())
validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@ -933,7 +933,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
ctx = ctx.WithBlockHeader(header) ctx = ctx.WithBlockHeader(header)
// unbond some of the other delegation's shares // unbond some of the other delegation's shares
redelegateTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction) redelegateTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
_, err = app.StakingKeeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], redelegateTokens.ToDec()) _, err = app.StakingKeeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], redelegateTokens.ToDec())
require.NoError(t, err) require.NoError(t, err)
@ -951,7 +951,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
addrVals := simapp.ConvertAddrsToValAddrs(addrDels) addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
startTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction) startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens)) startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
// add bonded tokens to pool for delegations // add bonded tokens to pool for delegations
@ -965,7 +965,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
validator := teststaking.NewValidator(t, addrVals[0], PKs[0]) validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
app.StakingKeeper.SetValidatorByConsAddr(ctx, validator) app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens) validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt()) require.Equal(t, valTokens, issuedShares.RoundInt())
validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@ -975,7 +975,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
// create a second delegation to this validator // create a second delegation to this validator
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator)
delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares = validator.AddTokensFromDel(delTokens) validator, issuedShares = validator.AddTokensFromDel(delTokens)
require.Equal(t, delTokens, issuedShares.RoundInt()) require.Equal(t, delTokens, issuedShares.RoundInt())
validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@ -1009,7 +1009,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
app.StakingKeeper.UnbondingToUnbonded(ctx, validator) app.StakingKeeper.UnbondingToUnbonded(ctx, validator)
// redelegate some of the delegation's shares // redelegate some of the delegation's shares
redelegationTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction) redelegationTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
_, err = app.StakingKeeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], redelegationTokens.ToDec()) _, err = app.StakingKeeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], redelegationTokens.ToDec())
require.NoError(t, err) require.NoError(t, err)

18
x/staking/keeper/grpc_query_test.go
View File

@ -395,7 +395,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryUnbondingDelegation() {
addrAcc2 := addrs[1] addrAcc2 := addrs[1]
addrVal2 := vals[1].OperatorAddress addrVal2 := vals[1].OperatorAddress
unbondingTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) unbondingTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
valAddr, err1 := sdk.ValAddressFromBech32(addrVal2) valAddr, err1 := sdk.ValAddressFromBech32(addrVal2)
suite.NoError(err1) suite.NoError(err1)
_, err := app.StakingKeeper.Undelegate(ctx, addrAcc2, valAddr, unbondingTokens.ToDec()) _, err := app.StakingKeeper.Undelegate(ctx, addrAcc2, valAddr, unbondingTokens.ToDec())
@ -450,7 +450,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryDelegatorUnbondingDelegations() {
addrAcc, addrAcc1 := addrs[0], addrs[1] addrAcc, addrAcc1 := addrs[0], addrs[1]
addrVal, addrVal2 := vals[0].OperatorAddress, vals[1].OperatorAddress addrVal, addrVal2 := vals[0].OperatorAddress, vals[1].OperatorAddress
unbondingTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) unbondingTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
valAddr1, err1 := sdk.ValAddressFromBech32(addrVal) valAddr1, err1 := sdk.ValAddressFromBech32(addrVal)
suite.NoError(err1) suite.NoError(err1)
_, err := app.StakingKeeper.Undelegate(ctx, addrAcc, valAddr1, unbondingTokens.ToDec()) _, err := app.StakingKeeper.Undelegate(ctx, addrAcc, valAddr1, unbondingTokens.ToDec())
@ -592,12 +592,12 @@ func (suite *KeeperTestSuite) TestGRPCQueryRedelegation() {
addrAcc, addrAcc1 := addrs[0], addrs[1] addrAcc, addrAcc1 := addrs[0], addrs[1]
valAddrs := simapp.ConvertAddrsToValAddrs(addrs) valAddrs := simapp.ConvertAddrsToValAddrs(addrs)
val1, val2, val3, val4 := vals[0], vals[1], valAddrs[3], valAddrs[4] val1, val2, val3, val4 := vals[0], vals[1], valAddrs[3], valAddrs[4]
delAmount := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction) delAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 1)
_, err := app.StakingKeeper.Delegate(ctx, addrAcc1, delAmount, types.Unbonded, val1, true) _, err := app.StakingKeeper.Delegate(ctx, addrAcc1, delAmount, types.Unbonded, val1, true)
suite.NoError(err) suite.NoError(err)
applyValidatorSetUpdates(suite.T(), ctx, app.StakingKeeper, -1) applyValidatorSetUpdates(suite.T(), ctx, app.StakingKeeper, -1)
rdAmount := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction) rdAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 1)
_, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc1, val1.GetOperator(), val2.GetOperator(), rdAmount.ToDec()) _, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc1, val1.GetOperator(), val2.GetOperator(), rdAmount.ToDec())
suite.NoError(err) suite.NoError(err)
applyValidatorSetUpdates(suite.T(), ctx, app.StakingKeeper, -1) applyValidatorSetUpdates(suite.T(), ctx, app.StakingKeeper, -1)
@ -684,7 +684,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryValidatorUnbondingDelegations() {
val1 := vals[0] val1 := vals[0]
// undelegate // undelegate
undelAmount := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) undelAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
_, err := app.StakingKeeper.Undelegate(ctx, addrAcc1, val1.GetOperator(), undelAmount.ToDec()) _, err := app.StakingKeeper.Undelegate(ctx, addrAcc1, val1.GetOperator(), undelAmount.ToDec())
suite.NoError(err) suite.NoError(err)
applyValidatorSetUpdates(suite.T(), ctx, app.StakingKeeper, -1) applyValidatorSetUpdates(suite.T(), ctx, app.StakingKeeper, -1)
@ -729,7 +729,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryValidatorUnbondingDelegations() {
} }
func createValidators(t *testing.T, ctx sdk.Context, app *simapp.SimApp, powers []int64) ([]sdk.AccAddress, []sdk.ValAddress, []types.Validator) { func createValidators(t *testing.T, ctx sdk.Context, app *simapp.SimApp, powers []int64) ([]sdk.AccAddress, []sdk.ValAddress, []types.Validator) {
addrs := simapp.AddTestAddrsIncremental(app, ctx, 5, sdk.TokensFromConsensusPower(300, sdk.DefaultPowerReduction)) addrs := simapp.AddTestAddrsIncremental(app, ctx, 5, app.StakingKeeper.TokensFromConsensusPower(ctx, 300))
valAddrs := simapp.ConvertAddrsToValAddrs(addrs) valAddrs := simapp.ConvertAddrsToValAddrs(addrs)
pks := simapp.CreateTestPubKeys(5) pks := simapp.CreateTestPubKeys(5)
cdc := simapp.MakeTestEncodingConfig().Marshaler cdc := simapp.MakeTestEncodingConfig().Marshaler
@ -752,11 +752,11 @@ func createValidators(t *testing.T, ctx sdk.Context, app *simapp.SimApp, powers
app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val1) app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val1)
app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val2) app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val2)
_, err := app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0], sdk.DefaultPowerReduction), types.Unbonded, val1, true) _, err := app.StakingKeeper.Delegate(ctx, addrs[0], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[0]), types.Unbonded, val1, true)
require.NoError(t, err) require.NoError(t, err)
_, err = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1], sdk.DefaultPowerReduction), types.Unbonded, val2, true) _, err = app.StakingKeeper.Delegate(ctx, addrs[1], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[1]), types.Unbonded, val2, true)
require.NoError(t, err) require.NoError(t, err)
_, err = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[2], sdk.DefaultPowerReduction), types.Unbonded, val2, true) _, err = app.StakingKeeper.Delegate(ctx, addrs[0], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[2]), types.Unbonded, val2, true)
require.NoError(t, err) require.NoError(t, err)
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)

6
x/staking/keeper/historical_info_test.go
View File

@ -25,7 +25,7 @@ func TestHistoricalInfo(t *testing.T) {
validators[i] = teststaking.NewValidator(t, valAddr, PKs[i]) validators[i] = teststaking.NewValidator(t, valAddr, PKs[i])
} }
hi := types.NewHistoricalInfo(ctx.BlockHeader(), validators, sdk.DefaultPowerReduction) hi := types.NewHistoricalInfo(ctx.BlockHeader(), validators, app.StakingKeeper.PowerReduction(ctx))
app.StakingKeeper.SetHistoricalInfo(ctx, 2, &hi) app.StakingKeeper.SetHistoricalInfo(ctx, 2, &hi)
recv, found := app.StakingKeeper.GetHistoricalInfo(ctx, 2) recv, found := app.StakingKeeper.GetHistoricalInfo(ctx, 2)
@ -65,8 +65,8 @@ func TestTrackHistoricalInfo(t *testing.T) {
teststaking.NewValidator(t, addrVals[0], PKs[0]), teststaking.NewValidator(t, addrVals[0], PKs[0]),
teststaking.NewValidator(t, addrVals[1], PKs[1]), teststaking.NewValidator(t, addrVals[1], PKs[1]),
} }
hi4 := types.NewHistoricalInfo(h4, valSet, sdk.DefaultPowerReduction) hi4 := types.NewHistoricalInfo(h4, valSet, app.StakingKeeper.PowerReduction(ctx))
hi5 := types.NewHistoricalInfo(h5, valSet, sdk.DefaultPowerReduction) hi5 := types.NewHistoricalInfo(h5, valSet, app.StakingKeeper.PowerReduction(ctx))
app.StakingKeeper.SetHistoricalInfo(ctx, 4, &hi4) app.StakingKeeper.SetHistoricalInfo(ctx, 4, &hi4)
app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi5) app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi5)
recv, found := app.StakingKeeper.GetHistoricalInfo(ctx, 4) recv, found := app.StakingKeeper.GetHistoricalInfo(ctx, 4)

2
x/staking/keeper/keeper_test.go
View File

@ -45,7 +45,7 @@ func (suite *KeeperTestSuite) SetupTest() {
// have its order changed // have its order changed
sortedVals := make([]types.Validator, len(validators)) sortedVals := make([]types.Validator, len(validators))
copy(sortedVals, validators) copy(sortedVals, validators)
hi := types.NewHistoricalInfo(header, sortedVals, sdk.DefaultPowerReduction) hi := types.NewHistoricalInfo(header, sortedVals, app.StakingKeeper.PowerReduction(ctx))
app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi) app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi)
suite.app, suite.ctx, suite.queryClient, suite.addrs, suite.vals = app, ctx, queryClient, addrs, validators suite.app, suite.ctx, suite.queryClient, suite.addrs, suite.vals = app, ctx, queryClient, addrs, validators

19
x/staking/keeper/power_reduction_test.go
View File

@ -1,21 +1,28 @@
package keeper_test package keeper_test
import ( import (
"testing" "math/big"
sdk "github.com/cosmos/cosmos-sdk/types" sdk "github.com/cosmos/cosmos-sdk/types"
) )
func (suite *KeeperTestSuite) TestPowerReductionChange(t *testing.T) { func (suite *KeeperTestSuite) TestPowerReductionChange() {
// TODO: Implement! // modify power reduction
newPowerReduction := sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(12), nil))
params := suite.app.StakingKeeper.GetParams(suite.ctx)
params.PowerReduction = newPowerReduction
suite.app.StakingKeeper.SetParams(suite.ctx, params)
// check power reduction change
suite.Require().Equal(newPowerReduction, suite.app.StakingKeeper.PowerReduction(suite.ctx))
} }
func (suite *KeeperTestSuite) TestTokensToConsensusPower() { func (suite *KeeperTestSuite) TestTokensToConsensusPower() {
suite.Require().Equal(int64(0), suite.app.StakingKeeper.TokensToConsensusPower(suite.ctx, sdk.NewInt(999_999))) suite.Require().Equal(int64(0), suite.app.StakingKeeper.TokensToConsensusPower(suite.ctx, sdk.DefaultPowerReduction.Sub(sdk.NewInt(1))))
suite.Require().Equal(int64(1), suite.app.StakingKeeper.TokensToConsensusPower(suite.ctx, sdk.NewInt(1_000_000))) suite.Require().Equal(int64(1), suite.app.StakingKeeper.TokensToConsensusPower(suite.ctx, sdk.DefaultPowerReduction))
} }
func (suite *KeeperTestSuite) TestTokensFromConsensusPower() { func (suite *KeeperTestSuite) TestTokensFromConsensusPower() {
suite.Require().Equal(sdk.NewInt(0), suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 0)) suite.Require().Equal(sdk.NewInt(0), suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 0))
suite.Require().Equal(sdk.NewInt(1_000_000), suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 1)) suite.Require().Equal(sdk.DefaultPowerReduction, suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 1))
} }

34
x/staking/keeper/querier_test.go
View File

@ -37,7 +37,7 @@ func TestNewQuerier(t *testing.T) {
ChainID: "HelloChain", ChainID: "HelloChain",
Height: 5, Height: 5,
} }
hi := types.NewHistoricalInfo(header, validators[:], sdk.DefaultPowerReduction) hi := types.NewHistoricalInfo(header, validators[:], app.StakingKeeper.PowerReduction(ctx))
app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi) app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi)
query := abci.RequestQuery{ query := abci.RequestQuery{
@ -140,7 +140,7 @@ func TestQueryValidators(t *testing.T) {
legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino()) legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino())
querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino) querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
addrs := simapp.AddTestAddrs(app, ctx, 500, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)) addrs := simapp.AddTestAddrs(app, ctx, 500, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
// Create Validators // Create Validators
amts := []sdk.Int{sdk.NewInt(9), sdk.NewInt(8), sdk.NewInt(7)} amts := []sdk.Int{sdk.NewInt(9), sdk.NewInt(8), sdk.NewInt(7)}
@ -208,7 +208,7 @@ func TestQueryDelegation(t *testing.T) {
legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino()) legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino())
querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino) querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)) addrs := simapp.AddTestAddrs(app, ctx, 2, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
addrAcc1, addrAcc2 := addrs[0], addrs[1] addrAcc1, addrAcc2 := addrs[0], addrs[1]
addrVal1, addrVal2 := sdk.ValAddress(addrAcc1), sdk.ValAddress(addrAcc2) addrVal1, addrVal2 := sdk.ValAddress(addrAcc1), sdk.ValAddress(addrAcc2)
@ -224,7 +224,7 @@ func TestQueryDelegation(t *testing.T) {
app.StakingKeeper.SetValidator(ctx, val2) app.StakingKeeper.SetValidator(ctx, val2)
app.StakingKeeper.SetValidatorByPowerIndex(ctx, val2) app.StakingKeeper.SetValidatorByPowerIndex(ctx, val2)
delTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
_, err := app.StakingKeeper.Delegate(ctx, addrAcc2, delTokens, types.Unbonded, val1, true) _, err := app.StakingKeeper.Delegate(ctx, addrAcc2, delTokens, types.Unbonded, val1, true)
require.NoError(t, err) require.NoError(t, err)
@ -348,7 +348,7 @@ func TestQueryDelegation(t *testing.T) {
require.Equal(t, sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), delegationsRes[0].Balance) require.Equal(t, sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), delegationsRes[0].Balance)
// Query unbonding delegation // Query unbonding delegation
unbondingTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) unbondingTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
_, err = app.StakingKeeper.Undelegate(ctx, addrAcc2, val1.GetOperator(), unbondingTokens.ToDec()) _, err = app.StakingKeeper.Undelegate(ctx, addrAcc2, val1.GetOperator(), unbondingTokens.ToDec())
require.NoError(t, err) require.NoError(t, err)
@ -401,7 +401,7 @@ func TestQueryDelegation(t *testing.T) {
require.Error(t, err) require.Error(t, err)
// Query redelegation // Query redelegation
redelegationTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) redelegationTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
_, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(), _, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(),
val2.GetOperator(), redelegationTokens.ToDec()) val2.GetOperator(), redelegationTokens.ToDec())
require.NoError(t, err) require.NoError(t, err)
@ -456,7 +456,7 @@ func TestQueryValidatorDelegations_Pagination(t *testing.T) {
legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino()) legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino())
querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino) querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
addrs := simapp.AddTestAddrs(app, ctx, 100, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)) addrs := simapp.AddTestAddrs(app, ctx, 100, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
pubKeys := simapp.CreateTestPubKeys(1) pubKeys := simapp.CreateTestPubKeys(1)
valAddress := sdk.ValAddress(addrs[0]) valAddress := sdk.ValAddress(addrs[0])
@ -472,7 +472,7 @@ func TestQueryValidatorDelegations_Pagination(t *testing.T) {
t.Error("expected validator not found") t.Error("expected validator not found")
} }
delTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
_, err := app.StakingKeeper.Delegate(ctx, addr, delTokens, types.Unbonded, validator, true) _, err := app.StakingKeeper.Delegate(ctx, addr, delTokens, types.Unbonded, validator, true)
require.NoError(t, err) require.NoError(t, err)
} }
@ -506,7 +506,7 @@ func TestQueryValidatorDelegations_Pagination(t *testing.T) {
// Undelegate // Undelegate
for _, addr := range addrs { for _, addr := range addrs {
delTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
_, err := app.StakingKeeper.Undelegate(ctx, addr, val1.GetOperator(), delTokens.ToDec()) _, err := app.StakingKeeper.Undelegate(ctx, addr, val1.GetOperator(), delTokens.ToDec())
require.NoError(t, err) require.NoError(t, err)
} }
@ -541,7 +541,7 @@ func TestQueryRedelegations(t *testing.T) {
legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino()) legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino())
querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino) querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)) addrs := simapp.AddTestAddrs(app, ctx, 2, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
addrAcc1, addrAcc2 := addrs[0], addrs[1] addrAcc1, addrAcc2 := addrs[0], addrs[1]
addrVal1, addrVal2 := sdk.ValAddress(addrAcc1), sdk.ValAddress(addrAcc2) addrVal1, addrVal2 := sdk.ValAddress(addrAcc1), sdk.ValAddress(addrAcc2)
@ -551,12 +551,12 @@ func TestQueryRedelegations(t *testing.T) {
app.StakingKeeper.SetValidator(ctx, val1) app.StakingKeeper.SetValidator(ctx, val1)
app.StakingKeeper.SetValidator(ctx, val2) app.StakingKeeper.SetValidator(ctx, val2)
delAmount := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) delAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
_, err := app.StakingKeeper.Delegate(ctx, addrAcc2, delAmount, types.Unbonded, val1, true) _, err := app.StakingKeeper.Delegate(ctx, addrAcc2, delAmount, types.Unbonded, val1, true)
require.NoError(t, err) require.NoError(t, err)
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
rdAmount := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction) rdAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
_, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(), val2.GetOperator(), rdAmount.ToDec()) _, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(), val2.GetOperator(), rdAmount.ToDec())
require.NoError(t, err) require.NoError(t, err)
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
@ -613,7 +613,7 @@ func TestQueryUnbondingDelegation(t *testing.T) {
legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino()) legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino())
querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino) querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)) addrs := simapp.AddTestAddrs(app, ctx, 2, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
addrAcc1, addrAcc2 := addrs[0], addrs[1] addrAcc1, addrAcc2 := addrs[0], addrs[1]
addrVal1 := sdk.ValAddress(addrAcc1) addrVal1 := sdk.ValAddress(addrAcc1)
@ -622,13 +622,13 @@ func TestQueryUnbondingDelegation(t *testing.T) {
app.StakingKeeper.SetValidator(ctx, val1) app.StakingKeeper.SetValidator(ctx, val1)
// delegate // delegate
delAmount := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) delAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
_, err := app.StakingKeeper.Delegate(ctx, addrAcc1, delAmount, types.Unbonded, val1, true) _, err := app.StakingKeeper.Delegate(ctx, addrAcc1, delAmount, types.Unbonded, val1, true)
require.NoError(t, err) require.NoError(t, err)
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
// undelegate // undelegate
undelAmount := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction) undelAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
_, err = app.StakingKeeper.Undelegate(ctx, addrAcc1, val1.GetOperator(), undelAmount.ToDec()) _, err = app.StakingKeeper.Undelegate(ctx, addrAcc1, val1.GetOperator(), undelAmount.ToDec())
require.NoError(t, err) require.NoError(t, err)
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
@ -709,7 +709,7 @@ func TestQueryHistoricalInfo(t *testing.T) {
legacyQuerierCdc := codec.NewAminoCodec(cdc) legacyQuerierCdc := codec.NewAminoCodec(cdc)
querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino) querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)) addrs := simapp.AddTestAddrs(app, ctx, 2, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
addrAcc1, addrAcc2 := addrs[0], addrs[1] addrAcc1, addrAcc2 := addrs[0], addrs[1]
addrVal1, addrVal2 := sdk.ValAddress(addrAcc1), sdk.ValAddress(addrAcc2) addrVal1, addrVal2 := sdk.ValAddress(addrAcc1), sdk.ValAddress(addrAcc2)
@ -724,7 +724,7 @@ func TestQueryHistoricalInfo(t *testing.T) {
ChainID: "HelloChain", ChainID: "HelloChain",
Height: 5, Height: 5,
} }
hi := types.NewHistoricalInfo(header, vals, sdk.DefaultPowerReduction) hi := types.NewHistoricalInfo(header, vals, app.StakingKeeper.PowerReduction(ctx))
app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi) app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi)
queryHistoricalParams := types.QueryHistoricalInfoRequest{Height: 4} queryHistoricalParams := types.QueryHistoricalInfoRequest{Height: 4}

2
x/staking/keeper/slash.go
View File

@ -29,7 +29,7 @@ func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeigh
} }
// Amount of slashing = slash slashFactor * power at time of infraction // Amount of slashing = slash slashFactor * power at time of infraction
amount := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) amount := k.TokensFromConsensusPower(ctx, power)
slashAmountDec := amount.ToDec().Mul(slashFactor) slashAmountDec := amount.ToDec().Mul(slashFactor)
slashAmount := slashAmountDec.TruncateInt() slashAmount := slashAmountDec.TruncateInt()

48
x/staking/keeper/slash_test.go
View File

@ -22,7 +22,7 @@ func bootstrapSlashTest(t *testing.T, power int64) (*simapp.SimApp, sdk.Context,
addrDels, addrVals := generateAddresses(app, ctx, 100) addrDels, addrVals := generateAddresses(app, ctx, 100)
amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) amt := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels))))) totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@ -219,12 +219,12 @@ func TestSlashAtNegativeHeight(t *testing.T) {
validator, found = app.StakingKeeper.GetValidator(ctx, validator.GetOperator()) validator, found = app.StakingKeeper.GetValidator(ctx, validator.GetOperator())
require.True(t, found) require.True(t, found)
// power decreased // power decreased
require.Equal(t, int64(5), validator.GetConsensusPower(sdk.DefaultPowerReduction)) require.Equal(t, int64(5), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
// pool bonded shares decreased // pool bonded shares decreased
newBondedPoolBalances := app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress()) newBondedPoolBalances := app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
diffTokens := oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx)) diffTokens := oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
require.Equal(t, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction).String(), diffTokens.String()) require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 5).String(), diffTokens.String())
} }
// tests Slash at the current height // tests Slash at the current height
@ -250,12 +250,12 @@ func TestSlashValidatorAtCurrentHeight(t *testing.T) {
validator, found = app.StakingKeeper.GetValidator(ctx, validator.GetOperator()) validator, found = app.StakingKeeper.GetValidator(ctx, validator.GetOperator())
assert.True(t, found) assert.True(t, found)
// power decreased // power decreased
require.Equal(t, int64(5), validator.GetConsensusPower(sdk.DefaultPowerReduction)) require.Equal(t, int64(5), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
// pool bonded shares decreased // pool bonded shares decreased
newBondedPoolBalances := app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress()) newBondedPoolBalances := app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
diffTokens := oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx)) diffTokens := oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
require.Equal(t, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction).String(), diffTokens.String()) require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 5).String(), diffTokens.String())
} }
// tests Slash at a previous height with an unbonding delegation // tests Slash at a previous height with an unbonding delegation
@ -267,7 +267,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
// set an unbonding delegation with expiration timestamp beyond which the // set an unbonding delegation with expiration timestamp beyond which the
// unbonding delegation shouldn't be slashed // unbonding delegation shouldn't be slashed
ubdTokens := sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction) ubdTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 4)
ubd := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11, ubd := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11,
time.Unix(0, 0), ubdTokens) time.Unix(0, 0), ubdTokens)
app.StakingKeeper.SetUnbondingDelegation(ctx, ubd) app.StakingKeeper.SetUnbondingDelegation(ctx, ubd)
@ -290,12 +290,12 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
require.Len(t, ubd.Entries, 1) require.Len(t, ubd.Entries, 1)
// balance decreased // balance decreased
require.Equal(t, sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction), ubd.Entries[0].Balance) require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 2), ubd.Entries[0].Balance)
// bonded tokens burned // bonded tokens burned
newBondedPoolBalances := app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress()) newBondedPoolBalances := app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
diffTokens := oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx)) diffTokens := oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
require.Equal(t, sdk.TokensFromConsensusPower(3, sdk.DefaultPowerReduction), diffTokens) require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 3), diffTokens)
// read updated validator // read updated validator
validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr) validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
@ -305,7 +305,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
// was still bonded at the time of discovery and was slashed by half, 4 stake // was still bonded at the time of discovery and was slashed by half, 4 stake
// bonded at the time of discovery hadn't been bonded at the time of infraction // bonded at the time of discovery hadn't been bonded at the time of infraction
// and wasn't slashed // and wasn't slashed
require.Equal(t, int64(7), validator.GetConsensusPower(sdk.DefaultPowerReduction)) require.Equal(t, int64(7), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
// slash validator again // slash validator again
ctx = ctx.WithBlockHeight(13) ctx = ctx.WithBlockHeight(13)
@ -321,14 +321,14 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
// bonded tokens burned again // bonded tokens burned again
newBondedPoolBalances = app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress()) newBondedPoolBalances = app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
diffTokens = oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx)) diffTokens = oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
require.Equal(t, sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction), diffTokens) require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 6), diffTokens)
// read updated validator // read updated validator
validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr) validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
require.True(t, found) require.True(t, found)
// power decreased by 3 again // power decreased by 3 again
require.Equal(t, int64(4), validator.GetConsensusPower(sdk.DefaultPowerReduction)) require.Equal(t, int64(4), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
// slash validator again // slash validator again
// all originally bonded stake has been slashed, so this will have no effect // all originally bonded stake has been slashed, so this will have no effect
@ -347,14 +347,14 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
// bonded tokens burned again // bonded tokens burned again
newBondedPoolBalances = app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress()) newBondedPoolBalances = app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
diffTokens = oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx)) diffTokens = oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
require.Equal(t, sdk.TokensFromConsensusPower(9, sdk.DefaultPowerReduction), diffTokens) require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 9), diffTokens)
// read updated validator // read updated validator
validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr) validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
require.True(t, found) require.True(t, found)
// power decreased by 3 again // power decreased by 3 again
require.Equal(t, int64(1), validator.GetConsensusPower(sdk.DefaultPowerReduction)) require.Equal(t, int64(1), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
// slash validator again // slash validator again
// all originally bonded stake has been slashed, so this will have no effect // all originally bonded stake has been slashed, so this will have no effect
@ -373,7 +373,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
// just 1 bonded token burned again since that's all the validator now has // just 1 bonded token burned again since that's all the validator now has
newBondedPoolBalances = app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress()) newBondedPoolBalances = app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
diffTokens = oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx)) diffTokens = oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
require.Equal(t, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction), diffTokens) require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 10), diffTokens)
// apply TM updates // apply TM updates
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
@ -394,7 +394,7 @@ func TestSlashWithRedelegation(t *testing.T) {
bondDenom := app.StakingKeeper.BondDenom(ctx) bondDenom := app.StakingKeeper.BondDenom(ctx)
// set a redelegation // set a redelegation
rdTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction) rdTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11, rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11,
time.Unix(0, 0), rdTokens, rdTokens.ToDec()) time.Unix(0, 0), rdTokens, rdTokens.ToDec())
app.StakingKeeper.SetRedelegation(ctx, rd) app.StakingKeeper.SetRedelegation(ctx, rd)
@ -424,7 +424,7 @@ func TestSlashWithRedelegation(t *testing.T) {
require.True(t, found) require.True(t, found)
require.NotPanics(t, func() { app.StakingKeeper.Slash(ctx, consAddr, 10, 10, fraction) }) require.NotPanics(t, func() { app.StakingKeeper.Slash(ctx, consAddr, 10, 10, fraction) })
burnAmount := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec().Mul(fraction).TruncateInt() burnAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 10).ToDec().Mul(fraction).TruncateInt()
bondedPool = app.StakingKeeper.GetBondedPool(ctx) bondedPool = app.StakingKeeper.GetBondedPool(ctx)
notBondedPool = app.StakingKeeper.GetNotBondedPool(ctx) notBondedPool = app.StakingKeeper.GetNotBondedPool(ctx)
@ -448,14 +448,14 @@ func TestSlashWithRedelegation(t *testing.T) {
// was still bonded at the time of discovery and was slashed by half, 4 stake // was still bonded at the time of discovery and was slashed by half, 4 stake
// bonded at the time of discovery hadn't been bonded at the time of infraction // bonded at the time of discovery hadn't been bonded at the time of infraction
// and wasn't slashed // and wasn't slashed
require.Equal(t, int64(8), validator.GetConsensusPower(sdk.DefaultPowerReduction)) require.Equal(t, int64(8), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
// slash the validator again // slash the validator again
validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr) validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
require.True(t, found) require.True(t, found)
require.NotPanics(t, func() { app.StakingKeeper.Slash(ctx, consAddr, 10, 10, sdk.OneDec()) }) require.NotPanics(t, func() { app.StakingKeeper.Slash(ctx, consAddr, 10, 10, sdk.OneDec()) })
burnAmount = sdk.TokensFromConsensusPower(7, sdk.DefaultPowerReduction) burnAmount = app.StakingKeeper.TokensFromConsensusPower(ctx, 7)
// read updated pool // read updated pool
bondedPool = app.StakingKeeper.GetBondedPool(ctx) bondedPool = app.StakingKeeper.GetBondedPool(ctx)
@ -481,7 +481,7 @@ func TestSlashWithRedelegation(t *testing.T) {
validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr) validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
require.True(t, found) require.True(t, found)
// power decreased by 4 // power decreased by 4
require.Equal(t, int64(4), validator.GetConsensusPower(sdk.DefaultPowerReduction)) require.Equal(t, int64(4), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
// slash the validator again, by 100% // slash the validator again, by 100%
ctx = ctx.WithBlockHeight(12) ctx = ctx.WithBlockHeight(12)
@ -490,7 +490,7 @@ func TestSlashWithRedelegation(t *testing.T) {
require.NotPanics(t, func() { app.StakingKeeper.Slash(ctx, consAddr, 10, 10, sdk.OneDec()) }) require.NotPanics(t, func() { app.StakingKeeper.Slash(ctx, consAddr, 10, 10, sdk.OneDec()) })
burnAmount = sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec().Mul(sdk.OneDec()).TruncateInt() burnAmount = app.StakingKeeper.TokensFromConsensusPower(ctx, 10).ToDec().Mul(sdk.OneDec()).TruncateInt()
burnAmount = burnAmount.Sub(sdk.OneDec().MulInt(rdTokens).TruncateInt()) burnAmount = burnAmount.Sub(sdk.OneDec().MulInt(rdTokens).TruncateInt())
// read updated pool // read updated pool
@ -550,7 +550,7 @@ func TestSlashBoth(t *testing.T) {
// set a redelegation with expiration timestamp beyond which the // set a redelegation with expiration timestamp beyond which the
// redelegation shouldn't be slashed // redelegation shouldn't be slashed
rdATokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction) rdATokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
rdA := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11, rdA := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11,
time.Unix(0, 0), rdATokens, time.Unix(0, 0), rdATokens,
rdATokens.ToDec()) rdATokens.ToDec())
@ -562,7 +562,7 @@ func TestSlashBoth(t *testing.T) {
// set an unbonding delegation with expiration timestamp (beyond which the // set an unbonding delegation with expiration timestamp (beyond which the
// unbonding delegation shouldn't be slashed) // unbonding delegation shouldn't be slashed)
ubdATokens := sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction) ubdATokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 4)
ubdA := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11, ubdA := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11,
time.Unix(0, 0), ubdATokens) time.Unix(0, 0), ubdATokens)
app.StakingKeeper.SetUnbondingDelegation(ctx, ubdA) app.StakingKeeper.SetUnbondingDelegation(ctx, ubdA)
@ -593,7 +593,7 @@ func TestSlashBoth(t *testing.T) {
app.StakingKeeper.Slash(ctx, consAddr0, 10, 10, fraction) app.StakingKeeper.Slash(ctx, consAddr0, 10, 10, fraction)
burnedNotBondedAmount := fraction.MulInt(ubdATokens).TruncateInt() burnedNotBondedAmount := fraction.MulInt(ubdATokens).TruncateInt()
burnedBondAmount := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec().Mul(fraction).TruncateInt() burnedBondAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 10).ToDec().Mul(fraction).TruncateInt()
burnedBondAmount = burnedBondAmount.Sub(burnedNotBondedAmount) burnedBondAmount = burnedBondAmount.Sub(burnedNotBondedAmount)
// read updated pool // read updated pool
@ -614,5 +614,5 @@ func TestSlashBoth(t *testing.T) {
validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(PKs[0])) validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(PKs[0]))
require.True(t, found) require.True(t, found)
// power not decreased, all stake was bonded since // power not decreased, all stake was bonded since
require.Equal(t, int64(10), validator.GetConsensusPower(sdk.DefaultPowerReduction)) require.Equal(t, int64(10), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
} }

188
x/staking/keeper/validator_test.go
View File

@ -30,7 +30,7 @@ func bootstrapValidatorTest(t *testing.T, power int64, numAddrs int) (*simapp.Si
addrDels, addrVals := generateAddresses(app, ctx, numAddrs) addrDels, addrVals := generateAddresses(app, ctx, numAddrs)
amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) amt := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels))))) totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@ -49,7 +49,7 @@ func initValidators(t *testing.T, power int64, numAddrs int, powers []int64) (*s
vs := make([]types.Validator, len(powers)) vs := make([]types.Validator, len(powers))
for i, power := range powers { for i, power := range powers {
vs[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i]) vs[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
vs[i], _ = vs[i].AddTokensFromDel(tokens) vs[i], _ = vs[i].AddTokensFromDel(tokens)
} }
return app, ctx, addrs, valAddrs, vs return app, ctx, addrs, valAddrs, vs
@ -60,7 +60,7 @@ func TestSetValidator(t *testing.T) {
valPubKey := PKs[0] valPubKey := PKs[0]
valAddr := sdk.ValAddress(valPubKey.Address().Bytes()) valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
// test how the validator is set from a purely unbonbed pool // test how the validator is set from a purely unbonbed pool
validator := teststaking.NewValidator(t, valAddr, valPubKey) validator := teststaking.NewValidator(t, valAddr, valPubKey)
@ -75,7 +75,7 @@ func TestSetValidator(t *testing.T) {
updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1) updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
validator, found := app.StakingKeeper.GetValidator(ctx, valAddr) validator, found := app.StakingKeeper.GetValidator(ctx, valAddr)
require.True(t, found) require.True(t, found)
require.Equal(t, validator.ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) require.Equal(t, validator.ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
// after the save the validator should be bonded // after the save the validator should be bonded
require.Equal(t, types.Bonded, validator.Status) require.Equal(t, types.Bonded, validator.Status)
@ -114,10 +114,10 @@ func TestUpdateValidatorByPowerIndex(t *testing.T) {
bondedPool := app.StakingKeeper.GetBondedPool(ctx) bondedPool := app.StakingKeeper.GetBondedPool(ctx)
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234, sdk.DefaultPowerReduction)))) err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 1234))))
require.NoError(t, err) require.NoError(t, err)
err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)))) err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))))
require.NoError(t, err) require.NoError(t, err)
app.AccountKeeper.SetModuleAccount(ctx, bondedPool) app.AccountKeeper.SetModuleAccount(ctx, bondedPool)
@ -125,28 +125,28 @@ func TestUpdateValidatorByPowerIndex(t *testing.T) {
// add a validator // add a validator
validator := teststaking.NewValidator(t, addrVals[0], PKs[0]) validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
validator, delSharesCreated := validator.AddTokensFromDel(sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)) validator, delSharesCreated := validator.AddTokensFromDel(app.StakingKeeper.TokensFromConsensusPower(ctx, 100))
require.Equal(t, types.Unbonded, validator.Status) require.Equal(t, types.Unbonded, validator.Status)
require.Equal(t, sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction), validator.Tokens) require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 100), validator.Tokens)
keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
validator, found := app.StakingKeeper.GetValidator(ctx, addrVals[0]) validator, found := app.StakingKeeper.GetValidator(ctx, addrVals[0])
require.True(t, found) require.True(t, found)
require.Equal(t, sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction), validator.Tokens) require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 100), validator.Tokens)
power := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction) power := types.GetValidatorsByPowerIndexKey(validator, app.StakingKeeper.PowerReduction(ctx))
require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power)) require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power))
// burn half the delegator shares // burn half the delegator shares
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator)
validator, burned := validator.RemoveDelShares(delSharesCreated.Quo(sdk.NewDec(2))) validator, burned := validator.RemoveDelShares(delSharesCreated.Quo(sdk.NewDec(2)))
require.Equal(t, sdk.TokensFromConsensusPower(50, sdk.DefaultPowerReduction), burned) require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 50), burned)
keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) // update the validator, possibly kicking it out keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) // update the validator, possibly kicking it out
require.False(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power)) require.False(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power))
validator, found = app.StakingKeeper.GetValidator(ctx, addrVals[0]) validator, found = app.StakingKeeper.GetValidator(ctx, addrVals[0])
require.True(t, found) require.True(t, found)
power = types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction) power = types.GetValidatorsByPowerIndexKey(validator, app.StakingKeeper.PowerReduction(ctx))
require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power)) require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power))
} }
@ -166,10 +166,10 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
app.StakingKeeper.SetParams(ctx, params) app.StakingKeeper.SetParams(ctx, params)
// create a random pool // create a random pool
err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234, sdk.DefaultPowerReduction)))) err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 1234))))
require.NoError(t, err) require.NoError(t, err)
err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)))) err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))))
require.NoError(t, err) require.NoError(t, err)
app.AccountKeeper.SetModuleAccount(ctx, bondedPool) app.AccountKeeper.SetModuleAccount(ctx, bondedPool)
@ -179,7 +179,7 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
for i := 0; i < len(validators); i++ { for i := 0; i < len(validators); i++ {
moniker := fmt.Sprintf("val#%d", int64(i)) moniker := fmt.Sprintf("val#%d", int64(i))
val := newMonikerValidator(t, valAddrs[i], PKs[i], moniker) val := newMonikerValidator(t, valAddrs[i], PKs[i], moniker)
delTokens := sdk.TokensFromConsensusPower(int64((i+1)*10), sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, int64((i+1)*10))
val, _ = val.AddTokensFromDel(delTokens) val, _ = val.AddTokensFromDel(delTokens)
val = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, val, true) val = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, val, true)
@ -191,7 +191,7 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
// remove enough tokens to kick out the validator below the current cliff // remove enough tokens to kick out the validator below the current cliff
// validator and next in line cliff validator // validator and next in line cliff validator
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, nextCliffVal) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, nextCliffVal)
shares := sdk.TokensFromConsensusPower(21, sdk.DefaultPowerReduction) shares := app.StakingKeeper.TokensFromConsensusPower(ctx, 21)
nextCliffVal, _ = nextCliffVal.RemoveDelShares(shares.ToDec()) nextCliffVal, _ = nextCliffVal.RemoveDelShares(shares.ToDec())
nextCliffVal = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, nextCliffVal, true) nextCliffVal = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, nextCliffVal, true)
@ -220,7 +220,7 @@ func TestSlashToZeroPowerRemoved(t *testing.T) {
// add a validator // add a validator
validator := teststaking.NewValidator(t, addrVals[0], PKs[0]) validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
valTokens := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
bondedPool := app.StakingKeeper.GetBondedPool(ctx) bondedPool := app.StakingKeeper.GetBondedPool(ctx)
@ -256,13 +256,13 @@ func TestValidatorBasics(t *testing.T) {
validators[i] = teststaking.NewValidator(t, addrVals[i], PKs[i]) validators[i] = teststaking.NewValidator(t, addrVals[i], PKs[i])
validators[i].Status = types.Unbonded validators[i].Status = types.Unbonded
validators[i].Tokens = sdk.ZeroInt() validators[i].Tokens = sdk.ZeroInt()
tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens) validators[i], _ = validators[i].AddTokensFromDel(tokens)
} }
assert.Equal(t, sdk.TokensFromConsensusPower(9, sdk.DefaultPowerReduction), validators[0].Tokens) assert.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 9), validators[0].Tokens)
assert.Equal(t, sdk.TokensFromConsensusPower(8, sdk.DefaultPowerReduction), validators[1].Tokens) assert.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 8), validators[1].Tokens)
assert.Equal(t, sdk.TokensFromConsensusPower(7, sdk.DefaultPowerReduction), validators[2].Tokens) assert.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 7), validators[2].Tokens)
// check the empty keeper first // check the empty keeper first
_, found := app.StakingKeeper.GetValidator(ctx, addrVals[0]) _, found := app.StakingKeeper.GetValidator(ctx, addrVals[0])
@ -292,11 +292,11 @@ func TestValidatorBasics(t *testing.T) {
require.Equal(t, 1, len(resVals)) require.Equal(t, 1, len(resVals))
assert.True(ValEq(t, validators[0], resVals[0])) assert.True(ValEq(t, validators[0], resVals[0]))
assert.Equal(t, types.Bonded, validators[0].Status) assert.Equal(t, types.Bonded, validators[0].Status)
assert.True(sdk.IntEq(t, sdk.TokensFromConsensusPower(9, sdk.DefaultPowerReduction), validators[0].BondedTokens())) assert.True(sdk.IntEq(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 9), validators[0].BondedTokens()))
// modify a records, save, and retrieve // modify a records, save, and retrieve
validators[0].Status = types.Bonded validators[0].Status = types.Bonded
validators[0].Tokens = sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) validators[0].Tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validators[0].DelegatorShares = validators[0].Tokens.ToDec() validators[0].DelegatorShares = validators[0].Tokens.ToDec()
validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], true) validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], true)
resVal, found = app.StakingKeeper.GetValidator(ctx, addrVals[0]) resVal, found = app.StakingKeeper.GetValidator(ctx, addrVals[0])
@ -351,10 +351,10 @@ func TestGetValidatorSortingUnmixed(t *testing.T) {
// initialize some validators into the state // initialize some validators into the state
amts := []sdk.Int{ amts := []sdk.Int{
sdk.NewIntFromUint64(0), sdk.NewIntFromUint64(0),
sdk.DefaultPowerReduction.MulRaw(100), app.StakingKeeper.PowerReduction(ctx).MulRaw(100),
sdk.DefaultPowerReduction, app.StakingKeeper.PowerReduction(ctx),
sdk.DefaultPowerReduction.MulRaw(400), app.StakingKeeper.PowerReduction(ctx).MulRaw(400),
sdk.DefaultPowerReduction.MulRaw(200)} app.StakingKeeper.PowerReduction(ctx).MulRaw(200)}
n := len(amts) n := len(amts)
var validators [5]types.Validator var validators [5]types.Validator
for i, amt := range amts { for i, amt := range amts {
@ -368,10 +368,10 @@ func TestGetValidatorSortingUnmixed(t *testing.T) {
// first make sure everything made it in to the gotValidator group // first make sure everything made it in to the gotValidator group
resValidators := app.StakingKeeper.GetBondedValidatorsByPower(ctx) resValidators := app.StakingKeeper.GetBondedValidatorsByPower(ctx)
assert.Equal(t, n, len(resValidators)) assert.Equal(t, n, len(resValidators))
assert.Equal(t, sdk.NewInt(400).Mul(sdk.DefaultPowerReduction), resValidators[0].BondedTokens(), "%v", resValidators) assert.Equal(t, sdk.NewInt(400).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[0].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(200).Mul(sdk.DefaultPowerReduction), resValidators[1].BondedTokens(), "%v", resValidators) assert.Equal(t, sdk.NewInt(200).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[1].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(100).Mul(sdk.DefaultPowerReduction), resValidators[2].BondedTokens(), "%v", resValidators) assert.Equal(t, sdk.NewInt(100).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[2].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(1).Mul(sdk.DefaultPowerReduction), resValidators[3].BondedTokens(), "%v", resValidators) assert.Equal(t, sdk.NewInt(1).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[3].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(0), resValidators[4].BondedTokens(), "%v", resValidators) assert.Equal(t, sdk.NewInt(0), resValidators[4].BondedTokens(), "%v", resValidators)
assert.Equal(t, validators[3].OperatorAddress, resValidators[0].OperatorAddress, "%v", resValidators) assert.Equal(t, validators[3].OperatorAddress, resValidators[0].OperatorAddress, "%v", resValidators)
assert.Equal(t, validators[4].OperatorAddress, resValidators[1].OperatorAddress, "%v", resValidators) assert.Equal(t, validators[4].OperatorAddress, resValidators[1].OperatorAddress, "%v", resValidators)
@ -380,14 +380,14 @@ func TestGetValidatorSortingUnmixed(t *testing.T) {
assert.Equal(t, validators[0].OperatorAddress, resValidators[4].OperatorAddress, "%v", resValidators) assert.Equal(t, validators[0].OperatorAddress, resValidators[4].OperatorAddress, "%v", resValidators)
// test a basic increase in voting power // test a basic increase in voting power
validators[3].Tokens = sdk.NewInt(500).Mul(sdk.DefaultPowerReduction) validators[3].Tokens = sdk.NewInt(500).Mul(app.StakingKeeper.PowerReduction(ctx))
keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx) resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
require.Equal(t, len(resValidators), n) require.Equal(t, len(resValidators), n)
assert.True(ValEq(t, validators[3], resValidators[0])) assert.True(ValEq(t, validators[3], resValidators[0]))
// test a decrease in voting power // test a decrease in voting power
validators[3].Tokens = sdk.NewInt(300).Mul(sdk.DefaultPowerReduction) validators[3].Tokens = sdk.NewInt(300).Mul(app.StakingKeeper.PowerReduction(ctx))
keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx) resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
require.Equal(t, len(resValidators), n) require.Equal(t, len(resValidators), n)
@ -395,7 +395,7 @@ func TestGetValidatorSortingUnmixed(t *testing.T) {
assert.True(ValEq(t, validators[4], resValidators[1])) assert.True(ValEq(t, validators[4], resValidators[1]))
// test equal voting power, different age // test equal voting power, different age
validators[3].Tokens = sdk.NewInt(200).Mul(sdk.DefaultPowerReduction) validators[3].Tokens = sdk.NewInt(200).Mul(app.StakingKeeper.PowerReduction(ctx))
ctx = ctx.WithBlockHeight(10) ctx = ctx.WithBlockHeight(10)
keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx) resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
@ -412,8 +412,8 @@ func TestGetValidatorSortingUnmixed(t *testing.T) {
assert.True(ValEq(t, validators[4], resValidators[1])) assert.True(ValEq(t, validators[4], resValidators[1]))
// change in voting power of both validators, both still in v-set, no age change // change in voting power of both validators, both still in v-set, no age change
validators[3].Tokens = sdk.NewInt(300).Mul(sdk.DefaultPowerReduction) validators[3].Tokens = sdk.NewInt(300).Mul(app.StakingKeeper.PowerReduction(ctx))
validators[4].Tokens = sdk.NewInt(300).Mul(sdk.DefaultPowerReduction) validators[4].Tokens = sdk.NewInt(300).Mul(app.StakingKeeper.PowerReduction(ctx))
keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx) resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
require.Equal(t, len(resValidators), n) require.Equal(t, len(resValidators), n)
@ -430,10 +430,10 @@ func TestGetValidatorSortingMixed(t *testing.T) {
bondedPool := app.StakingKeeper.GetBondedPool(ctx) bondedPool := app.StakingKeeper.GetBondedPool(ctx)
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(501, sdk.DefaultPowerReduction)))) err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 501))))
require.NoError(t, err) require.NoError(t, err)
err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(0, sdk.DefaultPowerReduction)))) err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 0))))
require.NoError(t, err) require.NoError(t, err)
app.AccountKeeper.SetModuleAccount(ctx, notBondedPool) app.AccountKeeper.SetModuleAccount(ctx, notBondedPool)
@ -447,10 +447,10 @@ func TestGetValidatorSortingMixed(t *testing.T) {
// initialize some validators into the state // initialize some validators into the state
amts := []sdk.Int{ amts := []sdk.Int{
sdk.NewIntFromUint64(0), sdk.NewIntFromUint64(0),
sdk.DefaultPowerReduction.MulRaw(100), app.StakingKeeper.PowerReduction(ctx).MulRaw(100),
sdk.DefaultPowerReduction, app.StakingKeeper.PowerReduction(ctx),
sdk.DefaultPowerReduction.MulRaw(400), app.StakingKeeper.PowerReduction(ctx).MulRaw(400),
sdk.DefaultPowerReduction.MulRaw(200)} app.StakingKeeper.PowerReduction(ctx).MulRaw(200)}
var validators [5]types.Validator var validators [5]types.Validator
for i, amt := range amts { for i, amt := range amts {
@ -481,8 +481,8 @@ func TestGetValidatorSortingMixed(t *testing.T) {
resValidators := app.StakingKeeper.GetBondedValidatorsByPower(ctx) resValidators := app.StakingKeeper.GetBondedValidatorsByPower(ctx)
// The validators returned should match the max validators // The validators returned should match the max validators
assert.Equal(t, 2, len(resValidators)) assert.Equal(t, 2, len(resValidators))
assert.Equal(t, sdk.NewInt(400).Mul(sdk.DefaultPowerReduction), resValidators[0].BondedTokens(), "%v", resValidators) assert.Equal(t, sdk.NewInt(400).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[0].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(200).Mul(sdk.DefaultPowerReduction), resValidators[1].BondedTokens(), "%v", resValidators) assert.Equal(t, sdk.NewInt(200).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[1].BondedTokens(), "%v", resValidators)
assert.Equal(t, validators[3].OperatorAddress, resValidators[0].OperatorAddress, "%v", resValidators) assert.Equal(t, validators[3].OperatorAddress, resValidators[0].OperatorAddress, "%v", resValidators)
assert.Equal(t, validators[4].OperatorAddress, resValidators[1].OperatorAddress, "%v", resValidators) assert.Equal(t, validators[4].OperatorAddress, resValidators[1].OperatorAddress, "%v", resValidators)
} }
@ -504,7 +504,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
moniker := fmt.Sprintf("val#%d", int64(i)) moniker := fmt.Sprintf("val#%d", int64(i))
validators[i] = newMonikerValidator(t, sdk.ValAddress(addrs[i]), PKs[i], moniker) validators[i] = newMonikerValidator(t, sdk.ValAddress(addrs[i]), PKs[i], moniker)
tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens) validators[i], _ = validators[i].AddTokensFromDel(tokens)
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@ -523,7 +523,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
// delegate 500 tokens to validator 0 // delegate 500 tokens to validator 0
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[0]) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[0])
delTokens := sdk.TokensFromConsensusPower(500, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 500)
validators[0], _ = validators[0].AddTokensFromDel(delTokens) validators[0], _ = validators[0].AddTokensFromDel(delTokens)
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@ -558,10 +558,10 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
validators[3], found = app.StakingKeeper.GetValidator(ctx, validators[3].GetOperator()) validators[3], found = app.StakingKeeper.GetValidator(ctx, validators[3].GetOperator())
assert.True(t, found) assert.True(t, found)
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[3]) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[3])
validators[3], _ = validators[3].AddTokensFromDel(sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)) validators[3], _ = validators[3].AddTokensFromDel(app.StakingKeeper.TokensFromConsensusPower(ctx, 1))
notBondedPool = app.StakingKeeper.GetNotBondedPool(ctx) notBondedPool = app.StakingKeeper.GetNotBondedPool(ctx)
newTokens = sdk.NewCoins(sdk.NewCoin(params.BondDenom, sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction))) newTokens = sdk.NewCoins(sdk.NewCoin(params.BondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 1)))
balances = app.BankKeeper.GetAllBalances(ctx, notBondedPool.GetAddress()) balances = app.BankKeeper.GetAllBalances(ctx, notBondedPool.GetAddress())
require.NoError(t, app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), balances.Add(newTokens...))) require.NoError(t, app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), balances.Add(newTokens...)))
app.AccountKeeper.SetModuleAccount(ctx, notBondedPool) app.AccountKeeper.SetModuleAccount(ctx, notBondedPool)
@ -620,9 +620,9 @@ func TestValidatorBondHeight(t *testing.T) {
validators[1] = teststaking.NewValidator(t, sdk.ValAddress(addrs[1]), PKs[1]) validators[1] = teststaking.NewValidator(t, sdk.ValAddress(addrs[1]), PKs[1])
validators[2] = teststaking.NewValidator(t, sdk.ValAddress(addrs[2]), PKs[2]) validators[2] = teststaking.NewValidator(t, sdk.ValAddress(addrs[2]), PKs[2])
tokens0 := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction) tokens0 := app.StakingKeeper.TokensFromConsensusPower(ctx, 200)
tokens1 := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) tokens1 := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
tokens2 := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) tokens2 := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
validators[0], _ = validators[0].AddTokensFromDel(tokens0) validators[0], _ = validators[0].AddTokensFromDel(tokens0)
validators[1], _ = validators[1].AddTokensFromDel(tokens1) validators[1], _ = validators[1].AddTokensFromDel(tokens1)
validators[2], _ = validators[2].AddTokensFromDel(tokens2) validators[2], _ = validators[2].AddTokensFromDel(tokens2)
@ -642,7 +642,7 @@ func TestValidatorBondHeight(t *testing.T) {
assert.True(ValEq(t, validators[1], resValidators[1])) assert.True(ValEq(t, validators[1], resValidators[1]))
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[1]) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[1])
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[2]) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[2])
delTokens := sdk.TokensFromConsensusPower(50, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 50)
validators[1], _ = validators[1].AddTokensFromDel(delTokens) validators[1], _ = validators[1].AddTokensFromDel(delTokens)
validators[2], _ = validators[2].AddTokensFromDel(delTokens) validators[2], _ = validators[2].AddTokensFromDel(delTokens)
validators[2] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[2], true) validators[2] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[2], true)
@ -665,7 +665,7 @@ func TestFullValidatorSetPowerChange(t *testing.T) {
var validators [5]types.Validator var validators [5]types.Validator
for i, power := range powers { for i, power := range powers {
validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i]) validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens) validators[i], _ = validators[i].AddTokensFromDel(tokens)
keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[i], true) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[i], true)
} }
@ -686,7 +686,7 @@ func TestFullValidatorSetPowerChange(t *testing.T) {
// test a swap in voting power // test a swap in voting power
tokens := sdk.TokensFromConsensusPower(600, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 600)
validators[0], _ = validators[0].AddTokensFromDel(tokens) validators[0], _ = validators[0].AddTokensFromDel(tokens)
validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], true) validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], true)
resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx) resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
@ -705,7 +705,7 @@ func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) {
valAddr := sdk.ValAddress(valPubKey.Address().Bytes()) valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
validators[i] = teststaking.NewValidator(t, valAddr, valPubKey) validators[i] = teststaking.NewValidator(t, valAddr, valPubKey)
tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens) validators[i], _ = validators[i].AddTokensFromDel(tokens)
} }
@ -720,8 +720,8 @@ func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) {
updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2) updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
validators[0], _ = app.StakingKeeper.GetValidator(ctx, validators[0].GetOperator()) validators[0], _ = app.StakingKeeper.GetValidator(ctx, validators[0].GetOperator())
validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator()) validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator())
assert.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1]) assert.Equal(t, validators[0].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
assert.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) assert.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
} }
func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) { func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) {
@ -732,7 +732,7 @@ func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) {
for i, power := range powers { for i, power := range powers {
validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i]) validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens) validators[i], _ = validators[i].AddTokensFromDel(tokens)
} }
@ -755,7 +755,7 @@ func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) {
for i, power := range powers { for i, power := range powers {
validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i]) validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens) validators[i], _ = validators[i].AddTokensFromDel(tokens)
} }
@ -766,11 +766,11 @@ func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) {
// test single value change // test single value change
// tendermintUpdate set: {} -> {c1'} // tendermintUpdate set: {} -> {c1'}
validators[0].Status = types.Bonded validators[0].Status = types.Bonded
validators[0].Tokens = sdk.TokensFromConsensusPower(600, sdk.DefaultPowerReduction) validators[0].Tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 600)
validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false) validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1) updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) require.Equal(t, validators[0].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
} }
func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) { func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) {
@ -784,16 +784,16 @@ func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) {
// test multiple value change // test multiple value change
// tendermintUpdate set: {c1, c3} -> {c1', c3'} // tendermintUpdate set: {c1, c3} -> {c1', c3'}
delTokens1 := sdk.TokensFromConsensusPower(190, sdk.DefaultPowerReduction) delTokens1 := app.StakingKeeper.TokensFromConsensusPower(ctx, 190)
delTokens2 := sdk.TokensFromConsensusPower(80, sdk.DefaultPowerReduction) delTokens2 := app.StakingKeeper.TokensFromConsensusPower(ctx, 80)
validators[0], _ = validators[0].AddTokensFromDel(delTokens1) validators[0], _ = validators[0].AddTokensFromDel(delTokens1)
validators[1], _ = validators[1].AddTokensFromDel(delTokens2) validators[1], _ = validators[1].AddTokensFromDel(delTokens2)
validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false) validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
validators[1] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[1], false) validators[1] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[1], false)
updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2) updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) require.Equal(t, validators[0].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1]) require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
} }
func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) { func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
@ -810,7 +810,7 @@ func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[2]) app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[2])
updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1) updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
validators[2], _ = app.StakingKeeper.GetValidator(ctx, validators[2].GetOperator()) validators[2], _ = app.StakingKeeper.GetValidator(ctx, validators[2].GetOperator())
require.Equal(t, validators[2].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) require.Equal(t, validators[2].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
// test validtor added at the beginning // test validtor added at the beginning
// tendermintUpdate set: {} -> {c0} // tendermintUpdate set: {} -> {c0}
@ -818,7 +818,7 @@ func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[3]) app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[3])
updates = applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1) updates = applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
validators[3], _ = app.StakingKeeper.GetValidator(ctx, validators[3].GetOperator()) validators[3], _ = app.StakingKeeper.GetValidator(ctx, validators[3].GetOperator())
require.Equal(t, validators[3].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) require.Equal(t, validators[3].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
// test validtor added at the end // test validtor added at the end
// tendermintUpdate set: {} -> {c0} // tendermintUpdate set: {} -> {c0}
@ -826,7 +826,7 @@ func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[4]) app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[4])
updates = applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1) updates = applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
validators[4], _ = app.StakingKeeper.GetValidator(ctx, validators[4].GetOperator()) validators[4], _ = app.StakingKeeper.GetValidator(ctx, validators[4].GetOperator())
require.Equal(t, validators[4].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) require.Equal(t, validators[4].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
} }
func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) { func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
@ -839,7 +839,7 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
var validators [5]types.Validator var validators [5]types.Validator
for i, power := range powers { for i, power := range powers {
validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i]) validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens) validators[i], _ = validators[i].AddTokensFromDel(tokens)
} }
validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false) validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
@ -855,14 +855,14 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
// tendermintUpdate set: {} -> {c0, c4} // tendermintUpdate set: {} -> {c0, c4}
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
tokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validators[2], _ = validators[2].AddTokensFromDel(tokens) validators[2], _ = validators[2].AddTokensFromDel(tokens)
app.StakingKeeper.SetValidator(ctx, validators[2]) app.StakingKeeper.SetValidator(ctx, validators[2])
app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[2]) app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[2])
updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2) updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
validators[2], _ = app.StakingKeeper.GetValidator(ctx, validators[2].GetOperator()) validators[2], _ = app.StakingKeeper.GetValidator(ctx, validators[2].GetOperator())
require.Equal(t, validators[0].ABCIValidatorUpdateZero(), updates[1]) require.Equal(t, validators[0].ABCIValidatorUpdateZero(), updates[1])
require.Equal(t, validators[2].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) require.Equal(t, validators[2].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
} }
func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) { func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
@ -872,7 +872,7 @@ func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
var validators [2]types.Validator var validators [2]types.Validator
for i, power := range powers { for i, power := range powers {
validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i]) validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens) validators[i], _ = validators[i].AddTokensFromDel(tokens)
} }
validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false) validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
@ -880,26 +880,26 @@ func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
// check initial power // check initial power
require.Equal(t, int64(100), validators[0].GetConsensusPower(sdk.DefaultPowerReduction)) require.Equal(t, int64(100), validators[0].GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
require.Equal(t, int64(100), validators[1].GetConsensusPower(sdk.DefaultPowerReduction)) require.Equal(t, int64(100), validators[1].GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
// test multiple value change // test multiple value change
// tendermintUpdate set: {c1, c3} -> {c1', c3'} // tendermintUpdate set: {c1, c3} -> {c1', c3'}
delTokens1 := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction) delTokens1 := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
delTokens2 := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction) delTokens2 := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
validators[0], _ = validators[0].RemoveDelShares(delTokens1.ToDec()) validators[0], _ = validators[0].RemoveDelShares(delTokens1.ToDec())
validators[1], _ = validators[1].RemoveDelShares(delTokens2.ToDec()) validators[1], _ = validators[1].RemoveDelShares(delTokens2.ToDec())
validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false) validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
validators[1] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[1], false) validators[1] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[1], false)
// power has changed // power has changed
require.Equal(t, int64(80), validators[0].GetConsensusPower(sdk.DefaultPowerReduction)) require.Equal(t, int64(80), validators[0].GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
require.Equal(t, int64(70), validators[1].GetConsensusPower(sdk.DefaultPowerReduction)) require.Equal(t, int64(70), validators[1].GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
// Tendermint updates should reflect power change // Tendermint updates should reflect power change
updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2) updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) require.Equal(t, validators[0].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1]) require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
} }
func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) { func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
@ -918,7 +918,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
valAddr := sdk.ValAddress(valPubKey.Address().Bytes()) valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
validators[i] = teststaking.NewValidator(t, valAddr, valPubKey) validators[i] = teststaking.NewValidator(t, valAddr, valPubKey)
tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens) validators[i], _ = validators[i].AddTokensFromDel(tokens)
app.StakingKeeper.SetValidator(ctx, validators[i]) app.StakingKeeper.SetValidator(ctx, validators[i])
@ -929,8 +929,8 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, len(validators)) updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, len(validators))
validators[0], _ = app.StakingKeeper.GetValidator(ctx, validators[0].GetOperator()) validators[0], _ = app.StakingKeeper.GetValidator(ctx, validators[0].GetOperator())
validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator()) validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator())
require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) require.Equal(t, validators[0].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1]) require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
@ -938,7 +938,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
for i, power := range powers { for i, power := range powers {
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[i]) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[i])
tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens) validators[i], _ = validators[i].AddTokensFromDel(tokens)
app.StakingKeeper.SetValidator(ctx, validators[i]) app.StakingKeeper.SetValidator(ctx, validators[i])
@ -965,7 +965,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
valAddr = sdk.ValAddress(valPubKey.Address().Bytes()) valAddr = sdk.ValAddress(valPubKey.Address().Bytes())
validator = teststaking.NewValidator(t, valAddr, valPubKey) validator = teststaking.NewValidator(t, valAddr, valPubKey)
tokens := sdk.TokensFromConsensusPower(500, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 500)
validator, _ = validator.AddTokensFromDel(tokens) validator, _ = validator.AddTokensFromDel(tokens)
app.StakingKeeper.SetValidator(ctx, validator) app.StakingKeeper.SetValidator(ctx, validator)
app.StakingKeeper.SetValidatorByPowerIndex(ctx, validator) app.StakingKeeper.SetValidatorByPowerIndex(ctx, validator)
@ -975,9 +975,9 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
validator, _ = app.StakingKeeper.GetValidator(ctx, validator.GetOperator()) validator, _ = app.StakingKeeper.GetValidator(ctx, validator.GetOperator())
validators[0], _ = app.StakingKeeper.GetValidator(ctx, validators[0].GetOperator()) validators[0], _ = app.StakingKeeper.GetValidator(ctx, validators[0].GetOperator())
validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator()) validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator())
require.Equal(t, validator.ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) require.Equal(t, validator.ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1]) require.Equal(t, validators[0].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[2]) require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[2])
} }
func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) { func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
@ -997,7 +997,7 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
valAddr := sdk.ValAddress(valPubKey.Address().Bytes()) valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
validators[i] = newMonikerValidator(t, valAddr, valPubKey, moniker) validators[i] = newMonikerValidator(t, valAddr, valPubKey, moniker)
tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens) validators[i], _ = validators[i].AddTokensFromDel(tokens)
app.StakingKeeper.SetValidator(ctx, validators[i]) app.StakingKeeper.SetValidator(ctx, validators[i])
app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[i]) app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[i])
@ -1007,8 +1007,8 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2) updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
validators[2], _ = app.StakingKeeper.GetValidator(ctx, validators[2].GetOperator()) validators[2], _ = app.StakingKeeper.GetValidator(ctx, validators[2].GetOperator())
validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator()) validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator())
require.Equal(t, validators[2].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) require.Equal(t, validators[2].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1]) require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
@ -1020,7 +1020,7 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
require.True(t, found) require.True(t, found)
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[0]) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[0])
tokens := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction) tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 1)
validators[0], _ = validators[0].AddTokensFromDel(tokens) validators[0], _ = validators[0].AddTokensFromDel(tokens)
app.StakingKeeper.SetValidator(ctx, validators[0]) app.StakingKeeper.SetValidator(ctx, validators[0])
app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[0]) app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[0])
@ -1042,14 +1042,14 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[1]) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[1])
tokens = sdk.TokensFromConsensusPower(250, sdk.DefaultPowerReduction) tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 250)
validators[1], _ = validators[1].AddTokensFromDel(tokens) validators[1], _ = validators[1].AddTokensFromDel(tokens)
app.StakingKeeper.SetValidator(ctx, validators[1]) app.StakingKeeper.SetValidator(ctx, validators[1])
app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[1]) app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[1])
// verify initial Tendermint updates are correct // verify initial Tendermint updates are correct
updates = applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1) updates = applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
} }

1
x/staking/legacy/v040/migrate_test.go
View File

@ -55,6 +55,7 @@ func TestMigrate(t *testing.T) {
"historical_entries": 0, "historical_entries": 0,
"max_entries": 0, "max_entries": 0,
"max_validators": 0, "max_validators": 0,
"power_reduction": "1000000",
"unbonding_time": "0s" "unbonding_time": "0s"
}, },
"redelegations": [], "redelegations": [],

2
x/staking/simulation/genesis_test.go
View File

@ -47,7 +47,7 @@ func TestRandomizedGenState(t *testing.T) {
require.Equal(t, uint32(8687), stakingGenesis.Params.HistoricalEntries) require.Equal(t, uint32(8687), stakingGenesis.Params.HistoricalEntries)
require.Equal(t, "stake", stakingGenesis.Params.BondDenom) require.Equal(t, "stake", stakingGenesis.Params.BondDenom)
require.Equal(t, float64(238280), stakingGenesis.Params.UnbondingTime.Seconds()) require.Equal(t, float64(238280), stakingGenesis.Params.UnbondingTime.Seconds())
require.Equal(t, sdk.NewInt(1000000), stakingGenesis.Params.PowerReduction) require.Equal(t, sdk.DefaultPowerReduction, stakingGenesis.Params.PowerReduction)
// check numbers of Delegations and Validators // check numbers of Delegations and Validators
require.Len(t, stakingGenesis.Delegations, 3) require.Len(t, stakingGenesis.Delegations, 3)
require.Len(t, stakingGenesis.Validators, 3) require.Len(t, stakingGenesis.Validators, 3)

8
x/staking/simulation/operations_test.go
View File

@ -181,7 +181,7 @@ func TestSimulateMsgUndelegate(t *testing.T) {
validator0 := getTestingValidator0(t, app, ctx, accounts) validator0 := getTestingValidator0(t, app, ctx, accounts)
// setup delegation // setup delegation
delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
validator0, issuedShares := validator0.AddTokensFromDel(delTokens) validator0, issuedShares := validator0.AddTokensFromDel(delTokens)
delegator := accounts[1] delegator := accounts[1]
delegation := types.NewDelegation(delegator.Address, validator0.GetOperator(), issuedShares) delegation := types.NewDelegation(delegator.Address, validator0.GetOperator(), issuedShares)
@ -227,7 +227,7 @@ func TestSimulateMsgBeginRedelegate(t *testing.T) {
validator0 := getTestingValidator0(t, app, ctx, accounts) validator0 := getTestingValidator0(t, app, ctx, accounts)
validator1 := getTestingValidator1(t, app, ctx, accounts) validator1 := getTestingValidator1(t, app, ctx, accounts)
delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
validator0, issuedShares := validator0.AddTokensFromDel(delTokens) validator0, issuedShares := validator0.AddTokensFromDel(delTokens)
// setup accounts[2] as delegator // setup accounts[2] as delegator
@ -276,7 +276,7 @@ func createTestApp(isCheckTx bool) (*simapp.SimApp, sdk.Context) {
func getTestingAccounts(t *testing.T, r *rand.Rand, app *simapp.SimApp, ctx sdk.Context, n int) []simtypes.Account { func getTestingAccounts(t *testing.T, r *rand.Rand, app *simapp.SimApp, ctx sdk.Context, n int) []simtypes.Account {
accounts := simtypes.RandomAccounts(r, n) accounts := simtypes.RandomAccounts(r, n)
initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction) initAmt := app.StakingKeeper.TokensFromConsensusPower(ctx, 200)
initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt)) initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
// add coins to the accounts // add coins to the accounts
@ -309,7 +309,7 @@ func getTestingValidator(t *testing.T, app *simapp.SimApp, ctx sdk.Context, acco
require.NoError(t, err) require.NoError(t, err)
validator.DelegatorShares = sdk.NewDec(100) validator.DelegatorShares = sdk.NewDec(100)
validator.Tokens = sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) validator.Tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
app.StakingKeeper.SetValidator(ctx, validator) app.StakingKeeper.SetValidator(ctx, validator)

4
x/staking/teststaking/helper.go
View File

@ -40,7 +40,7 @@ func (sh *Helper) CreateValidator(addr sdk.ValAddress, pk cryptotypes.PubKey, st
// CreateValidatorWithValPower calls handler to create a new staking validator with zero // CreateValidatorWithValPower calls handler to create a new staking validator with zero
// commission // commission
func (sh *Helper) CreateValidatorWithValPower(addr sdk.ValAddress, pk cryptotypes.PubKey, valPower int64, ok bool) sdk.Int { func (sh *Helper) CreateValidatorWithValPower(addr sdk.ValAddress, pk cryptotypes.PubKey, valPower int64, ok bool) sdk.Int {
amount := sdk.TokensFromConsensusPower(valPower, sdk.DefaultPowerReduction) amount := sh.k.TokensFromConsensusPower(sh.Ctx, valPower)
coin := sdk.NewCoin(sh.Denom, amount) coin := sdk.NewCoin(sh.Denom, amount)
sh.createValidator(addr, pk, coin, ok) sh.createValidator(addr, pk, coin, ok)
return amount return amount
@ -69,7 +69,7 @@ func (sh *Helper) Delegate(delegator sdk.AccAddress, val sdk.ValAddress, amount
// DelegateWithPower calls handler to delegate stake for a validator // DelegateWithPower calls handler to delegate stake for a validator
func (sh *Helper) DelegateWithPower(delegator sdk.AccAddress, val sdk.ValAddress, power int64) { func (sh *Helper) DelegateWithPower(delegator sdk.AccAddress, val sdk.ValAddress, power int64) {
coin := sdk.NewCoin(sh.Denom, sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)) coin := sdk.NewCoin(sh.Denom, sh.k.TokensFromConsensusPower(sh.Ctx, power))
msg := stakingtypes.NewMsgDelegate(delegator, val, coin) msg := stakingtypes.NewMsgDelegate(delegator, val, coin)
sh.Handle(msg, true) sh.Handle(msg, true)
} }