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

Merge pull request #8505 from sikkatech/powerreduction_param 

Turn staking power reduction into an on-chain param
This commit is contained in:
Sunny Aggarwal 2021-04-10 19:50:18 -04:00 committed by GitHub
parent 04ab271e9a 4b778abf91
commit a4c7fd7002
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
90 changed files with 9236 additions and 1138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -89,6 +89,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
* (x/bank) [\#8656](https://github.com/cosmos/cosmos-sdk/pull/8656) balance and supply are now correctly tracked via `coin_spent`, `coin_received`, `coinbase` and `burn` events.
* (x/bank) [\#8517](https://github.com/cosmos/cosmos-sdk/pull/8517) Supply is now stored and tracked as `sdk.Coins`
* (store) [\#8790](https://github.com/cosmos/cosmos-sdk/pull/8790) Reduce gas costs by 10x for transient store operations.
* (x/staking) [\#8505](https://github.com/cosmos/cosmos-sdk/pull/8505) Convert staking power reduction into an on-chain parameter rather than a hardcoded in-code variable.
* (x/bank) [\#9051](https://github.com/cosmos/cosmos-sdk/pull/9051) Supply value is stored as `sdk.Int` rather than `string`.
### Improvements

2
contrib/rosetta/configuration/bootstrap.json
View File

@ -1,7 +1,7 @@
[
{
"account_identifier": {
"address":"cosmos1tqpwnlx558r36pmf5h8xxct94qcq00h2p5evag"
"address":"cosmos1kezmr2chzy7w00nhh7qxhpqphdwum3j0mgdaw0"
},
"currency":{
"symbol":"stake",

BIN
contrib/rosetta/node/data.tar.gz
View File

Binary file not shown.

1
docs/core/proto-docs.md
View File

@ -6425,6 +6425,7 @@ Params defines the parameters for the staking module.
| `max_entries` | [uint32](#uint32) | | max_entries is the max entries for either unbonding delegation or redelegation (per pair/trio). |
| `historical_entries` | [uint32](#uint32) | | historical_entries is the number of historical entries to persist. |
| `bond_denom` | [string](#string) | | bond_denom defines the bondable coin denomination. |
| `power_reduction` | [string](#string) | | power_reduction is the amount of staking tokens required for 1 unit of consensus-engine power |

6
proto/cosmos/staking/v1beta1/staking.proto
View File

@ -282,6 +282,12 @@ message Params {
uint32 historical_entries = 4 [(gogoproto.moretags) = "yaml:\"historical_entries\""];
// bond_denom defines the bondable coin denomination.
string bond_denom = 5 [(gogoproto.moretags) = "yaml:\"bond_denom\""];
// power_reduction is the amount of staking tokens required for 1 unit of consensus-engine power
string power_reduction = 6 [
(gogoproto.moretags) = "yaml:\"power_reduction\"",
(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
(gogoproto.nullable) = false
];
}
// DelegationResponse is equivalent to Delegation except that it contains a

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

16
types/staking.go
View File

@ -1,9 +1,5 @@
package types
import (
"math/big"
)
// staking constants
const (
@ -22,15 +18,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 = NewIntFromUint64(1000000)
// 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

@ -333,7 +333,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 := s.createBankMsg(val1, account.GetAddress(),
sdk.NewCoins(sendTokens), fmt.Sprintf("--%s=true", flags.FlagGenerateOnly))
@ -528,7 +528,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 := s.createBankMsg(
val1, val1.Address,

2
x/auth/legacy/v043/store_test.go
View File

@ -657,7 +657,7 @@ func dirtyTrackingFields(ctx sdk.Context, vesting exported.VestingAccount, app *
}
func createValidator(t *testing.T, ctx sdk.Context, app *simapp.SimApp, powers int64) (sdk.AccAddress, sdk.ValAddress) {
valTokens := sdk.TokensFromConsensusPower(powers)
valTokens := sdk.TokensFromConsensusPower(powers, sdk.DefaultPowerReduction)
addrs := simapp.AddTestAddrsIncremental(app, ctx, 1, valTokens)
valAddrs := simapp.ConvertAddrsToValAddrs(addrs)
pks := simapp.CreateTestPubKeys(1)

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

@ -73,7 +73,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 := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 200000)
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 := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 200000)
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 := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 200000)
initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt))
granter := accounts[0]

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

@ -7,6 +7,7 @@ import (
"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"
"github.com/cosmos/cosmos-sdk/x/auth/legacy/legacytx"
@ -23,7 +24,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)

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

@ -40,7 +40,8 @@ var (
multiPermAcc = authtypes.NewEmptyModuleAccount(multiPerm, authtypes.Burner, authtypes.Minter, authtypes.Staking)
randomPermAcc = authtypes.NewEmptyModuleAccount(randomPerm, "random")
initTokens = sdk.TokensFromConsensusPower(initialPower)
// The default power validators are initialized to have within tests
initTokens = sdk.TokensFromConsensusPower(initialPower, sdk.DefaultPowerReduction)
initCoins = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))
)
@ -91,7 +92,7 @@ func (suite *IntegrationTestSuite) TestSupply() {
app, ctx := suite.app, suite.ctx
initialPower := int64(100)
initTokens := sdk.TokensFromConsensusPower(initialPower)
initTokens := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, initialPower)
totalSupply := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))
suite.NoError(app.BankKeeper.MintCoins(ctx, minttypes.ModuleName, 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 := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 200)
initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
// add coins to the accounts

4
x/bank/types/balance_test.go
View File

@ -106,7 +106,7 @@ func TestBalance_GetAddress(t *testing.T) {
func TestSanitizeBalances(t *testing.T) {
// 1. Generate balances
tokens := sdk.TokensFromConsensusPower(81)
tokens := sdk.TokensFromConsensusPower(81, sdk.DefaultPowerReduction)
coin := sdk.NewCoin("benchcoin", tokens)
coins := sdk.Coins{coin}
addrs, _ := makeRandomAddressesAndPublicKeys(20)
@ -158,7 +158,7 @@ func BenchmarkSanitizeBalances1000(b *testing.B) {
func benchmarkSanitizeBalances(b *testing.B, nAddresses int) {
b.ReportAllocs()
tokens := sdk.TokensFromConsensusPower(81)
tokens := sdk.TokensFromConsensusPower(81, sdk.DefaultPowerReduction)
coin := sdk.NewCoin("benchcoin", tokens)
coins := sdk.Coins{coin}
addrs, _ := makeRandomAddressesAndPublicKeys(nAddresses)

14
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.ToDec()}}
app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)
@ -269,11 +269,11 @@ func TestCalculateRewardsMultiDelegator(t *testing.T) {
}
func TestWithdrawDelegationRewardsBasic(t *testing.T) {
balancePower := int64(1000)
balanceTokens := sdk.TokensFromConsensusPower(balancePower)
app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, tmproto.Header{})
balancePower := int64(1000)
balanceTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, balancePower)
addr := simapp.AddTestAddrs(app, ctx, 1, sdk.NewInt(1000000000))
valAddrs := simapp.ConvertAddrsToValAddrs(addr)
tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
@ -305,7 +305,7 @@ func TestWithdrawDelegationRewardsBasic(t *testing.T) {
val := app.StakingKeeper.Validator(ctx, valAddrs[0])
// allocate some rewards
initial := sdk.TokensFromConsensusPower(10)
initial := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 10).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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 30).ToDec()
tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}
app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)

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

@ -55,7 +55,7 @@ func TestWithdrawValidatorCommission(t *testing.T) {
// check initial balance
balance := app.BankKeeper.GetAllBalances(ctx, sdk.AccAddress(valAddrs[0]))
expTokens := sdk.TokensFromConsensusPower(1000)
expTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 1000)
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 := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 2)
validator0, issuedShares := validator0.AddTokensFromDel(delTokens)
delegator := accounts[1]
delegation := stakingtypes.NewDelegation(delegator.Address, validator0.GetOperator(), issuedShares)
@ -222,7 +222,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 := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 200)
initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
// add coins to the accounts

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

@ -35,7 +35,8 @@ var (
sdk.ValAddress(pubkeys[2].Address()),
}
initAmt = sdk.TokensFromConsensusPower(200)
// The default power validators are initialized to have within tests
initAmt = sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
initCoins = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
)

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

@ -39,7 +39,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
@ -134,7 +134,7 @@ func (suite *SimTestSuite) TestSimulateMsgRevokeFeeAllowance() {
// begin a new block
app.BeginBlock(abci.RequestBeginBlock{Header: tmproto.Header{Height: suite.app.LastBlockHeight() + 1, AppHash: suite.app.LastCommitID().Hash}})
feeAmt := sdk.TokensFromConsensusPower(200000)
feeAmt := app.StakingKeeper.TokensFromConsensusPower(ctx, 200000)
feeCoins := sdk.NewCoins(sdk.NewCoin("foo", feeAmt))
granter, grantee := accounts[0], accounts[1]

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, app.StakingKeeper.TokensFromConsensusPower(ctx, 5))}
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 10))}
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 10)))
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], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[0]), stakingtypes.Unbonded, val1, true)
_, _ = app.StakingKeeper.Delegate(ctx, addrs[1], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[1]), stakingtypes.Unbonded, val2, true)
_, _ = app.StakingKeeper.Delegate(ctx, addrs[2], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[2]), 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, app.StakingKeeper.TokensFromConsensusPower(ctx, 4)))
fiveStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 5)))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 20)))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 20)))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 20)))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 30)))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 10)))
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
expectedAbstain := app.StakingKeeper.TokensFromConsensusPower(ctx, 0)
expectedNo := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
expectedNoWithVeto := app.StakingKeeper.TokensFromConsensusPower(ctx, 0)
expectedTallyResult := types.NewTallyResult(expectedYes, expectedAbstain, expectedNo, expectedNoWithVeto)
require.True(t, tallyResults.Equals(expectedTallyResult))

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

@ -264,7 +264,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 200)
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.NewInt(10000000)
DefaultQuorum = sdk.NewDecWithPrec(334, 3)
DefaultThreshold = sdk.NewDecWithPrec(5, 1)
DefaultVetoThreshold = sdk.NewDecWithPrec(334, 3)

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, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 20))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
app.SlashingKeeper.SetParams(ctx, testslashing.TestParams())
power := int64(100)

3
x/slashing/init_test.go
View File

@ -5,5 +5,6 @@ import (
)
var (
InitTokens = sdk.TokensFromConsensusPower(200)
// The default power validators are initialized to have within tests
InitTokens = sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
)

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

@ -3,5 +3,6 @@ package keeper_test
import sdk "github.com/cosmos/cosmos-sdk/types"
var (
InitTokens = sdk.TokensFromConsensusPower(200)
// The default power validators are initialized to have within tests
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 50)
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 1), 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, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
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(app.StakingKeeper.TokensFromConsensusPower(ctx, 1))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 200)
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)

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

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

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

@ -20,7 +20,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"

