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

on-chain power reduction param conversion basic work

This commit is contained in:
psaradev 2021-01-27 20:24:00 +10:00
parent fec543d4f8
commit 4f476d6890
73 changed files with 447 additions and 367 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
simapp/simd/cmd/testnet.go
View File

@ -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],

6
testutil/network/network.go
View File

@ -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),

12
types/staking.go
View File

@ -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)
}

4
types/staking_test.go
View File

@ -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))
}

4
x/auth/client/cli/cli_test.go
View File

@ -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,

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

@ -72,7 +72,7 @@ func (suite *SimTestSuite) TestWeightedOperations() {
func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
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]

3
x/bank/client/rest/tx_test.go
View File

@ -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)

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

@ -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))

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

@ -124,7 +124,7 @@ func (suite *SimTestSuite) TestSimulateMsgMultiSend() {
func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
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

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

@ -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)

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

@ -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)

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

@ -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

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

@ -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))
)

6
x/gov/abci_test.go
View File

@ -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)

4
x/gov/common_test.go
View File

@ -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(),

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

@ -48,9 +48,9 @@ func createValidators(t *testing.T, ctx sdk.Context, app *simapp.SimApp, powers
app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val2)
app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, 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)

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

@ -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])

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

@ -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)

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

@ -153,7 +153,7 @@ func TestQueries(t *testing.T) {
TestAddrs := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(20000001))
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

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

@ -245,7 +245,7 @@ func TestTallyDelgatorOverride(t *testing.T) {
addrs, valAddrs := createValidators(t, ctx, app, []int64{5, 6, 7})
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))

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

@ -222,7 +222,7 @@ func createTestApp(isCheckTx bool) (*simapp.SimApp, sdk.Context) {
func getTestingAccounts(t *testing.T, r *rand.Rand, app *simapp.SimApp, ctx sdk.Context, n int) []simtypes.Account {
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

2
x/gov/types/params.go
View File

@ -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)

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

@ -111,7 +111,7 @@ func (suite *KeeperTestSuite) SetupTest() {
val.Tokens = sdk.NewInt(rand.Int63())
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)
}

2
x/ibc/testing/chain.go
View File

@ -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)
}

2
x/slashing/abci_test.go
View File

@ -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)

4
x/slashing/app_test.go
View File

@ -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)

2
x/slashing/genesis_test.go
View File

@ -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))

10
x/slashing/handler_test.go
View File

@ -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)

2
x/slashing/init_test.go
View File

@ -5,5 +5,5 @@ import (
)
var (
InitTokens = sdk.TokensFromConsensusPower(200)
InitTokens = sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
)

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

@ -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)
)

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

@ -35,7 +35,7 @@ func (suite *SlashingTestSuite) SetupTest() {
app.BankKeeper.SetParams(ctx, banktypes.DefaultParams())
app.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))

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

@ -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)

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

@ -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()) })

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

@ -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

4
x/staking/app_test.go
View File

@ -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)

2
x/staking/client/cli/tx.go
View File

@ -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"

2
x/staking/common_test.go
View File

@ -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

4
x/staking/genesis.go
View File

@ -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(),
})

12
x/staking/genesis_test.go
View File

@ -23,7 +23,7 @@ func bootstrapGenesisTest(t *testing.T, power int64, numAddrs int) (*simapp.SimA
addrDels, _ := generateAddresses(app, ctx, numAddrs, sdk.NewInt(10000))
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)

74
x/staking/handler_test.go
View File

@ -32,7 +32,7 @@ func bootstrapHandlerGenesisTest(t *testing.T, power int64, numAddrs int, accAmo
addrDels, addrVals := generateAddresses(app, ctx, numAddrs, accAmount)
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())

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

@ -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

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

@ -183,7 +183,7 @@ func TestUnbondDelegation(t *testing.T) {
delAddrs := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000))
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)

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

@ -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)

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

@ -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)

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

@ -25,7 +25,7 @@ func TestHistoricalInfo(t *testing.T) {
validators[i] = teststaking.NewValidator(t, valAddr, PKs[i])
}
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)

4
x/staking/keeper/invariants.go
View File

@ -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() {

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

@ -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

8
x/staking/keeper/params.go
View File

@ -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),
)
}

15
x/staking/keeper/power_reduction.go Normal file
View File

@ -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))
}

21
x/staking/keeper/power_reduction_test.go Normal file
View File

@ -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))
}

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

@ -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}

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

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

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

@ -22,7 +22,7 @@ func bootstrapSlashTest(t *testing.T, power int64) (*simapp.SimApp, sdk.Context,
addrDels, addrVals := generateAddresses(app, ctx, 100)
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))
}

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

@ -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)
}

8
x/staking/keeper/validator.go
View File

@ -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())

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

@ -30,7 +30,7 @@ func bootstrapValidatorTest(t *testing.T, power int64, numAddrs int) (*simapp.Si
addrDels, addrVals := generateAddresses(app, ctx, numAddrs)
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)
}

2
x/staking/legacy/v040/migrate.go
View File

@ -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,

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

@ -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))
}

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

@ -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 (

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

@ -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)

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

@ -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)

9
x/staking/spec/01_state.md
View File

@ -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
}
```

1
x/staking/spec/08_params.md
View File

@ -13,3 +13,4 @@ The staking module contains the following parameters:
| KeyMaxEntries | uint16 | 7 |
| HistoricalEntries | uint16 | 3 |
| BondDenom | string | "uatom" |
| PowerReduction | string | "1000000" |

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

@ -40,7 +40,7 @@ func (sh *Helper) CreateValidator(addr sdk.ValAddress, pk cryptotypes.PubKey, st
// CreateValidatorWithValPower calls handler to create a new staking validator with zero
// 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)
}

9
x/staking/teststaking/tm.go
View File

@ -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
}

2
x/staking/types/exported.go
View File

@ -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

8
x/staking/types/historical_info.go
View File

@ -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,

5
x/staking/types/historical_info_test.go
View File

@ -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")
}

4
x/staking/types/keys.go
View File

@ -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))

8
x/staking/types/keys_test.go
View File

@ -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)
}

19
x/staking/types/params.go
View File

@ -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
}

28
x/staking/types/validator.go
View File

@ -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 }

10
x/staking/types/validator_test.go
View File

@ -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)
}