diff --git a/simapp/simd/cmd/testnet.go b/simapp/simd/cmd/testnet.go index 0717b39842..99cf099587 100644 --- a/simapp/simd/cmd/testnet.go +++ b/simapp/simd/cmd/testnet.go @@ -196,8 +196,8 @@ func InitTestnet( return err } - accTokens := sdk.TokensFromConsensusPower(1000) - accStakingTokens := sdk.TokensFromConsensusPower(500) + accTokens := sdk.TokensFromConsensusPower(1000, sdk.DefaultPowerReduction) + accStakingTokens := sdk.TokensFromConsensusPower(500, sdk.DefaultPowerReduction) coins := sdk.Coins{ sdk.NewCoin(fmt.Sprintf("%stoken", nodeDirName), accTokens), sdk.NewCoin(sdk.DefaultBondDenom, accStakingTokens), @@ -206,7 +206,7 @@ func InitTestnet( genBalances = append(genBalances, banktypes.Balance{Address: addr.String(), Coins: coins.Sort()}) genAccounts = append(genAccounts, authtypes.NewBaseAccount(addr, nil, 0, 0)) - valTokens := sdk.TokensFromConsensusPower(100) + valTokens := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) createValMsg, err := stakingtypes.NewMsgCreateValidator( sdk.ValAddress(addr), valPubKeys[i], diff --git a/testutil/network/network.go b/testutil/network/network.go index c73b69d18a..21102b51fd 100644 --- a/testutil/network/network.go +++ b/testutil/network/network.go @@ -111,9 +111,9 @@ func DefaultConfig() Config { NumValidators: 4, BondDenom: sdk.DefaultBondDenom, MinGasPrices: fmt.Sprintf("0.000006%s", sdk.DefaultBondDenom), - AccountTokens: sdk.TokensFromConsensusPower(1000), - StakingTokens: sdk.TokensFromConsensusPower(500), - BondedTokens: sdk.TokensFromConsensusPower(100), + AccountTokens: sdk.TokensFromConsensusPower(1000, sdk.DefaultPowerReduction), + StakingTokens: sdk.TokensFromConsensusPower(500, sdk.DefaultPowerReduction), + BondedTokens: sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction), PruningStrategy: storetypes.PruningOptionNothing, CleanupDir: true, SigningAlgo: string(hd.Secp256k1Type), diff --git a/types/staking.go b/types/staking.go index 0753d808b2..563f94176c 100644 --- a/types/staking.go +++ b/types/staking.go @@ -22,15 +22,15 @@ const ( ValidatorUpdateDelay int64 = 1 ) -// PowerReduction is the amount of staking tokens required for 1 unit of consensus-engine power -var PowerReduction = NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(6), nil)) +// DefaultPowerReduction is the default amount of staking tokens required for 1 unit of consensus-engine power +var DefaultPowerReduction = NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(6), nil)) // TokensToConsensusPower - convert input tokens to potential consensus-engine power -func TokensToConsensusPower(tokens Int) int64 { - return (tokens.Quo(PowerReduction)).Int64() +func TokensToConsensusPower(tokens Int, powerReduction Int) int64 { + return (tokens.Quo(powerReduction)).Int64() } // TokensFromConsensusPower - convert input power to tokens -func TokensFromConsensusPower(power int64) Int { - return NewInt(power).Mul(PowerReduction) +func TokensFromConsensusPower(power int64, powerReduction Int) Int { + return NewInt(power).Mul(powerReduction) } diff --git a/types/staking_test.go b/types/staking_test.go index e307230cd9..fe6c36bd99 100644 --- a/types/staking_test.go +++ b/types/staking_test.go @@ -21,6 +21,6 @@ func (s *stakingTestSuite) SetupSuite() { } func (s *stakingTestSuite) TestTokensToConsensusPower() { - s.Require().Equal(int64(0), sdk.TokensToConsensusPower(sdk.NewInt(999_999))) - s.Require().Equal(int64(1), sdk.TokensToConsensusPower(sdk.NewInt(1_000_000))) + s.Require().Equal(int64(0), sdk.TokensToConsensusPower(sdk.NewInt(999_999), sdk.DefaultPowerReduction)) + s.Require().Equal(int64(1), sdk.TokensToConsensusPower(sdk.NewInt(1_000_000), sdk.DefaultPowerReduction)) } diff --git a/x/auth/client/cli/cli_test.go b/x/auth/client/cli/cli_test.go index d8913d1ac0..744e4c714a 100644 --- a/x/auth/client/cli/cli_test.go +++ b/x/auth/client/cli/cli_test.go @@ -321,7 +321,7 @@ func (s *IntegrationTestSuite) TestCLISendGenerateSignAndBroadcast() { account, err := val1.ClientCtx.Keyring.Key("newAccount") s.Require().NoError(err) - sendTokens := sdk.NewCoin(s.cfg.BondDenom, sdk.TokensFromConsensusPower(10)) + sendTokens := sdk.NewCoin(s.cfg.BondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)) normalGeneratedTx, err := bankcli.MsgSendExec( val1.ClientCtx, @@ -544,7 +544,7 @@ func (s *IntegrationTestSuite) TestCLIMultisignInsufficientCosigners() { func (s *IntegrationTestSuite) TestCLIEncode() { val1 := s.network.Validators[0] - sendTokens := sdk.NewCoin(s.cfg.BondDenom, sdk.TokensFromConsensusPower(10)) + sendTokens := sdk.NewCoin(s.cfg.BondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)) normalGeneratedTx, err := bankcli.MsgSendExec( val1.ClientCtx, diff --git a/x/authz/simulation/operations_test.go b/x/authz/simulation/operations_test.go index 83be182df7..e8686f166a 100644 --- a/x/authz/simulation/operations_test.go +++ b/x/authz/simulation/operations_test.go @@ -72,7 +72,7 @@ func (suite *SimTestSuite) TestWeightedOperations() { func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account { accounts := simtypes.RandomAccounts(r, n) - initAmt := sdk.TokensFromConsensusPower(200000) + initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction) initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt)) // add coins to the accounts @@ -132,7 +132,7 @@ func (suite *SimTestSuite) TestSimulateRevokeAuthorization() { AppHash: suite.app.LastCommitID().Hash, }}) - initAmt := sdk.TokensFromConsensusPower(200000) + initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction) initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt)) granter := accounts[0] @@ -167,7 +167,7 @@ func (suite *SimTestSuite) TestSimulateExecAuthorization() { // begin a new block suite.app.BeginBlock(abci.RequestBeginBlock{Header: tmproto.Header{Height: suite.app.LastBlockHeight() + 1, AppHash: suite.app.LastCommitID().Hash}}) - initAmt := sdk.TokensFromConsensusPower(200000) + initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction) initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt)) granter := accounts[0] diff --git a/x/bank/client/rest/tx_test.go b/x/bank/client/rest/tx_test.go index d770ebec3d..f189eb5363 100644 --- a/x/bank/client/rest/tx_test.go +++ b/x/bank/client/rest/tx_test.go @@ -8,6 +8,7 @@ import ( "github.com/cosmos/cosmos-sdk/simapp" "github.com/cosmos/cosmos-sdk/testutil/network" "github.com/cosmos/cosmos-sdk/types" + sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/rest" authclient "github.com/cosmos/cosmos-sdk/x/auth/client" @@ -28,7 +29,7 @@ func (s *IntegrationTestSuite) TestCoinSend() { sendReq := generateSendReq( account, - types.Coins{types.NewCoin(s.cfg.BondDenom, types.TokensFromConsensusPower(1))}, + types.Coins{types.NewCoin(s.cfg.BondDenom, types.TokensFromConsensusPower(1, sdk.DefaultPowerReduction))}, ) stdTx, err := submitSendReq(val, sendReq) diff --git a/x/bank/keeper/keeper_test.go b/x/bank/keeper/keeper_test.go index 80b4b070c2..d57d60877a 100644 --- a/x/bank/keeper/keeper_test.go +++ b/x/bank/keeper/keeper_test.go @@ -35,7 +35,7 @@ var ( multiPermAcc = authtypes.NewEmptyModuleAccount(multiPerm, authtypes.Burner, authtypes.Minter, authtypes.Staking) randomPermAcc = authtypes.NewEmptyModuleAccount(randomPerm, "random") - initTokens = sdk.TokensFromConsensusPower(initialPower) + initTokens = sdk.TokensFromConsensusPower(initialPower, sdk.DefaultPowerReduction) initCoins = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens)) ) @@ -86,7 +86,7 @@ func (suite *IntegrationTestSuite) TestSupply() { app, ctx := suite.app, suite.ctx initialPower := int64(100) - initTokens := sdk.TokensFromConsensusPower(initialPower) + initTokens := sdk.TokensFromConsensusPower(initialPower, sdk.DefaultPowerReduction) totalSupply := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens)) app.BankKeeper.SetSupply(ctx, types.NewSupply(totalSupply)) diff --git a/x/bank/simulation/operations_test.go b/x/bank/simulation/operations_test.go index 144dc5dd34..5add9942ce 100644 --- a/x/bank/simulation/operations_test.go +++ b/x/bank/simulation/operations_test.go @@ -124,7 +124,7 @@ func (suite *SimTestSuite) TestSimulateMsgMultiSend() { func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account { accounts := simtypes.RandomAccounts(r, n) - initAmt := sdk.TokensFromConsensusPower(200) + initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction) initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt)) // add coins to the accounts diff --git a/x/distribution/keeper/delegation_test.go b/x/distribution/keeper/delegation_test.go index ac8ac4a334..0255a64ca3 100644 --- a/x/distribution/keeper/delegation_test.go +++ b/x/distribution/keeper/delegation_test.go @@ -112,7 +112,7 @@ func TestCalculateRewardsAfterSlash(t *testing.T) { ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) // allocate some rewards - initial := sdk.TokensFromConsensusPower(10) + initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.ToDec()}} app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens) @@ -175,7 +175,7 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) { ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) // allocate some rewards - initial := sdk.TokensFromConsensusPower(10) + initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.ToDec()}} app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens) @@ -270,7 +270,7 @@ func TestCalculateRewardsMultiDelegator(t *testing.T) { func TestWithdrawDelegationRewardsBasic(t *testing.T) { balancePower := int64(1000) - balanceTokens := sdk.TokensFromConsensusPower(balancePower) + balanceTokens := sdk.TokensFromConsensusPower(balancePower, sdk.DefaultPowerReduction) app := simapp.Setup(false) ctx := app.BaseApp.NewContext(false, tmproto.Header{}) @@ -305,7 +305,7 @@ func TestWithdrawDelegationRewardsBasic(t *testing.T) { val := app.StakingKeeper.Validator(ctx, valAddrs[0]) // allocate some rewards - initial := sdk.TokensFromConsensusPower(10) + initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) tokens := sdk.DecCoins{sdk.NewDecCoin(sdk.DefaultBondDenom, initial)} app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens) @@ -375,7 +375,7 @@ func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) { ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3) // allocate some rewards - initial := sdk.TokensFromConsensusPower(10).ToDec() + initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec() tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}} 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]) // allocate some rewards - initial := sdk.TokensFromConsensusPower(30).ToDec() + initial := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction).ToDec() tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}} app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens) diff --git a/x/distribution/keeper/keeper_test.go b/x/distribution/keeper/keeper_test.go index a8205dfdc1..cd39dafaa7 100644 --- a/x/distribution/keeper/keeper_test.go +++ b/x/distribution/keeper/keeper_test.go @@ -57,7 +57,7 @@ func TestWithdrawValidatorCommission(t *testing.T) { // check initial balance balance := app.BankKeeper.GetAllBalances(ctx, sdk.AccAddress(valAddrs[0])) - expTokens := sdk.TokensFromConsensusPower(1000) + expTokens := sdk.TokensFromConsensusPower(1000, sdk.DefaultPowerReduction) expCoins := sdk.NewCoins(sdk.NewCoin("stake", expTokens)) require.Equal(t, expCoins, balance) diff --git a/x/distribution/simulation/operations_test.go b/x/distribution/simulation/operations_test.go index 4a3dff3087..67ca4dd863 100644 --- a/x/distribution/simulation/operations_test.go +++ b/x/distribution/simulation/operations_test.go @@ -95,7 +95,7 @@ func (suite *SimTestSuite) TestSimulateMsgWithdrawDelegatorReward() { validator0 := suite.getTestingValidator0(accounts) // setup delegation - delTokens := sdk.TokensFromConsensusPower(2) + delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) validator0, issuedShares := validator0.AddTokensFromDel(delTokens) delegator := accounts[1] 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 { accounts := simtypes.RandomAccounts(r, n) - initAmt := sdk.TokensFromConsensusPower(200) + initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction) initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt)) // add coins to the accounts diff --git a/x/evidence/keeper/keeper_test.go b/x/evidence/keeper/keeper_test.go index 9165730466..0d518fa61f 100644 --- a/x/evidence/keeper/keeper_test.go +++ b/x/evidence/keeper/keeper_test.go @@ -34,7 +34,7 @@ var ( sdk.ValAddress(pubkeys[2].Address()), } - initAmt = sdk.TokensFromConsensusPower(200) + initAmt = sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction) initCoins = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt)) ) diff --git a/x/gov/abci_test.go b/x/gov/abci_test.go index bfda1b3590..56a401fffa 100644 --- a/x/gov/abci_test.go +++ b/x/gov/abci_test.go @@ -221,7 +221,7 @@ func TestTickPassedVotingPeriod(t *testing.T) { require.False(t, activeQueue.Valid()) activeQueue.Close() - proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(5))} + proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction))} newProposalMsg, err := types.NewMsgSubmitProposal(TestProposal, proposalCoins, addrs[0]) require.NoError(t, err) @@ -295,7 +295,7 @@ func TestProposalPassedEndblocker(t *testing.T) { proposal, err := app.GovKeeper.SubmitProposal(ctx, TestProposal) require.NoError(t, err) - proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10))} + proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction))} newDepositMsg := types.NewMsgDeposit(addrs[0], proposal.ProposalId, proposalCoins) handleAndCheck(t, handler, ctx, newDepositMsg) @@ -343,7 +343,7 @@ func TestEndBlockerProposalHandlerFailed(t *testing.T) { proposal, err := app.GovKeeper.SubmitProposal(ctx, TestProposal) require.NoError(t, err) - proposalCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10))) + proposalCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction))) newDepositMsg := types.NewMsgDeposit(addrs[0], proposal.ProposalId, proposalCoins) handleAndCheck(t, gov.NewHandler(app.GovKeeper), ctx, newDepositMsg) diff --git a/x/gov/common_test.go b/x/gov/common_test.go index 5ef50ea5db..3ff367e159 100644 --- a/x/gov/common_test.go +++ b/x/gov/common_test.go @@ -16,7 +16,7 @@ import ( ) var ( - valTokens = sdk.TokensFromConsensusPower(42) + valTokens = sdk.TokensFromConsensusPower(42, sdk.DefaultPowerReduction) TestProposal = types.NewTextProposal("Test", "description") TestDescription = stakingtypes.NewDescription("T", "E", "S", "T", "Z") TestCommissionRates = stakingtypes.NewCommissionRates(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()) @@ -82,7 +82,7 @@ func createValidators(t *testing.T, stakingHandler sdk.Handler, ctx sdk.Context, require.True(t, len(addrs) <= len(pubkeys), "Not enough pubkeys specified at top of file.") for i := 0; i < len(addrs); i++ { - valTokens := sdk.TokensFromConsensusPower(powerAmt[i]) + valTokens := sdk.TokensFromConsensusPower(powerAmt[i], sdk.DefaultPowerReduction) valCreateMsg, err := stakingtypes.NewMsgCreateValidator( addrs[i], pubkeys[i], sdk.NewCoin(sdk.DefaultBondDenom, valTokens), TestDescription, TestCommissionRates, sdk.OneInt(), diff --git a/x/gov/keeper/common_test.go b/x/gov/keeper/common_test.go index c7516eb697..a967b4e9cb 100644 --- a/x/gov/keeper/common_test.go +++ b/x/gov/keeper/common_test.go @@ -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, val3) - _, _ = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0]), stakingtypes.Unbonded, val1, true) - _, _ = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1]), stakingtypes.Unbonded, val2, true) - _, _ = app.StakingKeeper.Delegate(ctx, addrs[2], sdk.TokensFromConsensusPower(powers[2]), stakingtypes.Unbonded, val3, true) + _, _ = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0], sdk.DefaultPowerReduction), 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[2], sdk.TokensFromConsensusPower(powers[2], sdk.DefaultPowerReduction), stakingtypes.Unbonded, val3, true) _ = staking.EndBlocker(ctx, app.StakingKeeper) diff --git a/x/gov/keeper/deposit_test.go b/x/gov/keeper/deposit_test.go index dfa857dc57..e1415f099a 100644 --- a/x/gov/keeper/deposit_test.go +++ b/x/gov/keeper/deposit_test.go @@ -22,8 +22,8 @@ func TestDeposits(t *testing.T) { require.NoError(t, err) proposalID := proposal.ProposalId - fourStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(4))) - fiveStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(5))) + fourStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction))) + fiveStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction))) addr0Initial := app.BankKeeper.GetAllBalances(ctx, TestAddrs[0]) addr1Initial := app.BankKeeper.GetAllBalances(ctx, TestAddrs[1]) diff --git a/x/gov/keeper/grpc_query_test.go b/x/gov/keeper/grpc_query_test.go index dc330d7348..59bdd442c9 100644 --- a/x/gov/keeper/grpc_query_test.go +++ b/x/gov/keeper/grpc_query_test.go @@ -164,7 +164,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryProposals() { { "request with filter of deposit address", func() { - depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20))) + depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction))) deposit := types.NewDeposit(testProposals[0].ProposalId, addrs[0], depositCoins) app.GovKeeper.SetDeposit(ctx, deposit) @@ -584,7 +584,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryDeposit() { { "valid request", func() { - depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20))) + depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction))) deposit := types.NewDeposit(proposal.ProposalId, addrs[0], depositCoins) app.GovKeeper.SetDeposit(ctx, deposit) @@ -671,11 +671,11 @@ func (suite *KeeperTestSuite) TestGRPCQueryDeposits() { { "get deposits with default limit", func() { - depositAmount1 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20))) + depositAmount1 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction))) deposit1 := types.NewDeposit(proposal.ProposalId, addrs[0], depositAmount1) app.GovKeeper.SetDeposit(ctx, deposit1) - depositAmount2 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(30))) + depositAmount2 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction))) deposit2 := types.NewDeposit(proposal.ProposalId, addrs[1], depositAmount2) app.GovKeeper.SetDeposit(ctx, deposit2) diff --git a/x/gov/keeper/querier_test.go b/x/gov/keeper/querier_test.go index 9960fb116b..d416cb350d 100644 --- a/x/gov/keeper/querier_test.go +++ b/x/gov/keeper/querier_test.go @@ -153,7 +153,7 @@ func TestQueries(t *testing.T) { TestAddrs := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(20000001)) oneCoins := sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 1)) - consCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10))) + consCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction))) tp := TestProposal diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index 77f468cd2c..4e2ac847e9 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -245,7 +245,7 @@ func TestTallyDelgatorOverride(t *testing.T) { addrs, valAddrs := createValidators(t, ctx, app, []int64{5, 6, 7}) - delTokens := sdk.TokensFromConsensusPower(30) + delTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction) val1, found := app.StakingKeeper.GetValidator(ctx, valAddrs[0]) require.True(t, found) @@ -281,7 +281,7 @@ func TestTallyDelgatorInherit(t *testing.T) { addrs, vals := createValidators(t, ctx, app, []int64{5, 6, 7}) - delTokens := sdk.TokensFromConsensusPower(30) + delTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction) val3, found := app.StakingKeeper.GetValidator(ctx, vals[2]) require.True(t, found) @@ -316,7 +316,7 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) { addrs, vals := createValidators(t, ctx, app, []int64{5, 6, 7}) - delTokens := sdk.TokensFromConsensusPower(10) + delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) val1, found := app.StakingKeeper.GetValidator(ctx, vals[0]) require.True(t, found) 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}) - delTokens := sdk.TokensFromConsensusPower(10) + delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) val2, found := app.StakingKeeper.GetValidator(ctx, vals[1]) require.True(t, found) 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}) - delTokens := sdk.TokensFromConsensusPower(10) + delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) val2, found := app.StakingKeeper.GetValidator(ctx, valAddrs[1]) require.True(t, found) 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}) - delTokens := sdk.TokensFromConsensusPower(10) + delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) val2, found := app.StakingKeeper.GetValidator(ctx, valAddrs[1]) require.True(t, found) @@ -465,10 +465,10 @@ func TestTallyValidatorMultipleDelegations(t *testing.T) { require.True(t, passes) require.False(t, burnDeposits) - expectedYes := sdk.TokensFromConsensusPower(30) - expectedAbstain := sdk.TokensFromConsensusPower(0) - expectedNo := sdk.TokensFromConsensusPower(10) - expectedNoWithVeto := sdk.TokensFromConsensusPower(0) + expectedYes := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction) + expectedAbstain := sdk.TokensFromConsensusPower(0, sdk.DefaultPowerReduction) + expectedNo := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) + expectedNoWithVeto := sdk.TokensFromConsensusPower(0, sdk.DefaultPowerReduction) expectedTallyResult := types.NewTallyResult(expectedYes, expectedAbstain, expectedNo, expectedNoWithVeto) require.True(t, tallyResults.Equals(expectedTallyResult)) diff --git a/x/gov/simulation/operations_test.go b/x/gov/simulation/operations_test.go index 9c6e8306f8..169665ad9f 100644 --- a/x/gov/simulation/operations_test.go +++ b/x/gov/simulation/operations_test.go @@ -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 { accounts := simtypes.RandomAccounts(r, n) - initAmt := sdk.TokensFromConsensusPower(200) + initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction) initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt)) // add coins to the accounts diff --git a/x/gov/types/params.go b/x/gov/types/params.go index 5421136f39..45ed3ec522 100644 --- a/x/gov/types/params.go +++ b/x/gov/types/params.go @@ -17,7 +17,7 @@ const ( // Default governance params var ( - DefaultMinDepositTokens = sdk.TokensFromConsensusPower(10) + DefaultMinDepositTokens = sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) DefaultQuorum = sdk.NewDecWithPrec(334, 3) DefaultThreshold = sdk.NewDecWithPrec(5, 1) DefaultVetoThreshold = sdk.NewDecWithPrec(334, 3) diff --git a/x/ibc/core/02-client/keeper/keeper_test.go b/x/ibc/core/02-client/keeper/keeper_test.go index c22e80cc9e..b9ad609211 100644 --- a/x/ibc/core/02-client/keeper/keeper_test.go +++ b/x/ibc/core/02-client/keeper/keeper_test.go @@ -111,7 +111,7 @@ func (suite *KeeperTestSuite) SetupTest() { val.Tokens = sdk.NewInt(rand.Int63()) validators = append(validators, val) - hi := stakingtypes.NewHistoricalInfo(suite.ctx.BlockHeader(), validators) + hi := stakingtypes.NewHistoricalInfo(suite.ctx.BlockHeader(), validators, sdk.DefaultPowerReduction) app.StakingKeeper.SetHistoricalInfo(suite.ctx, int64(i), &hi) } diff --git a/x/ibc/testing/chain.go b/x/ibc/testing/chain.go index 0534066d88..edf77a7f24 100644 --- a/x/ibc/testing/chain.go +++ b/x/ibc/testing/chain.go @@ -329,7 +329,7 @@ func (chain *TestChain) GetValsAtHeight(height int64) (*tmtypes.ValidatorSet, bo valSet := stakingtypes.Validators(histInfo.Valset) - tmValidators, err := teststaking.ToTmValidators(valSet) + tmValidators, err := teststaking.ToTmValidators(valSet, sdk.DefaultPowerReduction) if err != nil { panic(err) } diff --git a/x/slashing/abci_test.go b/x/slashing/abci_test.go index 50140eb58e..f07b1c81fa 100644 --- a/x/slashing/abci_test.go +++ b/x/slashing/abci_test.go @@ -21,7 +21,7 @@ func TestBeginBlocker(t *testing.T) { ctx := app.BaseApp.NewContext(false, tmproto.Header{}) pks := simapp.CreateTestPubKeys(1) - simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200)) + simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) addr, pk := sdk.ValAddress(pks[0].Address()), pks[0] tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) diff --git a/x/slashing/app_test.go b/x/slashing/app_test.go index 5ee23b7cc5..028d417556 100644 --- a/x/slashing/app_test.go +++ b/x/slashing/app_test.go @@ -41,8 +41,8 @@ func checkValidatorSigningInfo(t *testing.T, app *simapp.SimApp, addr sdk.ConsAd } func TestSlashingMsgs(t *testing.T) { - genTokens := sdk.TokensFromConsensusPower(42) - bondTokens := sdk.TokensFromConsensusPower(10) + genTokens := sdk.TokensFromConsensusPower(42, sdk.DefaultPowerReduction) + bondTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) genCoin := sdk.NewCoin(sdk.DefaultBondDenom, genTokens) bondCoin := sdk.NewCoin(sdk.DefaultBondDenom, bondTokens) diff --git a/x/slashing/genesis_test.go b/x/slashing/genesis_test.go index b9241f0246..e31144f331 100644 --- a/x/slashing/genesis_test.go +++ b/x/slashing/genesis_test.go @@ -20,7 +20,7 @@ func TestExportAndInitGenesis(t *testing.T) { app.SlashingKeeper.SetParams(ctx, testslashing.TestParams()) - addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.TokensFromConsensusPower(200)) + addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) info1 := types.NewValidatorSigningInfo(sdk.ConsAddress(addrDels[0]), int64(4), int64(3), time.Now().UTC().Add(100000000000), false, int64(10)) diff --git a/x/slashing/handler_test.go b/x/slashing/handler_test.go index 7a83014b96..87746d8672 100644 --- a/x/slashing/handler_test.go +++ b/x/slashing/handler_test.go @@ -26,7 +26,7 @@ func TestCannotUnjailUnlessJailed(t *testing.T) { app := simapp.Setup(false) ctx := app.BaseApp.NewContext(false, tmproto.Header{}) pks := simapp.CreateTestPubKeys(1) - simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200)) + simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) slh := slashing.NewHandler(app.SlashingKeeper) @@ -52,12 +52,12 @@ func TestCannotUnjailUnlessMeetMinSelfDelegation(t *testing.T) { app := simapp.Setup(false) ctx := app.BaseApp.NewContext(false, tmproto.Header{}) pks := simapp.CreateTestPubKeys(1) - simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200)) + simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) slh := slashing.NewHandler(app.SlashingKeeper) addr, val := sdk.ValAddress(pks[0].Address()), pks[0] - amt := sdk.TokensFromConsensusPower(100) + amt := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) msg := tstaking.CreateValidatorMsg(addr, val, amt) msg.MinSelfDelegation = amt 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)}) pks := simapp.CreateTestPubKeys(3) - simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(20)) + simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)) app.SlashingKeeper.SetParams(ctx, testslashing.TestParams()) tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) @@ -145,7 +145,7 @@ func TestHandleAbsentValidator(t *testing.T) { app := simapp.Setup(false) ctx := app.BaseApp.NewContext(false, tmproto.Header{Time: time.Unix(0, 0)}) pks := simapp.CreateTestPubKeys(1) - simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200)) + simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) app.SlashingKeeper.SetParams(ctx, testslashing.TestParams()) power := int64(100) diff --git a/x/slashing/init_test.go b/x/slashing/init_test.go index 25a38a2d5e..fac4f3f326 100644 --- a/x/slashing/init_test.go +++ b/x/slashing/init_test.go @@ -5,5 +5,5 @@ import ( ) var ( - InitTokens = sdk.TokensFromConsensusPower(200) + InitTokens = sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction) ) diff --git a/x/slashing/keeper/common_test.go b/x/slashing/keeper/common_test.go index 940d995cac..aed5aa9203 100644 --- a/x/slashing/keeper/common_test.go +++ b/x/slashing/keeper/common_test.go @@ -3,5 +3,5 @@ package keeper_test import sdk "github.com/cosmos/cosmos-sdk/types" var ( - InitTokens = sdk.TokensFromConsensusPower(200) + InitTokens = sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction) ) diff --git a/x/slashing/keeper/grpc_query_test.go b/x/slashing/keeper/grpc_query_test.go index d923b822c7..c4880afd7f 100644 --- a/x/slashing/keeper/grpc_query_test.go +++ b/x/slashing/keeper/grpc_query_test.go @@ -35,7 +35,7 @@ func (suite *SlashingTestSuite) SetupTest() { app.BankKeeper.SetParams(ctx, banktypes.DefaultParams()) app.SlashingKeeper.SetParams(ctx, testslashing.TestParams()) - addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.TokensFromConsensusPower(200)) + addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) info1 := types.NewValidatorSigningInfo(sdk.ConsAddress(addrDels[0]), int64(4), int64(3), time.Unix(2, 0), false, int64(10)) diff --git a/x/slashing/keeper/keeper_test.go b/x/slashing/keeper/keeper_test.go index e083df637a..002d6a03a3 100644 --- a/x/slashing/keeper/keeper_test.go +++ b/x/slashing/keeper/keeper_test.go @@ -23,7 +23,7 @@ func TestUnJailNotBonded(t *testing.T) { p.MaxValidators = 5 app.StakingKeeper.SetParams(ctx, p) - addrDels := simapp.AddTestAddrsIncremental(app, ctx, 6, sdk.TokensFromConsensusPower(200)) + addrDels := simapp.AddTestAddrsIncremental(app, ctx, 6, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) valAddrs := simapp.ConvertAddrsToValAddrs(addrDels) pks := simapp.CreateTestPubKeys(6) 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) addr, val := valAddrs[5], pks[5] - amt := sdk.TokensFromConsensusPower(50) + amt := sdk.TokensFromConsensusPower(50, sdk.DefaultPowerReduction) msg := tstaking.CreateValidatorMsg(addr, val, amt) msg.MinSelfDelegation = amt tstaking.Handle(msg, true) @@ -51,7 +51,7 @@ func TestUnJailNotBonded(t *testing.T) { // unbond below minimum self-delegation require.Equal(t, p.BondDenom, tstaking.Denom) - tstaking.Undelegate(sdk.AccAddress(addr), addr, sdk.TokensFromConsensusPower(1), true) + tstaking.Undelegate(sdk.AccAddress(addr), addr, sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction), true) staking.EndBlocker(ctx, app.StakingKeeper) ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1) @@ -83,7 +83,7 @@ func TestHandleNewValidator(t *testing.T) { app := simapp.Setup(false) ctx := app.BaseApp.NewContext(false, tmproto.Header{}) - addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200)) + addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) valAddrs := simapp.ConvertAddrsToValAddrs(addrDels) pks := simapp.CreateTestPubKeys(1) addr, val := valAddrs[0], pks[0] @@ -116,7 +116,7 @@ func TestHandleNewValidator(t *testing.T) { validator, _ := app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val)) require.Equal(t, stakingtypes.Bonded, validator.GetStatus()) bondPool := app.StakingKeeper.GetBondedPool(ctx) - expTokens := sdk.TokensFromConsensusPower(100) + expTokens := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) 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) ctx := app.BaseApp.NewContext(false, tmproto.Header{}) - addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200)) + addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) valAddrs := simapp.ConvertAddrsToValAddrs(addrDels) pks := simapp.CreateTestPubKeys(1) addr, val := valAddrs[0], pks[0] @@ -159,7 +159,7 @@ func TestHandleAlreadyJailed(t *testing.T) { require.Equal(t, stakingtypes.Unbonding, validator.GetStatus()) // validator should have been slashed - resultingTokens := amt.Sub(sdk.TokensFromConsensusPower(1)) + resultingTokens := amt.Sub(sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)) require.Equal(t, resultingTokens, validator.GetTokens()) // another block missed @@ -188,7 +188,7 @@ func TestValidatorDippingInAndOut(t *testing.T) { power := int64(100) pks := simapp.CreateTestPubKeys(3) - simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200)) + simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) addr, val := pks[0].Address(), pks[0] consAddr := sdk.ConsAddress(addr) diff --git a/x/slashing/keeper/signing_info_test.go b/x/slashing/keeper/signing_info_test.go index 1b70c83b97..e1b4f1720a 100644 --- a/x/slashing/keeper/signing_info_test.go +++ b/x/slashing/keeper/signing_info_test.go @@ -15,7 +15,7 @@ import ( func TestGetSetValidatorSigningInfo(t *testing.T) { app := simapp.Setup(false) ctx := app.BaseApp.NewContext(false, tmproto.Header{}) - addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200)) + addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) info, found := app.SlashingKeeper.GetValidatorSigningInfo(ctx, sdk.ConsAddress(addrDels[0])) require.False(t, found) @@ -39,7 +39,7 @@ func TestGetSetValidatorSigningInfo(t *testing.T) { func TestGetSetValidatorMissedBlockBitArray(t *testing.T) { app := simapp.Setup(false) ctx := app.BaseApp.NewContext(false, tmproto.Header{}) - addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200)) + addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) missed := app.SlashingKeeper.GetValidatorMissedBlockBitArray(ctx, sdk.ConsAddress(addrDels[0]), 0) require.False(t, missed) // treat empty key as not missed @@ -51,7 +51,7 @@ func TestGetSetValidatorMissedBlockBitArray(t *testing.T) { func TestTombstoned(t *testing.T) { app := simapp.Setup(false) ctx := app.BaseApp.NewContext(false, tmproto.Header{}) - addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200)) + addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) require.Panics(t, func() { app.SlashingKeeper.Tombstone(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) { app := simapp.Setup(false) ctx := app.BaseApp.NewContext(false, tmproto.Header{}) - addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200)) + addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)) require.Panics(t, func() { app.SlashingKeeper.JailUntil(ctx, sdk.ConsAddress(addrDels[0]), time.Now()) }) diff --git a/x/slashing/simulation/operations_test.go b/x/slashing/simulation/operations_test.go index 15764c631e..2042821c7a 100644 --- a/x/slashing/simulation/operations_test.go +++ b/x/slashing/simulation/operations_test.go @@ -77,7 +77,7 @@ func TestSimulateMsgUnjail(t *testing.T) { app.StakingKeeper.Jail(ctx, val0ConsAddress) // setup self delegation - delTokens := sdk.TokensFromConsensusPower(2) + delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) validator0, issuedShares := validator0.AddTokensFromDel(delTokens) val0AccAddress, err := sdk.ValAddressFromBech32(validator0.OperatorAddress) 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 { accounts := simtypes.RandomAccounts(r, n) - initAmt := sdk.TokensFromConsensusPower(200) + initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction) initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt)) // add coins to the accounts diff --git a/x/staking/app_test.go b/x/staking/app_test.go index 207ac03e0c..65a6e4524e 100644 --- a/x/staking/app_test.go +++ b/x/staking/app_test.go @@ -40,8 +40,8 @@ func checkDelegation( } func TestStakingMsgs(t *testing.T) { - genTokens := sdk.TokensFromConsensusPower(42) - bondTokens := sdk.TokensFromConsensusPower(10) + genTokens := sdk.TokensFromConsensusPower(42, sdk.DefaultPowerReduction) + bondTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) genCoin := sdk.NewCoin(sdk.DefaultBondDenom, genTokens) bondCoin := sdk.NewCoin(sdk.DefaultBondDenom, bondTokens) diff --git a/x/staking/client/cli/tx.go b/x/staking/client/cli/tx.go index 10ceba6a45..9b79fd3186 100644 --- a/x/staking/client/cli/tx.go +++ b/x/staking/client/cli/tx.go @@ -19,7 +19,7 @@ import ( // default values var ( - DefaultTokens = sdk.TokensFromConsensusPower(100) + DefaultTokens = sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) defaultAmount = DefaultTokens.String() + sdk.DefaultBondDenom defaultCommissionRate = "0.1" defaultCommissionMaxRate = "0.2" diff --git a/x/staking/common_test.go b/x/staking/common_test.go index 0c26e6830d..5d8897b1c0 100644 --- a/x/staking/common_test.go +++ b/x/staking/common_test.go @@ -15,7 +15,7 @@ import ( ) func init() { - sdk.PowerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)) + sdk.DefaultPowerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)) } // nolint:deadcode,unused,varcheck diff --git a/x/staking/genesis.go b/x/staking/genesis.go index 02f6bc3174..2f2eb5bba9 100644 --- a/x/staking/genesis.go +++ b/x/staking/genesis.go @@ -143,7 +143,7 @@ func InitGenesis( panic(fmt.Sprintf("validator %s not found", lv.Address)) } - update := validator.ABCIValidatorUpdate() + update := validator.ABCIValidatorUpdate(keeper.PowerReduction(ctx)) update.Power = lv.Power // keep the next-val-set offset, use the last power for the first block res = append(res, update) } @@ -210,7 +210,7 @@ func WriteValidators(ctx sdk.Context, keeper keeper.Keeper) (vals []tmtypes.Gene vals = append(vals, tmtypes.GenesisValidator{ Address: sdk.ConsAddress(tmPk.Address()).Bytes(), PubKey: tmPk, - Power: validator.GetConsensusPower(), + Power: validator.GetConsensusPower(keeper.PowerReduction(ctx)), Name: validator.GetMoniker(), }) diff --git a/x/staking/genesis_test.go b/x/staking/genesis_test.go index 28e3dec8a0..4c4bf97847 100644 --- a/x/staking/genesis_test.go +++ b/x/staking/genesis_test.go @@ -23,7 +23,7 @@ func bootstrapGenesisTest(t *testing.T, power int64, numAddrs int) (*simapp.SimA addrDels, _ := generateAddresses(app, ctx, numAddrs, sdk.NewInt(10000)) - amt := sdk.TokensFromConsensusPower(power) + amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels))))) 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) { app, ctx, addrs := bootstrapGenesisTest(t, 1000, 10) - valTokens := sdk.TokensFromConsensusPower(1) + valTokens := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction) params := app.StakingKeeper.GetParams(ctx) validators := make([]types.Validator, 2) @@ -91,7 +91,7 @@ func TestInitGenesis(t *testing.T) { abcivals := make([]abci.ValidatorUpdate, len(vals)) for i, val := range validators { - abcivals[i] = val.ABCIValidatorUpdate() + abcivals[i] = val.ABCIValidatorUpdate(sdk.DefaultPowerReduction) } require.Equal(t, abcivals, vals) @@ -113,9 +113,9 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) { require.NoError(t, err) validators[i].Status = types.Bonded - tokens := sdk.TokensFromConsensusPower(1) + tokens := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction) if i < 100 { - tokens = sdk.TokensFromConsensusPower(2) + tokens = sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) } validators[i].Tokens = tokens validators[i].DelegatorShares = tokens.ToDec() @@ -126,7 +126,7 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) { abcivals := make([]abci.ValidatorUpdate, 100) for i, val := range validators[:100] { - abcivals[i] = val.ABCIValidatorUpdate() + abcivals[i] = val.ABCIValidatorUpdate(sdk.DefaultPowerReduction) } require.Equal(t, abcivals, vals) diff --git a/x/staking/handler_test.go b/x/staking/handler_test.go index 4b48f09427..07c3c23854 100644 --- a/x/staking/handler_test.go +++ b/x/staking/handler_test.go @@ -32,7 +32,7 @@ func bootstrapHandlerGenesisTest(t *testing.T, power int64, numAddrs int, accAmo addrDels, addrVals := generateAddresses(app, ctx, numAddrs, accAmount) - amt := sdk.TokensFromConsensusPower(power) + amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels))))) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) @@ -47,7 +47,7 @@ func bootstrapHandlerGenesisTest(t *testing.T, power int64, numAddrs int, accAmo func TestValidatorByPowerIndex(t *testing.T) { initPower := int64(1000000) - app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 10, sdk.TokensFromConsensusPower(initPower)) + 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) @@ -68,7 +68,7 @@ func TestValidatorByPowerIndex(t *testing.T) { // verify that the by power index exists validator, found := app.StakingKeeper.GetValidator(ctx, validatorAddr) require.True(t, found) - power := types.GetValidatorsByPowerIndexKey(validator) + power := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction) require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power)) // create a second validator keep it bonded @@ -97,11 +97,11 @@ func TestValidatorByPowerIndex(t *testing.T) { // but the new power record should have been created validator, found = app.StakingKeeper.GetValidator(ctx, validatorAddr) require.True(t, found) - power2 := types.GetValidatorsByPowerIndexKey(validator) + power2 := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction) require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power2)) // now the new record power index should be the same as the original record - power3 := types.GetValidatorsByPowerIndexKey(validator) + power3 := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction) require.Equal(t, power2, power3) // unbond self-delegation @@ -124,7 +124,7 @@ func TestValidatorByPowerIndex(t *testing.T) { func TestDuplicatesMsgCreateValidator(t *testing.T) { initPower := int64(1000000) - app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 10, sdk.TokensFromConsensusPower(initPower)) + app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 10, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) addr1, addr2 := valAddrs[0], valAddrs[1] pk1, pk2 := PKs[0], PKs[1] @@ -172,7 +172,7 @@ func TestDuplicatesMsgCreateValidator(t *testing.T) { func TestInvalidPubKeyTypeMsgCreateValidator(t *testing.T) { initPower := int64(1000) - app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower)) + app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) ctx = ctx.WithConsensusParams(&abci.ConsensusParams{ Validator: &tmproto.ValidatorParams{PubKeyTypes: []string{tmtypes.ABCIPubKeyTypeEd25519}}, }) @@ -218,7 +218,7 @@ func TestBothPubKeyTypesMsgCreateValidator(t *testing.T) { func TestLegacyValidatorDelegations(t *testing.T) { initPower := int64(1000) - app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower)) + app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) valAddr := valAddrs[0] @@ -297,8 +297,8 @@ func TestLegacyValidatorDelegations(t *testing.T) { func TestIncrementsMsgDelegate(t *testing.T) { initPower := int64(1000) - initBond := sdk.TokensFromConsensusPower(initPower) - app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower)) + initBond := sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction) + app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) params := app.StakingKeeper.GetParams(ctx) validatorAddr, delegatorAddr := valAddrs[0], delAddrs[1] @@ -356,8 +356,8 @@ func TestIncrementsMsgDelegate(t *testing.T) { func TestEditValidatorDecreaseMinSelfDelegation(t *testing.T) { initPower := int64(100) - initBond := sdk.TokensFromConsensusPower(100) - app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower)) + initBond := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) + app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) validatorAddr := valAddrs[0] tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) @@ -387,9 +387,9 @@ func TestEditValidatorDecreaseMinSelfDelegation(t *testing.T) { func TestEditValidatorIncreaseMinSelfDelegationBeyondCurrentBond(t *testing.T) { initPower := int64(100) - initBond := sdk.TokensFromConsensusPower(100) + initBond := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) - app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower)) + app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) validatorAddr := valAddrs[0] tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) @@ -419,7 +419,7 @@ func TestEditValidatorIncreaseMinSelfDelegationBeyondCurrentBond(t *testing.T) { func TestIncrementsMsgUnbond(t *testing.T) { initPower := int64(1000) - app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower)) + app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) params := app.StakingKeeper.GetParams(ctx) denom := params.BondDenom @@ -491,8 +491,8 @@ func TestIncrementsMsgUnbond(t *testing.T) { errorCases := []sdk.Int{ //1<<64 - 1, // more than int64 power //1<<63 + 1, // more than int64 power - sdk.TokensFromConsensusPower(1<<63 - 1), - sdk.TokensFromConsensusPower(1 << 31), + sdk.TokensFromConsensusPower(1<<63-1, sdk.DefaultPowerReduction), + sdk.TokensFromConsensusPower(1<<31, sdk.DefaultPowerReduction), initBond, } @@ -507,8 +507,8 @@ func TestIncrementsMsgUnbond(t *testing.T) { func TestMultipleMsgCreateValidator(t *testing.T) { initPower := int64(1000) - initTokens := sdk.TokensFromConsensusPower(initPower) - app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower)) + initTokens := sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction) + app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) params := app.StakingKeeper.GetParams(ctx) blockTime := time.Now().UTC() @@ -527,7 +527,7 @@ func TestMultipleMsgCreateValidator(t *testing.T) { } // bond them all - amt := sdk.TokensFromConsensusPower(10) + amt := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) for i, validatorAddr := range validatorAddrs { tstaking.CreateValidator(validatorAddr, PKs[i], amt, true) // verify that the account is bonded @@ -577,7 +577,7 @@ func TestMultipleMsgCreateValidator(t *testing.T) { func TestMultipleMsgDelegate(t *testing.T) { initPower := int64(1000) - app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 50, sdk.TokensFromConsensusPower(initPower)) + app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 50, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) validatorAddr, delegatorAddrs := valAddrs[0], delAddrs[1:] tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) var amount int64 = 10 @@ -611,7 +611,7 @@ func TestMultipleMsgDelegate(t *testing.T) { func TestJailValidator(t *testing.T) { initPower := int64(1000) - app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower)) + app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) validatorAddr, delegatorAddr := valAddrs[0], delAddrs[1] tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) var amt int64 = 10 @@ -650,7 +650,7 @@ func TestJailValidator(t *testing.T) { func TestValidatorQueue(t *testing.T) { initPower := int64(1000) - app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower)) + app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) validatorAddr, delegatorAddr := valAddrs[0], delAddrs[1] tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) @@ -697,7 +697,7 @@ func TestValidatorQueue(t *testing.T) { func TestUnbondingPeriod(t *testing.T) { initPower := int64(1000) - app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower)) + app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) validatorAddr := valAddrs[0] tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) @@ -736,7 +736,7 @@ func TestUnbondingPeriod(t *testing.T) { func TestUnbondingFromUnbondingValidator(t *testing.T) { initPower := int64(1000) - app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower)) + app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) validatorAddr, delegatorAddr := valAddrs[0], delAddrs[1] tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) @@ -769,7 +769,7 @@ func TestUnbondingFromUnbondingValidator(t *testing.T) { func TestRedelegationPeriod(t *testing.T) { initPower := int64(1000) - app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower)) + app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) validatorAddr, validatorAddr2 := valAddrs[0], valAddrs[1] denom := app.StakingKeeper.GetParams(ctx).BondDenom tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) @@ -820,7 +820,7 @@ func TestRedelegationPeriod(t *testing.T) { func TestTransitiveRedelegation(t *testing.T) { initPower := int64(1000) - app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower)) + app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) val1, val2, val3 := valAddrs[0], valAddrs[1], valAddrs[2] blockTime := time.Now().UTC() @@ -854,7 +854,7 @@ func TestTransitiveRedelegation(t *testing.T) { func TestMultipleRedelegationAtSameTime(t *testing.T) { initPower := int64(1000) - app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower)) + app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) valAddr := valAddrs[0] valAddr2 := valAddrs[1] tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) @@ -898,7 +898,7 @@ func TestMultipleRedelegationAtSameTime(t *testing.T) { func TestMultipleRedelegationAtUniqueTimes(t *testing.T) { initPower := int64(1000) - app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower)) + app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) valAddr := valAddrs[0] valAddr2 := valAddrs[1] tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) @@ -945,7 +945,7 @@ func TestMultipleRedelegationAtUniqueTimes(t *testing.T) { func TestMultipleUnbondingDelegationAtSameTime(t *testing.T) { initPower := int64(1000) - app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower)) + app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) valAddr := valAddrs[0] tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) @@ -985,7 +985,7 @@ func TestMultipleUnbondingDelegationAtSameTime(t *testing.T) { func TestMultipleUnbondingDelegationAtUniqueTimes(t *testing.T) { initPower := int64(1000) - app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower)) + app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) valAddr := valAddrs[0] tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) @@ -1033,7 +1033,7 @@ func TestMultipleUnbondingDelegationAtUniqueTimes(t *testing.T) { func TestUnbondingWhenExcessValidators(t *testing.T) { initPower := int64(1000) - app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower)) + app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) val1 := valAddrs[0] val2 := valAddrs[1] val3 := valAddrs[2] @@ -1073,7 +1073,7 @@ func TestUnbondingWhenExcessValidators(t *testing.T) { func TestBondUnbondRedelegateSlashTwice(t *testing.T) { initPower := int64(1000) - app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower)) + app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) valA, valB, del := valAddrs[0], valAddrs[1], delAddrs[2] consAddr0 := sdk.ConsAddress(PKs[0].Address()) tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) @@ -1094,11 +1094,11 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) { tstaking.Ctx = ctx // begin unbonding 4 stake - unbondAmt := sdk.TokensFromConsensusPower(4) + unbondAmt := sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction) tstaking.Undelegate(del, valA, unbondAmt, true) // begin redelegate 6 stake - redAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(6)) + redAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction)) msgBeginRedelegate := types.NewMsgBeginRedelegate(del, valA, valB, redAmt) tstaking.Handle(msgBeginRedelegate, true) @@ -1178,11 +1178,11 @@ func TestInvalidMsg(t *testing.T) { func TestInvalidCoinDenom(t *testing.T) { initPower := int64(1000) - app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower)) + app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)) valA, valB, delAddr := valAddrs[0], valAddrs[1], delAddrs[2] tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper) - valTokens := sdk.TokensFromConsensusPower(100) + valTokens := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) invalidCoin := sdk.NewCoin("churros", valTokens) validCoin := sdk.NewCoin(sdk.DefaultBondDenom, valTokens) oneCoin := sdk.NewCoin(sdk.DefaultBondDenom, sdk.OneInt()) diff --git a/x/staking/keeper/common_test.go b/x/staking/keeper/common_test.go index 7ec4e9677c..fb07d8694e 100644 --- a/x/staking/keeper/common_test.go +++ b/x/staking/keeper/common_test.go @@ -18,7 +18,7 @@ var ( ) func init() { - sdk.PowerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)) + sdk.DefaultPowerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)) } // createTestInput Returns a simapp with custom StakingKeeper diff --git a/x/staking/keeper/delegation_test.go b/x/staking/keeper/delegation_test.go index 77f4cb8e2c..7ec6bfe521 100644 --- a/x/staking/keeper/delegation_test.go +++ b/x/staking/keeper/delegation_test.go @@ -183,7 +183,7 @@ func TestUnbondDelegation(t *testing.T) { delAddrs := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000)) valAddrs := simapp.ConvertAddrsToValAddrs(delAddrs) - startTokens := sdk.TokensFromConsensusPower(10) + startTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) require.NoError(t, @@ -207,7 +207,7 @@ func TestUnbondDelegation(t *testing.T) { delegation := types.NewDelegation(delAddrs[0], valAddrs[0], issuedShares) app.StakingKeeper.SetDelegation(ctx, delegation) - bondTokens := sdk.TokensFromConsensusPower(6) + bondTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction) amount, err := app.StakingKeeper.Unbond(ctx, delAddrs[0], valAddrs[0], bondTokens.ToDec()) require.NoError(t, err) 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)) addrVals := simapp.ConvertAddrsToValAddrs(addrDels) - startTokens := sdk.TokensFromConsensusPower(10) + startTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) bondDenom := app.StakingKeeper.BondDenom(ctx) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) @@ -310,7 +310,7 @@ func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) { addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000)) addrVals := simapp.ConvertAddrsToValAddrs(addrDels) - delTokens := sdk.TokensFromConsensusPower(10) + delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens)) //create a validator with a self-delegation @@ -358,7 +358,7 @@ func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) { app.StakingKeeper.SetDelegation(ctx, delegation) val0AccAddr := sdk.AccAddress(addrVals[0].Bytes()) - _, err = app.StakingKeeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.TokensFromConsensusPower(6).ToDec()) + _, err = app.StakingKeeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction).ToDec()) require.NoError(t, err) // end block @@ -366,14 +366,14 @@ func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) { validator, found := app.StakingKeeper.GetValidator(ctx, addrVals[0]) require.True(t, found) - require.Equal(t, sdk.TokensFromConsensusPower(14), validator.Tokens) + require.Equal(t, sdk.TokensFromConsensusPower(14, sdk.DefaultPowerReduction), validator.Tokens) require.Equal(t, types.Unbonding, validator.Status) require.True(t, validator.Jailed) } func TestUndelegateFromUnbondingValidator(t *testing.T) { _, app, ctx := createTestInput() - delTokens := sdk.TokensFromConsensusPower(10) + delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens)) addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0)) @@ -466,7 +466,7 @@ func TestUndelegateFromUnbondingValidator(t *testing.T) { func TestUndelegateFromUnbondedValidator(t *testing.T) { _, app, ctx := createTestInput() - delTokens := sdk.TokensFromConsensusPower(10) + delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens)) 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]) app.StakingKeeper.SetValidatorByConsAddr(ctx, validator) - valTokens := sdk.TokensFromConsensusPower(10) + valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) validator, issuedShares := validator.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) @@ -534,7 +534,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) { require.Equal(t, validator.Status, types.Unbonded) // unbond some of the other delegation's shares - unbondTokens := sdk.TokensFromConsensusPower(6) + unbondTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction) _, err = app.StakingKeeper.Undelegate(ctx, addrDels[1], addrVals[0], unbondTokens.ToDec()) require.NoError(t, err) @@ -550,7 +550,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) { func TestUnbondingAllDelegationFromValidator(t *testing.T) { _, app, ctx := createTestInput() - delTokens := sdk.TokensFromConsensusPower(10) + delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens)) 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]) app.StakingKeeper.SetValidatorByConsAddr(ctx, validator) - valTokens := sdk.TokensFromConsensusPower(10) + valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) validator, issuedShares := validator.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) @@ -720,7 +720,7 @@ func TestRedelegateToSameValidator(t *testing.T) { addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(0)) addrVals := simapp.ConvertAddrsToValAddrs(addrDels) - valTokens := sdk.TokensFromConsensusPower(10) + valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), valTokens)) // 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)) addrVals := simapp.ConvertAddrsToValAddrs(addrDels) - startTokens := sdk.TokensFromConsensusPower(20) + startTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction) startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens)) // add bonded tokens to pool for delegations @@ -763,7 +763,7 @@ func TestRedelegationMaxEntries(t *testing.T) { // create a validator with a self-delegation validator := teststaking.NewValidator(t, addrVals[0], PKs[0]) - valTokens := sdk.TokensFromConsensusPower(10) + valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) validator, issuedShares := validator.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) 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)) addrVals := simapp.ConvertAddrsToValAddrs(addrDels) - startTokens := sdk.TokensFromConsensusPower(30) + startTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction) startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens)) // add bonded tokens to pool for delegations @@ -823,7 +823,7 @@ func TestRedelegateSelfDelegation(t *testing.T) { validator := teststaking.NewValidator(t, addrVals[0], PKs[0]) app.StakingKeeper.SetValidatorByConsAddr(ctx, validator) - valTokens := sdk.TokensFromConsensusPower(10) + valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) validator, issuedShares := validator.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) @@ -841,7 +841,7 @@ func TestRedelegateSelfDelegation(t *testing.T) { require.Equal(t, types.Bonded, validator2.Status) // create a second delegation to validator 1 - delTokens := sdk.TokensFromConsensusPower(10) + delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) validator, issuedShares = validator.AddTokensFromDel(delTokens) require.Equal(t, delTokens, issuedShares.RoundInt()) 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)) addrVals := simapp.ConvertAddrsToValAddrs(addrDels) - startTokens := sdk.TokensFromConsensusPower(30) + startTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction) startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens)) // add bonded tokens to pool for delegations @@ -881,7 +881,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) { validator := teststaking.NewValidator(t, addrVals[0], PKs[0]) app.StakingKeeper.SetValidatorByConsAddr(ctx, validator) - valTokens := sdk.TokensFromConsensusPower(10) + valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) validator, issuedShares := validator.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) @@ -891,7 +891,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) { // create a second delegation to this validator app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator) - delTokens := sdk.TokensFromConsensusPower(10) + delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) validator, issuedShares = validator.AddTokensFromDel(delTokens) require.Equal(t, delTokens, issuedShares.RoundInt()) validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) @@ -933,7 +933,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) { ctx = ctx.WithBlockHeader(header) // unbond some of the other delegation's shares - redelegateTokens := sdk.TokensFromConsensusPower(6) + redelegateTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction) _, err = app.StakingKeeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], redelegateTokens.ToDec()) require.NoError(t, err) @@ -951,7 +951,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) { addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0)) addrVals := simapp.ConvertAddrsToValAddrs(addrDels) - startTokens := sdk.TokensFromConsensusPower(30) + startTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction) startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens)) // add bonded tokens to pool for delegations @@ -965,7 +965,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) { validator := teststaking.NewValidator(t, addrVals[0], PKs[0]) app.StakingKeeper.SetValidatorByConsAddr(ctx, validator) - valTokens := sdk.TokensFromConsensusPower(10) + valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) validator, issuedShares := validator.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) @@ -975,7 +975,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) { // create a second delegation to this validator app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator) - delTokens := sdk.TokensFromConsensusPower(10) + delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) validator, issuedShares = validator.AddTokensFromDel(delTokens) require.Equal(t, delTokens, issuedShares.RoundInt()) validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) @@ -1009,7 +1009,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) { app.StakingKeeper.UnbondingToUnbonded(ctx, validator) // redelegate some of the delegation's shares - redelegationTokens := sdk.TokensFromConsensusPower(6) + redelegationTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction) _, err = app.StakingKeeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], redelegationTokens.ToDec()) require.NoError(t, err) diff --git a/x/staking/keeper/grpc_query_test.go b/x/staking/keeper/grpc_query_test.go index aa3b341b09..a1d4c88883 100644 --- a/x/staking/keeper/grpc_query_test.go +++ b/x/staking/keeper/grpc_query_test.go @@ -395,7 +395,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryUnbondingDelegation() { addrAcc2 := addrs[1] addrVal2 := vals[1].OperatorAddress - unbondingTokens := sdk.TokensFromConsensusPower(2) + unbondingTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) valAddr, err1 := sdk.ValAddressFromBech32(addrVal2) suite.NoError(err1) _, err := app.StakingKeeper.Undelegate(ctx, addrAcc2, valAddr, unbondingTokens.ToDec()) @@ -450,7 +450,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryDelegatorUnbondingDelegations() { addrAcc, addrAcc1 := addrs[0], addrs[1] addrVal, addrVal2 := vals[0].OperatorAddress, vals[1].OperatorAddress - unbondingTokens := sdk.TokensFromConsensusPower(2) + unbondingTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) valAddr1, err1 := sdk.ValAddressFromBech32(addrVal) suite.NoError(err1) _, err := app.StakingKeeper.Undelegate(ctx, addrAcc, valAddr1, unbondingTokens.ToDec()) @@ -592,12 +592,12 @@ func (suite *KeeperTestSuite) TestGRPCQueryRedelegation() { addrAcc, addrAcc1 := addrs[0], addrs[1] valAddrs := simapp.ConvertAddrsToValAddrs(addrs) val1, val2, val3, val4 := vals[0], vals[1], valAddrs[3], valAddrs[4] - delAmount := sdk.TokensFromConsensusPower(1) + delAmount := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction) _, err := app.StakingKeeper.Delegate(ctx, addrAcc1, delAmount, types.Unbonded, val1, true) suite.NoError(err) applyValidatorSetUpdates(suite.T(), ctx, app.StakingKeeper, -1) - rdAmount := sdk.TokensFromConsensusPower(1) + rdAmount := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction) _, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc1, val1.GetOperator(), val2.GetOperator(), rdAmount.ToDec()) suite.NoError(err) applyValidatorSetUpdates(suite.T(), ctx, app.StakingKeeper, -1) @@ -684,7 +684,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryValidatorUnbondingDelegations() { val1 := vals[0] // undelegate - undelAmount := sdk.TokensFromConsensusPower(2) + undelAmount := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) _, err := app.StakingKeeper.Undelegate(ctx, addrAcc1, val1.GetOperator(), undelAmount.ToDec()) suite.NoError(err) 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) { - addrs := simapp.AddTestAddrsIncremental(app, ctx, 5, sdk.TokensFromConsensusPower(300)) + addrs := simapp.AddTestAddrsIncremental(app, ctx, 5, sdk.TokensFromConsensusPower(300, sdk.DefaultPowerReduction)) valAddrs := simapp.ConvertAddrsToValAddrs(addrs) pks := simapp.CreateTestPubKeys(5) 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, val2) - _, err := app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0]), types.Unbonded, val1, true) + _, err := app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0], sdk.DefaultPowerReduction), types.Unbonded, val1, true) require.NoError(t, err) - _, err = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1]), types.Unbonded, val2, true) + _, err = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1], sdk.DefaultPowerReduction), types.Unbonded, val2, true) require.NoError(t, err) - _, err = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[2]), types.Unbonded, val2, true) + _, err = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[2], sdk.DefaultPowerReduction), types.Unbonded, val2, true) require.NoError(t, err) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1) diff --git a/x/staking/keeper/historical_info.go b/x/staking/keeper/historical_info.go index 20c5a8ce85..f56f49eb14 100644 --- a/x/staking/keeper/historical_info.go +++ b/x/staking/keeper/historical_info.go @@ -91,7 +91,7 @@ func (k Keeper) TrackHistoricalInfo(ctx sdk.Context) { // Create HistoricalInfo struct lastVals := k.GetLastValidators(ctx) - historicalEntry := types.NewHistoricalInfo(ctx.BlockHeader(), lastVals) + historicalEntry := types.NewHistoricalInfo(ctx.BlockHeader(), lastVals, k.PowerReduction(ctx)) // Set latest HistoricalInfo at current height k.SetHistoricalInfo(ctx, ctx.BlockHeight(), &historicalEntry) diff --git a/x/staking/keeper/historical_info_test.go b/x/staking/keeper/historical_info_test.go index a9411d0db9..b31407cf8e 100644 --- a/x/staking/keeper/historical_info_test.go +++ b/x/staking/keeper/historical_info_test.go @@ -25,7 +25,7 @@ func TestHistoricalInfo(t *testing.T) { validators[i] = teststaking.NewValidator(t, valAddr, PKs[i]) } - hi := types.NewHistoricalInfo(ctx.BlockHeader(), validators) + hi := types.NewHistoricalInfo(ctx.BlockHeader(), validators, sdk.DefaultPowerReduction) app.StakingKeeper.SetHistoricalInfo(ctx, 2, &hi) 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[1], PKs[1]), } - hi4 := types.NewHistoricalInfo(h4, valSet) - hi5 := types.NewHistoricalInfo(h5, valSet) + hi4 := types.NewHistoricalInfo(h4, valSet, sdk.DefaultPowerReduction) + hi5 := types.NewHistoricalInfo(h5, valSet, sdk.DefaultPowerReduction) app.StakingKeeper.SetHistoricalInfo(ctx, 4, &hi4) app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi5) recv, found := app.StakingKeeper.GetHistoricalInfo(ctx, 4) diff --git a/x/staking/keeper/invariants.go b/x/staking/keeper/invariants.go index e21de8f951..3516316f6c 100644 --- a/x/staking/keeper/invariants.go +++ b/x/staking/keeper/invariants.go @@ -105,13 +105,13 @@ func NonNegativePowerInvariant(k Keeper) sdk.Invariant { panic(fmt.Sprintf("validator record not found for address: %X\n", iterator.Value())) } - powerKey := types.GetValidatorsByPowerIndexKey(validator) + powerKey := types.GetValidatorsByPowerIndexKey(validator, k.PowerReduction(ctx)) if !bytes.Equal(iterator.Key(), powerKey) { broken = true msg += fmt.Sprintf("power store invariance:\n\tvalidator.Power: %v"+ "\n\tkey should be: %v\n\tkey in store: %v\n", - validator.GetConsensusPower(), powerKey, iterator.Key()) + validator.GetConsensusPower(k.PowerReduction(ctx)), powerKey, iterator.Key()) } if validator.Tokens.IsNegative() { diff --git a/x/staking/keeper/keeper_test.go b/x/staking/keeper/keeper_test.go index 2f9819989f..bc0825a8e7 100644 --- a/x/staking/keeper/keeper_test.go +++ b/x/staking/keeper/keeper_test.go @@ -45,7 +45,7 @@ func (suite *KeeperTestSuite) SetupTest() { // have its order changed sortedVals := make([]types.Validator, len(validators)) copy(sortedVals, validators) - hi := types.NewHistoricalInfo(header, sortedVals) + hi := types.NewHistoricalInfo(header, sortedVals, sdk.DefaultPowerReduction) app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi) suite.app, suite.ctx, suite.queryClient, suite.addrs, suite.vals = app, ctx, queryClient, addrs, validators diff --git a/x/staking/keeper/params.go b/x/staking/keeper/params.go index 7fe0a8d098..37c433415b 100644 --- a/x/staking/keeper/params.go +++ b/x/staking/keeper/params.go @@ -39,6 +39,13 @@ func (k Keeper) BondDenom(ctx sdk.Context) (res string) { return } +// PowerReduction - is the amount of staking tokens required for 1 unit of consensus-engine power +// governance can update it on a running chain +func (k Keeper) PowerReduction(ctx sdk.Context) (res sdk.Int) { + k.paramstore.Get(ctx, types.KeyPowerReduction, &res) + return +} + // Get all parameteras as types.Params func (k Keeper) GetParams(ctx sdk.Context) types.Params { return types.NewParams( @@ -47,6 +54,7 @@ func (k Keeper) GetParams(ctx sdk.Context) types.Params { k.MaxEntries(ctx), k.HistoricalEntries(ctx), k.BondDenom(ctx), + k.PowerReduction(ctx), ) } diff --git a/x/staking/keeper/power_reduction.go b/x/staking/keeper/power_reduction.go new file mode 100644 index 0000000000..d979228b36 --- /dev/null +++ b/x/staking/keeper/power_reduction.go @@ -0,0 +1,15 @@ +package keeper + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" +) + +// TokensToConsensusPower - convert input tokens to potential consensus-engine power +func (k Keeper) TokensToConsensusPower(ctx sdk.Context, tokens sdk.Int) int64 { + return sdk.TokensToConsensusPower(tokens, k.PowerReduction(ctx)) +} + +// TokensFromConsensusPower - convert input power to tokens +func (k Keeper) TokensFromConsensusPower(ctx sdk.Context, power int64) sdk.Int { + return sdk.TokensFromConsensusPower(power, k.PowerReduction(ctx)) +} diff --git a/x/staking/keeper/power_reduction_test.go b/x/staking/keeper/power_reduction_test.go new file mode 100644 index 0000000000..df54a0358f --- /dev/null +++ b/x/staking/keeper/power_reduction_test.go @@ -0,0 +1,21 @@ +package keeper_test + +import ( + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" +) + +func (suite *KeeperTestSuite) TestPowerReductionChange(t *testing.T) { + // TODO: Implement! +} + +func (suite *KeeperTestSuite) TestTokensToConsensusPower() { + suite.Require().Equal(int64(0), suite.app.StakingKeeper.TokensToConsensusPower(suite.ctx, sdk.NewInt(999_999))) + suite.Require().Equal(int64(1), suite.app.StakingKeeper.TokensToConsensusPower(suite.ctx, sdk.NewInt(1_000_000))) +} + +func (suite *KeeperTestSuite) TestTokensFromConsensusPower() { + 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)) +} diff --git a/x/staking/keeper/querier_test.go b/x/staking/keeper/querier_test.go index 0b194bd6dc..14cd841f2e 100644 --- a/x/staking/keeper/querier_test.go +++ b/x/staking/keeper/querier_test.go @@ -37,7 +37,7 @@ func TestNewQuerier(t *testing.T) { ChainID: "HelloChain", Height: 5, } - hi := types.NewHistoricalInfo(header, validators[:]) + hi := types.NewHistoricalInfo(header, validators[:], sdk.DefaultPowerReduction) app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi) query := abci.RequestQuery{ @@ -140,7 +140,7 @@ func TestQueryValidators(t *testing.T) { legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino()) querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino) - addrs := simapp.AddTestAddrs(app, ctx, 500, sdk.TokensFromConsensusPower(10000)) + addrs := simapp.AddTestAddrs(app, ctx, 500, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)) // Create Validators 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()) querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino) - addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000)) + addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)) addrAcc1, addrAcc2 := addrs[0], addrs[1] addrVal1, addrVal2 := sdk.ValAddress(addrAcc1), sdk.ValAddress(addrAcc2) @@ -224,7 +224,7 @@ func TestQueryDelegation(t *testing.T) { app.StakingKeeper.SetValidator(ctx, val2) app.StakingKeeper.SetValidatorByPowerIndex(ctx, val2) - delTokens := sdk.TokensFromConsensusPower(20) + delTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction) _, err := app.StakingKeeper.Delegate(ctx, addrAcc2, delTokens, types.Unbonded, val1, true) 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) // Query unbonding delegation - unbondingTokens := sdk.TokensFromConsensusPower(10) + unbondingTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) _, err = app.StakingKeeper.Undelegate(ctx, addrAcc2, val1.GetOperator(), unbondingTokens.ToDec()) require.NoError(t, err) @@ -401,7 +401,7 @@ func TestQueryDelegation(t *testing.T) { require.Error(t, err) // Query redelegation - redelegationTokens := sdk.TokensFromConsensusPower(10) + redelegationTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) _, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(), val2.GetOperator(), redelegationTokens.ToDec()) require.NoError(t, err) @@ -456,7 +456,7 @@ func TestQueryValidatorDelegations_Pagination(t *testing.T) { legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino()) querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino) - addrs := simapp.AddTestAddrs(app, ctx, 100, sdk.TokensFromConsensusPower(10000)) + addrs := simapp.AddTestAddrs(app, ctx, 100, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)) pubKeys := simapp.CreateTestPubKeys(1) valAddress := sdk.ValAddress(addrs[0]) @@ -472,7 +472,7 @@ func TestQueryValidatorDelegations_Pagination(t *testing.T) { t.Error("expected validator not found") } - delTokens := sdk.TokensFromConsensusPower(20) + delTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction) _, err := app.StakingKeeper.Delegate(ctx, addr, delTokens, types.Unbonded, validator, true) require.NoError(t, err) } @@ -506,7 +506,7 @@ func TestQueryValidatorDelegations_Pagination(t *testing.T) { // Undelegate for _, addr := range addrs { - delTokens := sdk.TokensFromConsensusPower(20) + delTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction) _, err := app.StakingKeeper.Undelegate(ctx, addr, val1.GetOperator(), delTokens.ToDec()) require.NoError(t, err) } @@ -541,7 +541,7 @@ func TestQueryRedelegations(t *testing.T) { legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino()) querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino) - addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000)) + addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)) addrAcc1, addrAcc2 := addrs[0], addrs[1] 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, val2) - delAmount := sdk.TokensFromConsensusPower(100) + delAmount := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) _, err := app.StakingKeeper.Delegate(ctx, addrAcc2, delAmount, types.Unbonded, val1, true) require.NoError(t, err) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1) - rdAmount := sdk.TokensFromConsensusPower(20) + rdAmount := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction) _, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(), val2.GetOperator(), rdAmount.ToDec()) require.NoError(t, err) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1) @@ -613,7 +613,7 @@ func TestQueryUnbondingDelegation(t *testing.T) { legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino()) querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino) - addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000)) + addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)) addrAcc1, addrAcc2 := addrs[0], addrs[1] addrVal1 := sdk.ValAddress(addrAcc1) @@ -622,13 +622,13 @@ func TestQueryUnbondingDelegation(t *testing.T) { app.StakingKeeper.SetValidator(ctx, val1) // delegate - delAmount := sdk.TokensFromConsensusPower(100) + delAmount := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) _, err := app.StakingKeeper.Delegate(ctx, addrAcc1, delAmount, types.Unbonded, val1, true) require.NoError(t, err) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1) // undelegate - undelAmount := sdk.TokensFromConsensusPower(20) + undelAmount := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction) _, err = app.StakingKeeper.Undelegate(ctx, addrAcc1, val1.GetOperator(), undelAmount.ToDec()) require.NoError(t, err) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1) @@ -709,7 +709,7 @@ func TestQueryHistoricalInfo(t *testing.T) { legacyQuerierCdc := codec.NewAminoCodec(cdc) querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino) - addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000)) + addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)) addrAcc1, addrAcc2 := addrs[0], addrs[1] addrVal1, addrVal2 := sdk.ValAddress(addrAcc1), sdk.ValAddress(addrAcc2) @@ -724,7 +724,7 @@ func TestQueryHistoricalInfo(t *testing.T) { ChainID: "HelloChain", Height: 5, } - hi := types.NewHistoricalInfo(header, vals) + hi := types.NewHistoricalInfo(header, vals, sdk.DefaultPowerReduction) app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi) queryHistoricalParams := types.QueryHistoricalInfoRequest{Height: 4} diff --git a/x/staking/keeper/slash.go b/x/staking/keeper/slash.go index a36f6f2e6e..42e5b383ef 100644 --- a/x/staking/keeper/slash.go +++ b/x/staking/keeper/slash.go @@ -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 := sdk.TokensFromConsensusPower(power) + amount := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) slashAmountDec := amount.ToDec().Mul(slashFactor) slashAmount := slashAmountDec.TruncateInt() diff --git a/x/staking/keeper/slash_test.go b/x/staking/keeper/slash_test.go index 356c022e4e..941a5a70be 100644 --- a/x/staking/keeper/slash_test.go +++ b/x/staking/keeper/slash_test.go @@ -22,7 +22,7 @@ func bootstrapSlashTest(t *testing.T, power int64) (*simapp.SimApp, sdk.Context, addrDels, addrVals := generateAddresses(app, ctx, 100) - amt := sdk.TokensFromConsensusPower(power) + amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels))))) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) @@ -219,12 +219,12 @@ func TestSlashAtNegativeHeight(t *testing.T) { validator, found = app.StakingKeeper.GetValidator(ctx, validator.GetOperator()) require.True(t, found) // power decreased - require.Equal(t, int64(5), validator.GetConsensusPower()) + require.Equal(t, int64(5), validator.GetConsensusPower(sdk.DefaultPowerReduction)) // pool bonded shares decreased newBondedPoolBalances := app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress()) diffTokens := oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx)) - require.Equal(t, sdk.TokensFromConsensusPower(5).String(), diffTokens.String()) + require.Equal(t, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction).String(), diffTokens.String()) } // tests Slash at the current height @@ -250,12 +250,12 @@ func TestSlashValidatorAtCurrentHeight(t *testing.T) { validator, found = app.StakingKeeper.GetValidator(ctx, validator.GetOperator()) assert.True(t, found) // power decreased - require.Equal(t, int64(5), validator.GetConsensusPower()) + require.Equal(t, int64(5), validator.GetConsensusPower(sdk.DefaultPowerReduction)) // pool bonded shares decreased newBondedPoolBalances := app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress()) diffTokens := oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx)) - require.Equal(t, sdk.TokensFromConsensusPower(5).String(), diffTokens.String()) + require.Equal(t, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction).String(), diffTokens.String()) } // 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 // unbonding delegation shouldn't be slashed - ubdTokens := sdk.TokensFromConsensusPower(4) + ubdTokens := sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction) ubd := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11, time.Unix(0, 0), ubdTokens) app.StakingKeeper.SetUnbondingDelegation(ctx, ubd) @@ -290,12 +290,12 @@ func TestSlashWithUnbondingDelegation(t *testing.T) { require.Len(t, ubd.Entries, 1) // balance decreased - require.Equal(t, sdk.TokensFromConsensusPower(2), ubd.Entries[0].Balance) + require.Equal(t, sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction), ubd.Entries[0].Balance) // bonded tokens burned newBondedPoolBalances := app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress()) diffTokens := oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx)) - require.Equal(t, sdk.TokensFromConsensusPower(3), diffTokens) + require.Equal(t, sdk.TokensFromConsensusPower(3, sdk.DefaultPowerReduction), diffTokens) // read updated validator 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 // bonded at the time of discovery hadn't been bonded at the time of infraction // and wasn't slashed - require.Equal(t, int64(7), validator.GetConsensusPower()) + require.Equal(t, int64(7), validator.GetConsensusPower(sdk.DefaultPowerReduction)) // slash validator again ctx = ctx.WithBlockHeight(13) @@ -321,14 +321,14 @@ func TestSlashWithUnbondingDelegation(t *testing.T) { // bonded tokens burned again newBondedPoolBalances = app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress()) diffTokens = oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx)) - require.Equal(t, sdk.TokensFromConsensusPower(6), diffTokens) + require.Equal(t, sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction), diffTokens) // read updated validator validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) // power decreased by 3 again - require.Equal(t, int64(4), validator.GetConsensusPower()) + require.Equal(t, int64(4), validator.GetConsensusPower(sdk.DefaultPowerReduction)) // slash validator again // 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 newBondedPoolBalances = app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress()) diffTokens = oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx)) - require.Equal(t, sdk.TokensFromConsensusPower(9), diffTokens) + require.Equal(t, sdk.TokensFromConsensusPower(9, sdk.DefaultPowerReduction), diffTokens) // read updated validator validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) // power decreased by 3 again - require.Equal(t, int64(1), validator.GetConsensusPower()) + require.Equal(t, int64(1), validator.GetConsensusPower(sdk.DefaultPowerReduction)) // slash validator again // 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 newBondedPoolBalances = app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress()) diffTokens = oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx)) - require.Equal(t, sdk.TokensFromConsensusPower(10), diffTokens) + require.Equal(t, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction), diffTokens) // apply TM updates applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1) @@ -394,7 +394,7 @@ func TestSlashWithRedelegation(t *testing.T) { bondDenom := app.StakingKeeper.BondDenom(ctx) // set a redelegation - rdTokens := sdk.TokensFromConsensusPower(6) + rdTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction) rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11, time.Unix(0, 0), rdTokens, rdTokens.ToDec()) app.StakingKeeper.SetRedelegation(ctx, rd) @@ -424,7 +424,7 @@ func TestSlashWithRedelegation(t *testing.T) { require.True(t, found) require.NotPanics(t, func() { app.StakingKeeper.Slash(ctx, consAddr, 10, 10, fraction) }) - burnAmount := sdk.TokensFromConsensusPower(10).ToDec().Mul(fraction).TruncateInt() + burnAmount := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec().Mul(fraction).TruncateInt() bondedPool = app.StakingKeeper.GetBondedPool(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 // bonded at the time of discovery hadn't been bonded at the time of infraction // and wasn't slashed - require.Equal(t, int64(8), validator.GetConsensusPower()) + require.Equal(t, int64(8), validator.GetConsensusPower(sdk.DefaultPowerReduction)) // slash the validator again validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) require.NotPanics(t, func() { app.StakingKeeper.Slash(ctx, consAddr, 10, 10, sdk.OneDec()) }) - burnAmount = sdk.TokensFromConsensusPower(7) + burnAmount = sdk.TokensFromConsensusPower(7, sdk.DefaultPowerReduction) // read updated pool bondedPool = app.StakingKeeper.GetBondedPool(ctx) @@ -481,7 +481,7 @@ func TestSlashWithRedelegation(t *testing.T) { validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) // power decreased by 4 - require.Equal(t, int64(4), validator.GetConsensusPower()) + require.Equal(t, int64(4), validator.GetConsensusPower(sdk.DefaultPowerReduction)) // slash the validator again, by 100% 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()) }) - burnAmount = sdk.TokensFromConsensusPower(10).ToDec().Mul(sdk.OneDec()).TruncateInt() + burnAmount = sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec().Mul(sdk.OneDec()).TruncateInt() burnAmount = burnAmount.Sub(sdk.OneDec().MulInt(rdTokens).TruncateInt()) // read updated pool @@ -550,7 +550,7 @@ func TestSlashBoth(t *testing.T) { // set a redelegation with expiration timestamp beyond which the // redelegation shouldn't be slashed - rdATokens := sdk.TokensFromConsensusPower(6) + rdATokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction) rdA := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11, time.Unix(0, 0), rdATokens, rdATokens.ToDec()) @@ -562,7 +562,7 @@ func TestSlashBoth(t *testing.T) { // set an unbonding delegation with expiration timestamp (beyond which the // unbonding delegation shouldn't be slashed) - ubdATokens := sdk.TokensFromConsensusPower(4) + ubdATokens := sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction) ubdA := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11, time.Unix(0, 0), ubdATokens) app.StakingKeeper.SetUnbondingDelegation(ctx, ubdA) @@ -593,7 +593,7 @@ func TestSlashBoth(t *testing.T) { app.StakingKeeper.Slash(ctx, consAddr0, 10, 10, fraction) burnedNotBondedAmount := fraction.MulInt(ubdATokens).TruncateInt() - burnedBondAmount := sdk.TokensFromConsensusPower(10).ToDec().Mul(fraction).TruncateInt() + burnedBondAmount := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec().Mul(fraction).TruncateInt() burnedBondAmount = burnedBondAmount.Sub(burnedNotBondedAmount) // read updated pool @@ -614,5 +614,5 @@ func TestSlashBoth(t *testing.T) { validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(PKs[0])) require.True(t, found) // power not decreased, all stake was bonded since - require.Equal(t, int64(10), validator.GetConsensusPower()) + require.Equal(t, int64(10), validator.GetConsensusPower(sdk.DefaultPowerReduction)) } diff --git a/x/staking/keeper/val_state_change.go b/x/staking/keeper/val_state_change.go index f06994f44f..b8e1c3d458 100644 --- a/x/staking/keeper/val_state_change.go +++ b/x/staking/keeper/val_state_change.go @@ -135,7 +135,7 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab // if we get to a zero-power validator (which we don't bond), // there are no more possible bonded validators - if validator.PotentialConsensusPower() == 0 { + if validator.PotentialConsensusPower(k.PowerReduction(ctx)) == 0 { break } @@ -164,12 +164,12 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab copy(valAddrBytes[:], valAddr[:]) oldPowerBytes, found := last[valAddrBytes] - newPower := validator.ConsensusPower() + newPower := validator.ConsensusPower(k.PowerReduction(ctx)) newPowerBytes := k.cdc.MustMarshalBinaryBare(&gogotypes.Int64Value{Value: newPower}) // update the validator set if power has changed if !found || !bytes.Equal(oldPowerBytes, newPowerBytes) { - updates = append(updates, validator.ABCIValidatorUpdate()) + updates = append(updates, validator.ABCIValidatorUpdate(k.PowerReduction(ctx))) k.SetLastValidatorPower(ctx, valAddr, newPower) } diff --git a/x/staking/keeper/validator.go b/x/staking/keeper/validator.go index edb00ddba5..591ab374d7 100644 --- a/x/staking/keeper/validator.go +++ b/x/staking/keeper/validator.go @@ -118,19 +118,19 @@ func (k Keeper) SetValidatorByPowerIndex(ctx sdk.Context, validator types.Valida } store := ctx.KVStore(k.storeKey) - store.Set(types.GetValidatorsByPowerIndexKey(validator), validator.GetOperator()) + store.Set(types.GetValidatorsByPowerIndexKey(validator, k.PowerReduction(ctx)), validator.GetOperator()) } // validator index func (k Keeper) DeleteValidatorByPowerIndex(ctx sdk.Context, validator types.Validator) { store := ctx.KVStore(k.storeKey) - store.Delete(types.GetValidatorsByPowerIndexKey(validator)) + store.Delete(types.GetValidatorsByPowerIndexKey(validator, k.PowerReduction(ctx))) } // validator index func (k Keeper) SetNewValidatorByPowerIndex(ctx sdk.Context, validator types.Validator) { store := ctx.KVStore(k.storeKey) - store.Set(types.GetValidatorsByPowerIndexKey(validator), validator.GetOperator()) + store.Set(types.GetValidatorsByPowerIndexKey(validator, k.PowerReduction(ctx)), validator.GetOperator()) } // Update the tokens of an existing validator, update the validators power index key @@ -210,7 +210,7 @@ func (k Keeper) RemoveValidator(ctx sdk.Context, address sdk.ValAddress) { store := ctx.KVStore(k.storeKey) store.Delete(types.GetValidatorKey(address)) store.Delete(types.GetValidatorByConsAddrKey(valConsAddr)) - store.Delete(types.GetValidatorsByPowerIndexKey(validator)) + store.Delete(types.GetValidatorsByPowerIndexKey(validator, k.PowerReduction(ctx))) // call hooks k.AfterValidatorRemoved(ctx, valConsAddr, validator.GetOperator()) diff --git a/x/staking/keeper/validator_test.go b/x/staking/keeper/validator_test.go index ae98c177ef..4d847977c9 100644 --- a/x/staking/keeper/validator_test.go +++ b/x/staking/keeper/validator_test.go @@ -30,7 +30,7 @@ func bootstrapValidatorTest(t *testing.T, power int64, numAddrs int) (*simapp.Si addrDels, addrVals := generateAddresses(app, ctx, numAddrs) - amt := sdk.TokensFromConsensusPower(power) + amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels))))) 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)) for i, power := range powers { vs[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i]) - tokens := sdk.TokensFromConsensusPower(power) + tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) vs[i], _ = vs[i].AddTokensFromDel(tokens) } return app, ctx, addrs, valAddrs, vs @@ -60,7 +60,7 @@ func TestSetValidator(t *testing.T) { valPubKey := PKs[0] valAddr := sdk.ValAddress(valPubKey.Address().Bytes()) - valTokens := sdk.TokensFromConsensusPower(10) + valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) // test how the validator is set from a purely unbonbed pool validator := teststaking.NewValidator(t, valAddr, valPubKey) @@ -75,7 +75,7 @@ func TestSetValidator(t *testing.T) { updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1) validator, found := app.StakingKeeper.GetValidator(ctx, valAddr) require.True(t, found) - require.Equal(t, validator.ABCIValidatorUpdate(), updates[0]) + require.Equal(t, validator.ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) // after the save the validator should be bonded require.Equal(t, types.Bonded, validator.Status) @@ -114,10 +114,10 @@ func TestUpdateValidatorByPowerIndex(t *testing.T) { bondedPool := app.StakingKeeper.GetBondedPool(ctx) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) - err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234)))) + err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234, sdk.DefaultPowerReduction)))) require.NoError(t, err) - err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000)))) + err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)))) require.NoError(t, err) app.AccountKeeper.SetModuleAccount(ctx, bondedPool) @@ -125,28 +125,28 @@ func TestUpdateValidatorByPowerIndex(t *testing.T) { // add a validator validator := teststaking.NewValidator(t, addrVals[0], PKs[0]) - validator, delSharesCreated := validator.AddTokensFromDel(sdk.TokensFromConsensusPower(100)) + validator, delSharesCreated := validator.AddTokensFromDel(sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)) require.Equal(t, types.Unbonded, validator.Status) - require.Equal(t, sdk.TokensFromConsensusPower(100), validator.Tokens) + require.Equal(t, sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction), validator.Tokens) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) validator, found := app.StakingKeeper.GetValidator(ctx, addrVals[0]) require.True(t, found) - require.Equal(t, sdk.TokensFromConsensusPower(100), validator.Tokens) + require.Equal(t, sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction), validator.Tokens) - power := types.GetValidatorsByPowerIndexKey(validator) + power := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction) require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power)) // burn half the delegator shares app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator) validator, burned := validator.RemoveDelShares(delSharesCreated.Quo(sdk.NewDec(2))) - require.Equal(t, sdk.TokensFromConsensusPower(50), burned) + require.Equal(t, sdk.TokensFromConsensusPower(50, sdk.DefaultPowerReduction), burned) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) // update the validator, possibly kicking it out require.False(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power)) validator, found = app.StakingKeeper.GetValidator(ctx, addrVals[0]) require.True(t, found) - power = types.GetValidatorsByPowerIndexKey(validator) + power = types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction) require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power)) } @@ -166,10 +166,10 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) { app.StakingKeeper.SetParams(ctx, params) // create a random pool - err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234)))) + err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234, sdk.DefaultPowerReduction)))) require.NoError(t, err) - err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000)))) + err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction)))) require.NoError(t, err) app.AccountKeeper.SetModuleAccount(ctx, bondedPool) @@ -179,7 +179,7 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) { for i := 0; i < len(validators); i++ { moniker := fmt.Sprintf("val#%d", int64(i)) val := newMonikerValidator(t, valAddrs[i], PKs[i], moniker) - delTokens := sdk.TokensFromConsensusPower(int64((i + 1) * 10)) + delTokens := sdk.TokensFromConsensusPower(int64((i+1)*10), sdk.DefaultPowerReduction) val, _ = val.AddTokensFromDel(delTokens) 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 // validator and next in line cliff validator app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, nextCliffVal) - shares := sdk.TokensFromConsensusPower(21) + shares := sdk.TokensFromConsensusPower(21, sdk.DefaultPowerReduction) nextCliffVal, _ = nextCliffVal.RemoveDelShares(shares.ToDec()) nextCliffVal = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, nextCliffVal, true) @@ -220,7 +220,7 @@ func TestSlashToZeroPowerRemoved(t *testing.T) { // add a validator validator := teststaking.NewValidator(t, addrVals[0], PKs[0]) - valTokens := sdk.TokensFromConsensusPower(100) + valTokens := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) 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].Status = types.Unbonded validators[i].Tokens = sdk.ZeroInt() - tokens := sdk.TokensFromConsensusPower(power) + tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) validators[i], _ = validators[i].AddTokensFromDel(tokens) } - assert.Equal(t, sdk.TokensFromConsensusPower(9), validators[0].Tokens) - assert.Equal(t, sdk.TokensFromConsensusPower(8), validators[1].Tokens) - assert.Equal(t, sdk.TokensFromConsensusPower(7), validators[2].Tokens) + assert.Equal(t, sdk.TokensFromConsensusPower(9, sdk.DefaultPowerReduction), validators[0].Tokens) + assert.Equal(t, sdk.TokensFromConsensusPower(8, sdk.DefaultPowerReduction), validators[1].Tokens) + assert.Equal(t, sdk.TokensFromConsensusPower(7, sdk.DefaultPowerReduction), validators[2].Tokens) // check the empty keeper first _, found := app.StakingKeeper.GetValidator(ctx, addrVals[0]) @@ -292,11 +292,11 @@ func TestValidatorBasics(t *testing.T) { require.Equal(t, 1, len(resVals)) assert.True(ValEq(t, validators[0], resVals[0])) assert.Equal(t, types.Bonded, validators[0].Status) - assert.True(sdk.IntEq(t, sdk.TokensFromConsensusPower(9), validators[0].BondedTokens())) + assert.True(sdk.IntEq(t, sdk.TokensFromConsensusPower(9, sdk.DefaultPowerReduction), validators[0].BondedTokens())) // modify a records, save, and retrieve validators[0].Status = types.Bonded - validators[0].Tokens = sdk.TokensFromConsensusPower(10) + validators[0].Tokens = sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) validators[0].DelegatorShares = validators[0].Tokens.ToDec() validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], true) resVal, found = app.StakingKeeper.GetValidator(ctx, addrVals[0]) @@ -351,10 +351,10 @@ func TestGetValidatorSortingUnmixed(t *testing.T) { // initialize some validators into the state amts := []sdk.Int{ sdk.NewIntFromUint64(0), - sdk.PowerReduction.MulRaw(100), - sdk.PowerReduction, - sdk.PowerReduction.MulRaw(400), - sdk.PowerReduction.MulRaw(200)} + sdk.DefaultPowerReduction.MulRaw(100), + sdk.DefaultPowerReduction, + sdk.DefaultPowerReduction.MulRaw(400), + sdk.DefaultPowerReduction.MulRaw(200)} n := len(amts) var validators [5]types.Validator 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 resValidators := app.StakingKeeper.GetBondedValidatorsByPower(ctx) assert.Equal(t, n, len(resValidators)) - assert.Equal(t, sdk.NewInt(400).Mul(sdk.PowerReduction), resValidators[0].BondedTokens(), "%v", resValidators) - assert.Equal(t, sdk.NewInt(200).Mul(sdk.PowerReduction), resValidators[1].BondedTokens(), "%v", resValidators) - assert.Equal(t, sdk.NewInt(100).Mul(sdk.PowerReduction), resValidators[2].BondedTokens(), "%v", resValidators) - assert.Equal(t, sdk.NewInt(1).Mul(sdk.PowerReduction), resValidators[3].BondedTokens(), "%v", resValidators) + assert.Equal(t, sdk.NewInt(400).Mul(sdk.DefaultPowerReduction), resValidators[0].BondedTokens(), "%v", resValidators) + assert.Equal(t, sdk.NewInt(200).Mul(sdk.DefaultPowerReduction), resValidators[1].BondedTokens(), "%v", resValidators) + assert.Equal(t, sdk.NewInt(100).Mul(sdk.DefaultPowerReduction), resValidators[2].BondedTokens(), "%v", resValidators) + assert.Equal(t, sdk.NewInt(1).Mul(sdk.DefaultPowerReduction), resValidators[3].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[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) // test a basic increase in voting power - validators[3].Tokens = sdk.NewInt(500).Mul(sdk.PowerReduction) + validators[3].Tokens = sdk.NewInt(500).Mul(sdk.DefaultPowerReduction) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true) resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx) require.Equal(t, len(resValidators), n) assert.True(ValEq(t, validators[3], resValidators[0])) // test a decrease in voting power - validators[3].Tokens = sdk.NewInt(300).Mul(sdk.PowerReduction) + validators[3].Tokens = sdk.NewInt(300).Mul(sdk.DefaultPowerReduction) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true) resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx) require.Equal(t, len(resValidators), n) @@ -395,7 +395,7 @@ func TestGetValidatorSortingUnmixed(t *testing.T) { assert.True(ValEq(t, validators[4], resValidators[1])) // test equal voting power, different age - validators[3].Tokens = sdk.NewInt(200).Mul(sdk.PowerReduction) + validators[3].Tokens = sdk.NewInt(200).Mul(sdk.DefaultPowerReduction) ctx = ctx.WithBlockHeight(10) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true) resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx) @@ -412,8 +412,8 @@ func TestGetValidatorSortingUnmixed(t *testing.T) { assert.True(ValEq(t, validators[4], resValidators[1])) // change in voting power of both validators, both still in v-set, no age change - validators[3].Tokens = sdk.NewInt(300).Mul(sdk.PowerReduction) - validators[4].Tokens = sdk.NewInt(300).Mul(sdk.PowerReduction) + validators[3].Tokens = sdk.NewInt(300).Mul(sdk.DefaultPowerReduction) + validators[4].Tokens = sdk.NewInt(300).Mul(sdk.DefaultPowerReduction) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true) resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx) require.Equal(t, len(resValidators), n) @@ -430,10 +430,10 @@ func TestGetValidatorSortingMixed(t *testing.T) { bondedPool := app.StakingKeeper.GetBondedPool(ctx) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) - err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(501)))) + err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(501, sdk.DefaultPowerReduction)))) require.NoError(t, err) - err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(0)))) + err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(0, sdk.DefaultPowerReduction)))) require.NoError(t, err) app.AccountKeeper.SetModuleAccount(ctx, notBondedPool) @@ -447,10 +447,10 @@ func TestGetValidatorSortingMixed(t *testing.T) { // initialize some validators into the state amts := []sdk.Int{ sdk.NewIntFromUint64(0), - sdk.PowerReduction.MulRaw(100), - sdk.PowerReduction, - sdk.PowerReduction.MulRaw(400), - sdk.PowerReduction.MulRaw(200)} + sdk.DefaultPowerReduction.MulRaw(100), + sdk.DefaultPowerReduction, + sdk.DefaultPowerReduction.MulRaw(400), + sdk.DefaultPowerReduction.MulRaw(200)} var validators [5]types.Validator for i, amt := range amts { @@ -481,8 +481,8 @@ func TestGetValidatorSortingMixed(t *testing.T) { resValidators := app.StakingKeeper.GetBondedValidatorsByPower(ctx) // The validators returned should match the max validators assert.Equal(t, 2, len(resValidators)) - assert.Equal(t, sdk.NewInt(400).Mul(sdk.PowerReduction), resValidators[0].BondedTokens(), "%v", resValidators) - assert.Equal(t, sdk.NewInt(200).Mul(sdk.PowerReduction), resValidators[1].BondedTokens(), "%v", resValidators) + assert.Equal(t, sdk.NewInt(400).Mul(sdk.DefaultPowerReduction), resValidators[0].BondedTokens(), "%v", resValidators) + assert.Equal(t, sdk.NewInt(200).Mul(sdk.DefaultPowerReduction), resValidators[1].BondedTokens(), "%v", resValidators) assert.Equal(t, validators[3].OperatorAddress, resValidators[0].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)) validators[i] = newMonikerValidator(t, sdk.ValAddress(addrs[i]), PKs[i], moniker) - tokens := sdk.TokensFromConsensusPower(power) + tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) validators[i], _ = validators[i].AddTokensFromDel(tokens) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) @@ -523,7 +523,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) { // delegate 500 tokens to validator 0 app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[0]) - delTokens := sdk.TokensFromConsensusPower(500) + delTokens := sdk.TokensFromConsensusPower(500, sdk.DefaultPowerReduction) validators[0], _ = validators[0].AddTokensFromDel(delTokens) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) @@ -558,10 +558,10 @@ func TestGetValidatorsEdgeCases(t *testing.T) { validators[3], found = app.StakingKeeper.GetValidator(ctx, validators[3].GetOperator()) assert.True(t, found) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[3]) - validators[3], _ = validators[3].AddTokensFromDel(sdk.TokensFromConsensusPower(1)) + validators[3], _ = validators[3].AddTokensFromDel(sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)) notBondedPool = app.StakingKeeper.GetNotBondedPool(ctx) - newTokens = sdk.NewCoins(sdk.NewCoin(params.BondDenom, sdk.TokensFromConsensusPower(1))) + newTokens = sdk.NewCoins(sdk.NewCoin(params.BondDenom, sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction))) balances = app.BankKeeper.GetAllBalances(ctx, notBondedPool.GetAddress()) require.NoError(t, app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), balances.Add(newTokens...))) 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[2] = teststaking.NewValidator(t, sdk.ValAddress(addrs[2]), PKs[2]) - tokens0 := sdk.TokensFromConsensusPower(200) - tokens1 := sdk.TokensFromConsensusPower(100) - tokens2 := sdk.TokensFromConsensusPower(100) + tokens0 := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction) + tokens1 := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) + tokens2 := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) validators[0], _ = validators[0].AddTokensFromDel(tokens0) validators[1], _ = validators[1].AddTokensFromDel(tokens1) validators[2], _ = validators[2].AddTokensFromDel(tokens2) @@ -642,7 +642,7 @@ func TestValidatorBondHeight(t *testing.T) { assert.True(ValEq(t, validators[1], resValidators[1])) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[1]) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[2]) - delTokens := sdk.TokensFromConsensusPower(50) + delTokens := sdk.TokensFromConsensusPower(50, sdk.DefaultPowerReduction) validators[1], _ = validators[1].AddTokensFromDel(delTokens) validators[2], _ = validators[2].AddTokensFromDel(delTokens) validators[2] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[2], true) @@ -665,7 +665,7 @@ func TestFullValidatorSetPowerChange(t *testing.T) { var validators [5]types.Validator for i, power := range powers { validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i]) - tokens := sdk.TokensFromConsensusPower(power) + tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) validators[i], _ = validators[i].AddTokensFromDel(tokens) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[i], true) } @@ -686,7 +686,7 @@ func TestFullValidatorSetPowerChange(t *testing.T) { // test a swap in voting power - tokens := sdk.TokensFromConsensusPower(600) + tokens := sdk.TokensFromConsensusPower(600, sdk.DefaultPowerReduction) validators[0], _ = validators[0].AddTokensFromDel(tokens) validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], true) resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx) @@ -705,7 +705,7 @@ func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) { valAddr := sdk.ValAddress(valPubKey.Address().Bytes()) validators[i] = teststaking.NewValidator(t, valAddr, valPubKey) - tokens := sdk.TokensFromConsensusPower(power) + tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) validators[i], _ = validators[i].AddTokensFromDel(tokens) } @@ -720,8 +720,8 @@ func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) { updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2) validators[0], _ = app.StakingKeeper.GetValidator(ctx, validators[0].GetOperator()) validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator()) - assert.Equal(t, validators[0].ABCIValidatorUpdate(), updates[1]) - assert.Equal(t, validators[1].ABCIValidatorUpdate(), updates[0]) + assert.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1]) + assert.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) } func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) { @@ -732,7 +732,7 @@ func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) { for i, power := range powers { validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i]) - tokens := sdk.TokensFromConsensusPower(power) + tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) validators[i], _ = validators[i].AddTokensFromDel(tokens) } @@ -755,7 +755,7 @@ func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) { for i, power := range powers { validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i]) - tokens := sdk.TokensFromConsensusPower(power) + tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) validators[i], _ = validators[i].AddTokensFromDel(tokens) } @@ -766,11 +766,11 @@ func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) { // test single value change // tendermintUpdate set: {} -> {c1'} validators[0].Status = types.Bonded - validators[0].Tokens = sdk.TokensFromConsensusPower(600) + validators[0].Tokens = sdk.TokensFromConsensusPower(600, sdk.DefaultPowerReduction) validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false) updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1) - require.Equal(t, validators[0].ABCIValidatorUpdate(), updates[0]) + require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) } func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) { @@ -784,16 +784,16 @@ func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) { // test multiple value change // tendermintUpdate set: {c1, c3} -> {c1', c3'} - delTokens1 := sdk.TokensFromConsensusPower(190) - delTokens2 := sdk.TokensFromConsensusPower(80) + delTokens1 := sdk.TokensFromConsensusPower(190, sdk.DefaultPowerReduction) + delTokens2 := sdk.TokensFromConsensusPower(80, sdk.DefaultPowerReduction) validators[0], _ = validators[0].AddTokensFromDel(delTokens1) validators[1], _ = validators[1].AddTokensFromDel(delTokens2) validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false) validators[1] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[1], false) updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2) - require.Equal(t, validators[0].ABCIValidatorUpdate(), updates[0]) - require.Equal(t, validators[1].ABCIValidatorUpdate(), updates[1]) + require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) + require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1]) } func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) { @@ -810,7 +810,7 @@ func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) { app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[2]) updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1) validators[2], _ = app.StakingKeeper.GetValidator(ctx, validators[2].GetOperator()) - require.Equal(t, validators[2].ABCIValidatorUpdate(), updates[0]) + require.Equal(t, validators[2].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) // test validtor added at the beginning // tendermintUpdate set: {} -> {c0} @@ -818,7 +818,7 @@ func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) { app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[3]) updates = applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1) validators[3], _ = app.StakingKeeper.GetValidator(ctx, validators[3].GetOperator()) - require.Equal(t, validators[3].ABCIValidatorUpdate(), updates[0]) + require.Equal(t, validators[3].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) // test validtor added at the end // tendermintUpdate set: {} -> {c0} @@ -826,7 +826,7 @@ func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) { app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[4]) updates = applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1) validators[4], _ = app.StakingKeeper.GetValidator(ctx, validators[4].GetOperator()) - require.Equal(t, validators[4].ABCIValidatorUpdate(), updates[0]) + require.Equal(t, validators[4].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) } func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) { @@ -839,7 +839,7 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) { var validators [5]types.Validator for i, power := range powers { validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i]) - tokens := sdk.TokensFromConsensusPower(power) + tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) validators[i], _ = validators[i].AddTokensFromDel(tokens) } validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false) @@ -855,14 +855,14 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) { // tendermintUpdate set: {} -> {c0, c4} applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0) - tokens := sdk.TokensFromConsensusPower(10) + tokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) validators[2], _ = validators[2].AddTokensFromDel(tokens) app.StakingKeeper.SetValidator(ctx, validators[2]) app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[2]) updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2) validators[2], _ = app.StakingKeeper.GetValidator(ctx, validators[2].GetOperator()) require.Equal(t, validators[0].ABCIValidatorUpdateZero(), updates[1]) - require.Equal(t, validators[2].ABCIValidatorUpdate(), updates[0]) + require.Equal(t, validators[2].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) } func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) { @@ -872,7 +872,7 @@ func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) { var validators [2]types.Validator for i, power := range powers { validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i]) - tokens := sdk.TokensFromConsensusPower(power) + tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) validators[i], _ = validators[i].AddTokensFromDel(tokens) } 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) // check initial power - require.Equal(t, int64(100), validators[0].GetConsensusPower()) - require.Equal(t, int64(100), validators[1].GetConsensusPower()) + require.Equal(t, int64(100), validators[0].GetConsensusPower(sdk.DefaultPowerReduction)) + require.Equal(t, int64(100), validators[1].GetConsensusPower(sdk.DefaultPowerReduction)) // test multiple value change // tendermintUpdate set: {c1, c3} -> {c1', c3'} - delTokens1 := sdk.TokensFromConsensusPower(20) - delTokens2 := sdk.TokensFromConsensusPower(30) + delTokens1 := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction) + delTokens2 := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction) validators[0], _ = validators[0].RemoveDelShares(delTokens1.ToDec()) validators[1], _ = validators[1].RemoveDelShares(delTokens2.ToDec()) validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false) validators[1] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[1], false) // power has changed - require.Equal(t, int64(80), validators[0].GetConsensusPower()) - require.Equal(t, int64(70), validators[1].GetConsensusPower()) + require.Equal(t, int64(80), validators[0].GetConsensusPower(sdk.DefaultPowerReduction)) + require.Equal(t, int64(70), validators[1].GetConsensusPower(sdk.DefaultPowerReduction)) // Tendermint updates should reflect power change updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2) - require.Equal(t, validators[0].ABCIValidatorUpdate(), updates[0]) - require.Equal(t, validators[1].ABCIValidatorUpdate(), updates[1]) + require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) + require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1]) } func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) { @@ -918,7 +918,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) { valAddr := sdk.ValAddress(valPubKey.Address().Bytes()) validators[i] = teststaking.NewValidator(t, valAddr, valPubKey) - tokens := sdk.TokensFromConsensusPower(power) + tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) validators[i], _ = validators[i].AddTokensFromDel(tokens) app.StakingKeeper.SetValidator(ctx, validators[i]) @@ -929,8 +929,8 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) { updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, len(validators)) validators[0], _ = app.StakingKeeper.GetValidator(ctx, validators[0].GetOperator()) validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator()) - require.Equal(t, validators[0].ABCIValidatorUpdate(), updates[0]) - require.Equal(t, validators[1].ABCIValidatorUpdate(), updates[1]) + require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) + require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1]) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0) @@ -938,7 +938,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) { for i, power := range powers { app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[i]) - tokens := sdk.TokensFromConsensusPower(power) + tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) validators[i], _ = validators[i].AddTokensFromDel(tokens) app.StakingKeeper.SetValidator(ctx, validators[i]) @@ -965,7 +965,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) { valAddr = sdk.ValAddress(valPubKey.Address().Bytes()) validator = teststaking.NewValidator(t, valAddr, valPubKey) - tokens := sdk.TokensFromConsensusPower(500) + tokens := sdk.TokensFromConsensusPower(500, sdk.DefaultPowerReduction) validator, _ = validator.AddTokensFromDel(tokens) app.StakingKeeper.SetValidator(ctx, validator) app.StakingKeeper.SetValidatorByPowerIndex(ctx, validator) @@ -975,9 +975,9 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) { validator, _ = app.StakingKeeper.GetValidator(ctx, validator.GetOperator()) validators[0], _ = app.StakingKeeper.GetValidator(ctx, validators[0].GetOperator()) validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator()) - require.Equal(t, validator.ABCIValidatorUpdate(), updates[0]) - require.Equal(t, validators[0].ABCIValidatorUpdate(), updates[1]) - require.Equal(t, validators[1].ABCIValidatorUpdate(), updates[2]) + require.Equal(t, validator.ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) + require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1]) + require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[2]) } func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) { @@ -997,7 +997,7 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) { valAddr := sdk.ValAddress(valPubKey.Address().Bytes()) validators[i] = newMonikerValidator(t, valAddr, valPubKey, moniker) - tokens := sdk.TokensFromConsensusPower(power) + tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction) validators[i], _ = validators[i].AddTokensFromDel(tokens) app.StakingKeeper.SetValidator(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) validators[2], _ = app.StakingKeeper.GetValidator(ctx, validators[2].GetOperator()) validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator()) - require.Equal(t, validators[2].ABCIValidatorUpdate(), updates[0]) - require.Equal(t, validators[1].ABCIValidatorUpdate(), updates[1]) + require.Equal(t, validators[2].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) + require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1]) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0) @@ -1020,7 +1020,7 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) { require.True(t, found) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[0]) - tokens := sdk.TokensFromConsensusPower(1) + tokens := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction) validators[0], _ = validators[0].AddTokensFromDel(tokens) app.StakingKeeper.SetValidator(ctx, validators[0]) app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[0]) @@ -1042,14 +1042,14 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) { applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0) app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[1]) - tokens = sdk.TokensFromConsensusPower(250) + tokens = sdk.TokensFromConsensusPower(250, sdk.DefaultPowerReduction) validators[1], _ = validators[1].AddTokensFromDel(tokens) app.StakingKeeper.SetValidator(ctx, validators[1]) app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[1]) // verify initial Tendermint updates are correct updates = applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1) - require.Equal(t, validators[1].ABCIValidatorUpdate(), updates[0]) + require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0]) applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0) } diff --git a/x/staking/legacy/v040/migrate.go b/x/staking/legacy/v040/migrate.go index b0746fa363..87ec0000ef 100644 --- a/x/staking/legacy/v040/migrate.go +++ b/x/staking/legacy/v040/migrate.go @@ -4,6 +4,7 @@ import ( "fmt" codectypes "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" v034staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v034" v038staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v038" v040staking "github.com/cosmos/cosmos-sdk/x/staking/types" @@ -129,6 +130,7 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState { MaxEntries: uint32(stakingState.Params.MaxEntries), HistoricalEntries: uint32(stakingState.Params.HistoricalEntries), BondDenom: stakingState.Params.BondDenom, + PowerReduction: sdk.DefaultPowerReduction, }, LastTotalPower: stakingState.LastTotalPower, LastValidatorPowers: newLastValidatorPowers, diff --git a/x/staking/simulation/common_test.go b/x/staking/simulation/common_test.go index 880cb442de..e22ecd15aa 100644 --- a/x/staking/simulation/common_test.go +++ b/x/staking/simulation/common_test.go @@ -7,5 +7,5 @@ import ( ) func init() { - sdk.PowerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)) + sdk.DefaultPowerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)) } diff --git a/x/staking/simulation/genesis.go b/x/staking/simulation/genesis.go index 0c33fa9ee2..bf01b90bfe 100644 --- a/x/staking/simulation/genesis.go +++ b/x/staking/simulation/genesis.go @@ -63,7 +63,7 @@ func RandomizedGenState(simState *module.SimulationState) { // NOTE: the slashing module need to be defined after the staking module on the // NewSimulationManager constructor for this to work simState.UnbondTime = unbondTime - params := types.NewParams(simState.UnbondTime, maxVals, 7, histEntries, sdk.DefaultBondDenom) + params := types.NewParams(simState.UnbondTime, maxVals, 7, histEntries, sdk.DefaultBondDenom, sdk.DefaultPowerReduction) // validators & delegations var ( diff --git a/x/staking/simulation/genesis_test.go b/x/staking/simulation/genesis_test.go index aba85cd2bf..35e59b6c23 100644 --- a/x/staking/simulation/genesis_test.go +++ b/x/staking/simulation/genesis_test.go @@ -10,6 +10,7 @@ import ( "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec" + sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" "github.com/cosmos/cosmos-sdk/x/staking/simulation" @@ -46,6 +47,7 @@ func TestRandomizedGenState(t *testing.T) { require.Equal(t, uint32(8687), stakingGenesis.Params.HistoricalEntries) require.Equal(t, "stake", stakingGenesis.Params.BondDenom) require.Equal(t, float64(238280), stakingGenesis.Params.UnbondingTime.Seconds()) + require.Equal(t, sdk.NewInt(1000000), stakingGenesis.Params.PowerReduction) // check numbers of Delegations and Validators require.Len(t, stakingGenesis.Delegations, 3) require.Len(t, stakingGenesis.Validators, 3) diff --git a/x/staking/simulation/operations_test.go b/x/staking/simulation/operations_test.go index fca3b78125..6ca1886bf5 100644 --- a/x/staking/simulation/operations_test.go +++ b/x/staking/simulation/operations_test.go @@ -181,7 +181,7 @@ func TestSimulateMsgUndelegate(t *testing.T) { validator0 := getTestingValidator0(t, app, ctx, accounts) // setup delegation - delTokens := sdk.TokensFromConsensusPower(2) + delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) validator0, issuedShares := validator0.AddTokensFromDel(delTokens) delegator := accounts[1] delegation := types.NewDelegation(delegator.Address, validator0.GetOperator(), issuedShares) @@ -227,7 +227,7 @@ func TestSimulateMsgBeginRedelegate(t *testing.T) { validator0 := getTestingValidator0(t, app, ctx, accounts) validator1 := getTestingValidator1(t, app, ctx, accounts) - delTokens := sdk.TokensFromConsensusPower(2) + delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction) validator0, issuedShares := validator0.AddTokensFromDel(delTokens) // 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 { accounts := simtypes.RandomAccounts(r, n) - initAmt := sdk.TokensFromConsensusPower(200) + initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction) initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt)) // 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) validator.DelegatorShares = sdk.NewDec(100) - validator.Tokens = sdk.TokensFromConsensusPower(100) + validator.Tokens = sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction) app.StakingKeeper.SetValidator(ctx, validator) diff --git a/x/staking/spec/01_state.md b/x/staking/spec/01_state.md index c5f7376d76..c0aae9943b 100644 --- a/x/staking/spec/01_state.md +++ b/x/staking/spec/01_state.md @@ -19,10 +19,11 @@ and defines overall functioning of the staking module. ```go type Params struct { - UnbondingTime time.Duration // time duration of unbonding - MaxValidators uint16 // maximum number of validators - MaxEntries uint16 // max entries for either unbonding delegation or redelegation (per pair/trio) - BondDenom string // bondable coin denomination + UnbondingTime time.Duration // time duration of unbonding + MaxValidators uint16 // maximum number of validators + MaxEntries uint16 // max entries for either unbonding delegation or redelegation (per pair/trio) + BondDenom string // bondable coin denomination + PowerReduction sdk.Int // power reduction on-chain param } ``` diff --git a/x/staking/spec/08_params.md b/x/staking/spec/08_params.md index 3d87879e18..706f41fc35 100644 --- a/x/staking/spec/08_params.md +++ b/x/staking/spec/08_params.md @@ -13,3 +13,4 @@ The staking module contains the following parameters: | KeyMaxEntries | uint16 | 7 | | HistoricalEntries | uint16 | 3 | | BondDenom | string | "uatom" | +| PowerReduction | string | "1000000" | diff --git a/x/staking/teststaking/helper.go b/x/staking/teststaking/helper.go index b33118f541..607ad56ada 100644 --- a/x/staking/teststaking/helper.go +++ b/x/staking/teststaking/helper.go @@ -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 // commission func (sh *Helper) CreateValidatorWithValPower(addr sdk.ValAddress, pk cryptotypes.PubKey, valPower int64, ok bool) sdk.Int { - amount := sdk.TokensFromConsensusPower(valPower) + amount := sdk.TokensFromConsensusPower(valPower, sdk.DefaultPowerReduction) coin := sdk.NewCoin(sh.Denom, amount) sh.createValidator(addr, pk, coin, ok) 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 func (sh *Helper) DelegateWithPower(delegator sdk.AccAddress, val sdk.ValAddress, power int64) { - coin := sdk.NewCoin(sh.Denom, sdk.TokensFromConsensusPower(power)) + coin := sdk.NewCoin(sh.Denom, sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)) msg := stakingtypes.NewMsgDelegate(delegator, val, coin) sh.Handle(msg, true) } diff --git a/x/staking/teststaking/tm.go b/x/staking/teststaking/tm.go index 9a9c030d06..4c0863f593 100644 --- a/x/staking/teststaking/tm.go +++ b/x/staking/teststaking/tm.go @@ -5,6 +5,7 @@ import ( tmtypes "github.com/tendermint/tendermint/types" cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec" + sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/staking/types" ) @@ -19,21 +20,21 @@ func GetTmConsPubKey(v types.Validator) (tmcrypto.PubKey, error) { } // ToTmValidator casts an SDK validator to a tendermint type Validator. -func ToTmValidator(v types.Validator) (*tmtypes.Validator, error) { +func ToTmValidator(v types.Validator, powerReduction sdk.Int) (*tmtypes.Validator, error) { tmPk, err := GetTmConsPubKey(v) if err != nil { return nil, err } - return tmtypes.NewValidator(tmPk, v.ConsensusPower()), nil + return tmtypes.NewValidator(tmPk, v.ConsensusPower(powerReduction)), nil } // ToTmValidators casts all validators to the corresponding tendermint type. -func ToTmValidators(v types.Validators) ([]*tmtypes.Validator, error) { +func ToTmValidators(v types.Validators, powerReduction sdk.Int) ([]*tmtypes.Validator, error) { validators := make([]*tmtypes.Validator, len(v)) var err error for i, val := range v { - validators[i], err = ToTmValidator(val) + validators[i], err = ToTmValidator(val, powerReduction) if err != nil { return nil, err } diff --git a/x/staking/types/exported.go b/x/staking/types/exported.go index a02adc34ba..9599da100d 100644 --- a/x/staking/types/exported.go +++ b/x/staking/types/exported.go @@ -28,7 +28,7 @@ type ValidatorI interface { GetConsAddr() (sdk.ConsAddress, error) // validation consensus address GetTokens() sdk.Int // validation tokens GetBondedTokens() sdk.Int // validator bonded tokens - GetConsensusPower() int64 // validation power in tendermint + GetConsensusPower(sdk.Int) int64 // validation power in tendermint GetCommission() sdk.Dec // validator commission rate GetMinSelfDelegation() sdk.Int // validator minimum self delegation GetDelegatorShares() sdk.Dec // total outstanding delegator shares diff --git a/x/staking/types/historical_info.go b/x/staking/types/historical_info.go index 1a8461ad13..c06e82dc02 100644 --- a/x/staking/types/historical_info.go +++ b/x/staking/types/historical_info.go @@ -8,14 +8,18 @@ import ( "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) // NewHistoricalInfo will create a historical information struct from header and valset // it will first sort valset before inclusion into historical info -func NewHistoricalInfo(header tmproto.Header, valSet Validators) HistoricalInfo { +func NewHistoricalInfo(header tmproto.Header, valSet Validators, powerReduction sdk.Int) HistoricalInfo { // Must sort in the same way that tendermint does - sort.Sort(ValidatorsByVotingPower(valSet)) + // TODO: check with sort.Sort(ValidatorsByVotingPower(valSet)) + sort.SliceStable(valSet, func(i, j int) bool { + return ValidatorsByVotingPower(valSet).LessAfterPowerReductionApply(i, j, powerReduction) + }) return HistoricalInfo{ Header: header, diff --git a/x/staking/types/historical_info_test.go b/x/staking/types/historical_info_test.go index d8a25fa929..b465a3db6a 100644 --- a/x/staking/types/historical_info_test.go +++ b/x/staking/types/historical_info_test.go @@ -8,6 +8,7 @@ import ( "github.com/stretchr/testify/require" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" + sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/staking/types" ) @@ -26,7 +27,7 @@ func createValidators(t *testing.T) []types.Validator { func TestHistoricalInfo(t *testing.T) { validators := createValidators(t) - hi := types.NewHistoricalInfo(header, validators) + hi := types.NewHistoricalInfo(header, validators, sdk.DefaultPowerReduction) require.True(t, sort.IsSorted(types.Validators(hi.Valset)), "Validators are not sorted") var value []byte @@ -67,7 +68,7 @@ func TestValidateBasic(t *testing.T) { err = types.ValidateBasic(hi) require.Error(t, err, "ValidateBasic passed on unsorted ValSet") - hi = types.NewHistoricalInfo(header, validators) + hi = types.NewHistoricalInfo(header, validators, sdk.DefaultPowerReduction) err = types.ValidateBasic(hi) require.NoError(t, err, "ValidateBasic failed on valid HistoricalInfo") } diff --git a/x/staking/types/keys.go b/x/staking/types/keys.go index 40d62244a0..abdbe8ccff 100644 --- a/x/staking/types/keys.go +++ b/x/staking/types/keys.go @@ -69,11 +69,11 @@ func AddressFromLastValidatorPowerKey(key []byte) []byte { // Power index is the key used in the power-store, and represents the relative // power ranking of the validator. // VALUE: validator operator address ([]byte) -func GetValidatorsByPowerIndexKey(validator Validator) []byte { +func GetValidatorsByPowerIndexKey(validator Validator, powerReduction sdk.Int) []byte { // NOTE the address doesn't need to be stored because counter bytes must always be different // NOTE the larger values are of higher value - consensusPower := sdk.TokensToConsensusPower(validator.Tokens) + consensusPower := sdk.TokensToConsensusPower(validator.Tokens, powerReduction) consensusPowerBytes := make([]byte, 8) binary.BigEndian.PutUint64(consensusPowerBytes, uint64(consensusPower)) diff --git a/x/staking/types/keys_test.go b/x/staking/types/keys_test.go index 0f63617f26..0bd7a7c20b 100644 --- a/x/staking/types/keys_test.go +++ b/x/staking/types/keys_test.go @@ -28,10 +28,10 @@ func TestGetValidatorPowerRank(t *testing.T) { val1 := newValidator(t, valAddr1, keysPK1) val1.Tokens = sdk.ZeroInt() val2, val3, val4 := val1, val1, val1 - val2.Tokens = sdk.TokensFromConsensusPower(1) - val3.Tokens = sdk.TokensFromConsensusPower(10) + val2.Tokens = sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction) + val3.Tokens = sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction) x := new(big.Int).Exp(big.NewInt(2), big.NewInt(40), big.NewInt(0)) - val4.Tokens = sdk.TokensFromConsensusPower(x.Int64()) + val4.Tokens = sdk.TokensFromConsensusPower(x.Int64(), sdk.DefaultPowerReduction) tests := []struct { validator types.Validator @@ -43,7 +43,7 @@ func TestGetValidatorPowerRank(t *testing.T) { {val4, "2300000100000000009c288ede7df62742fc3b7d0962045a8cef0f79f6"}, } for i, tt := range tests { - got := hex.EncodeToString(types.GetValidatorsByPowerIndexKey(tt.validator)) + got := hex.EncodeToString(types.GetValidatorsByPowerIndexKey(tt.validator, sdk.DefaultPowerReduction)) require.Equal(t, tt.wantHex, got, "Keys did not match on test case %d", i) } diff --git a/x/staking/types/params.go b/x/staking/types/params.go index 549189fa4f..92fb0dad89 100644 --- a/x/staking/types/params.go +++ b/x/staking/types/params.go @@ -38,6 +38,7 @@ var ( KeyMaxEntries = []byte("MaxEntries") KeyBondDenom = []byte("BondDenom") KeyHistoricalEntries = []byte("HistoricalEntries") + KeyPowerReduction = []byte("PowerReduction") ) var _ paramtypes.ParamSet = (*Params)(nil) @@ -48,13 +49,14 @@ func ParamKeyTable() paramtypes.KeyTable { } // NewParams creates a new Params instance -func NewParams(unbondingTime time.Duration, maxValidators, maxEntries, historicalEntries uint32, bondDenom string) Params { +func NewParams(unbondingTime time.Duration, maxValidators, maxEntries, historicalEntries uint32, bondDenom string, powerReduction sdk.Int) Params { return Params{ UnbondingTime: unbondingTime, MaxValidators: maxValidators, MaxEntries: maxEntries, HistoricalEntries: historicalEntries, BondDenom: bondDenom, + PowerReduction: powerReduction, } } @@ -66,6 +68,7 @@ func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs { paramtypes.NewParamSetPair(KeyMaxEntries, &p.MaxEntries, validateMaxEntries), paramtypes.NewParamSetPair(KeyHistoricalEntries, &p.HistoricalEntries, validateHistoricalEntries), paramtypes.NewParamSetPair(KeyBondDenom, &p.BondDenom, validateBondDenom), + paramtypes.NewParamSetPair(KeyPowerReduction, &p.PowerReduction, validatePowerReduction), } } @@ -77,6 +80,7 @@ func DefaultParams() Params { DefaultMaxEntries, DefaultHistoricalEntries, sdk.DefaultBondDenom, + sdk.DefaultPowerReduction, ) } @@ -191,3 +195,16 @@ func validateBondDenom(i interface{}) error { return nil } + +func validatePowerReduction(i interface{}) error { + v, ok := i.(sdk.Int) + if !ok { + return fmt.Errorf("invalid parameter type: %T", i) + } + + if v.LT(sdk.NewInt(1)) { + return fmt.Errorf("power reduction cannot be lower than 1") + } + + return nil +} diff --git a/x/staking/types/validator.go b/x/staking/types/validator.go index e551e75252..5cf55db5d6 100644 --- a/x/staking/types/validator.go +++ b/x/staking/types/validator.go @@ -117,7 +117,11 @@ type ValidatorsByVotingPower []Validator func (valz ValidatorsByVotingPower) Len() int { return len(valz) } func (valz ValidatorsByVotingPower) Less(i, j int) bool { - if valz[i].ConsensusPower() == valz[j].ConsensusPower() { + return valz.LessAfterPowerReductionApply(i, j, sdk.DefaultPowerReduction) +} + +func (valz ValidatorsByVotingPower) LessAfterPowerReductionApply(i, j int, powerReduction sdk.Int) bool { + if valz[i].ConsensusPower(powerReduction) == valz[j].ConsensusPower(powerReduction) { addrI, errI := valz[i].GetConsAddr() addrJ, errJ := valz[j].GetConsAddr() // If either returns error, then return false @@ -126,7 +130,7 @@ func (valz ValidatorsByVotingPower) Less(i, j int) bool { } return bytes.Compare(addrI, addrJ) == -1 } - return valz[i].ConsensusPower() > valz[j].ConsensusPower() + return valz[i].ConsensusPower(powerReduction) > valz[j].ConsensusPower(powerReduction) } func (valz ValidatorsByVotingPower) Swap(i, j int) { @@ -257,7 +261,7 @@ func (d Description) EnsureLength() (Description, error) { // ABCIValidatorUpdate returns an abci.ValidatorUpdate from a staking validator type // with the full validator power -func (v Validator) ABCIValidatorUpdate() abci.ValidatorUpdate { +func (v Validator) ABCIValidatorUpdate(powerReduction sdk.Int) abci.ValidatorUpdate { tmProtoPk, err := v.TmConsPublicKey() if err != nil { panic(err) @@ -265,7 +269,7 @@ func (v Validator) ABCIValidatorUpdate() abci.ValidatorUpdate { return abci.ValidatorUpdate{ PubKey: tmProtoPk, - Power: v.ConsensusPower(), + Power: v.ConsensusPower(powerReduction), } } @@ -349,17 +353,17 @@ func (v Validator) BondedTokens() sdk.Int { // ConsensusPower gets the consensus-engine power. Aa reduction of 10^6 from // validator tokens is applied -func (v Validator) ConsensusPower() int64 { +func (v Validator) ConsensusPower(powerReduction sdk.Int) int64 { if v.IsBonded() { - return v.PotentialConsensusPower() + return v.PotentialConsensusPower(powerReduction) } return 0 } // PotentialConsensusPower returns the potential consensus-engine power. -func (v Validator) PotentialConsensusPower() int64 { - return sdk.TokensToConsensusPower(v.Tokens) +func (v Validator) PotentialConsensusPower(powerReduction sdk.Int) int64 { + return sdk.TokensToConsensusPower(v.Tokens, powerReduction) } // UpdateStatus updates the location of the shares within a validator @@ -505,9 +509,11 @@ func (v Validator) GetConsAddr() (sdk.ConsAddress, error) { return sdk.ConsAddress(pk.Address()), nil } -func (v Validator) GetTokens() sdk.Int { return v.Tokens } -func (v Validator) GetBondedTokens() sdk.Int { return v.BondedTokens() } -func (v Validator) GetConsensusPower() int64 { return v.ConsensusPower() } +func (v Validator) GetTokens() sdk.Int { return v.Tokens } +func (v Validator) GetBondedTokens() sdk.Int { return v.BondedTokens() } +func (v Validator) GetConsensusPower(powerReduction sdk.Int) int64 { + return v.ConsensusPower(powerReduction) +} func (v Validator) GetCommission() sdk.Dec { return v.Commission.Rate } func (v Validator) GetMinSelfDelegation() sdk.Int { return v.MinSelfDelegation } func (v Validator) GetDelegatorShares() sdk.Dec { return v.DelegatorShares } diff --git a/x/staking/types/validator_test.go b/x/staking/types/validator_test.go index 08204215d5..f7888b7e42 100644 --- a/x/staking/types/validator_test.go +++ b/x/staking/types/validator_test.go @@ -58,7 +58,7 @@ func TestUpdateDescription(t *testing.T) { func TestABCIValidatorUpdate(t *testing.T) { validator := newValidator(t, valAddr1, pk1) - abciVal := validator.ABCIValidatorUpdate() + abciVal := validator.ABCIValidatorUpdate(sdk.DefaultPowerReduction) pk, err := validator.TmConsPublicKey() require.NoError(t, err) require.Equal(t, pk, abciVal.PubKey) @@ -290,13 +290,13 @@ func TestValidatorsSortTendermint(t *testing.T) { valz := types.Validators(vals) // create expected tendermint validators by converting to tendermint then sorting - expectedVals, err := teststaking.ToTmValidators(valz) + expectedVals, err := teststaking.ToTmValidators(valz, sdk.DefaultPowerReduction) require.NoError(t, err) sort.Sort(tmtypes.ValidatorsByVotingPower(expectedVals)) // sort in SDK and then convert to tendermint sort.Sort(types.ValidatorsByVotingPower(valz)) - actualVals, err := teststaking.ToTmValidators(valz) + actualVals, err := teststaking.ToTmValidators(valz, sdk.DefaultPowerReduction) require.NoError(t, err) require.Equal(t, expectedVals, actualVals, "sorting in SDK is not the same as sorting in Tendermint") @@ -314,9 +314,9 @@ func TestValidatorToTm(t *testing.T) { vals[i] = val tmPk, err := cryptocodec.ToTmPubKeyInterface(pk) require.NoError(t, err) - expected[i] = tmtypes.NewValidator(tmPk, val.ConsensusPower()) + expected[i] = tmtypes.NewValidator(tmPk, val.ConsensusPower(sdk.DefaultPowerReduction)) } - vs, err := teststaking.ToTmValidators(vals) + vs, err := teststaking.ToTmValidators(vals, sdk.DefaultPowerReduction) require.NoError(t, err) require.Equal(t, expected, vs) }