1
x/staking/client/testutil/test_helpers.go
View File

@ -26,6 +26,7 @@ func MsgRedelegateExec(clientCtx client.Context, from, src, dst, amount fmt.Stri
dst.String(),
amount.String(),
fmt.Sprintf("--%s=%s", flags.FlagFrom, from.String()),
fmt.Sprintf("--%s=%d", flags.FlagGas, 300000),
}
args = append(args, extraArgs...)

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

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

10
x/staking/genesis_test.go
View File

@ -29,7 +29,7 @@ func bootstrapGenesisTest(numAddrs int) (*simapp.SimApp, sdk.Context, []sdk.AccA
func TestInitGenesis(t *testing.T) {
app, ctx, addrs := bootstrapGenesisTest(10)
valTokens := sdk.TokensFromConsensusPower(1)
valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 1)
params := app.StakingKeeper.GetParams(ctx)
validators := app.StakingKeeper.GetAllValidators(ctx)
@ -99,7 +99,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(app.StakingKeeper.PowerReduction(ctx))
}
require.Equal(t, abcivals, vals)
@ -168,9 +168,9 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) {
require.NoError(t, err)
validators[i].Status = types.Bonded
tokens := sdk.TokensFromConsensusPower(1)
tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 1)
if i < 100 {
tokens = sdk.TokensFromConsensusPower(2)
tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
}
validators[i].Tokens = tokens
validators[i].DelegatorShares = tokens.ToDec()
@ -194,7 +194,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(app.StakingKeeper.PowerReduction(ctx))
}
require.Equal(t, abcivals, vals)

119
x/staking/handler_test.go
View File

@ -31,7 +31,7 @@ func bootstrapHandlerGenesisTest(t *testing.T, power int64, numAddrs int, accAmo
addrDels, addrVals := generateAddresses(app, ctx, numAddrs, accAmount)
amt := sdk.TokensFromConsensusPower(power)
amt := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@ -42,9 +42,54 @@ func bootstrapHandlerGenesisTest(t *testing.T, power int64, numAddrs int, accAmo
return app, ctx, addrDels, addrVals
}
func TestPowerReductionChangeValidatorSetUpdates(t *testing.T) {
initPower := int64(1000000)
app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 10, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
validatorAddr, validatorAddr3 := valAddrs[0], valAddrs[1]
tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
// create validator
tstaking.CreateValidatorWithValPower(validatorAddr, PKs[0], initPower, true)
// must end-block
updates, err := app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
require.NoError(t, err)
require.Equal(t, 1, len(updates))
// create a second validator keep it bonded
tstaking.CreateValidatorWithValPower(validatorAddr3, PKs[2], initPower, true)
// must end-block
updates, err = app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
require.NoError(t, err)
require.Equal(t, 1, len(updates))
// modify power reduction to 10 times bigger one
params := app.StakingKeeper.GetParams(ctx)
params.PowerReduction = sdk.DefaultPowerReduction.Mul(sdk.NewInt(10))
app.StakingKeeper.SetParams(ctx, params)
// validator updates for tendermint power
updates, err = app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
require.NoError(t, err)
require.Equal(t, 2, len(updates))
require.Equal(t, updates[0].Power, initPower/10)
require.Equal(t, updates[1].Power, initPower/10)
// power reduction back to default
params = app.StakingKeeper.GetParams(ctx)
params.PowerReduction = sdk.DefaultPowerReduction
app.StakingKeeper.SetParams(ctx, params)
// validator updates for tendermint power
updates, err = app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
require.NoError(t, err)
require.Equal(t, 2, len(updates))
}
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)
@ -65,7 +110,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, app.StakingKeeper.PowerReduction(ctx))
require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power))
// create a second validator keep it bonded
@ -94,11 +139,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, app.StakingKeeper.PowerReduction(ctx))
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, app.StakingKeeper.PowerReduction(ctx))
require.Equal(t, power2, power3)
// unbond self-delegation
@ -121,7 +166,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]
@ -169,7 +214,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}},
})
@ -215,7 +260,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]
@ -294,8 +339,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]
@ -353,8 +398,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)
@ -384,9 +429,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)
@ -416,7 +461,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
@ -488,8 +533,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),
app.StakingKeeper.TokensFromConsensusPower(ctx, 1<<63-1),
app.StakingKeeper.TokensFromConsensusPower(ctx, 1<<31),
initBond,
}
@ -504,8 +549,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()
@ -524,7 +569,7 @@ func TestMultipleMsgCreateValidator(t *testing.T) {
}
// bond them all
amt := sdk.TokensFromConsensusPower(10)
amt := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
for i, validatorAddr := range validatorAddrs {
tstaking.CreateValidator(validatorAddr, PKs[i], amt, true)
// verify that the account is bonded
@ -574,7 +619,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
@ -608,7 +653,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
@ -647,7 +692,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)
@ -694,7 +739,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)
@ -733,7 +778,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)
@ -766,7 +811,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)
@ -817,7 +862,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()
@ -851,7 +896,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)
@ -895,7 +940,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)
@ -942,7 +987,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)
@ -982,7 +1027,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)
@ -1030,7 +1075,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]
@ -1070,7 +1115,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)
@ -1091,11 +1136,11 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
tstaking.Ctx = ctx
// begin unbonding 4 stake
unbondAmt := sdk.TokensFromConsensusPower(4)
unbondAmt := app.StakingKeeper.TokensFromConsensusPower(ctx, 4)
tstaking.Undelegate(del, valA, unbondAmt, true)
// begin redelegate 6 stake
redAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(6))
redAmt := sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 6))
msgBeginRedelegate := types.NewMsgBeginRedelegate(del, valA, valB, redAmt)
tstaking.Handle(msgBeginRedelegate, true)
@ -1175,11 +1220,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
require.NoError(t, simapp.FundModuleAccount(app, ctx, notBondedPool.GetName(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))))
@ -201,7 +201,7 @@ func TestUnbondDelegation(t *testing.T) {
delegation := types.NewDelegation(delAddrs[0], valAddrs[0], issuedShares)
app.StakingKeeper.SetDelegation(ctx, delegation)
bondTokens := sdk.TokensFromConsensusPower(6)
bondTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
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
@ -222,7 +222,7 @@ func TestUnbondingDelegationsMaxEntries(t *testing.T) {
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000))
addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
startTokens := sdk.TokensFromConsensusPower(10)
startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
bondDenom := app.StakingKeeper.BondDenom(ctx)
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@ -303,7 +303,7 @@ func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) {
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000))
addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
delTokens := sdk.TokensFromConsensusPower(10)
delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
//create a validator with a self-delegation
@ -345,7 +345,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], app.StakingKeeper.TokensFromConsensusPower(ctx, 6).ToDec())
require.NoError(t, err)
// end block
@ -353,14 +353,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, app.StakingKeeper.TokensFromConsensusPower(ctx, 14), 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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
@ -445,7 +445,7 @@ func TestUndelegateFromUnbondingValidator(t *testing.T) {
func TestUndelegateFromUnbondedValidator(t *testing.T) {
_, app, ctx := createTestInput()
delTokens := sdk.TokensFromConsensusPower(10)
delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
@ -460,7 +460,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
valTokens := sdk.TokensFromConsensusPower(10)
valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@ -509,7 +509,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
_, err = app.StakingKeeper.Undelegate(ctx, addrDels[1], addrVals[0], unbondTokens.ToDec())
require.NoError(t, err)
@ -525,7 +525,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
func TestUnbondingAllDelegationFromValidator(t *testing.T) {
_, app, ctx := createTestInput()
delTokens := sdk.TokensFromConsensusPower(10)
delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
@ -540,7 +540,7 @@ func TestUnbondingAllDelegationFromValidator(t *testing.T) {
validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
valTokens := sdk.TokensFromConsensusPower(10)
valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
@ -691,7 +691,7 @@ func TestRedelegateToSameValidator(t *testing.T) {
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(0))
addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
valTokens := sdk.TokensFromConsensusPower(10)
valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), valTokens))
// add bonded tokens to pool for delegations
@ -720,7 +720,7 @@ func TestRedelegationMaxEntries(t *testing.T) {
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
startTokens := sdk.TokensFromConsensusPower(20)
startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
// add bonded tokens to pool for delegations
@ -730,7 +730,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@ -776,7 +776,7 @@ func TestRedelegateSelfDelegation(t *testing.T) {
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
startTokens := sdk.TokensFromConsensusPower(30)
startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
// add bonded tokens to pool for delegations
@ -788,7 +788,7 @@ func TestRedelegateSelfDelegation(t *testing.T) {
validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
valTokens := sdk.TokensFromConsensusPower(10)
valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
@ -806,7 +806,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares = validator.AddTokensFromDel(delTokens)
require.Equal(t, delTokens, issuedShares.RoundInt())
validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@ -832,7 +832,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
startTokens := sdk.TokensFromConsensusPower(30)
startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
// add bonded tokens to pool for delegations
@ -844,7 +844,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
valTokens := sdk.TokensFromConsensusPower(10)
valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@ -854,7 +854,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
// create a second delegation to this validator
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator)
delTokens := sdk.TokensFromConsensusPower(10)
delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares = validator.AddTokensFromDel(delTokens)
require.Equal(t, delTokens, issuedShares.RoundInt())
validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@ -896,7 +896,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
ctx = ctx.WithBlockHeader(header)
// unbond some of the other delegation's shares
redelegateTokens := sdk.TokensFromConsensusPower(6)
redelegateTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
_, err = app.StakingKeeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], redelegateTokens.ToDec())
require.NoError(t, err)
@ -914,7 +914,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
startTokens := sdk.TokensFromConsensusPower(30)
startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
// add bonded tokens to pool for delegations
@ -926,7 +926,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
valTokens := sdk.TokensFromConsensusPower(10)
valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares := validator.AddTokensFromDel(valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@ -936,7 +936,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
// create a second delegation to this validator
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator)
delTokens := sdk.TokensFromConsensusPower(10)
delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
validator, issuedShares = validator.AddTokensFromDel(delTokens)
require.Equal(t, delTokens, issuedShares.RoundInt())
validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@ -970,7 +970,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
app.StakingKeeper.UnbondingToUnbonded(ctx, validator)
// redelegate some of the delegation's shares
redelegationTokens := sdk.TokensFromConsensusPower(6)
redelegationTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
_, 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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 1)
_, 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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 1)
_, 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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
_, 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, app.StakingKeeper.TokensFromConsensusPower(ctx, 300))
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], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[0]), 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], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[1]), 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], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[2]), 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)

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

@ -1,7 +1,6 @@
package keeper_test
import (
"sort"
"testing"
"github.com/stretchr/testify/require"
@ -13,6 +12,17 @@ import (
"github.com/cosmos/cosmos-sdk/x/staking/types"
)
// IsValSetSorted reports whether valset is sorted.
func IsValSetSorted(data []types.Validator, powerReduction sdk.Int) bool {
n := len(data)
for i := n - 1; i > 0; i-- {
if types.ValidatorsByVotingPower(data).Less(i, i-1, powerReduction) {
return false
}
}
return true
}
func TestHistoricalInfo(t *testing.T) {
_, app, ctx := createTestInput()
@ -25,13 +35,13 @@ 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, app.StakingKeeper.PowerReduction(ctx))
app.StakingKeeper.SetHistoricalInfo(ctx, 2, &hi)
recv, found := app.StakingKeeper.GetHistoricalInfo(ctx, 2)
require.True(t, found, "HistoricalInfo not found after set")
require.Equal(t, hi, recv, "HistoricalInfo not equal")
require.True(t, sort.IsSorted(types.ValidatorsByVotingPower(recv.Valset)), "HistoricalInfo validators is not sorted")
require.True(t, IsValSetSorted(recv.Valset, app.StakingKeeper.PowerReduction(ctx)), "HistoricalInfo validators is not sorted")
app.StakingKeeper.DeleteHistoricalInfo(ctx, 2)
@ -65,8 +75,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, app.StakingKeeper.PowerReduction(ctx))
hi5 := types.NewHistoricalInfo(h5, valSet, app.StakingKeeper.PowerReduction(ctx))
app.StakingKeeper.SetHistoricalInfo(ctx, 4, &hi4)
app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi5)
recv, found := app.StakingKeeper.GetHistoricalInfo(ctx, 4)
@ -78,14 +88,18 @@ func TestTrackHistoricalInfo(t *testing.T) {
// Set bonded validators in keeper
val1 := teststaking.NewValidator(t, addrVals[2], PKs[2])
val1.Status = types.Bonded // when not bonded, consensus power is Zero
val1.Tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
app.StakingKeeper.SetValidator(ctx, val1)
app.StakingKeeper.SetLastValidatorPower(ctx, val1.GetOperator(), 10)
val2 := teststaking.NewValidator(t, addrVals[3], PKs[3])
val1.Status = types.Bonded
val2.Tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 80)
app.StakingKeeper.SetValidator(ctx, val2)
app.StakingKeeper.SetLastValidatorPower(ctx, val2.GetOperator(), 80)
vals := []types.Validator{val1, val2}
sort.Sort(types.ValidatorsByVotingPower(vals))
IsValSetSorted(vals, app.StakingKeeper.PowerReduction(ctx))
// Set Header for BeginBlock context
header := tmproto.Header{
@ -103,7 +117,7 @@ func TestTrackHistoricalInfo(t *testing.T) {
}
recv, found = app.StakingKeeper.GetHistoricalInfo(ctx, 10)
require.True(t, found, "GetHistoricalInfo failed after BeginBlock")
require.Equal(t, expected, recv, "GetHistoricalInfo returned eunexpected result")
require.Equal(t, expected, recv, "GetHistoricalInfo returned unexpected result")
// Check HistoricalInfo at height 5, 4 is pruned
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, app.StakingKeeper.PowerReduction(ctx))
app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi)
suite.app, suite.ctx, suite.queryClient, suite.addrs, suite.vals = app, ctx, queryClient, addrs, validators

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

@ -17,5 +17,5 @@ func NewMigrator(keeper Keeper) Migrator {
// Migrate1to2 migrates from version 1 to 2.
func (m Migrator) Migrate1to2(ctx sdk.Context) error {
return v043.MigrateStore(ctx, m.keeper.storeKey)
return v043.MigrateStore(ctx, m.keeper.storeKey, m.keeper.paramstore)
}

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

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

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

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

@ -37,7 +37,7 @@ func TestNewQuerier(t *testing.T) {
ChainID: "HelloChain",
Height: 5,
}
hi := types.NewHistoricalInfo(header, validators[:])
hi := types.NewHistoricalInfo(header, validators[:], app.StakingKeeper.PowerReduction(ctx))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
// 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, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
_, 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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
_, 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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
_, 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, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
_, 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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
_, 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, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
_, 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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
_, 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, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
_, 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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
_, 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, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
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, app.StakingKeeper.PowerReduction(ctx))
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 := k.TokensFromConsensusPower(ctx, power)
slashAmountDec := amount.ToDec().Mul(slashFactor)
slashAmount := slashAmountDec.TruncateInt()

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

@ -21,7 +21,7 @@ func bootstrapSlashTest(t *testing.T, power int64) (*simapp.SimApp, sdk.Context,
addrDels, addrVals := generateAddresses(app, ctx, 100)
amt := sdk.TokensFromConsensusPower(power)
amt := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@ -215,12 +215,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(app.StakingKeeper.PowerReduction(ctx)))
// 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, app.StakingKeeper.TokensFromConsensusPower(ctx, 5).String(), diffTokens.String())
}
// tests Slash at the current height
@ -246,12 +246,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(app.StakingKeeper.PowerReduction(ctx)))
// 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, app.StakingKeeper.TokensFromConsensusPower(ctx, 5).String(), diffTokens.String())
}
// tests Slash at a previous height with an unbonding delegation
@ -263,7 +263,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 4)
ubd := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11, time.Unix(0, 0), ubdTokens)
app.StakingKeeper.SetUnbondingDelegation(ctx, ubd)
@ -285,12 +285,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, app.StakingKeeper.TokensFromConsensusPower(ctx, 2), 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, app.StakingKeeper.TokensFromConsensusPower(ctx, 3), diffTokens)
// read updated validator
validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
@ -300,7 +300,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(app.StakingKeeper.PowerReduction(ctx)))
// slash validator again
ctx = ctx.WithBlockHeight(13)
@ -316,14 +316,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, app.StakingKeeper.TokensFromConsensusPower(ctx, 6), 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(app.StakingKeeper.PowerReduction(ctx)))
// slash validator again
// all originally bonded stake has been slashed, so this will have no effect
@ -342,14 +342,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, app.StakingKeeper.TokensFromConsensusPower(ctx, 9), 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(app.StakingKeeper.PowerReduction(ctx)))
// slash validator again
// all originally bonded stake has been slashed, so this will have no effect
@ -368,7 +368,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, app.StakingKeeper.TokensFromConsensusPower(ctx, 10), diffTokens)
// apply TM updates
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
@ -388,7 +388,7 @@ func TestSlashWithRedelegation(t *testing.T) {
bondDenom := app.StakingKeeper.BondDenom(ctx)
// set a redelegation
rdTokens := sdk.TokensFromConsensusPower(6)
rdTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11,
time.Unix(0, 0), rdTokens, rdTokens.ToDec())
app.StakingKeeper.SetRedelegation(ctx, rd)
@ -415,7 +415,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 10).ToDec().Mul(fraction).TruncateInt()
bondedPool = app.StakingKeeper.GetBondedPool(ctx)
notBondedPool = app.StakingKeeper.GetNotBondedPool(ctx)
@ -439,14 +439,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(app.StakingKeeper.PowerReduction(ctx)))
// 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 = app.StakingKeeper.TokensFromConsensusPower(ctx, 7)
// read updated pool
bondedPool = app.StakingKeeper.GetBondedPool(ctx)
@ -472,7 +472,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(app.StakingKeeper.PowerReduction(ctx)))
// slash the validator again, by 100%
ctx = ctx.WithBlockHeight(12)
@ -481,7 +481,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 = app.StakingKeeper.TokensFromConsensusPower(ctx, 10).ToDec().Mul(sdk.OneDec()).TruncateInt()
burnAmount = burnAmount.Sub(sdk.OneDec().MulInt(rdTokens).TruncateInt())
// read updated pool
@ -541,7 +541,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
rdA := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11,
time.Unix(0, 0), rdATokens,
rdATokens.ToDec())
@ -553,7 +553,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 4)
ubdA := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11,
time.Unix(0, 0), ubdATokens)
app.StakingKeeper.SetUnbondingDelegation(ctx, ubdA)
@ -581,7 +581,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 10).ToDec().Mul(fraction).TruncateInt()
burnedBondAmount = burnedBondAmount.Sub(burnedNotBondedAmount)
// read updated pool
@ -602,5 +602,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(app.StakingKeeper.PowerReduction(ctx)))
}

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

@ -110,7 +110,9 @@ func (k Keeper) BlockValidatorUpdates(ctx sdk.Context) []abci.ValidatorUpdate {
// at the previous block height or were removed from the validator set entirely
// are returned to Tendermint.
func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []abci.ValidatorUpdate, err error) {
maxValidators := k.GetParams(ctx).MaxValidators
params := k.GetParams(ctx)
maxValidators := params.MaxValidators
powerReduction := params.PowerReduction
totalPower := sdk.ZeroInt()
amtFromBondedToNotBonded, amtFromNotBondedToBonded := sdk.ZeroInt(), sdk.ZeroInt()
@ -138,7 +140,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
}
@ -168,12 +170,12 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab
return nil, err
}
oldPowerBytes, found := last[valAddrStr]
newPower := validator.ConsensusPower()
newPower := validator.ConsensusPower(powerReduction)
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(powerReduction))
k.SetLastValidatorPower(ctx, valAddr, newPower)
}

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

@ -79,19 +79,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
@ -171,7 +171,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

@ -29,7 +29,7 @@ func bootstrapValidatorTest(t testing.TB, power int64, numAddrs int) (*simapp.Si
addrDels, addrVals := generateAddresses(app, ctx, numAddrs)
amt := sdk.TokensFromConsensusPower(power)
amt := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@ -48,7 +48,7 @@ func initValidators(t testing.TB, 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 := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
vs[i], _ = vs[i].AddTokensFromDel(tokens)
}
return app, ctx, addrs, valAddrs, vs
@ -59,7 +59,7 @@ func TestSetValidator(t *testing.T) {
valPubKey := PKs[0]
valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
valTokens := sdk.TokensFromConsensusPower(10)
valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
// test how the validator is set from a purely unbonbed pool
validator := teststaking.NewValidator(t, valAddr, valPubKey)
@ -74,7 +74,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(app.StakingKeeper.PowerReduction(ctx)), updates[0])
// after the save the validator should be bonded
require.Equal(t, types.Bonded, validator.Status)
@ -113,36 +113,36 @@ func TestUpdateValidatorByPowerIndex(t *testing.T) {
bondedPool := app.StakingKeeper.GetBondedPool(ctx)
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
require.NoError(t, simapp.FundModuleAccount(app, ctx, bondedPool.GetName(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234)))))
require.NoError(t, simapp.FundModuleAccount(app, ctx, notBondedPool.GetName(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000)))))
require.NoError(t, simapp.FundModuleAccount(app, ctx, bondedPool.GetName(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 1234)))))
require.NoError(t, simapp.FundModuleAccount(app, ctx, notBondedPool.GetName(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 10000)))))
app.AccountKeeper.SetModuleAccount(ctx, bondedPool)
app.AccountKeeper.SetModuleAccount(ctx, notBondedPool)
// add a validator
validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
validator, delSharesCreated := validator.AddTokensFromDel(sdk.TokensFromConsensusPower(100))
validator, delSharesCreated := validator.AddTokensFromDel(app.StakingKeeper.TokensFromConsensusPower(ctx, 100))
require.Equal(t, types.Unbonded, validator.Status)
require.Equal(t, sdk.TokensFromConsensusPower(100), validator.Tokens)
require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 100), 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, app.StakingKeeper.TokensFromConsensusPower(ctx, 100), validator.Tokens)
power := types.GetValidatorsByPowerIndexKey(validator)
power := types.GetValidatorsByPowerIndexKey(validator, app.StakingKeeper.PowerReduction(ctx))
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 50), 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, app.StakingKeeper.PowerReduction(ctx))
require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power))
}
@ -162,8 +162,8 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
app.StakingKeeper.SetParams(ctx, params)
// create a random pool
require.NoError(t, simapp.FundModuleAccount(app, ctx, bondedPool.GetName(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234)))))
require.NoError(t, simapp.FundModuleAccount(app, ctx, notBondedPool.GetName(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000)))))
require.NoError(t, simapp.FundModuleAccount(app, ctx, bondedPool.GetName(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 1234)))))
require.NoError(t, simapp.FundModuleAccount(app, ctx, notBondedPool.GetName(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 10000)))))
app.AccountKeeper.SetModuleAccount(ctx, bondedPool)
app.AccountKeeper.SetModuleAccount(ctx, notBondedPool)
@ -172,7 +172,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, int64((i+1)*10))
val, _ = val.AddTokensFromDel(delTokens)
val = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, val, true)
@ -184,7 +184,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 21)
nextCliffVal, _ = nextCliffVal.RemoveDelShares(shares.ToDec())
nextCliffVal = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, nextCliffVal, true)
@ -213,7 +213,7 @@ func TestSlashToZeroPowerRemoved(t *testing.T) {
// add a validator
validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
valTokens := sdk.TokensFromConsensusPower(100)
valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
bondedPool := app.StakingKeeper.GetBondedPool(ctx)
@ -248,13 +248,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
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, app.StakingKeeper.TokensFromConsensusPower(ctx, 9), validators[0].Tokens)
assert.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 8), validators[1].Tokens)
assert.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 7), validators[2].Tokens)
// check the empty keeper first
_, found := app.StakingKeeper.GetValidator(ctx, addrVals[0])
@ -284,11 +284,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, app.StakingKeeper.TokensFromConsensusPower(ctx, 9), validators[0].BondedTokens()))
// modify a records, save, and retrieve
validators[0].Status = types.Bonded
validators[0].Tokens = sdk.TokensFromConsensusPower(10)
validators[0].Tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
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])
@ -343,10 +343,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)}
app.StakingKeeper.PowerReduction(ctx).MulRaw(100),
app.StakingKeeper.PowerReduction(ctx),
app.StakingKeeper.PowerReduction(ctx).MulRaw(400),
app.StakingKeeper.PowerReduction(ctx).MulRaw(200)}
n := len(amts)
var validators [5]types.Validator
for i, amt := range amts {
@ -360,10 +360,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(app.StakingKeeper.PowerReduction(ctx)), resValidators[0].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(200).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[1].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(100).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[2].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(1).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[3].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(0), resValidators[4].BondedTokens(), "%v", resValidators)
assert.Equal(t, validators[3].OperatorAddress, resValidators[0].OperatorAddress, "%v", resValidators)
assert.Equal(t, validators[4].OperatorAddress, resValidators[1].OperatorAddress, "%v", resValidators)
@ -372,14 +372,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(app.StakingKeeper.PowerReduction(ctx))
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(app.StakingKeeper.PowerReduction(ctx))
keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
require.Equal(t, len(resValidators), n)
@ -387,7 +387,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(app.StakingKeeper.PowerReduction(ctx))
ctx = ctx.WithBlockHeight(10)
keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
@ -404,8 +404,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(app.StakingKeeper.PowerReduction(ctx))
validators[4].Tokens = sdk.NewInt(300).Mul(app.StakingKeeper.PowerReduction(ctx))
keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
require.Equal(t, len(resValidators), n)
@ -422,8 +422,8 @@ func TestGetValidatorSortingMixed(t *testing.T) {
bondedPool := app.StakingKeeper.GetBondedPool(ctx)
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
require.NoError(t, simapp.FundModuleAccount(app, ctx, bondedPool.GetName(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(501)))))
require.NoError(t, simapp.FundModuleAccount(app, ctx, notBondedPool.GetName(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(0)))))
require.NoError(t, simapp.FundModuleAccount(app, ctx, bondedPool.GetName(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 501)))))
require.NoError(t, simapp.FundModuleAccount(app, ctx, notBondedPool.GetName(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 0)))))
app.AccountKeeper.SetModuleAccount(ctx, notBondedPool)
app.AccountKeeper.SetModuleAccount(ctx, bondedPool)
@ -436,10 +436,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)}
app.StakingKeeper.PowerReduction(ctx).MulRaw(100),
app.StakingKeeper.PowerReduction(ctx),
app.StakingKeeper.PowerReduction(ctx).MulRaw(400),
app.StakingKeeper.PowerReduction(ctx).MulRaw(200)}
var validators [5]types.Validator
for i, amt := range amts {
@ -470,8 +470,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(app.StakingKeeper.PowerReduction(ctx)), resValidators[0].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(200).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[1].BondedTokens(), "%v", resValidators)
assert.Equal(t, validators[3].OperatorAddress, resValidators[0].OperatorAddress, "%v", resValidators)
assert.Equal(t, validators[4].OperatorAddress, resValidators[1].OperatorAddress, "%v", resValidators)
}
@ -493,7 +493,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens)
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@ -510,7 +510,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
// delegate 500 tokens to validator 0
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[0])
delTokens := sdk.TokensFromConsensusPower(500)
delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 500)
validators[0], _ = validators[0].AddTokensFromDel(delTokens)
notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@ -544,10 +544,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(app.StakingKeeper.TokensFromConsensusPower(ctx, 1))
notBondedPool = app.StakingKeeper.GetNotBondedPool(ctx)
newTokens = sdk.NewCoins(sdk.NewCoin(params.BondDenom, sdk.TokensFromConsensusPower(1)))
newTokens = sdk.NewCoins(sdk.NewCoin(params.BondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 1)))
require.NoError(t, simapp.FundModuleAccount(app, ctx, notBondedPool.GetName(), newTokens))
app.AccountKeeper.SetModuleAccount(ctx, notBondedPool)
@ -603,9 +603,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 200)
tokens1 := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
tokens2 := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
validators[0], _ = validators[0].AddTokensFromDel(tokens0)
validators[1], _ = validators[1].AddTokensFromDel(tokens1)
validators[2], _ = validators[2].AddTokensFromDel(tokens2)
@ -625,7 +625,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 50)
validators[1], _ = validators[1].AddTokensFromDel(delTokens)
validators[2], _ = validators[2].AddTokensFromDel(delTokens)
validators[2] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[2], true)
@ -648,7 +648,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens)
keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[i], true)
}
@ -669,7 +669,7 @@ func TestFullValidatorSetPowerChange(t *testing.T) {
// test a swap in voting power
tokens := sdk.TokensFromConsensusPower(600)
tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 600)
validators[0], _ = validators[0].AddTokensFromDel(tokens)
validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], true)
resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
@ -688,7 +688,7 @@ func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) {
valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
validators[i] = teststaking.NewValidator(t, valAddr, valPubKey)
tokens := sdk.TokensFromConsensusPower(power)
tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens)
}
@ -703,8 +703,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(app.StakingKeeper.PowerReduction(ctx)), updates[1])
assert.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
}
func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) {
@ -715,7 +715,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens)
}
@ -738,7 +738,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens)
}
@ -749,11 +749,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 = app.StakingKeeper.TokensFromConsensusPower(ctx, 600)
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(app.StakingKeeper.PowerReduction(ctx)), updates[0])
}
func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) {
@ -767,16 +767,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 190)
delTokens2 := app.StakingKeeper.TokensFromConsensusPower(ctx, 80)
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(app.StakingKeeper.PowerReduction(ctx)), updates[0])
require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
}
func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
@ -793,7 +793,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(app.StakingKeeper.PowerReduction(ctx)), updates[0])
// test validtor added at the beginning
// tendermintUpdate set: {} -> {c0}
@ -801,7 +801,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(app.StakingKeeper.PowerReduction(ctx)), updates[0])
// test validtor added at the end
// tendermintUpdate set: {} -> {c0}
@ -809,7 +809,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(app.StakingKeeper.PowerReduction(ctx)), updates[0])
}
func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
@ -822,7 +822,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens)
}
validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
@ -838,14 +838,14 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
// tendermintUpdate set: {} -> {c0, c4}
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
tokens := sdk.TokensFromConsensusPower(10)
tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
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(app.StakingKeeper.PowerReduction(ctx)), updates[0])
}
func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
@ -855,7 +855,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 := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens)
}
validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
@ -863,26 +863,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(app.StakingKeeper.PowerReduction(ctx)))
require.Equal(t, int64(100), validators[1].GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
// test multiple value change
// tendermintUpdate set: {c1, c3} -> {c1', c3'}
delTokens1 := sdk.TokensFromConsensusPower(20)
delTokens2 := sdk.TokensFromConsensusPower(30)
delTokens1 := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
delTokens2 := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
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(app.StakingKeeper.PowerReduction(ctx)))
require.Equal(t, int64(70), validators[1].GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
// 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(app.StakingKeeper.PowerReduction(ctx)), updates[0])
require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
}
func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
@ -901,7 +901,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
validators[i] = teststaking.NewValidator(t, valAddr, valPubKey)
tokens := sdk.TokensFromConsensusPower(power)
tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens)
app.StakingKeeper.SetValidator(ctx, validators[i])
@ -912,8 +912,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(app.StakingKeeper.PowerReduction(ctx)), updates[0])
require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
@ -921,7 +921,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
for i, power := range powers {
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[i])
tokens := sdk.TokensFromConsensusPower(power)
tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens)
app.StakingKeeper.SetValidator(ctx, validators[i])
@ -948,7 +948,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
valAddr = sdk.ValAddress(valPubKey.Address().Bytes())
validator = teststaking.NewValidator(t, valAddr, valPubKey)
tokens := sdk.TokensFromConsensusPower(500)
tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 500)
validator, _ = validator.AddTokensFromDel(tokens)
app.StakingKeeper.SetValidator(ctx, validator)
app.StakingKeeper.SetValidatorByPowerIndex(ctx, validator)
@ -958,9 +958,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(app.StakingKeeper.PowerReduction(ctx)), updates[0])
require.Equal(t, validators[0].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[2])
}
func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
@ -980,7 +980,7 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
validators[i] = newMonikerValidator(t, valAddr, valPubKey, moniker)
tokens := sdk.TokensFromConsensusPower(power)
tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
validators[i], _ = validators[i].AddTokensFromDel(tokens)
app.StakingKeeper.SetValidator(ctx, validators[i])
app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[i])
@ -990,8 +990,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(app.StakingKeeper.PowerReduction(ctx)), updates[0])
require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
@ -1003,7 +1003,7 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
require.True(t, found)
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[0])
tokens := sdk.TokensFromConsensusPower(1)
tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 1)
validators[0], _ = validators[0].AddTokensFromDel(tokens)
app.StakingKeeper.SetValidator(ctx, validators[0])
app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[0])
@ -1025,14 +1025,14 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[1])
tokens = sdk.TokensFromConsensusPower(250)
tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 250)
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(app.StakingKeeper.PowerReduction(ctx)), updates[0])
applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
}

944
x/staking/legacy/v040/genesis.pb.go Normal file
View File

@ -0,0 +1,944 @@
// Package v040 is taken from:
// https://github.com/cosmos/cosmos-sdk/blob/v0.40.1/x/staking/types/genesis.pb.go
// by copy-pasted only the relevants parts for Genesis.
// nolint
package v040
import (
fmt "fmt"
io "io"
math "math"
math_bits "math/bits"
github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
// GenesisState defines the staking module's genesis state.
type GenesisState struct {
// params defines all the paramaters of related to deposit.
Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
// last_total_power tracks the total amounts of bonded tokens recorded during
// the previous end block.
LastTotalPower github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=last_total_power,json=lastTotalPower,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"last_total_power" yaml:"last_total_power"`
// last_validator_powers is a special index that provides a historical list
// of the last-block's bonded validators.
LastValidatorPowers []LastValidatorPower `protobuf:"bytes,3,rep,name=last_validator_powers,json=lastValidatorPowers,proto3" json:"last_validator_powers" yaml:"last_validator_powers"`
// delegations defines the validator set at genesis.
Validators []Validator `protobuf:"bytes,4,rep,name=validators,proto3" json:"validators"`
// delegations defines the delegations active at genesis.
Delegations []Delegation `protobuf:"bytes,5,rep,name=delegations,proto3" json:"delegations"`
// unbonding_delegations defines the unbonding delegations active at genesis.
UnbondingDelegations []UnbondingDelegation `protobuf:"bytes,6,rep,name=unbonding_delegations,json=unbondingDelegations,proto3" json:"unbonding_delegations" yaml:"unbonding_delegations"`
// redelegations defines the redelegations active at genesis.
Redelegations []Redelegation `protobuf:"bytes,7,rep,name=redelegations,proto3" json:"redelegations"`
Exported bool `protobuf:"varint,8,opt,name=exported,proto3" json:"exported,omitempty"`
}
func (m *GenesisState) Reset() { *m = GenesisState{} }
func (m *GenesisState) String() string { return proto.CompactTextString(m) }
func (*GenesisState) ProtoMessage() {}
func (*GenesisState) Descriptor() ([]byte, []int) {
return fileDescriptor_9b3dec8894f2831b, []int{0}
}
func (m *GenesisState) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_GenesisState.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *GenesisState) XXX_Merge(src proto.Message) {
xxx_messageInfo_GenesisState.Merge(m, src)
}
func (m *GenesisState) XXX_Size() int {
return m.Size()
}
func (m *GenesisState) XXX_DiscardUnknown() {
xxx_messageInfo_GenesisState.DiscardUnknown(m)
}
var xxx_messageInfo_GenesisState proto.InternalMessageInfo
func (m *GenesisState) GetParams() Params {
if m != nil {
return m.Params
}
return Params{}
}
func (m *GenesisState) GetLastValidatorPowers() []LastValidatorPower {
if m != nil {
return m.LastValidatorPowers
}
return nil
}
func (m *GenesisState) GetValidators() []Validator {
if m != nil {
return m.Validators
}
return nil
}
func (m *GenesisState) GetDelegations() []Delegation {
if m != nil {
return m.Delegations
}
return nil
}
func (m *GenesisState) GetUnbondingDelegations() []UnbondingDelegation {
if m != nil {
return m.UnbondingDelegations
}
return nil
}
func (m *GenesisState) GetRedelegations() []Redelegation {
if m != nil {
return m.Redelegations
}
return nil
}
func (m *GenesisState) GetExported() bool {
if m != nil {
return m.Exported
}
return false
}
// LastValidatorPower required for validator set update logic.
type LastValidatorPower struct {
// address is the address of the validator.
Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
// power defines the power of the validator.
Power int64 `protobuf:"varint,2,opt,name=power,proto3" json:"power,omitempty"`
}
func (m *LastValidatorPower) Reset() { *m = LastValidatorPower{} }
func (m *LastValidatorPower) String() string { return proto.CompactTextString(m) }
func (*LastValidatorPower) ProtoMessage() {}
func (*LastValidatorPower) Descriptor() ([]byte, []int) {
return fileDescriptor_9b3dec8894f2831b, []int{1}
}
func (m *LastValidatorPower) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *LastValidatorPower) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_LastValidatorPower.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *LastValidatorPower) XXX_Merge(src proto.Message) {
xxx_messageInfo_LastValidatorPower.Merge(m, src)
}
func (m *LastValidatorPower) XXX_Size() int {
return m.Size()
}
func (m *LastValidatorPower) XXX_DiscardUnknown() {
xxx_messageInfo_LastValidatorPower.DiscardUnknown(m)
}
var xxx_messageInfo_LastValidatorPower proto.InternalMessageInfo
func init() {
// proto.RegisterType((*GenesisState)(nil), "cosmos.staking.v1beta1.GenesisState")
// proto.RegisterType((*LastValidatorPower)(nil), "cosmos.staking.v1beta1.LastValidatorPower")
}
func init() {
// proto.RegisterFile("cosmos/staking/v1beta1/genesis.proto", fileDescriptor_9b3dec8894f2831b)
}
var fileDescriptor_9b3dec8894f2831b = []byte{
// 493 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0x3d, 0x6f, 0xd3, 0x40,
0x18, 0xc7, 0x7d, 0xa4, 0x49, 0xc3, 0xa5, 0x20, 0x74, 0xa4, 0x60, 0x45, 0xc8, 0x0e, 0x56, 0x84,
0x22, 0x5e, 0x6c, 0xb5, 0x6c, 0x15, 0x53, 0x84, 0xa8, 0x8a, 0x10, 0x8a, 0x8e, 0x97, 0x81, 0x25,
0xba, 0xd4, 0x27, 0x63, 0xd5, 0xf1, 0x59, 0x7e, 0x2e, 0xa5, 0xdd, 0x11, 0x62, 0xe4, 0x23, 0xf4,
0xe3, 0x74, 0xec, 0xc0, 0x80, 0x18, 0x2c, 0x94, 0x2c, 0xcc, 0xfd, 0x04, 0xc8, 0xe7, 0x17, 0x4c,
0x52, 0x33, 0x25, 0x77, 0xfa, 0xfd, 0x7f, 0x7f, 0xfb, 0xfc, 0x1c, 0x1e, 0x1c, 0x0a, 0x98, 0x09,
0x70, 0x40, 0xb2, 0x23, 0x3f, 0xf4, 0x9c, 0xe3, 0x9d, 0x29, 0x97, 0x6c, 0xc7, 0xf1, 0x78, 0xc8,
0xc1, 0x07, 0x3b, 0x8a, 0x85, 0x14, 0xe4, 0x4e, 0x46, 0xd9, 0x39, 0x65, 0xe7, 0x54, 0xaf, 0xeb,
0x09, 0x4f, 0x28, 0xc4, 0x49, 0xff, 0x65, 0x74, 0xaf, 0xce, 0x59, 0xa4, 0x15, 0x65, 0x7d, 0x6f,
0xe2, 0xad, 0xfd, 0xac, 0xe5, 0x8d, 0x64, 0x92, 0x93, 0x67, 0xb8, 0x15, 0xb1, 0x98, 0xcd, 0x40,
0x47, 0x7d, 0x34, 0xec, 0xec, 0x1a, 0xf6, 0xd5, 0xad, 0xf6, 0x58, 0x51, 0xa3, 0x8d, 0xf3, 0xc4,
0xd4, 0x68, 0x9e, 0x21, 0x80, 0x6f, 0x05, 0x0c, 0xe4, 0x44, 0x0a, 0xc9, 0x82, 0x49, 0x24, 0x3e,
0xf1, 0x58, 0xbf, 0xd6, 0x47, 0xc3, 0xad, 0xd1, 0x41, 0xca, 0xfd, 0x4c, 0xcc, 0x07, 0x9e, 0x2f,
0x3f, 0xce, 0xa7, 0xf6, 0xa1, 0x98, 0x39, 0xf9, 0x13, 0x66, 0x3f, 0x4f, 0xc0, 0x3d, 0x72, 0xe4,
0x69, 0xc4, 0xc1, 0x3e, 0x08, 0xe5, 0x65, 0x62, 0xde, 0x3d, 0x65, 0xb3, 0x60, 0xcf, 0x5a, 0xf5,
0x59, 0xf4, 0x66, 0xba, 0xf5, 0x36, 0xdd, 0x19, 0xa7, 0x1b, 0xe4, 0x33, 0xc2, 0xdb, 0x8a, 0x3a,
0x66, 0x81, 0xef, 0x32, 0x29, 0xe2, 0x8c, 0x04, 0xbd, 0xd1, 0x6f, 0x0c, 0x3b, 0xbb, 0x0f, 0xeb,
0x5e, 0xe1, 0x15, 0x03, 0xf9, 0xbe, 0xc8, 0x28, 0xd7, 0x68, 0x90, 0x3e, 0xe6, 0x65, 0x62, 0xde,
0xab, 0x94, 0xaf, 0x6a, 0x2d, 0x7a, 0x3b, 0x58, 0x4b, 0x02, 0xd9, 0xc7, 0xb8, 0x24, 0x41, 0xdf,
0x50, 0xd5, 0xf7, 0xeb, 0xaa, 0xcb, 0x70, 0x7e, 0x80, 0x95, 0x28, 0x79, 0x89, 0x3b, 0x2e, 0x0f,
0xb8, 0xc7, 0xa4, 0x2f, 0x42, 0xd0, 0x9b, 0xca, 0x64, 0xd5, 0x99, 0x9e, 0x97, 0x68, 0xae, 0xaa,
0x86, 0xc9, 0x17, 0x84, 0xb7, 0xe7, 0xe1, 0x54, 0x84, 0xae, 0x1f, 0x7a, 0x93, 0xaa, 0xb6, 0xa5,
0xb4, 0x8f, 0xea, 0xb4, 0xef, 0x8a, 0x50, 0xc5, 0xbf, 0x72, 0x38, 0x57, 0x7a, 0x2d, 0xda, 0x9d,
0xaf, 0x47, 0x81, 0x8c, 0xf1, 0x8d, 0x98, 0x57, 0xfb, 0x37, 0x55, 0xff, 0xa0, 0xae, 0x9f, 0x56,
0xe0, 0xfc, 0xc5, 0xfe, 0x15, 0x90, 0x1e, 0x6e, 0xf3, 0x93, 0x48, 0xc4, 0x92, 0xbb, 0x7a, 0xbb,
0x8f, 0x86, 0x6d, 0x5a, 0xae, 0xad, 0xd7, 0x98, 0xac, 0x7f, 0x5c, 0xa2, 0xe3, 0x4d, 0xe6, 0xba,
0x31, 0x87, 0x6c, 0xb8, 0xaf, 0xd3, 0x62, 0x49, 0xba, 0xb8, 0xf9, 0x77, 0x58, 0x1b, 0x34, 0x5b,
0xec, 0xb5, 0xbf, 0x9e, 0x99, 0xda, 0xef, 0x33, 0x53, 0x1b, 0xbd, 0x38, 0x5f, 0x18, 0xe8, 0x62,
0x61, 0xa0, 0x5f, 0x0b, 0x03, 0x7d, 0x5b, 0x1a, 0xda, 0xc5, 0xd2, 0xd0, 0x7e, 0x2c, 0x0d, 0xed,
0xc3, 0xe3, 0xff, 0xce, 0xf3, 0x49, 0x79, 0xfd, 0xd4, 0x64, 0x4f, 0x5b, 0xea, 0xd6, 0x3d, 0xfd,
0x13, 0x00, 0x00, 0xff, 0xff, 0xff, 0x85, 0xad, 0xc8, 0xf1, 0x03, 0x00, 0x00,
}
func (m *GenesisState) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *GenesisState) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Exported {
i--
if m.Exported {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x40
}
if len(m.Redelegations) > 0 {
for iNdEx := len(m.Redelegations) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Redelegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintGenesis(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x3a
}
}
if len(m.UnbondingDelegations) > 0 {
for iNdEx := len(m.UnbondingDelegations) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.UnbondingDelegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintGenesis(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x32
}
}
if len(m.Delegations) > 0 {
for iNdEx := len(m.Delegations) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Delegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintGenesis(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x2a
}
}
if len(m.Validators) > 0 {
for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Validators[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintGenesis(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
}
}
if len(m.LastValidatorPowers) > 0 {
for iNdEx := len(m.LastValidatorPowers) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.LastValidatorPowers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintGenesis(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1a
}
}
{
size := m.LastTotalPower.Size()
i -= size
if _, err := m.LastTotalPower.MarshalTo(dAtA[i:]); err != nil {
return 0, err
}
i = encodeVarintGenesis(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
{
size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintGenesis(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
return len(dAtA) - i, nil
}
func (m *LastValidatorPower) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *LastValidatorPower) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *LastValidatorPower) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Power != 0 {
i = encodeVarintGenesis(dAtA, i, uint64(m.Power))
i--
dAtA[i] = 0x10
}
if len(m.Address) > 0 {
i -= len(m.Address)
copy(dAtA[i:], m.Address)
i = encodeVarintGenesis(dAtA, i, uint64(len(m.Address)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
offset -= sovGenesis(v)
base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return base
}
func (m *GenesisState) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = m.Params.Size()
n += 1 + l + sovGenesis(uint64(l))
l = m.LastTotalPower.Size()
n += 1 + l + sovGenesis(uint64(l))
if len(m.LastValidatorPowers) > 0 {
for _, e := range m.LastValidatorPowers {
l = e.Size()
n += 1 + l + sovGenesis(uint64(l))
}
}
if len(m.Validators) > 0 {
for _, e := range m.Validators {
l = e.Size()
n += 1 + l + sovGenesis(uint64(l))
}
}
if len(m.Delegations) > 0 {
for _, e := range m.Delegations {
l = e.Size()
n += 1 + l + sovGenesis(uint64(l))
}
}
if len(m.UnbondingDelegations) > 0 {
for _, e := range m.UnbondingDelegations {
l = e.Size()
n += 1 + l + sovGenesis(uint64(l))
}
}
if len(m.Redelegations) > 0 {
for _, e := range m.Redelegations {
l = e.Size()
n += 1 + l + sovGenesis(uint64(l))
}
}
if m.Exported {
n += 2
}
return n
}
func (m *LastValidatorPower) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Address)
if l > 0 {
n += 1 + l + sovGenesis(uint64(l))
}
if m.Power != 0 {
n += 1 + sovGenesis(uint64(m.Power))
}
return n
}
func sovGenesis(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
func sozGenesis(x uint64) (n int) {
return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GenesisState) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: GenesisState: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenesis
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field LastTotalPower", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthGenesis
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.LastTotalPower.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field LastValidatorPowers", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenesis
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.LastValidatorPowers = append(m.LastValidatorPowers, LastValidatorPower{})
if err := m.LastValidatorPowers[len(m.LastValidatorPowers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenesis
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Validators = append(m.Validators, Validator{})
if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Delegations", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenesis
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Delegations = append(m.Delegations, Delegation{})
if err := m.Delegations[len(m.Delegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field UnbondingDelegations", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenesis
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.UnbondingDelegations = append(m.UnbondingDelegations, UnbondingDelegation{})
if err := m.UnbondingDelegations[len(m.UnbondingDelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 7:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Redelegations", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenesis
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Redelegations = append(m.Redelegations, Redelegation{})
if err := m.Redelegations[len(m.Redelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 8:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Exported", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.Exported = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipGenesis(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthGenesis
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *LastValidatorPower) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: LastValidatorPower: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: LastValidatorPower: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenesis
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Address = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Power", wireType)
}
m.Power = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Power |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipGenesis(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthGenesis
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipGenesis(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowGenesis
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
wireType := int(wire & 0x7)
switch wireType {
case 0:
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowGenesis
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if dAtA[iNdEx-1] < 0x80 {
break
}
}
case 1:
iNdEx += 8
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowGenesis
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
length |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if length < 0 {
return 0, ErrInvalidLengthGenesis
}
iNdEx += length
case 3:
depth++
case 4:
if depth == 0 {
return 0, ErrUnexpectedEndOfGroupGenesis
}
depth--
case 5:
iNdEx += 4
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
if iNdEx < 0 {
return 0, ErrInvalidLengthGenesis
}
if depth == 0 {
return iNdEx, nil
}
}
return 0, io.ErrUnexpectedEOF
}
var (
ErrInvalidLengthGenesis = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowGenesis = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
)

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

@ -77,7 +77,7 @@ func GetValidatorsByPowerIndexKey(validator types.Validator) []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, sdk.DefaultPowerReduction)
consensusPowerBytes := make([]byte, 8)
binary.BigEndian.PutUint64(consensusPowerBytes, uint64(consensusPower))

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

@ -6,19 +6,18 @@ import (
codectypes "github.com/cosmos/cosmos-sdk/codec/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"
)
func migrateBondStatus(oldStatus v034staking.BondStatus) v040staking.BondStatus {
func migrateBondStatus(oldStatus v034staking.BondStatus) BondStatus {
switch oldStatus {
case v034staking.Unbonded:
return v040staking.Unbonded
return Unbonded
case v034staking.Unbonding:
return v040staking.Unbonding
return Unbonding
case v034staking.Bonded:
return v040staking.Bonded
return Bonded
default:
panic(fmt.Errorf("invalid bond status %d", oldStatus))
@ -31,29 +30,29 @@ func migrateBondStatus(oldStatus v034staking.BondStatus) v040staking.BondStatus
// - Convert addresses from bytes to bech32 strings.
// - Update BondStatus staking constants.
// - Re-encode in v0.40 GenesisState.
func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
newLastValidatorPowers := make([]v040staking.LastValidatorPower, len(stakingState.LastValidatorPowers))
func Migrate(stakingState v038staking.GenesisState) *GenesisState {
newLastValidatorPowers := make([]LastValidatorPower, len(stakingState.LastValidatorPowers))
for i, oldLastValidatorPower := range stakingState.LastValidatorPowers {
newLastValidatorPowers[i] = v040staking.LastValidatorPower{
newLastValidatorPowers[i] = LastValidatorPower{
Address: oldLastValidatorPower.Address.String(),
Power: oldLastValidatorPower.Power,
}
}
newValidators := make([]v040staking.Validator, len(stakingState.Validators))
newValidators := make([]Validator, len(stakingState.Validators))
for i, oldValidator := range stakingState.Validators {
pkAny, err := codectypes.NewAnyWithValue(oldValidator.ConsPubKey)
if err != nil {
panic(fmt.Sprintf("Can't pack validator consensus PK as Any: %s", err))
}
newValidators[i] = v040staking.Validator{
newValidators[i] = Validator{
OperatorAddress: oldValidator.OperatorAddress.String(),
ConsensusPubkey: pkAny,
Jailed: oldValidator.Jailed,
Status: migrateBondStatus(oldValidator.Status),
Tokens: oldValidator.Tokens,
DelegatorShares: oldValidator.DelegatorShares,
Description: v040staking.Description{
Description: Description{
Moniker: oldValidator.Description.Moniker,
Identity: oldValidator.Description.Identity,
Website: oldValidator.Description.Website,
@ -62,8 +61,8 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
},
UnbondingHeight: oldValidator.UnbondingHeight,
UnbondingTime: oldValidator.UnbondingCompletionTime,
Commission: v040staking.Commission{
CommissionRates: v040staking.CommissionRates{
Commission: Commission{
CommissionRates: CommissionRates{
Rate: oldValidator.Commission.Rate,
MaxRate: oldValidator.Commission.MaxRate,
MaxChangeRate: oldValidator.Commission.MaxChangeRate,
@ -74,20 +73,20 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
}
}
newDelegations := make([]v040staking.Delegation, len(stakingState.Delegations))
newDelegations := make([]Delegation, len(stakingState.Delegations))
for i, oldDelegation := range stakingState.Delegations {
newDelegations[i] = v040staking.Delegation{
newDelegations[i] = Delegation{
DelegatorAddress: oldDelegation.DelegatorAddress.String(),
ValidatorAddress: oldDelegation.ValidatorAddress.String(),
Shares: oldDelegation.Shares,
}
}
newUnbondingDelegations := make([]v040staking.UnbondingDelegation, len(stakingState.UnbondingDelegations))
newUnbondingDelegations := make([]UnbondingDelegation, len(stakingState.UnbondingDelegations))
for i, oldUnbondingDelegation := range stakingState.UnbondingDelegations {
newEntries := make([]v040staking.UnbondingDelegationEntry, len(oldUnbondingDelegation.Entries))
newEntries := make([]UnbondingDelegationEntry, len(oldUnbondingDelegation.Entries))
for j, oldEntry := range oldUnbondingDelegation.Entries {
newEntries[j] = v040staking.UnbondingDelegationEntry{
newEntries[j] = UnbondingDelegationEntry{
CreationHeight: oldEntry.CreationHeight,
CompletionTime: oldEntry.CompletionTime,
InitialBalance: oldEntry.InitialBalance,
@ -95,18 +94,18 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
}
}
newUnbondingDelegations[i] = v040staking.UnbondingDelegation{
newUnbondingDelegations[i] = UnbondingDelegation{
DelegatorAddress: oldUnbondingDelegation.DelegatorAddress.String(),
ValidatorAddress: oldUnbondingDelegation.ValidatorAddress.String(),
Entries: newEntries,
}
}
newRedelegations := make([]v040staking.Redelegation, len(stakingState.Redelegations))
newRedelegations := make([]Redelegation, len(stakingState.Redelegations))
for i, oldRedelegation := range stakingState.Redelegations {
newEntries := make([]v040staking.RedelegationEntry, len(oldRedelegation.Entries))
newEntries := make([]RedelegationEntry, len(oldRedelegation.Entries))
for j, oldEntry := range oldRedelegation.Entries {
newEntries[j] = v040staking.RedelegationEntry{
newEntries[j] = RedelegationEntry{
CreationHeight: oldEntry.CreationHeight,
CompletionTime: oldEntry.CompletionTime,
InitialBalance: oldEntry.InitialBalance,
@ -114,7 +113,7 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
}
}
newRedelegations[i] = v040staking.Redelegation{
newRedelegations[i] = Redelegation{
DelegatorAddress: oldRedelegation.DelegatorAddress.String(),
ValidatorSrcAddress: oldRedelegation.ValidatorSrcAddress.String(),
ValidatorDstAddress: oldRedelegation.ValidatorDstAddress.String(),
@ -122,8 +121,8 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
}
}
return &v040staking.GenesisState{
Params: v040staking.Params{
return &GenesisState{
Params: Params{
UnbondingTime: stakingState.Params.UnbondingTime,
MaxValidators: uint32(stakingState.Params.MaxValidators),
MaxEntries: uint32(stakingState.Params.MaxEntries),

6525
x/staking/legacy/v040/staking.pb.go Normal file
View File

File diff suppressed because it is too large Load Diff

201
x/staking/legacy/v040/types.go Normal file
View File

@ -0,0 +1,201 @@
package v040
import (
"fmt"
"strings"
"time"
yaml "gopkg.in/yaml.v2"
sdk "github.com/cosmos/cosmos-sdk/types"
)
// Staking params default values
const (
// DefaultUnbondingTime reflects three weeks in seconds as the default
// unbonding time.
// TODO: Justify our choice of default here.
DefaultUnbondingTime time.Duration = time.Hour * 24 * 7 * 3
// Default maximum number of bonded validators
DefaultMaxValidators uint32 = 100
// Default maximum entries in a UBD/RED pair
DefaultMaxEntries uint32 = 7
// DefaultHistorical entries is 10000. Apps that don't use IBC can ignore this
// value by not adding the staking module to the application module manager's
// SetOrderBeginBlockers.
DefaultHistoricalEntries uint32 = 10000
)
// NewParams creates a new Params instance
func NewParams(unbondingTime time.Duration, maxValidators, maxEntries, historicalEntries uint32, bondDenom string) Params {
return Params{
UnbondingTime: unbondingTime,
MaxValidators: maxValidators,
MaxEntries: maxEntries,
HistoricalEntries: historicalEntries,
BondDenom: bondDenom,
}
}
// String returns a human readable string representation of the parameters.
func (p Params) String() string {
out, _ := yaml.Marshal(p)
return string(out)
}
func DefaultParams() Params {
return NewParams(
DefaultUnbondingTime,
DefaultMaxValidators,
DefaultMaxEntries,
DefaultHistoricalEntries,
sdk.DefaultBondDenom,
)
}
// String implements the Stringer interface for a Commission object.
func (c Commission) String() string {
out, _ := yaml.Marshal(c)
return string(out)
}
// String implements the Stringer interface for a CommissionRates object.
func (cr CommissionRates) String() string {
out, _ := yaml.Marshal(cr)
return string(out)
}
// String implements the Stringer interface for a DVPair object.
func (dv DVPair) String() string {
out, _ := yaml.Marshal(dv)
return string(out)
}
// String implements the Stringer interface for a DVVTriplet object.
func (dvv DVVTriplet) String() string {
out, _ := yaml.Marshal(dvv)
return string(out)
}
// String returns a human readable string representation of a Delegation.
func (d Delegation) String() string {
out, _ := yaml.Marshal(d)
return string(out)
}
// Delegations is a collection of delegations
type Delegations []Delegation
func (d Delegations) String() (out string) {
for _, del := range d {
out += del.String() + "\n"
}
return strings.TrimSpace(out)
}
// String implements the stringer interface for a UnbondingDelegationEntry.
func (e UnbondingDelegationEntry) String() string {
out, _ := yaml.Marshal(e)
return string(out)
}
// String returns a human readable string representation of an UnbondingDelegation.
func (ubd UnbondingDelegation) String() string {
out := fmt.Sprintf(`Unbonding Delegations between:
Delegator: %s
Validator: %s
Entries:`, ubd.DelegatorAddress, ubd.ValidatorAddress)
for i, entry := range ubd.Entries {
out += fmt.Sprintf(` Unbonding Delegation %d:
Creation Height: %v
Min time to unbond (unix): %v
Expected balance: %s`, i, entry.CreationHeight,
entry.CompletionTime, entry.Balance)
}
return out
}
// UnbondingDelegations is a collection of UnbondingDelegation
type UnbondingDelegations []UnbondingDelegation
func (ubds UnbondingDelegations) String() (out string) {
for _, u := range ubds {
out += u.String() + "\n"
}
return strings.TrimSpace(out)
}
// String implements the Stringer interface for a RedelegationEntry object.
func (e RedelegationEntry) String() string {
out, _ := yaml.Marshal(e)
return string(out)
}
// String returns a human readable string representation of a Redelegation.
func (red Redelegation) String() string {
out := fmt.Sprintf(`Redelegations between:
Delegator: %s
Source Validator: %s
Destination Validator: %s
Entries:
`,
red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress,
)
for i, entry := range red.Entries {
out += fmt.Sprintf(` Redelegation Entry #%d:
Creation height: %v
Min time to unbond (unix): %v
Dest Shares: %s
`,
i, entry.CreationHeight, entry.CompletionTime, entry.SharesDst,
)
}
return strings.TrimRight(out, "\n")
}
// Redelegations are a collection of Redelegation
type Redelegations []Redelegation
func (d Redelegations) String() (out string) {
for _, red := range d {
out += red.String() + "\n"
}
return strings.TrimSpace(out)
}
// String implements the Stringer interface for DelegationResponse.
func (d DelegationResponse) String() string {
return fmt.Sprintf("%s\n Balance: %s", d.Delegation.String(), d.Balance)
}
// String implements the Stringer interface for a Validator object.
func (v Validator) String() string {
out, _ := yaml.Marshal(v)
return string(out)
}
// Validators is a collection of Validator
type Validators []Validator
func (v Validators) String() (out string) {
for _, val := range v {
out += val.String() + "\n"
}
return strings.TrimSpace(out)
}
// String implements the Stringer interface for a Description object.
func (d Description) String() string {
out, _ := yaml.Marshal(d)
return string(out)
}

138
x/staking/legacy/v043/json.go Normal file
View File

@ -0,0 +1,138 @@
package v043
import (
sdk "github.com/cosmos/cosmos-sdk/types"
v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040"
v043staking "github.com/cosmos/cosmos-sdk/x/staking/types"
)
// MigrateJSON accepts exported v0.40 x/gov genesis state and migrates it to
// v0.43 x/gov genesis state. The migration includes:
//
// - Gov weighted votes.
func MigrateJSON(oldState *v040staking.GenesisState) *v043staking.GenesisState {
return &v043staking.GenesisState{
Params: migrateParams(oldState.Params),
LastTotalPower: oldState.LastTotalPower,
LastValidatorPowers: migrateLastValidatorPowers(oldState.LastValidatorPowers),
Validators: migrateValidators(oldState.Validators),
Delegations: migrateDelegations(oldState.Delegations),
UnbondingDelegations: migrateUnbondingDelegations(oldState.UnbondingDelegations),
Redelegations: migrateRedelegations(oldState.Redelegations),
Exported: oldState.Exported,
}
}
func migrateParams(oldParams v040staking.Params) v043staking.Params {
return v043staking.NewParams(
oldParams.UnbondingTime,
oldParams.MaxValidators,
oldParams.MaxEntries,
oldParams.HistoricalEntries,
oldParams.BondDenom,
sdk.DefaultPowerReduction,
)
}
func migrateLastValidatorPowers(oldLastValidatorPowers []v040staking.LastValidatorPower) []v043staking.LastValidatorPower {
newLastValidatorPowers := make([]v043staking.LastValidatorPower, len(oldLastValidatorPowers))
for i, oldLastValidatorPower := range oldLastValidatorPowers {
newLastValidatorPowers[i] = v043staking.LastValidatorPower{
Address: oldLastValidatorPower.Address,
Power: oldLastValidatorPower.Power,
}
}
return newLastValidatorPowers
}
func migrateValidators(oldValidators []v040staking.Validator) []v043staking.Validator {
newValidators := make([]v043staking.Validator, len(oldValidators))
for i, oldValidator := range oldValidators {
newValidators[i] = v043staking.Validator{
OperatorAddress: oldValidator.OperatorAddress,
ConsensusPubkey: oldValidator.ConsensusPubkey,
Jailed: oldValidator.Jailed,
Status: v043staking.BondStatus(oldValidator.Status),
Tokens: oldValidator.Tokens,
DelegatorShares: oldValidator.DelegatorShares,
Description: v043staking.Description{
Moniker: oldValidator.Description.Moniker,
Identity: oldValidator.Description.Identity,
Website: oldValidator.Description.Website,
SecurityContact: oldValidator.Description.SecurityContact,
Details: oldValidator.Description.Details,
},
UnbondingHeight: oldValidator.UnbondingHeight,
UnbondingTime: oldValidator.UnbondingTime,
Commission: v043staking.Commission{
CommissionRates: v043staking.CommissionRates{
Rate: oldValidator.Commission.CommissionRates.Rate,
MaxRate: oldValidator.Commission.CommissionRates.MaxRate,
MaxChangeRate: oldValidator.Commission.CommissionRates.MaxChangeRate,
},
UpdateTime: oldValidator.Commission.UpdateTime,
},
MinSelfDelegation: oldValidator.MinSelfDelegation,
}
}
return newValidators
}
func migrateDelegations(oldDelegations []v040staking.Delegation) []v043staking.Delegation {
newDelegations := make([]v043staking.Delegation, len(oldDelegations))
for i, oldDelegation := range oldDelegations {
newDelegations[i] = v043staking.Delegation{
DelegatorAddress: oldDelegation.DelegatorAddress,
ValidatorAddress: oldDelegation.ValidatorAddress,
Shares: oldDelegation.Shares,
}
}
return newDelegations
}
func migrateUnbondingDelegations(oldUnbondingDelegations []v040staking.UnbondingDelegation) []v043staking.UnbondingDelegation {
newUnbondingDelegations := make([]v043staking.UnbondingDelegation, len(oldUnbondingDelegations))
for i, oldUnbondingDelegation := range oldUnbondingDelegations {
newEntries := make([]v043staking.UnbondingDelegationEntry, len(oldUnbondingDelegation.Entries))
for j, oldEntry := range oldUnbondingDelegation.Entries {
newEntries[j] = v043staking.UnbondingDelegationEntry{
CreationHeight: oldEntry.CreationHeight,
CompletionTime: oldEntry.CompletionTime,
InitialBalance: oldEntry.InitialBalance,
Balance: oldEntry.Balance,
}
}
newUnbondingDelegations[i] = v043staking.UnbondingDelegation{
DelegatorAddress: oldUnbondingDelegation.DelegatorAddress,
ValidatorAddress: oldUnbondingDelegation.ValidatorAddress,
Entries: newEntries,
}
}
return newUnbondingDelegations
}
func migrateRedelegations(oldRedelegations []v040staking.Redelegation) []v043staking.Redelegation {
newRedelegations := make([]v043staking.Redelegation, len(oldRedelegations))
for i, oldRedelegation := range oldRedelegations {
newEntries := make([]v043staking.RedelegationEntry, len(oldRedelegation.Entries))
for j, oldEntry := range oldRedelegation.Entries {
newEntries[j] = v043staking.RedelegationEntry{
CreationHeight: oldEntry.CreationHeight,
CompletionTime: oldEntry.CompletionTime,
InitialBalance: oldEntry.InitialBalance,
SharesDst: oldEntry.SharesDst,
}
}
newRedelegations[i] = v043staking.Redelegation{
DelegatorAddress: oldRedelegation.DelegatorAddress,
ValidatorSrcAddress: oldRedelegation.ValidatorSrcAddress,
ValidatorDstAddress: oldRedelegation.ValidatorDstAddress,
Entries: newEntries,
}
}
return newRedelegations
}

67
x/staking/legacy/v043/json_test.go Normal file
View File

@ -0,0 +1,67 @@
package v043_test
import (
"encoding/json"
"fmt"
"testing"
"github.com/stretchr/testify/require"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040"
v043staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v043"
)
func TestMigrateJSON(t *testing.T) {
encodingConfig := simapp.MakeTestEncodingConfig()
clientCtx := client.Context{}.
WithInterfaceRegistry(encodingConfig.InterfaceRegistry).
WithTxConfig(encodingConfig.TxConfig).
WithJSONMarshaler(encodingConfig.Marshaler)
// voter, err := sdk.AccAddressFromBech32("cosmos1fl48vsnmsdzcv85q5d2q4z5ajdha8yu34mf0eh")
// require.NoError(t, err)
stakingGenState := &v040staking.GenesisState{
Params: v040staking.DefaultParams(),
}
migrated := v043staking.MigrateJSON(stakingGenState)
require.True(t, migrated.Params.PowerReduction.Equal(sdk.DefaultPowerReduction))
bz, err := clientCtx.JSONMarshaler.MarshalJSON(migrated)
require.NoError(t, err)
// Indent the JSON bz correctly.
var jsonObj map[string]interface{}
err = json.Unmarshal(bz, &jsonObj)
require.NoError(t, err)
indentedBz, err := json.MarshalIndent(jsonObj, "", "\t")
require.NoError(t, err)
// Make sure about:
// - Votes are all ADR-037 weighted votes with weight 1.
expected := `{
"delegations": [],
"exported": false,
"last_total_power": "0",
"last_validator_powers": [],
"params": {
"bond_denom": "stake",
"historical_entries": 10000,
"max_entries": 7,
"max_validators": 100,
"power_reduction": "1000000",
"unbonding_time": "1814400s"
},
"redelegations": [],
"unbonding_delegations": [],
"validators": []
}`
fmt.Println(string(indentedBz))
require.Equal(t, expected, string(indentedBz))
}

14
x/staking/legacy/v043/store.go
View File

@ -6,6 +6,7 @@ import (
"github.com/cosmos/cosmos-sdk/types/address"
v040auth "github.com/cosmos/cosmos-sdk/x/auth/legacy/v040"
v043distribution "github.com/cosmos/cosmos-sdk/x/distribution/legacy/v043"
paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040"
"github.com/cosmos/cosmos-sdk/x/staking/types"
)
@ -54,11 +55,16 @@ func migrateValidatorsByPowerIndexKey(store sdk.KVStore) {
}
}
// MigrateStore performs in-place store migrations from v0.40 to v0.42. The
func migrateParamsStore(ctx sdk.Context, paramstore paramtypes.Subspace) {
paramstore.WithKeyTable(types.ParamKeyTable())
paramstore.Set(ctx, types.KeyPowerReduction, sdk.DefaultPowerReduction)
}
// MigrateStore performs in-place store migrations from v0.40 to v0.43. The
// migration includes:
//
// - Change addresses to be length-prefixed.
func MigrateStore(ctx sdk.Context, storeKey sdk.StoreKey) error {
// - Setting the Power Reduction param in the paramstore
func MigrateStore(ctx sdk.Context, storeKey sdk.StoreKey, paramstore paramtypes.Subspace) error {
store := ctx.KVStore(storeKey)
v043distribution.MigratePrefixAddress(store, v040staking.LastValidatorPowerKey)
@ -74,5 +80,7 @@ func MigrateStore(ctx sdk.Context, storeKey sdk.StoreKey) error {
migratePrefixAddressAddressAddress(store, v040staking.RedelegationByValSrcIndexKey)
migratePrefixAddressAddressAddress(store, v040staking.RedelegationByValDstIndexKey)
migrateParamsStore(ctx, paramstore)
return nil
}

16
x/staking/legacy/v043/store_test.go
View File

@ -7,9 +7,11 @@ import (
"github.com/stretchr/testify/require"
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/testutil"
"github.com/cosmos/cosmos-sdk/testutil/testdata"
sdk "github.com/cosmos/cosmos-sdk/types"
paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040"
v043staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v043"
"github.com/cosmos/cosmos-sdk/x/staking/teststaking"
@ -17,10 +19,14 @@ import (
)
func TestStoreMigration(t *testing.T) {
encCfg := simapp.MakeTestEncodingConfig()
stakingKey := sdk.NewKVStoreKey("staking")
ctx := testutil.DefaultContext(stakingKey, sdk.NewTransientStoreKey("transient_test"))
tStakingKey := sdk.NewTransientStoreKey("transient_test")
ctx := testutil.DefaultContext(stakingKey, tStakingKey)
store := ctx.KVStore(stakingKey)
paramSubspace := paramtypes.NewSubspace(encCfg.Marshaler, encCfg.Amino, stakingKey, tStakingKey, types.ModuleName)
_, pk1, addr1 := testdata.KeyTestPubAddr()
valAddr1 := sdk.ValAddress(addr1)
val := teststaking.NewValidator(t, valAddr1, pk1)
@ -61,7 +67,7 @@ func TestStoreMigration(t *testing.T) {
{
"ValidatorsByPowerIndexKey",
v040staking.GetValidatorsByPowerIndexKey(val),
types.GetValidatorsByPowerIndexKey(val),
types.GetValidatorsByPowerIndexKey(val, sdk.DefaultPowerReduction),
},
{
"DelegationKey",
@ -121,7 +127,7 @@ func TestStoreMigration(t *testing.T) {
}
// Run migrations.
err := v043staking.MigrateStore(ctx, stakingKey)
err := v043staking.MigrateStore(ctx, stakingKey, paramSubspace)
require.NoError(t, err)
// Make sure the new keys are set and old keys are deleted.
@ -134,4 +140,8 @@ func TestStoreMigration(t *testing.T) {
require.Equal(t, value, store.Get(tc.newKey))
})
}
powerReduction := sdk.NewInt(0)
paramSubspace.Get(ctx, types.KeyPowerReduction, &powerReduction)
require.True(t, powerReduction.Equal(sdk.DefaultPowerReduction))
}

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.DefaultPowerReduction, 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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
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 := app.StakingKeeper.TokensFromConsensusPower(ctx, 200)
initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
// add coins to the accounts
@ -308,7 +308,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 = app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
app.StakingKeeper.SetValidator(ctx, validator)

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 | "stake" |
| 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 := sh.k.TokensFromConsensusPower(sh.Ctx, valPower)
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, sh.k.TokensFromConsensusPower(sh.Ctx, power))
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, r 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(r)), nil
}
// ToTmValidators casts all validators to the corresponding tendermint type.
func ToTmValidators(v types.Validators) ([]*tmtypes.Validator, error) {
func ToTmValidators(v types.Validators, r 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, r)
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

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

@ -8,14 +8,17 @@ 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))
sort.SliceStable(valSet, func(i, j int) bool {
return ValidatorsByVotingPower(valSet).Less(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

@ -75,11 +75,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, "230000010000000000149c288ede7df62742fc3b7d0962045a8cef0f79f6"},
}
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
}

1506
x/staking/types/staking.pb.go
View File

File diff suppressed because it is too large Load Diff

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

@ -114,8 +114,8 @@ 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() {
func (valz ValidatorsByVotingPower) Less(i, j int, r sdk.Int) bool {
if valz[i].ConsensusPower(r) == valz[j].ConsensusPower(r) {
addrI, errI := valz[i].GetConsAddr()
addrJ, errJ := valz[j].GetConsAddr()
// If either returns error, then return false
@ -124,7 +124,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(r) > valz[j].ConsensusPower(r)
}
func (valz ValidatorsByVotingPower) Swap(i, j int) {
@ -255,7 +255,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(r sdk.Int) abci.ValidatorUpdate {
tmProtoPk, err := v.TmConsPublicKey()
if err != nil {
panic(err)
@ -263,7 +263,7 @@ func (v Validator) ABCIValidatorUpdate() abci.ValidatorUpdate {
return abci.ValidatorUpdate{
PubKey: tmProtoPk,
Power: v.ConsensusPower(),
Power: v.ConsensusPower(r),
}
}
@ -347,17 +347,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(r sdk.Int) int64 {
if v.IsBonded() {
return v.PotentialConsensusPower()
return v.PotentialConsensusPower(r)
}
return 0
}
// PotentialConsensusPower returns the potential consensus-engine power.
func (v Validator) PotentialConsensusPower() int64 {
return sdk.TokensToConsensusPower(v.Tokens)
func (v Validator) PotentialConsensusPower(r sdk.Int) int64 {
return sdk.TokensToConsensusPower(v.Tokens, r)
}
// UpdateStatus updates the location of the shares within a validator
@ -503,9 +503,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(r sdk.Int) int64 {
return v.ConsensusPower(r)
}
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 }

14
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,15 @@ 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)
sort.SliceStable(valz, func(i, j int) bool {
return types.ValidatorsByVotingPower(valz).Less(i, j, sdk.DefaultPowerReduction)
})
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 +316,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)
}