LaconicNetwork/cosmos-sdk
10
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

Merge PR #3400: power reduction for Tendermint

Browse Source 
* add uncompiled power functionality

* fix some compile errors

* Power -> TendermintPower

* tests rename GetTendermintPower

* test fix

* working

* fix delegation tests

* fix slash tests

* staking/keeper tests passing

* docs reversion

* debuggin workin

* x/staking test pass

* fix gov tests

* fix x/slashing tests

* working distribution test fixes

* fix distribution tests

* lint

* fix lcd tests

* fix gov test

* lint

* CLI fixes, rm stakingTypes

* typos

* working cli fixes

* cli test fix

* cli tests fixed

* testnet creation modification

* typo

* pending

* Sanitize Dec.Roundint64 (#3475)

* merge fixes

* @cwgoes comments

* fix tests

* change power reduction to 10^-6

* option to turn off minting for LCD tests
This commit is contained in:
frog power 4000 2019-02-05 21:30:48 -08:00 committed by GitHub
parent df94f522f9
commit 52f2ec71a9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
56 changed files with 1159 additions and 955 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
PENDING.md
View File

@ -23,6 +23,7 @@ BREAKING CHANGES
* [\#3457](https://github.com/cosmos/cosmos-sdk/issues/3457) Changed governance tally validatorGovInfo to use sdk.Int power instead of sdk.Dec
* SDK
* \#2513 Tendermint updates are adjusted by 10^-6 relative to staking tokens,
* [\#3487](https://github.com/cosmos/cosmos-sdk/pull/3487) Move HTTP/REST utilities out of client/utils into a new dedicated client/rest package.
* [\#3490](https://github.com/cosmos/cosmos-sdk/issues/3490) ReadRESTReq() returns bool to avoid callers to write error responses twice.
* [\#3502](https://github.com/cosmos/cosmos-sdk/pull/3502) Fixes issue when comparing genesis states
@ -79,6 +80,7 @@ IMPROVEMENTS
* [\#2605] x/params add subkey accessing
* [\#2986](https://github.com/cosmos/cosmos-sdk/pull/2986) Store Refactor
* \#3435 Test that store implementations do not allow nil values
* \#2509 Sanitize all usage of Dec.RoundInt64()
* [\#556](https://github.com/cosmos/cosmos-sdk/issues/556) Increase `BaseApp`
test coverage.

166
client/lcd/lcd_test.go
View File

@ -27,7 +27,6 @@ import (
"github.com/cosmos/cosmos-sdk/x/gov"
"github.com/cosmos/cosmos-sdk/x/slashing"
"github.com/cosmos/cosmos-sdk/x/staking"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
)
const (
@ -39,7 +38,7 @@ const (
altPw = "12345678901"
)
var fees = sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)}
var fees = sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 5)}
func init() {
mintkey.BcryptSecurityParameter = 1
@ -48,7 +47,7 @@ func init() {
func TestSeedsAreDifferent(t *testing.T) {
addr, _ := CreateAddr(t, name1, pw, GetKeyBase(t))
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
defer cleanup()
mnemonic1 := getKeysSeed(t, port)
@ -58,7 +57,7 @@ func TestSeedsAreDifferent(t *testing.T) {
}
func TestKeyRecover(t *testing.T) {
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
defer cleanup()
myName1 := "TestKeyRecover_1"
@ -79,7 +78,7 @@ func TestKeyRecover(t *testing.T) {
}
func TestKeyRecoverHDPath(t *testing.T) {
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
defer cleanup()
mnemonic := getKeysSeed(t, port)
@ -108,7 +107,7 @@ func TestKeys(t *testing.T) {
addr1, _ := CreateAddr(t, name1, pw, GetKeyBase(t))
addr1Bech32 := addr1.String()
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr1})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr1}, true)
defer cleanup()
// get new seed & recover key
@ -157,7 +156,7 @@ func TestVersion(t *testing.T) {
t.SkipNow()
}
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
defer cleanup()
// node info
@ -180,14 +179,14 @@ func TestVersion(t *testing.T) {
}
func TestNodeStatus(t *testing.T) {
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
defer cleanup()
getNodeInfo(t, port)
getSyncStatus(t, port, false)
}
func TestBlock(t *testing.T) {
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
defer cleanup()
getBlock(t, port, -1, false)
getBlock(t, port, 2, false)
@ -195,7 +194,7 @@ func TestBlock(t *testing.T) {
}
func TestValidators(t *testing.T) {
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
defer cleanup()
resultVals := getValidatorSets(t, port, -1, false)
require.Contains(t, resultVals.Validators[0].Address.String(), "cosmosvalcons")
@ -206,7 +205,7 @@ func TestValidators(t *testing.T) {
func TestCoinSend(t *testing.T) {
addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
defer cleanup()
bz, err := hex.DecodeString("8FA6AB57AD6870F6B5B2E57735F38F2F30E73CB6")
@ -232,14 +231,14 @@ func TestCoinSend(t *testing.T) {
coins := acc.GetCoins()
expectedBalance := initialBalance[0].Minus(fees[0])
require.Equal(t, stakingTypes.DefaultBondDenom, coins[0].Denom)
require.Equal(t, staking.DefaultBondDenom, coins[0].Denom)
require.Equal(t, expectedBalance.Amount.SubRaw(1), coins[0].Amount)
expectedBalance = coins[0]
// query receiver
acc2 := getAccount(t, port, receiveAddr)
coins2 := acc2.GetCoins()
require.Equal(t, stakingTypes.DefaultBondDenom, coins2[0].Denom)
require.Equal(t, staking.DefaultBondDenom, coins2[0].Denom)
require.Equal(t, int64(1), coins2[0].Amount.Int64())
// test failure with too little gas
@ -275,7 +274,7 @@ func TestCoinSend(t *testing.T) {
require.NotZero(t, gasEstResp.GasEstimate)
acc = getAccount(t, port, addr)
require.Equal(t, expectedBalance.Amount, acc.GetCoins().AmountOf(stakingTypes.DefaultBondDenom))
require.Equal(t, expectedBalance.Amount, acc.GetCoins().AmountOf(staking.DefaultBondDenom))
// run successful tx
gas := fmt.Sprintf("%d", gasEstResp.GasEstimate)
@ -290,12 +289,12 @@ func TestCoinSend(t *testing.T) {
acc = getAccount(t, port, addr)
expectedBalance = expectedBalance.Minus(fees[0])
require.Equal(t, expectedBalance.Amount.SubRaw(1), acc.GetCoins().AmountOf(stakingTypes.DefaultBondDenom))
require.Equal(t, expectedBalance.Amount.SubRaw(1), acc.GetCoins().AmountOf(staking.DefaultBondDenom))
}
func TestCoinSendAccAuto(t *testing.T) {
addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
defer cleanup()
acc := getAccount(t, port, addr)
@ -310,13 +309,13 @@ func TestCoinSendAccAuto(t *testing.T) {
coins := acc.GetCoins()
expectedBalance := initialBalance[0].Minus(fees[0])
require.Equal(t, stakingTypes.DefaultBondDenom, coins[0].Denom)
require.Equal(t, staking.DefaultBondDenom, coins[0].Denom)
require.Equal(t, expectedBalance.Amount.SubRaw(1), coins[0].Amount)
}
func TestCoinMultiSendGenerateOnly(t *testing.T) {
addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
defer cleanup()
// generate only
@ -337,7 +336,7 @@ func TestCoinMultiSendGenerateOnly(t *testing.T) {
func TestCoinSendGenerateSignAndBroadcast(t *testing.T) {
addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
defer cleanup()
acc := getAccount(t, port, addr)
@ -409,7 +408,7 @@ func TestCoinSendGenerateSignAndBroadcast(t *testing.T) {
func TestTxs(t *testing.T) {
addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
defer cleanup()
var emptyTxs []sdk.TxResponse
@ -448,7 +447,7 @@ func TestTxs(t *testing.T) {
func TestPoolParamsQuery(t *testing.T) {
addr, _ := CreateAddr(t, name1, pw, GetKeyBase(t))
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
defer cleanup()
defaultParams := staking.DefaultParams()
@ -459,16 +458,21 @@ func TestPoolParamsQuery(t *testing.T) {
pool := getStakingPool(t, port)
initialPool := staking.InitialPool()
initialPool.NotBondedTokens = initialPool.NotBondedTokens.Add(sdk.NewInt(100))
initialPool.BondedTokens = initialPool.BondedTokens.Add(sdk.NewInt(100)) // Delegate tx on GaiaAppGenState
initialPool.NotBondedTokens = initialPool.NotBondedTokens.Add(sdk.NewInt(50)) // freeFermionsAcc = 50 on GaiaAppGenState
tokens := staking.TokensFromTendermintPower(100)
freeFermions := staking.TokensFromTendermintPower(50)
initialPool.NotBondedTokens = initialPool.NotBondedTokens.Add(tokens)
initialPool.BondedTokens = initialPool.BondedTokens.Add(tokens) // Delegate tx on GaiaAppGenState
initialPool.NotBondedTokens = initialPool.NotBondedTokens.Add(freeFermions) // freeFermionsAcc = 50 on GaiaAppGenState
require.Equal(t, initialPool.BondedTokens, pool.BondedTokens)
require.Equal(t, initialPool.NotBondedTokens, pool.NotBondedTokens)
//TODO include this test once REST for distribution is online, need to include distribution tokens from inflation
// for this equality to make sense
//require.Equal(t, initialPool.NotBondedTokens, pool.NotBondedTokens)
}
func TestValidatorsQuery(t *testing.T) {
cleanup, valPubKeys, operAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
cleanup, valPubKeys, operAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
defer cleanup()
require.Equal(t, 1, len(valPubKeys))
@ -488,7 +492,7 @@ func TestValidatorsQuery(t *testing.T) {
}
func TestValidatorQuery(t *testing.T) {
cleanup, valPubKeys, operAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
cleanup, valPubKeys, operAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
defer cleanup()
require.Equal(t, 1, len(valPubKeys))
require.Equal(t, 1, len(operAddrs))
@ -500,20 +504,22 @@ func TestValidatorQuery(t *testing.T) {
func TestBonding(t *testing.T) {
addr, _ := CreateAddr(t, name1, pw, GetKeyBase(t))
cleanup, valPubKeys, operAddrs, port := InitializeTestLCD(t, 2, []sdk.AccAddress{addr})
cleanup, valPubKeys, operAddrs, port := InitializeTestLCD(t, 2, []sdk.AccAddress{addr}, true)
defer cleanup()
require.Equal(t, 2, len(valPubKeys))
require.Equal(t, 2, len(operAddrs))
amt := sdk.NewDec(60)
amt := staking.TokensFromTendermintPower(60)
amtDec := sdk.NewDecFromInt(amt)
validator := getValidator(t, port, operAddrs[0])
acc := getAccount(t, port, addr)
initialBalance := acc.GetCoins()
// create bond TX
resultTx := doDelegate(t, port, name1, pw, addr, operAddrs[0], 60, fees)
delTokens := staking.TokensFromTendermintPower(60)
resultTx := doDelegate(t, port, name1, pw, addr, operAddrs[0], delTokens, fees)
tests.WaitForHeight(resultTx.Height+1, port)
require.Equal(t, uint32(0), resultTx.Code)
@ -530,16 +536,16 @@ func TestBonding(t *testing.T) {
acc = getAccount(t, port, addr)
coins := acc.GetCoins()
expectedBalance := initialBalance[0].Minus(fees[0])
require.Equal(t, expectedBalance.Amount.SubRaw(60), coins.AmountOf(stakingTypes.DefaultBondDenom))
require.Equal(t, expectedBalance.Amount.Sub(delTokens), coins.AmountOf(staking.DefaultBondDenom))
expectedBalance = coins[0]
// query delegation
bond := getDelegation(t, port, addr, operAddrs[0])
require.Equal(t, amt, bond.Shares)
require.Equal(t, amtDec, bond.Shares)
delegatorDels := getDelegatorDelegations(t, port, addr)
require.Len(t, delegatorDels, 1)
require.Equal(t, amt, delegatorDels[0].Shares)
require.Equal(t, amtDec, delegatorDels[0].Shares)
// query all delegations to validator
bonds := getValidatorDelegations(t, port, operAddrs[0])
@ -548,13 +554,14 @@ func TestBonding(t *testing.T) {
bondedValidators := getDelegatorValidators(t, port, addr)
require.Len(t, bondedValidators, 1)
require.Equal(t, operAddrs[0], bondedValidators[0].OperatorAddr)
require.Equal(t, validator.DelegatorShares.Add(amt).String(), bondedValidators[0].DelegatorShares.String())
require.Equal(t, validator.DelegatorShares.Add(amtDec).String(), bondedValidators[0].DelegatorShares.String())
bondedValidator := getDelegatorValidator(t, port, addr, operAddrs[0])
require.Equal(t, operAddrs[0], bondedValidator.OperatorAddr)
// testing unbonding
resultTx = doUndelegate(t, port, name1, pw, addr, operAddrs[0], 30, fees)
unbondingTokens := staking.TokensFromTendermintPower(30)
resultTx = doUndelegate(t, port, name1, pw, addr, operAddrs[0], unbondingTokens, fees)
tests.WaitForHeight(resultTx.Height+1, port)
require.Equal(t, uint32(0), resultTx.Code)
@ -564,8 +571,8 @@ func TestBonding(t *testing.T) {
coins = acc.GetCoins()
expectedBalance = expectedBalance.Minus(fees[0])
require.True(t,
expectedBalance.Amount.LT(coins.AmountOf(stakingTypes.DefaultBondDenom)) ||
expectedBalance.Amount.Equal(coins.AmountOf(stakingTypes.DefaultBondDenom)),
expectedBalance.Amount.LT(coins.AmountOf(staking.DefaultBondDenom)) ||
expectedBalance.Amount.Equal(coins.AmountOf(staking.DefaultBondDenom)),
"should get tokens back from automatic withdrawal after an unbonding delegation",
)
expectedBalance = coins[0]
@ -580,10 +587,11 @@ func TestBonding(t *testing.T) {
ubd := getUnbondingDelegation(t, port, addr, operAddrs[0])
require.Len(t, ubd.Entries, 1)
require.Equal(t, int64(30), ubd.Entries[0].Balance.Amount.Int64())
require.Equal(t, delTokens.DivRaw(2), ubd.Entries[0].Balance.Amount)
// test redelegation
resultTx = doBeginRedelegation(t, port, name1, pw, addr, operAddrs[0], operAddrs[1], 30, fees)
rdTokens := staking.TokensFromTendermintPower(30)
resultTx = doBeginRedelegation(t, port, name1, pw, addr, operAddrs[0], operAddrs[1], rdTokens, fees)
tests.WaitForHeight(resultTx.Height+1, port)
require.Equal(t, uint32(0), resultTx.Code)
@ -592,8 +600,8 @@ func TestBonding(t *testing.T) {
acc = getAccount(t, port, addr)
expectedBalance = expectedBalance.Minus(fees[0])
require.True(t,
expectedBalance.Amount.LT(coins.AmountOf(stakingTypes.DefaultBondDenom)) ||
expectedBalance.Amount.Equal(coins.AmountOf(stakingTypes.DefaultBondDenom)),
expectedBalance.Amount.LT(coins.AmountOf(staking.DefaultBondDenom)) ||
expectedBalance.Amount.Equal(coins.AmountOf(staking.DefaultBondDenom)),
"should get tokens back from automatic withdrawal after an unbonding delegation",
)
@ -607,34 +615,35 @@ func TestBonding(t *testing.T) {
require.Equal(t, resultTx.Height, txs[0].Height)
// query delegations, unbondings and redelegations from validator and delegator
rdShares := sdk.NewDecFromInt(rdTokens)
delegatorDels = getDelegatorDelegations(t, port, addr)
require.Len(t, delegatorDels, 1)
require.Equal(t, "30.000000000000000000", delegatorDels[0].GetShares().String())
require.Equal(t, rdShares, delegatorDels[0].GetShares())
redelegation := getRedelegations(t, port, addr, operAddrs[0], operAddrs[1])
require.Len(t, redelegation, 1)
require.Len(t, redelegation[0].Entries, 1)
require.Equal(t, "30", redelegation[0].Entries[0].Balance.Amount.String())
require.Equal(t, rdTokens, redelegation[0].Entries[0].Balance.Amount)
delegatorUbds := getDelegatorUnbondingDelegations(t, port, addr)
require.Len(t, delegatorUbds, 1)
require.Len(t, delegatorUbds[0].Entries, 1)
require.Equal(t, "30", delegatorUbds[0].Entries[0].Balance.Amount.String())
require.Equal(t, rdTokens, delegatorUbds[0].Entries[0].Balance.Amount)
delegatorReds := getRedelegations(t, port, addr, nil, nil)
require.Len(t, delegatorReds, 1)
require.Len(t, delegatorReds[0].Entries, 1)
require.Equal(t, "30", delegatorReds[0].Entries[0].Balance.Amount.String())
require.Equal(t, rdTokens, delegatorReds[0].Entries[0].Balance.Amount)
validatorUbds := getValidatorUnbondingDelegations(t, port, operAddrs[0])
require.Len(t, validatorUbds, 1)
require.Len(t, validatorUbds[0].Entries, 1)
require.Equal(t, "30", validatorUbds[0].Entries[0].Balance.Amount.String())
require.Equal(t, rdTokens, validatorUbds[0].Entries[0].Balance.Amount)
validatorReds := getRedelegations(t, port, nil, operAddrs[0], nil)
require.Len(t, validatorReds, 1)
require.Len(t, validatorReds[0].Entries, 1)
require.Equal(t, "30", validatorReds[0].Entries[0].Balance.Amount.String())
require.Equal(t, rdTokens, validatorReds[0].Entries[0].Balance.Amount)
// TODO Undonding status not currently implemented
// require.Equal(t, sdk.Unbonding, bondedValidators[0].Status)
@ -655,14 +664,15 @@ func TestBonding(t *testing.T) {
func TestSubmitProposal(t *testing.T) {
addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
defer cleanup()
acc := getAccount(t, port, addr)
initialBalance := acc.GetCoins()
// create SubmitProposal TX
resultTx := doSubmitProposal(t, port, seed, name1, pw, addr, 5, fees)
proposalTokens := staking.TokensFromTendermintPower(5)
resultTx := doSubmitProposal(t, port, seed, name1, pw, addr, proposalTokens, fees)
tests.WaitForHeight(resultTx.Height+1, port)
// check if tx was committed
@ -674,7 +684,7 @@ func TestSubmitProposal(t *testing.T) {
// verify balance
acc = getAccount(t, port, addr)
expectedBalance := initialBalance[0].Minus(fees[0])
require.Equal(t, expectedBalance.Amount.SubRaw(5), acc.GetCoins().AmountOf(stakingTypes.DefaultBondDenom))
require.Equal(t, expectedBalance.Amount.Sub(proposalTokens), acc.GetCoins().AmountOf(staking.DefaultBondDenom))
// query proposal
proposal := getProposal(t, port, proposalID)
@ -687,14 +697,15 @@ func TestSubmitProposal(t *testing.T) {
func TestDeposit(t *testing.T) {
addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
defer cleanup()
acc := getAccount(t, port, addr)
initialBalance := acc.GetCoins()
// create SubmitProposal TX
resultTx := doSubmitProposal(t, port, seed, name1, pw, addr, 5, fees)
proposalTokens := staking.TokensFromTendermintPower(5)
resultTx := doSubmitProposal(t, port, seed, name1, pw, addr, proposalTokens, fees)
tests.WaitForHeight(resultTx.Height+1, port)
// check if tx was committed
@ -707,7 +718,7 @@ func TestDeposit(t *testing.T) {
acc = getAccount(t, port, addr)
coins := acc.GetCoins()
expectedBalance := initialBalance[0].Minus(fees[0])
require.Equal(t, expectedBalance.Amount.SubRaw(5), coins.AmountOf(stakingTypes.DefaultBondDenom))
require.Equal(t, expectedBalance.Amount.Sub(proposalTokens), coins.AmountOf(staking.DefaultBondDenom))
expectedBalance = coins[0]
// query proposal
@ -715,13 +726,14 @@ func TestDeposit(t *testing.T) {
require.Equal(t, "Test", proposal.GetTitle())
// create SubmitProposal TX
resultTx = doDeposit(t, port, seed, name1, pw, addr, proposalID, 5, fees)
depositTokens := staking.TokensFromTendermintPower(5)
resultTx = doDeposit(t, port, seed, name1, pw, addr, proposalID, depositTokens, fees)
tests.WaitForHeight(resultTx.Height+1, port)
// verify balance after deposit and fee
acc = getAccount(t, port, addr)
expectedBalance = expectedBalance.Minus(fees[0])
require.Equal(t, expectedBalance.Amount.SubRaw(5), acc.GetCoins().AmountOf(stakingTypes.DefaultBondDenom))
require.Equal(t, expectedBalance.Amount.Sub(depositTokens), acc.GetCoins().AmountOf(staking.DefaultBondDenom))
// query tx
txs := getTransactions(t, port, fmt.Sprintf("action=deposit&depositor=%s", addr))
@ -729,24 +741,26 @@ func TestDeposit(t *testing.T) {
require.Equal(t, resultTx.Height, txs[0].Height)
// query proposal
totalCoins := sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, staking.TokensFromTendermintPower(10))}
proposal = getProposal(t, port, proposalID)
require.True(t, proposal.GetTotalDeposit().IsEqual(sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10)}))
require.True(t, proposal.GetTotalDeposit().IsEqual(totalCoins))
// query deposit
deposit := getDeposit(t, port, proposalID, addr)
require.True(t, deposit.Amount.IsEqual(sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10)}))
require.True(t, deposit.Amount.IsEqual(totalCoins))
}
func TestVote(t *testing.T) {
addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
cleanup, _, operAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
cleanup, _, operAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
defer cleanup()
acc := getAccount(t, port, addr)
initialBalance := acc.GetCoins()
// create SubmitProposal TX
resultTx := doSubmitProposal(t, port, seed, name1, pw, addr, 10, fees)
proposalTokens := staking.TokensFromTendermintPower(10)
resultTx := doSubmitProposal(t, port, seed, name1, pw, addr, proposalTokens, fees)
tests.WaitForHeight(resultTx.Height+1, port)
// check if tx was committed
@ -759,7 +773,7 @@ func TestVote(t *testing.T) {
acc = getAccount(t, port, addr)
coins := acc.GetCoins()
expectedBalance := initialBalance[0].Minus(fees[0])
require.Equal(t, expectedBalance.Amount.SubRaw(10), coins.AmountOf(stakingTypes.DefaultBondDenom))
require.Equal(t, expectedBalance.Amount.Sub(proposalTokens), coins.AmountOf(staking.DefaultBondDenom))
expectedBalance = coins[0]
// query proposal
@ -775,7 +789,7 @@ func TestVote(t *testing.T) {
acc = getAccount(t, port, addr)
coins = acc.GetCoins()
expectedBalance = expectedBalance.Minus(fees[0])
require.Equal(t, expectedBalance.Amount, coins.AmountOf(stakingTypes.DefaultBondDenom))
require.Equal(t, expectedBalance.Amount, coins.AmountOf(staking.DefaultBondDenom))
expectedBalance = coins[0]
// query tx
@ -791,18 +805,19 @@ func TestVote(t *testing.T) {
require.Equal(t, sdk.ZeroDec(), tally.Yes, "tally should be 0 as the address is not bonded")
// create bond TX
resultTx = doDelegate(t, port, name1, pw, addr, operAddrs[0], 60, fees)
delTokens := staking.TokensFromTendermintPower(60)
resultTx = doDelegate(t, port, name1, pw, addr, operAddrs[0], delTokens, fees)
tests.WaitForHeight(resultTx.Height+1, port)
// verify balance
acc = getAccount(t, port, addr)
coins = acc.GetCoins()
expectedBalance = expectedBalance.Minus(fees[0])
require.Equal(t, expectedBalance.Amount.SubRaw(60), coins.AmountOf(stakingTypes.DefaultBondDenom))
require.Equal(t, expectedBalance.Amount.Sub(delTokens), coins.AmountOf(staking.DefaultBondDenom))
expectedBalance = coins[0]
tally = getTally(t, port, proposalID)
require.Equal(t, sdk.NewDec(60), tally.Yes, "tally should be equal to the amount delegated")
require.Equal(t, sdk.NewDecFromInt(delTokens), tally.Yes, "tally should be equal to the amount delegated")
// change vote option
resultTx = doVote(t, port, seed, name1, pw, addr, proposalID, "No", fees)
@ -811,16 +826,16 @@ func TestVote(t *testing.T) {
// verify balance
acc = getAccount(t, port, addr)
expectedBalance = expectedBalance.Minus(fees[0])
require.Equal(t, expectedBalance.Amount, acc.GetCoins().AmountOf(stakingTypes.DefaultBondDenom))
require.Equal(t, expectedBalance.Amount, acc.GetCoins().AmountOf(staking.DefaultBondDenom))
tally = getTally(t, port, proposalID)
require.Equal(t, sdk.ZeroDec(), tally.Yes, "tally should be 0 the user changed the option")
require.Equal(t, sdk.NewDec(60), tally.No, "tally should be equal to the amount delegated")
require.Equal(t, sdk.NewDecFromInt(delTokens), tally.No, "tally should be equal to the amount delegated")
}
func TestUnjail(t *testing.T) {
addr, _ := CreateAddr(t, name1, pw, GetKeyBase(t))
cleanup, valPubKeys, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
cleanup, valPubKeys, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
defer cleanup()
// XXX: any less than this and it fails
@ -836,11 +851,11 @@ func TestUnjail(t *testing.T) {
func TestProposalsQuery(t *testing.T) {
addrs, seeds, names, passwords := CreateAddrs(t, GetKeyBase(t), 2)
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addrs[0], addrs[1]})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addrs[0], addrs[1]}, true)
defer cleanup()
depositParam := getDepositParam(t, port)
halfMinDeposit := depositParam.MinDeposit.AmountOf(stakingTypes.DefaultBondDenom).Int64() / 2
halfMinDeposit := depositParam.MinDeposit.AmountOf(staking.DefaultBondDenom).DivRaw(2)
getVotingParam(t, port)
getTallyingParam(t, port)
@ -887,7 +902,8 @@ func TestProposalsQuery(t *testing.T) {
require.Equal(t, deposit, deposits[0])
// increasing the amount of the deposit should update the existing one
resultTx = doDeposit(t, port, seeds[0], names[0], passwords[0], addrs[0], proposalID1, 1, fees)
depositTokens := staking.TokensFromTendermintPower(1)
resultTx = doDeposit(t, port, seeds[0], names[0], passwords[0], addrs[0], proposalID1, depositTokens, fees)
tests.WaitForHeight(resultTx.Height+1, port)
deposits = getDeposits(t, port, proposalID1)
@ -955,7 +971,7 @@ func TestProposalsQuery(t *testing.T) {
}
func TestSlashingGetParams(t *testing.T) {
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
defer cleanup()
res, body := Request(t, port, "GET", "/slashing/parameters", nil)
@ -967,7 +983,7 @@ func TestSlashingGetParams(t *testing.T) {
}
func TestDistributionGetParams(t *testing.T) {
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
defer cleanup()
res, body := Request(t, port, "GET", "/distribution/parameters", nil)
@ -977,8 +993,7 @@ func TestDistributionGetParams(t *testing.T) {
func TestDistributionFlow(t *testing.T) {
addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
//addr2, seed2 = CreateAddr(t, name2, pw, GetKeyBase(t))
cleanup, _, valAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
cleanup, _, valAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, false)
defer cleanup()
valAddr := valAddrs[0]
@ -999,7 +1014,8 @@ func TestDistributionFlow(t *testing.T) {
require.Equal(t, valDistInfo.SelfBondRewards, sdk.DecCoins(nil))
// Delegate some coins
resultTx := doDelegate(t, port, name1, pw, addr, valAddr, 60, fees)
delTokens := staking.TokensFromTendermintPower(60)
resultTx := doDelegate(t, port, name1, pw, addr, valAddr, delTokens, fees)
tests.WaitForHeight(resultTx.Height+1, port)
require.Equal(t, uint32(0), resultTx.Code)

102
client/lcd/test_helpers.go
View File

@ -15,6 +15,9 @@ import (
"strings"
"testing"
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/keys"
"github.com/cosmos/cosmos-sdk/client/rest"
@ -23,26 +26,22 @@ import (
gapp "github.com/cosmos/cosmos-sdk/cmd/gaia/app"
"github.com/cosmos/cosmos-sdk/codec"
crkeys "github.com/cosmos/cosmos-sdk/crypto/keys"
cryptoKeys "github.com/cosmos/cosmos-sdk/crypto/keys"
"github.com/cosmos/cosmos-sdk/server"
"github.com/cosmos/cosmos-sdk/tests"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
authRest "github.com/cosmos/cosmos-sdk/x/auth/client/rest"
authrest "github.com/cosmos/cosmos-sdk/x/auth/client/rest"
txbuilder "github.com/cosmos/cosmos-sdk/x/auth/client/txbuilder"
bankRest "github.com/cosmos/cosmos-sdk/x/bank/client/rest"
bankrest "github.com/cosmos/cosmos-sdk/x/bank/client/rest"
distr "github.com/cosmos/cosmos-sdk/x/distribution"
distrrest "github.com/cosmos/cosmos-sdk/x/distribution/client/rest"
"github.com/cosmos/cosmos-sdk/x/gov"
govRest "github.com/cosmos/cosmos-sdk/x/gov/client/rest"
govrest "github.com/cosmos/cosmos-sdk/x/gov/client/rest"
gcutils "github.com/cosmos/cosmos-sdk/x/gov/client/utils"
"github.com/cosmos/cosmos-sdk/x/slashing"
slashingRest "github.com/cosmos/cosmos-sdk/x/slashing/client/rest"
slashingrest "github.com/cosmos/cosmos-sdk/x/slashing/client/rest"
"github.com/cosmos/cosmos-sdk/x/staking"
stakingRest "github.com/cosmos/cosmos-sdk/x/staking/client/rest"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
stakingrest "github.com/cosmos/cosmos-sdk/x/staking/client/rest"
abci "github.com/tendermint/tendermint/abci/types"
tmcfg "github.com/tendermint/tendermint/config"
@ -59,9 +58,6 @@ import (
ctypes "github.com/tendermint/tendermint/rpc/core/types"
tmrpc "github.com/tendermint/tendermint/rpc/lib/server"
tmtypes "github.com/tendermint/tendermint/types"
distr "github.com/cosmos/cosmos-sdk/x/distribution"
distrRest "github.com/cosmos/cosmos-sdk/x/distribution/client/rest"
)
// makePathname creates a unique pathname for each test. It will panic if it
@ -202,9 +198,8 @@ func (b AddrSeedSlice) Swap(i, j int) {
// their respective sockets where nValidators is the total number of validators
// and initAddrs are the accounts to initialize with some steak tokens. It
// returns a cleanup function, a set of validator public keys, and a port.
func InitializeTestLCD(
t *testing.T, nValidators int, initAddrs []sdk.AccAddress,
) (cleanup func(), valConsPubKeys []crypto.PubKey, valOperAddrs []sdk.ValAddress, port string) {
func InitializeTestLCD(t *testing.T, nValidators int, initAddrs []sdk.AccAddress, minting bool) (
cleanup func(), valConsPubKeys []crypto.PubKey, valOperAddrs []sdk.ValAddress, port string) {
if nValidators < 1 {
panic("InitializeTestLCD must use at least one validator")
@ -239,16 +234,19 @@ func InitializeTestLCD(
operPrivKey := secp256k1.GenPrivKey()
operAddr := operPrivKey.PubKey().Address()
pubKey := privVal.GetPubKey()
delegation := 100
power := int64(100)
if i > 0 {
pubKey = ed25519.GenPrivKey().PubKey()
delegation = 1
power = 1
}
startTokens := staking.TokensFromTendermintPower(power)
msg := staking.NewMsgCreateValidator(
sdk.ValAddress(operAddr),
pubKey,
sdk.NewCoin(stakingTypes.DefaultBondDenom, sdk.NewInt(int64(delegation))),
staking.Description{Moniker: fmt.Sprintf("validator-%d", i+1)},
sdk.NewCoin(staking.DefaultBondDenom, startTokens),
staking.NewDescription(fmt.Sprintf("validator-%d", i+1), "", "", ""),
staking.NewCommissionMsg(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()),
)
stdSignMsg := txbuilder.StdSignMsg{
@ -260,12 +258,14 @@ func InitializeTestLCD(
tx := auth.NewStdTx([]sdk.Msg{msg}, auth.StdFee{}, []auth.StdSignature{{Signature: sig, PubKey: operPrivKey.PubKey()}}, "")
txBytes, err := cdc.MarshalJSON(tx)
require.Nil(t, err)
genTxs = append(genTxs, txBytes)
valConsPubKeys = append(valConsPubKeys, pubKey)
valOperAddrs = append(valOperAddrs, sdk.ValAddress(operAddr))
accAuth := auth.NewBaseAccountWithAddress(sdk.AccAddress(operAddr))
accAuth.Coins = sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 150)}
accTokens := staking.TokensFromTendermintPower(150)
accAuth.Coins = sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, accTokens)}
accs = append(accs, gapp.NewGenesisAccount(&accAuth))
}
@ -279,15 +279,21 @@ func InitializeTestLCD(
// add some tokens to init accounts
for _, addr := range initAddrs {
accAuth := auth.NewBaseAccountWithAddress(addr)
accAuth.Coins = sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 100)}
accTokens := staking.TokensFromTendermintPower(100)
accAuth.Coins = sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, accTokens)}
acc := gapp.NewGenesisAccount(&accAuth)
genesisState.Accounts = append(genesisState.Accounts, acc)
genesisState.StakingData.Pool.NotBondedTokens = genesisState.StakingData.Pool.NotBondedTokens.Add(sdk.NewInt(100))
genesisState.StakingData.Pool.NotBondedTokens = genesisState.StakingData.Pool.NotBondedTokens.Add(accTokens)
}
inflationMin := sdk.MustNewDecFromStr("10000.0")
inflationMin := sdk.ZeroDec()
if minting {
inflationMin = sdk.MustNewDecFromStr("10000.0")
genesisState.MintData.Params.InflationMax = sdk.MustNewDecFromStr("15000.0")
} else {
genesisState.MintData.Params.InflationMax = inflationMin
}
genesisState.MintData.Minter.Inflation = inflationMin
genesisState.MintData.Params.InflationMax = sdk.MustNewDecFromStr("15000.0")
genesisState.MintData.Params.InflationMin = inflationMin
appState, err := codec.MarshalJSONIndent(cdc, genesisState)
@ -335,6 +341,7 @@ func startTM(
tmcfg *tmcfg.Config, logger log.Logger, genDoc *tmtypes.GenesisDoc,
privVal tmtypes.PrivValidator, app abci.Application,
) (*nm.Node, error) {
genDocProvider := func() (*tmtypes.GenesisDoc, error) { return genDoc, nil }
dbProvider := func(*nm.DBContext) (dbm.DB, error) { return dbm.NewMemDB(), nil }
nodeKey, err := p2p.LoadOrGenNodeKey(tmcfg.NodeKeyFile())
@ -384,12 +391,12 @@ func registerRoutes(rs *RestServer) {
keys.RegisterRoutes(rs.Mux, rs.CliCtx.Indent)
rpc.RegisterRoutes(rs.CliCtx, rs.Mux)
tx.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc)
authRest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, auth.StoreKey)
bankRest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
distrRest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, distr.StoreKey)
stakingRest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
slashingRest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
govRest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc)
authrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, auth.StoreKey)
bankrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
distrrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, distr.StoreKey)
stakingrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
slashingrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
govrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc)
}
// Request makes a test LCD test request. It returns a response object and a
@ -678,7 +685,7 @@ func doTransferWithGas(
kb := client.MockKeyBase()
receiveInfo, _, err := kb.CreateMnemonic(
"receive_address", cryptoKeys.English, gapp.DefaultKeyPass, cryptoKeys.SigningAlgo("secp256k1"),
"receive_address", crkeys.English, gapp.DefaultKeyPass, crkeys.SigningAlgo("secp256k1"),
)
require.Nil(t, err)
@ -700,7 +707,7 @@ func doTransferWithGas(
)
sr := rest.SendReq{
Amount: sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 1)},
Amount: sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 1)},
BaseReq: baseReq,
}
@ -720,7 +727,7 @@ func doTransferWithGasAccAuto(
kb := client.MockKeyBase()
receiveInfo, _, err := kb.CreateMnemonic(
"receive_address", cryptoKeys.English, gapp.DefaultKeyPass, cryptoKeys.SigningAlgo("secp256k1"),
"receive_address", crkeys.English, gapp.DefaultKeyPass, crkeys.SigningAlgo("secp256k1"),
)
require.Nil(t, err)
@ -733,7 +740,7 @@ func doTransferWithGasAccAuto(
)
sr := rest.SendReq{
Amount: sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 1)},
Amount: sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 1)},
BaseReq: baseReq,
}
@ -755,7 +762,8 @@ type sendReq struct {
// POST /staking/delegators/{delegatorAddr}/delegations Submit delegation
func doDelegate(t *testing.T, port, name, password string,
delAddr sdk.AccAddress, valAddr sdk.ValAddress, amount int64, fees sdk.Coins) (resultTx sdk.TxResponse) {
delAddr sdk.AccAddress, valAddr sdk.ValAddress, amount sdk.Int, fees sdk.Coins) (resultTx sdk.TxResponse) {
acc := getAccount(t, port, delAddr)
accnum := acc.GetAccountNumber()
sequence := acc.GetSequence()
@ -765,7 +773,7 @@ func doDelegate(t *testing.T, port, name, password string,
BaseReq: baseReq,
DelegatorAddr: delAddr,
ValidatorAddr: valAddr,
Delegation: sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, amount),
Delegation: sdk.NewCoin(staking.DefaultBondDenom, amount),
}
req, err := cdc.MarshalJSON(msg)
require.NoError(t, err)
@ -788,7 +796,7 @@ type msgDelegationsInput struct {
// POST /staking/delegators/{delegatorAddr}/delegations Submit delegation
func doUndelegate(t *testing.T, port, name, password string,
delAddr sdk.AccAddress, valAddr sdk.ValAddress, amount int64, fees sdk.Coins) (resultTx sdk.TxResponse) {
delAddr sdk.AccAddress, valAddr sdk.ValAddress, amount sdk.Int, fees sdk.Coins) (resultTx sdk.TxResponse) {
acc := getAccount(t, port, delAddr)
accnum := acc.GetAccountNumber()
@ -799,7 +807,7 @@ func doUndelegate(t *testing.T, port, name, password string,
BaseReq: baseReq,
DelegatorAddr: delAddr,
ValidatorAddr: valAddr,
SharesAmount: sdk.NewDec(amount),
SharesAmount: sdk.NewDecFromInt(amount),
}
req, err := cdc.MarshalJSON(msg)
require.NoError(t, err)
@ -823,7 +831,8 @@ type msgUndelegateInput struct {
// POST /staking/delegators/{delegatorAddr}/delegations Submit delegation
func doBeginRedelegation(t *testing.T, port, name, password string,
delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress, amount int64, fees sdk.Coins) (resultTx sdk.TxResponse) {
delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress, amount sdk.Int,
fees sdk.Coins) (resultTx sdk.TxResponse) {
acc := getAccount(t, port, delAddr)
accnum := acc.GetAccountNumber()
@ -837,7 +846,7 @@ func doBeginRedelegation(t *testing.T, port, name, password string,
DelegatorAddr: delAddr,
ValidatorSrcAddr: valSrcAddr,
ValidatorDstAddr: valDstAddr,
SharesAmount: sdk.NewDec(amount),
SharesAmount: sdk.NewDecFromInt(amount),
}
req, err := cdc.MarshalJSON(msg)
require.NoError(t, err)
@ -1056,7 +1065,9 @@ func getStakingParams(t *testing.T, port string) staking.Params {
// ICS 22 - Gov
// ----------------------------------------------------------------------
// POST /gov/proposals Submit a proposal
func doSubmitProposal(t *testing.T, port, seed, name, password string, proposerAddr sdk.AccAddress, amount int64, fees sdk.Coins) (resultTx sdk.TxResponse) {
func doSubmitProposal(t *testing.T, port, seed, name, password string, proposerAddr sdk.AccAddress,
amount sdk.Int, fees sdk.Coins) (resultTx sdk.TxResponse) {
acc := getAccount(t, port, proposerAddr)
accnum := acc.GetAccountNumber()
sequence := acc.GetSequence()
@ -1068,7 +1079,7 @@ func doSubmitProposal(t *testing.T, port, seed, name, password string, proposerA
Description: "test",
ProposalType: "Text",
Proposer: proposerAddr,
InitialDeposit: sdk.Coins{sdk.NewCoin(stakingTypes.DefaultBondDenom, sdk.NewInt(amount))},
InitialDeposit: sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, amount)},
BaseReq: baseReq,
}
@ -1151,7 +1162,8 @@ func getProposalsFilterStatus(t *testing.T, port string, status gov.ProposalStat
}
// POST /gov/proposals/{proposalId}/deposits Deposit tokens to a proposal
func doDeposit(t *testing.T, port, seed, name, password string, proposerAddr sdk.AccAddress, proposalID uint64, amount int64, fees sdk.Coins) (resultTx sdk.TxResponse) {
func doDeposit(t *testing.T, port, seed, name, password string, proposerAddr sdk.AccAddress, proposalID uint64,
amount sdk.Int, fees sdk.Coins) (resultTx sdk.TxResponse) {
acc := getAccount(t, port, proposerAddr)
accnum := acc.GetAccountNumber()
@ -1161,7 +1173,7 @@ func doDeposit(t *testing.T, port, seed, name, password string, proposerAddr sdk
dr := rest.DepositReq{
Depositor: proposerAddr,
Amount: sdk.Coins{sdk.NewCoin(stakingTypes.DefaultBondDenom, sdk.NewInt(amount))},
Amount: sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, amount)},
BaseReq: baseReq,
}

6
cmd/gaia/app/genesis.go
View File

@ -23,14 +23,12 @@ import (
"github.com/cosmos/cosmos-sdk/x/mint"
"github.com/cosmos/cosmos-sdk/x/slashing"
"github.com/cosmos/cosmos-sdk/x/staking"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
)
var (
// bonded tokens given to genesis validators/accounts
freeFermionVal = int64(100)
freeFermionsAcc = sdk.NewInt(150)
bondDenom = stakingTypes.DefaultBondDenom
freeFermionsAcc = staking.TokensFromTendermintPower(150)
bondDenom = staking.DefaultBondDenom
)
// State to Unmarshal

9
cmd/gaia/app/genesis_test.go
View File

@ -15,7 +15,6 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
"github.com/cosmos/cosmos-sdk/x/staking"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
)
var (
@ -104,7 +103,7 @@ func TestGaiaAppGenState(t *testing.T) {
func makeMsg(name string, pk crypto.PubKey) auth.StdTx {
desc := staking.NewDescription(name, "", "", "")
comm := stakingTypes.CommissionMsg{}
comm := staking.CommissionMsg{}
msg := staking.NewMsgCreateValidator(sdk.ValAddress(pk.Address()), pk, sdk.NewInt64Coin(bondDenom,
50), desc, comm)
return auth.NewStdTx([]sdk.Msg{msg}, auth.StdFee{}, nil, "")
@ -131,7 +130,7 @@ func TestGaiaGenesisValidation(t *testing.T) {
// require bonded + jailed validator fails validation
genesisState = makeGenesisState(t, genTxs)
val1 := stakingTypes.NewValidator(addr1, pk1, stakingTypes.Description{Moniker: "test #2"})
val1 := staking.NewValidator(addr1, pk1, staking.NewDescription("test #2", "", "", ""))
val1.Jailed = true
val1.Status = sdk.Bonded
genesisState.StakingData.Validators = append(genesisState.StakingData.Validators, val1)
@ -141,7 +140,7 @@ func TestGaiaGenesisValidation(t *testing.T) {
// require duplicate validator fails validation
val1.Jailed = false
genesisState = makeGenesisState(t, genTxs)
val2 := stakingTypes.NewValidator(addr1, pk1, stakingTypes.Description{Moniker: "test #3"})
val2 := staking.NewValidator(addr1, pk1, staking.NewDescription("test #3", "", "", ""))
genesisState.StakingData.Validators = append(genesisState.StakingData.Validators, val1)
genesisState.StakingData.Validators = append(genesisState.StakingData.Validators, val2)
err = GaiaValidateGenesisState(genesisState)
@ -152,7 +151,7 @@ func TestNewDefaultGenesisAccount(t *testing.T) {
addr := secp256k1.GenPrivKeySecp256k1([]byte("")).PubKey().Address()
acc := NewDefaultGenesisAccount(sdk.AccAddress(addr))
require.Equal(t, sdk.NewInt(1000), acc.Coins.AmountOf("footoken"))
require.Equal(t, sdk.NewInt(150), acc.Coins.AmountOf(bondDenom))
require.Equal(t, staking.TokensFromTendermintPower(150), acc.Coins.AmountOf(bondDenom))
}
func TestGenesisStateSanitize(t *testing.T) {

9
cmd/gaia/app/sim_test.go
View File

@ -34,7 +34,6 @@ import (
slashingsim "github.com/cosmos/cosmos-sdk/x/slashing/simulation"
"github.com/cosmos/cosmos-sdk/x/staking"
stakingsim "github.com/cosmos/cosmos-sdk/x/staking/simulation"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
)
var (
@ -98,7 +97,7 @@ func appStateRandomizedFn(r *rand.Rand, accs []simulation.Account, genesisTimest
// randomly generate some genesis accounts
for i, acc := range accs {
coins := sdk.Coins{sdk.NewCoin(stakingTypes.DefaultBondDenom, sdk.NewInt(amount))}
coins := sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, sdk.NewInt(amount))}
bacc := auth.NewBaseAccountWithAddress(acc.Address)
bacc.SetCoins(coins)
@ -155,7 +154,7 @@ func appStateRandomizedFn(r *rand.Rand, accs []simulation.Account, genesisTimest
govGenesis := gov.GenesisState{
StartingProposalID: uint64(r.Intn(100)),
DepositParams: gov.DepositParams{
MinDeposit: sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, int64(r.Intn(1e3)))},
MinDeposit: sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, int64(r.Intn(1e3)))},
MaxDepositPeriod: vp,
},
VotingParams: gov.VotingParams{
@ -174,7 +173,7 @@ func appStateRandomizedFn(r *rand.Rand, accs []simulation.Account, genesisTimest
Params: staking.Params{
UnbondingTime: time.Duration(randIntBetween(r, 60, 60*60*24*3*2)) * time.Second,
MaxValidators: uint16(r.Intn(250)),
BondDenom: stakingTypes.DefaultBondDenom,
BondDenom: staking.DefaultBondDenom,
},
}
fmt.Printf("Selected randomly generated staking parameters:\n\t%+v\n", stakingGenesis)
@ -195,7 +194,7 @@ func appStateRandomizedFn(r *rand.Rand, accs []simulation.Account, genesisTimest
Minter: mint.InitialMinter(
sdk.NewDecWithPrec(int64(r.Intn(99)), 2)),
Params: mint.NewParams(
stakingTypes.DefaultBondDenom,
staking.DefaultBondDenom,
sdk.NewDecWithPrec(int64(r.Intn(99)), 2),
sdk.NewDecWithPrec(20, 2),
sdk.NewDecWithPrec(7, 2),

128
cmd/gaia/cli_test/cli_test.go
View File

@ -20,7 +20,6 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/gov"
"github.com/cosmos/cosmos-sdk/x/staking"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
)
func TestGaiaCLIKeysAddMultisig(t *testing.T) {
@ -167,8 +166,9 @@ func TestGaiaCLIFeesDeduction(t *testing.T) {
require.Equal(t, fooAmt.Int64(), fooAcc.GetCoins().AmountOf(fooDenom).Int64())
// insufficient funds (coins + fees) tx fails
largeCoins := staking.TokensFromTendermintPower(10000000)
success, _, _ = f.TxSend(
keyFoo, barAddr, sdk.NewInt64Coin(fooDenom, 10000000),
keyFoo, barAddr, sdk.NewCoin(fooDenom, largeCoins),
fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(feeDenom, 2)))
require.False(t, success)
@ -201,45 +201,47 @@ func TestGaiaCLISend(t *testing.T) {
barAddr := f.KeyAddress(keyBar)
fooAcc := f.QueryAccount(fooAddr)
require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(denom).Int64())
startTokens := staking.TokensFromTendermintPower(50)
require.Equal(t, startTokens, fooAcc.GetCoins().AmountOf(denom))
// Send some tokens from one account to the other
f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10))
sendTokens := staking.TokensFromTendermintPower(10)
f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens))
tests.WaitForNextNBlocksTM(1, f.Port)
// Ensure account balances match expected
barAcc := f.QueryAccount(barAddr)
require.Equal(t, int64(10), barAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, sendTokens, barAcc.GetCoins().AmountOf(denom))
fooAcc = f.QueryAccount(fooAddr)
require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, startTokens.Sub(sendTokens), fooAcc.GetCoins().AmountOf(denom))
// Test --dry-run
success, _, _ := f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--dry-run")
success, _, _ := f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--dry-run")
require.True(t, success)
// Check state didn't change
fooAcc = f.QueryAccount(fooAddr)
require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, startTokens.Sub(sendTokens), fooAcc.GetCoins().AmountOf(denom))
// test autosequencing
f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10))
f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens))
tests.WaitForNextNBlocksTM(1, f.Port)
// Ensure account balances match expected
barAcc = f.QueryAccount(barAddr)
require.Equal(t, int64(20), barAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, sendTokens.MulRaw(2), barAcc.GetCoins().AmountOf(denom))
fooAcc = f.QueryAccount(fooAddr)
require.Equal(t, int64(30), fooAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, startTokens.Sub(sendTokens.MulRaw(2)), fooAcc.GetCoins().AmountOf(denom))
// test memo
f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--memo='testmemo'")
f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--memo='testmemo'")
tests.WaitForNextNBlocksTM(1, f.Port)
// Ensure account balances match expected
barAcc = f.QueryAccount(barAddr)
require.Equal(t, int64(30), barAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, sendTokens.MulRaw(3), barAcc.GetCoins().AmountOf(denom))
fooAcc = f.QueryAccount(fooAddr)
require.Equal(t, int64(20), fooAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, startTokens.Sub(sendTokens.MulRaw(3)), fooAcc.GetCoins().AmountOf(denom))
f.Cleanup()
}
@ -256,34 +258,36 @@ func TestGaiaCLIGasAuto(t *testing.T) {
barAddr := f.KeyAddress(keyBar)
fooAcc := f.QueryAccount(fooAddr)
require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(denom).Int64())
startTokens := staking.TokensFromTendermintPower(50)
require.Equal(t, startTokens, fooAcc.GetCoins().AmountOf(denom))
// Test failure with auto gas disabled and very little gas set by hand
success, _, _ := f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--gas=10")
sendTokens := staking.TokensFromTendermintPower(10)
success, _, _ := f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--gas=10")
require.False(t, success)
// Check state didn't change
fooAcc = f.QueryAccount(fooAddr)
require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, startTokens, fooAcc.GetCoins().AmountOf(denom))
// Test failure with negative gas
success, _, _ = f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--gas=-100")
success, _, _ = f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--gas=-100")
require.False(t, success)
// Check state didn't change
fooAcc = f.QueryAccount(fooAddr)
require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, startTokens, fooAcc.GetCoins().AmountOf(denom))
// Test failure with 0 gas
success, _, _ = f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--gas=0")
success, _, _ = f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--gas=0")
require.False(t, success)
// Check state didn't change
fooAcc = f.QueryAccount(fooAddr)
require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, startTokens, fooAcc.GetCoins().AmountOf(denom))
// Enable auto gas
success, stdout, stderr := f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--gas=auto")
success, stdout, stderr := f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--gas=auto")
require.NotEmpty(t, stderr)
require.True(t, success)
cdc := app.MakeCodec()
@ -295,7 +299,7 @@ func TestGaiaCLIGasAuto(t *testing.T) {
// Check state has changed accordingly
fooAcc = f.QueryAccount(fooAddr)
require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, startTokens.Sub(sendTokens), fooAcc.GetCoins().AmountOf(denom))
f.Cleanup()
}
@ -308,23 +312,17 @@ func TestGaiaCLICreateValidator(t *testing.T) {
proc := f.GDStart()
defer proc.Stop(false)
fooAddr := f.KeyAddress(keyFoo)
barAddr := f.KeyAddress(keyBar)
barVal := sdk.ValAddress(barAddr)
consPubKey := sdk.MustBech32ifyConsPub(ed25519.GenPrivKey().PubKey())
f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10))
sendTokens := staking.TokensFromTendermintPower(10)
f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens))
tests.WaitForNextNBlocksTM(1, f.Port)
barAcc := f.QueryAccount(barAddr)
require.Equal(t, int64(10), barAcc.GetCoins().AmountOf(denom).Int64())
fooAcc := f.QueryAccount(fooAddr)
require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf(denom).Int64())
defaultParams := staking.DefaultParams()
initialPool := staking.InitialPool()
initialPool.BondedTokens = initialPool.BondedTokens.Add(sdk.NewInt(101)) // Delegate tx on GaiaAppGenState
require.Equal(t, sendTokens, barAcc.GetCoins().AmountOf(denom))
// Generate a create validator transaction and ensure correctness
success, stdout, stderr := f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewInt64Coin(denom, 2), "--generate-only")
@ -337,21 +335,22 @@ func TestGaiaCLICreateValidator(t *testing.T) {
require.Equal(t, 0, len(msg.GetSignatures()))
// Test --dry-run
success, _, _ = f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewInt64Coin(denom, 2), "--dry-run")
newValTokens := staking.TokensFromTendermintPower(2)
success, _, _ = f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewCoin(denom, newValTokens), "--dry-run")
require.True(t, success)
// Create the validator
f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewInt64Coin(denom, 2))
f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewCoin(denom, newValTokens))
tests.WaitForNextNBlocksTM(1, f.Port)
// Ensure funds were deducted properly
barAcc = f.QueryAccount(barAddr)
require.Equal(t, int64(8), barAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, sendTokens.Sub(newValTokens), barAcc.GetCoins().AmountOf(denom))
// Ensure that validator state is as expected
validator := f.QueryStakingValidator(barVal)
require.Equal(t, validator.OperatorAddr, barVal)
require.True(sdk.IntEq(t, sdk.NewInt(2), validator.Tokens))
require.True(sdk.IntEq(t, newValTokens, validator.Tokens))
// Query delegations to the validator
validatorDelegations := f.QueryStakingDelegationsTo(barVal)
@ -359,27 +358,21 @@ func TestGaiaCLICreateValidator(t *testing.T) {
require.NotZero(t, validatorDelegations[0].Shares)
// unbond a single share
success = f.TxStakingUnbond(keyBar, "1", barVal)
unbondTokens := staking.TokensFromTendermintPower(1)
success = f.TxStakingUnbond(keyBar, unbondTokens.String(), barVal)
require.True(t, success)
tests.WaitForNextNBlocksTM(1, f.Port)
// Ensure bonded staking is correct
remainingTokens := newValTokens.Sub(unbondTokens)
validator = f.QueryStakingValidator(barVal)
require.Equal(t, "1", validator.Tokens.String())
require.Equal(t, remainingTokens, validator.Tokens)
// Get unbonding delegations from the validator
validatorUbds := f.QueryStakingUnbondingDelegationsFrom(barVal)
require.Len(t, validatorUbds, 1)
require.Len(t, validatorUbds[0].Entries, 1)
require.Equal(t, "1", validatorUbds[0].Entries[0].Balance.Amount.String())
// Query staking parameters
params := f.QueryStakingParameters()
require.True(t, defaultParams.Equal(params))
// Query staking pool
pool := f.QueryStakingPool()
require.Equal(t, initialPool.BondedTokens, pool.BondedTokens)
require.Equal(t, remainingTokens.String(), validatorUbds[0].Entries[0].Balance.Amount.String())
f.Cleanup()
}
@ -399,14 +392,16 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
fooAddr := f.KeyAddress(keyFoo)
fooAcc := f.QueryAccount(fooAddr)
require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(stakingTypes.DefaultBondDenom).Int64())
startTokens := staking.TokensFromTendermintPower(50)
require.Equal(t, startTokens, fooAcc.GetCoins().AmountOf(staking.DefaultBondDenom))
proposalsQuery := f.QueryGovProposals()
require.Empty(t, proposalsQuery)
// Test submit generate only for submit proposal
proposalTokens := staking.TokensFromTendermintPower(5)
success, stdout, stderr := f.TxGovSubmitProposal(
keyFoo, "Text", "Test", "test", sdk.NewInt64Coin(denom, 5), "--generate-only")
keyFoo, "Text", "Test", "test", sdk.NewCoin(denom, proposalTokens), "--generate-only")
require.True(t, success)
require.Empty(t, stderr)
msg := unmarshalStdTx(t, stdout)
@ -415,11 +410,11 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
require.Equal(t, 0, len(msg.GetSignatures()))
// Test --dry-run
success, _, _ = f.TxGovSubmitProposal(keyFoo, "Text", "Test", "test", sdk.NewInt64Coin(denom, 5), "--dry-run")
success, _, _ = f.TxGovSubmitProposal(keyFoo, "Text", "Test", "test", sdk.NewCoin(denom, proposalTokens), "--dry-run")
require.True(t, success)
// Create the proposal
f.TxGovSubmitProposal(keyFoo, "Text", "Test", "test", sdk.NewInt64Coin(denom, 5))
f.TxGovSubmitProposal(keyFoo, "Text", "Test", "test", sdk.NewCoin(denom, proposalTokens))
tests.WaitForNextNBlocksTM(1, f.Port)
// Ensure transaction tags can be queried
@ -428,7 +423,7 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
// Ensure deposit was deducted
fooAcc = f.QueryAccount(fooAddr)
require.Equal(t, int64(45), fooAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, startTokens.Sub(proposalTokens), fooAcc.GetCoins().AmountOf(denom))
// Ensure propsal is directly queryable
proposal1 := f.QueryGovProposal(1)
@ -441,10 +436,11 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
// Query the deposits on the proposal
deposit := f.QueryGovDeposit(1, fooAddr)
require.Equal(t, int64(5), deposit.Amount.AmountOf(denom).Int64())
require.Equal(t, proposalTokens, deposit.Amount.AmountOf(denom))
// Test deposit generate only
success, stdout, stderr = f.TxGovDeposit(1, keyFoo, sdk.NewInt64Coin(denom, 10), "--generate-only")
depositTokens := staking.TokensFromTendermintPower(10)
success, stdout, stderr = f.TxGovDeposit(1, keyFoo, sdk.NewCoin(denom, depositTokens), "--generate-only")
require.True(t, success)
require.Empty(t, stderr)
msg = unmarshalStdTx(t, stdout)
@ -453,17 +449,17 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
require.Equal(t, 0, len(msg.GetSignatures()))
// Run the deposit transaction
f.TxGovDeposit(1, keyFoo, sdk.NewInt64Coin(denom, 10))
f.TxGovDeposit(1, keyFoo, sdk.NewCoin(denom, depositTokens))
tests.WaitForNextNBlocksTM(1, f.Port)
// test query deposit
deposits := f.QueryGovDeposits(1)
require.Len(t, deposits, 1)
require.Equal(t, int64(15), deposits[0].Amount.AmountOf(denom).Int64())
require.Equal(t, proposalTokens.Add(depositTokens), deposits[0].Amount.AmountOf(denom))
// Ensure querying the deposit returns the proper amount
deposit = f.QueryGovDeposit(1, fooAddr)
require.Equal(t, int64(15), deposit.Amount.AmountOf(denom).Int64())
require.Equal(t, proposalTokens.Add(depositTokens), deposit.Amount.AmountOf(denom))
// Ensure tags are set on the transaction
txs = f.QueryTxs(1, 50, "action:deposit", fmt.Sprintf("depositor:%s", fooAddr))
@ -471,7 +467,7 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
// Ensure account has expected amount of funds
fooAcc = f.QueryAccount(fooAddr)
require.Equal(t, int64(35), fooAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, startTokens.Sub(proposalTokens.Add(depositTokens)), fooAcc.GetCoins().AmountOf(denom))
// Fetch the proposal and ensure it is now in the voting period
proposal1 = f.QueryGovProposal(1)
@ -515,7 +511,7 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
require.Equal(t, uint64(1), proposalsQuery[0].GetProposalID())
// submit a second test proposal
f.TxGovSubmitProposal(keyFoo, "Text", "Apples", "test", sdk.NewInt64Coin(denom, 5))
f.TxGovSubmitProposal(keyFoo, "Text", "Apples", "test", sdk.NewCoin(denom, proposalTokens))
tests.WaitForNextNBlocksTM(1, f.Port)
// Test limit on proposals query
@ -635,7 +631,8 @@ func TestGaiaCLISendGenerateSignAndBroadcast(t *testing.T) {
barAddr := f.KeyAddress(keyBar)
// Test generate sendTx with default gas
success, stdout, stderr := f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--generate-only")
sendTokens := staking.TokensFromTendermintPower(10)
success, stdout, stderr := f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--generate-only")
require.True(t, success)
require.Empty(t, stderr)
msg := unmarshalStdTx(t, stdout)
@ -644,7 +641,7 @@ func TestGaiaCLISendGenerateSignAndBroadcast(t *testing.T) {
require.Equal(t, 0, len(msg.GetSignatures()))
// Test generate sendTx with --gas=$amount
success, stdout, stderr = f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--gas=100", "--generate-only")
success, stdout, stderr = f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--gas=100", "--generate-only")
require.True(t, success)
require.Empty(t, stderr)
msg = unmarshalStdTx(t, stdout)
@ -653,7 +650,7 @@ func TestGaiaCLISendGenerateSignAndBroadcast(t *testing.T) {
require.Equal(t, 0, len(msg.GetSignatures()))
// Test generate sendTx, estimate gas
success, stdout, stderr = f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--gas=auto", "--generate-only")
success, stdout, stderr = f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--gas=auto", "--generate-only")
require.True(t, success)
require.NotEmpty(t, stderr)
msg = unmarshalStdTx(t, stdout)
@ -689,7 +686,8 @@ func TestGaiaCLISendGenerateSignAndBroadcast(t *testing.T) {
// Ensure foo has right amount of funds
fooAcc := f.QueryAccount(fooAddr)
require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(denom).Int64())
startTokens := staking.TokensFromTendermintPower(50)
require.Equal(t, startTokens, fooAcc.GetCoins().AmountOf(denom))
// Test broadcast
success, stdout, _ = f.TxBroadcast(signedTxFile.Name())
@ -706,8 +704,8 @@ func TestGaiaCLISendGenerateSignAndBroadcast(t *testing.T) {
// Ensure account state
barAcc := f.QueryAccount(barAddr)
fooAcc = f.QueryAccount(fooAddr)
require.Equal(t, int64(10), barAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf(denom).Int64())
require.Equal(t, sendTokens, barAcc.GetCoins().AmountOf(denom))
require.Equal(t, startTokens.Sub(sendTokens), fooAcc.GetCoins().AmountOf(denom))
f.Cleanup()
}

8
cmd/gaia/cli_test/test_helpers.go
View File

@ -38,10 +38,10 @@ const (
)
var startCoins = sdk.Coins{
sdk.NewInt64Coin(feeDenom, 1000000),
sdk.NewInt64Coin(fee2Denom, 1000000),
sdk.NewInt64Coin(fooDenom, 1000),
sdk.NewInt64Coin(denom, 150),
sdk.NewCoin(feeDenom, staking.TokensFromTendermintPower(1000000)),
sdk.NewCoin(fee2Denom, staking.TokensFromTendermintPower(1000000)),
sdk.NewCoin(fooDenom, staking.TokensFromTendermintPower(1000)),
sdk.NewCoin(denom, staking.TokensFromTendermintPower(150)),
}
//___________________________________________________________________________________

7
cmd/gaia/init/gentx.go
View File

@ -26,12 +26,13 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
authtxb "github.com/cosmos/cosmos-sdk/x/auth/client/txbuilder"
"github.com/cosmos/cosmos-sdk/x/staking"
"github.com/cosmos/cosmos-sdk/x/staking/client/cli"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
)
const (
defaultAmount = "100" + stakingTypes.DefaultBondDenom
var (
defaultTokens = staking.TokensFromTendermintPower(100)
defaultAmount = defaultTokens.String() + staking.DefaultBondDenom
defaultCommissionRate = "0.1"
defaultCommissionMaxRate = "0.2"
defaultCommissionMaxChangeRate = "0.01"

9
cmd/gaia/init/testnet.go
View File

@ -188,18 +188,21 @@ func initTestnet(config *tmconfig.Config, cdc *codec.Codec) error {
return err
}
accTokens := staking.TokensFromTendermintPower(1000)
accStakingTokens := staking.TokensFromTendermintPower(500)
accs = append(accs, app.GenesisAccount{
Address: addr,
Coins: sdk.Coins{
sdk.NewInt64Coin(fmt.Sprintf("%stoken", nodeDirName), 1000),
sdk.NewInt64Coin(stakingtypes.DefaultBondDenom, 500),
sdk.NewCoin(fmt.Sprintf("%stoken", nodeDirName), accTokens),
sdk.NewCoin(stakingtypes.DefaultBondDenom, accStakingTokens),
},
})
valTokens := staking.TokensFromTendermintPower(100)
msg := staking.NewMsgCreateValidator(
sdk.ValAddress(addr),
valPubKeys[i],
sdk.NewInt64Coin(stakingtypes.DefaultBondDenom, 100),
sdk.NewCoin(stakingtypes.DefaultBondDenom, valTokens),
staking.NewDescription(nodeDirName, "", "", ""),
staking.NewCommissionMsg(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()),
)

16
types/decimal.go
View File

@ -249,6 +249,16 @@ func (d Dec) MulInt(i Int) Dec {
return Dec{mul}
}
// MulInt64 - multiplication with int64
func (d Dec) MulInt64(i int64) Dec {
mul := new(big.Int).Mul(d.Int, big.NewInt(i))
if mul.BitLen() > 255+DecimalPrecisionBits {
panic("Int overflow")
}
return Dec{mul}
}
// quotient
func (d Dec) Quo(d2 Dec) Dec {
@ -287,6 +297,12 @@ func (d Dec) QuoInt(i Int) Dec {
return Dec{mul}
}
// QuoInt64 - quotient with int64
func (d Dec) QuoInt64(i int64) Dec {
mul := new(big.Int).Quo(d.Int, big.NewInt(i))
return Dec{mul}
}
// is integer, e.g. decimals are zero
func (d Dec) IsInteger() bool {
return new(big.Int).Rem(d.Int, precisionReuse).Sign() == 0

5
types/stake.go
View File

@ -42,8 +42,9 @@ type Validator interface {
GetOperator() ValAddress // operator address to receive/return validators coins
GetConsPubKey() crypto.PubKey // validation consensus pubkey
GetConsAddr() ConsAddress // validation consensus address
GetPower() Int // validation power
GetTokens() Int // validation tokens
GetBondedTokens() Int // validator bonded tokens
GetTendermintPower() int64 // validation power in tendermint
GetCommission() Dec // validator commission rate
GetDelegatorShares() Dec // total outstanding delegator shares
GetBondHeight() int64 // height in which the validator became active
@ -54,7 +55,7 @@ type Validator interface {
func ABCIValidator(v Validator) abci.Validator {
return abci.Validator{
Address: v.GetConsPubKey().Address(),
Power: v.GetPower().Int64(),
Power: v.GetTendermintPower(),
}
}

2
x/auth/ante.go
View File

@ -342,7 +342,7 @@ func EnsureSufficientMempoolFees(ctx sdk.Context, stdFee StdFee) sdk.Result {
glDec := sdk.NewDec(int64(stdFee.Gas))
for i, gp := range minGasPrices {
fee := gp.Amount.Mul(glDec)
requiredFees[i] = sdk.NewInt64Coin(gp.Denom, fee.Ceil().RoundInt64())
requiredFees[i] = sdk.NewCoin(gp.Denom, fee.Ceil().RoundInt())
}
if !stdFee.Amount.IsAllGTE(requiredFees) {

2
x/auth/client/txbuilder/txbuilder.go
View File

@ -177,7 +177,7 @@ func (bldr TxBuilder) Build(msgs []sdk.Msg) (StdSignMsg, error) {
fees = make(sdk.Coins, len(bldr.gasPrices))
for i, gp := range bldr.gasPrices {
fee := gp.Amount.Mul(glDec)
fees[i] = sdk.NewInt64Coin(gp.Denom, fee.Ceil().RoundInt64())
fees[i] = sdk.NewCoin(gp.Denom, fee.Ceil().RoundInt())
}
}

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

@ -71,9 +71,12 @@ func TestCalculateRewardsAfterSlash(t *testing.T) {
// create validator with 50% commission
commission := staking.NewCommissionMsg(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
valPower := int64(100)
valTokens := staking.TokensFromTendermintPower(valPower)
msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
sdk.NewCoin(staking.DefaultBondDenom, sdk.NewInt(100)), staking.Description{}, commission)
require.True(t, sh(ctx, msg).IsOK())
sdk.NewCoin(staking.DefaultBondDenom, valTokens), staking.Description{}, commission)
got := sh(ctx, msg)
require.True(t, got.IsOK(), "%v", got)
// end block to bond validator
staking.EndBlocker(ctx, sk)
@ -95,7 +98,7 @@ func TestCalculateRewardsAfterSlash(t *testing.T) {
ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
// slash the validator by 50%
sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), 100, sdk.NewDecWithPrec(5, 1))
sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), valPower, sdk.NewDecWithPrec(5, 1))
// retrieve validator
val = sk.Validator(ctx, valOpAddr1)
@ -104,8 +107,8 @@ func TestCalculateRewardsAfterSlash(t *testing.T) {
ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
// allocate some rewards
initial := int64(10)
tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}
initial := staking.TokensFromTendermintPower(10)
tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDecFromInt(initial)}}
k.AllocateTokensToValidator(ctx, val, tokens)
// end period
@ -115,10 +118,11 @@ func TestCalculateRewardsAfterSlash(t *testing.T) {
rewards = k.calculateDelegationRewards(ctx, val, del, endingPeriod)
// rewards should be half the tokens
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial / 2)}}, rewards)
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDecFromInt(initial.DivRaw(2))}}, rewards)
// commission should be the other half
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial / 2)}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDecFromInt(initial.DivRaw(2))}},
k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
}
func TestCalculateRewardsAfterManySlashes(t *testing.T) {
@ -129,9 +133,11 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
k.SetOutstandingRewards(ctx, sdk.DecCoins{})
// create validator with 50% commission
power := int64(100)
valTokens := staking.TokensFromTendermintPower(power)
commission := staking.NewCommissionMsg(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
sdk.NewCoin(staking.DefaultBondDenom, sdk.NewInt(100)), staking.Description{}, commission)
sdk.NewCoin(staking.DefaultBondDenom, valTokens), staking.Description{}, commission)
require.True(t, sh(ctx, msg).IsOK())
// end block to bond validator
@ -154,7 +160,7 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
// slash the validator by 50%
sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), 100, sdk.NewDecWithPrec(5, 1))
sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power, sdk.NewDecWithPrec(5, 1))
// fetch the validator again
val = sk.Validator(ctx, valOpAddr1)
@ -163,12 +169,12 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
// allocate some rewards
initial := int64(10)
tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}
initial := staking.TokensFromTendermintPower(10)
tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDecFromInt(initial)}}
k.AllocateTokensToValidator(ctx, val, tokens)
// slash the validator by 50% again
sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), 50, sdk.NewDecWithPrec(5, 1))
sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power/2, sdk.NewDecWithPrec(5, 1))
// fetch the validator again
val = sk.Validator(ctx, valOpAddr1)
@ -186,10 +192,11 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
rewards = k.calculateDelegationRewards(ctx, val, del, endingPeriod)
// rewards should be half the tokens
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}, rewards)
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDecFromInt(initial)}}, rewards)
// commission should be the other half
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDecFromInt(initial)}},
k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
}
func TestCalculateRewardsMultiDelegator(t *testing.T) {
@ -251,22 +258,27 @@ func TestCalculateRewardsMultiDelegator(t *testing.T) {
}
func TestWithdrawDelegationRewardsBasic(t *testing.T) {
balance := int64(1000)
ctx, ak, k, sk, _ := CreateTestInputDefault(t, false, balance)
balancePower := int64(1000)
balanceTokens := staking.TokensFromTendermintPower(balancePower)
ctx, ak, k, sk, _ := CreateTestInputDefault(t, false, balancePower)
sh := staking.NewHandler(sk)
// initialize state
k.SetOutstandingRewards(ctx, sdk.DecCoins{})
// create validator with 50% commission
bond := int64(100)
power := int64(100)
valTokens := staking.TokensFromTendermintPower(power)
commission := staking.NewCommissionMsg(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
sdk.NewCoin(staking.DefaultBondDenom, sdk.NewInt(bond)), staking.Description{}, commission)
sdk.NewCoin(staking.DefaultBondDenom, valTokens), staking.Description{}, commission)
require.True(t, sh(ctx, msg).IsOK())
// assert correct initial balance
require.Equal(t, sdk.Coins{{staking.DefaultBondDenom, sdk.NewInt(balance - bond)}}, ak.GetAccount(ctx, sdk.AccAddress(valOpAddr1)).GetCoins())
expTokens := balanceTokens.Sub(valTokens)
require.Equal(t,
sdk.Coins{{staking.DefaultBondDenom, expTokens}},
ak.GetAccount(ctx, sdk.AccAddress(valOpAddr1)).GetCoins())
// end block to bond validator
staking.EndBlocker(ctx, sk)
@ -278,8 +290,8 @@ func TestWithdrawDelegationRewardsBasic(t *testing.T) {
val := sk.Validator(ctx, valOpAddr1)
// allocate some rewards
initial := int64(10)
tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}
initial := staking.TokensFromTendermintPower(10)
tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDecFromInt(initial)}}
k.AllocateTokensToValidator(ctx, val, tokens)
// historical count should be 2 (initial + latest for delegation)
@ -292,13 +304,15 @@ func TestWithdrawDelegationRewardsBasic(t *testing.T) {
require.Equal(t, uint64(2), k.GetValidatorHistoricalReferenceCount(ctx))
// assert correct balance
require.Equal(t, sdk.Coins{{staking.DefaultBondDenom, sdk.NewInt(balance - bond + (initial / 2))}}, ak.GetAccount(ctx, sdk.AccAddress(valOpAddr1)).GetCoins())
exp := balanceTokens.Sub(valTokens).Add(initial.DivRaw(2))
require.Equal(t, sdk.Coins{{staking.DefaultBondDenom, exp}}, ak.GetAccount(ctx, sdk.AccAddress(valOpAddr1)).GetCoins())
// withdraw commission
require.Nil(t, k.WithdrawValidatorCommission(ctx, valOpAddr1))
// assert correct balance
require.Equal(t, sdk.Coins{{staking.DefaultBondDenom, sdk.NewInt(balance - bond + initial)}}, ak.GetAccount(ctx, sdk.AccAddress(valOpAddr1)).GetCoins())
exp = balanceTokens.Sub(valTokens).Add(initial)
require.Equal(t, sdk.Coins{{staking.DefaultBondDenom, exp}}, ak.GetAccount(ctx, sdk.AccAddress(valOpAddr1)).GetCoins())
}
func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) {
@ -309,9 +323,11 @@ func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) {
k.SetOutstandingRewards(ctx, sdk.DecCoins{})
// create validator with 50% commission
power := int64(100)
valTokens := staking.TokensFromTendermintPower(power)
commission := staking.NewCommissionMsg(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
sdk.NewCoin(staking.DefaultBondDenom, sdk.NewInt(100)), staking.Description{}, commission)
sdk.NewCoin(staking.DefaultBondDenom, valTokens), staking.Description{}, commission)
require.True(t, sh(ctx, msg).IsOK())
// end block to bond validator
@ -334,15 +350,15 @@ func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) {
ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
// allocate some rewards
initial := int64(10)
tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}
initial := sdk.NewDecFromInt(staking.TokensFromTendermintPower(10))
tokens := sdk.DecCoins{{staking.DefaultBondDenom, initial}}
k.AllocateTokensToValidator(ctx, val, tokens)
// slash the validator by 50%
sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), 100, sdk.NewDecWithPrec(5, 1))
sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power, sdk.NewDecWithPrec(5, 1))
// slash the validator by 50% again
sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), 50, sdk.NewDecWithPrec(5, 1))
sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power/2, sdk.NewDecWithPrec(5, 1))
// fetch the validator again
val = sk.Validator(ctx, valOpAddr1)
@ -360,10 +376,10 @@ func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) {
rewards = k.calculateDelegationRewards(ctx, val, del, endingPeriod)
// rewards should be half the tokens
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}, rewards)
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, initial}}, rewards)
// commission should be the other half
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, initial}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
}
func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
@ -375,8 +391,10 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
// create validator with 50% commission
commission := staking.NewCommissionMsg(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
power := int64(100)
valTokens := staking.TokensFromTendermintPower(power)
msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
sdk.NewCoin(staking.DefaultBondDenom, sdk.NewInt(100)), staking.Description{}, commission)
sdk.NewCoin(staking.DefaultBondDenom, valTokens), staking.Description{}, commission)
require.True(t, sh(ctx, msg).IsOK())
// end block to bond validator
@ -387,17 +405,19 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
del1 := sk.Delegation(ctx, sdk.AccAddress(valOpAddr1), valOpAddr1)
// allocate some rewards
initial := int64(30)
tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}
initial := sdk.NewDecFromInt(staking.TokensFromTendermintPower(30))
tokens := sdk.DecCoins{{staking.DefaultBondDenom, initial}}
k.AllocateTokensToValidator(ctx, val, tokens)
// slash the validator
ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), 100, sdk.NewDecWithPrec(5, 1))
sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power, sdk.NewDecWithPrec(5, 1))
ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
// second delegation
msg2 := staking.NewMsgDelegate(sdk.AccAddress(valOpAddr2), valOpAddr1, sdk.NewCoin(staking.DefaultBondDenom, sdk.NewInt(100)))
delTokens := staking.TokensFromTendermintPower(100)
msg2 := staking.NewMsgDelegate(sdk.AccAddress(valOpAddr2), valOpAddr1,
sdk.NewCoin(staking.DefaultBondDenom, delTokens))
require.True(t, sh(ctx, msg2).IsOK())
del2 := sk.Delegation(ctx, sdk.AccAddress(valOpAddr2), valOpAddr1)
@ -409,7 +429,7 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
// slash the validator again
ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), 100, sdk.NewDecWithPrec(5, 1))
sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power, sdk.NewDecWithPrec(5, 1))
ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
// fetch updated validator
@ -422,16 +442,16 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
rewards := k.calculateDelegationRewards(ctx, val, del1, endingPeriod)
// rewards for del1 should be 2/3 initial (half initial first period, 1/6 initial second period)
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec((initial / 2) + (initial / 6))}}, rewards)
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, initial.QuoInt64(2).Add(initial.QuoInt64(6))}}, rewards)
// calculate delegation rewards for del2
rewards = k.calculateDelegationRewards(ctx, val, del2, endingPeriod)
// rewards for del2 should be initial / 3
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial / 3)}}, rewards)
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, initial.QuoInt64(3)}}, rewards)
// commission should be equal to initial (twice 50% commission, unaffected by slashing)
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, initial}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
}
func TestCalculateRewardsMultiDelegatorMultWithdraw(t *testing.T) {

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

@ -7,6 +7,7 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/distribution/types"
"github.com/cosmos/cosmos-sdk/x/staking"
)
func TestSetWithdrawAddr(t *testing.T) {
@ -31,9 +32,10 @@ func TestWithdrawValidatorCommission(t *testing.T) {
// check initial balance
balance := ak.GetAccount(ctx, sdk.AccAddress(valOpAddr3)).GetCoins()
require.Equal(t, balance, sdk.Coins{
{"stake", sdk.NewInt(1000)},
})
expTokens := staking.TokensFromTendermintPower(1000)
require.Equal(t, sdk.Coins{
{"stake", staking.TokensFromTendermintPower(1000)},
}, balance)
// set commission
keeper.SetValidatorAccumulatedCommission(ctx, valOpAddr3, sdk.DecCoins{
@ -46,17 +48,17 @@ func TestWithdrawValidatorCommission(t *testing.T) {
// check balance increase
balance = ak.GetAccount(ctx, sdk.AccAddress(valOpAddr3)).GetCoins()
require.Equal(t, balance, sdk.Coins{
require.Equal(t, sdk.Coins{
{"mytoken", sdk.NewInt(1)},
{"stake", sdk.NewInt(1001)},
})
{"stake", expTokens.AddRaw(1)},
}, balance)
// check remainder
remainder := keeper.GetValidatorAccumulatedCommission(ctx, valOpAddr3)
require.Equal(t, remainder, sdk.DecCoins{
require.Equal(t, sdk.DecCoins{
{"mytoken", sdk.NewDec(1).Quo(sdk.NewDec(4))},
{"stake", sdk.NewDec(1).Quo(sdk.NewDec(2))},
})
}, remainder)
require.True(t, true)
}

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

@ -71,18 +71,20 @@ func MakeTestCodec() *codec.Codec {
}
// test input with default values
func CreateTestInputDefault(t *testing.T, isCheckTx bool, initCoins int64) (
func CreateTestInputDefault(t *testing.T, isCheckTx bool, initPower int64) (
sdk.Context, auth.AccountKeeper, Keeper, staking.Keeper, DummyFeeCollectionKeeper) {
communityTax := sdk.NewDecWithPrec(2, 2)
return CreateTestInputAdvanced(t, isCheckTx, initCoins, communityTax)
return CreateTestInputAdvanced(t, isCheckTx, initPower, communityTax)
}
// hogpodge of all sorts of input required for testing
func CreateTestInputAdvanced(t *testing.T, isCheckTx bool, initCoins int64,
func CreateTestInputAdvanced(t *testing.T, isCheckTx bool, initPower int64,
communityTax sdk.Dec) (
sdk.Context, auth.AccountKeeper, Keeper, staking.Keeper, DummyFeeCollectionKeeper) {
initCoins := staking.TokensFromTendermintPower(initPower)
keyDistr := sdk.NewKVStoreKey(types.StoreKey)
keyStaking := sdk.NewKVStoreKey(staking.StoreKey)
tkeyStaking := sdk.NewTransientStoreKey(staking.TStoreKey)
@ -119,10 +121,10 @@ func CreateTestInputAdvanced(t *testing.T, isCheckTx bool, initCoins int64,
for _, addr := range addrs {
pool := sk.GetPool(ctx)
_, _, err := ck.AddCoins(ctx, addr, sdk.Coins{
{sk.GetParams(ctx).BondDenom, sdk.NewInt(initCoins)},
sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins),
})
require.Nil(t, err)
pool.NotBondedTokens = pool.NotBondedTokens.Add(sdk.NewInt(initCoins))
pool.NotBondedTokens = pool.NotBondedTokens.Add(initCoins)
sk.SetPool(ctx, pool)
}

17
x/gov/endblocker_test.go
View File

@ -9,7 +9,7 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
sdk "github.com/cosmos/cosmos-sdk/types"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
"github.com/cosmos/cosmos-sdk/x/staking"
)
func TestTickExpiredDepositPeriod(t *testing.T) {
@ -23,7 +23,7 @@ func TestTickExpiredDepositPeriod(t *testing.T) {
require.False(t, inactiveQueue.Valid())
inactiveQueue.Close()
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)})
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 5)})
res := govHandler(ctx, newProposalMsg)
require.True(t, res.IsOK())
@ -66,7 +66,7 @@ func TestTickMultipleExpiredDepositPeriod(t *testing.T) {
require.False(t, inactiveQueue.Valid())
inactiveQueue.Close()
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)})
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 5)})
res := govHandler(ctx, newProposalMsg)
require.True(t, res.IsOK())
@ -83,7 +83,7 @@ func TestTickMultipleExpiredDepositPeriod(t *testing.T) {
require.False(t, inactiveQueue.Valid())
inactiveQueue.Close()
newProposalMsg2 := NewMsgSubmitProposal("Test2", "test2", ProposalTypeText, addrs[1], sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)})
newProposalMsg2 := NewMsgSubmitProposal("Test2", "test2", ProposalTypeText, addrs[1], sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 5)})
res = govHandler(ctx, newProposalMsg2)
require.True(t, res.IsOK())
@ -126,7 +126,7 @@ func TestTickPassedDepositPeriod(t *testing.T) {
require.False(t, activeQueue.Valid())
activeQueue.Close()
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)})
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 5)})
res := govHandler(ctx, newProposalMsg)
require.True(t, res.IsOK())
@ -145,7 +145,7 @@ func TestTickPassedDepositPeriod(t *testing.T) {
require.False(t, inactiveQueue.Valid())
inactiveQueue.Close()
newDepositMsg := NewMsgDeposit(addrs[1], proposalID, sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)})
newDepositMsg := NewMsgDeposit(addrs[1], proposalID, sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 5)})
res = govHandler(ctx, newDepositMsg)
require.True(t, res.IsOK())
@ -169,7 +169,8 @@ func TestTickPassedVotingPeriod(t *testing.T) {
require.False(t, activeQueue.Valid())
activeQueue.Close()
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)})
proposalCoins := sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, staking.TokensFromTendermintPower(5))}
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], proposalCoins)
res := govHandler(ctx, newProposalMsg)
require.True(t, res.IsOK())
@ -180,7 +181,7 @@ func TestTickPassedVotingPeriod(t *testing.T) {
newHeader.Time = ctx.BlockHeader().Time.Add(time.Duration(1) * time.Second)
ctx = ctx.WithBlockHeader(newHeader)
newDepositMsg := NewMsgDeposit(addrs[1], proposalID, sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)})
newDepositMsg := NewMsgDeposit(addrs[1], proposalID, proposalCoins)
res = govHandler(ctx, newDepositMsg)
require.True(t, res.IsOK())

5
x/gov/genesis.go
View File

@ -5,7 +5,7 @@ import (
"time"
sdk "github.com/cosmos/cosmos-sdk/types"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
"github.com/cosmos/cosmos-sdk/x/staking"
)
// GenesisState - all staking state that must be provided at genesis
@ -42,10 +42,11 @@ func NewGenesisState(startingProposalID uint64, dp DepositParams, vp VotingParam
// get raw genesis raw message for testing
func DefaultGenesisState() GenesisState {
minDepositTokens := staking.TokensFromTendermintPower(10)
return GenesisState{
StartingProposalID: 1,
DepositParams: DepositParams{
MinDeposit: sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10)},
MinDeposit: sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, minDepositTokens)},
MaxDepositPeriod: time.Duration(172800) * time.Second,
},
VotingParams: VotingParams{

11
x/gov/keeper_test.go
View File

@ -9,7 +9,7 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
sdk "github.com/cosmos/cosmos-sdk/types"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
"github.com/cosmos/cosmos-sdk/x/staking"
)
func TestGetSetProposal(t *testing.T) {
@ -70,15 +70,14 @@ func TestDeposits(t *testing.T) {
proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
proposalID := proposal.GetProposalID()
fourSteak := sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 4)}
fiveSteak := sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)}
fourSteak := sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, staking.TokensFromTendermintPower(4))}
fiveSteak := sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, staking.TokensFromTendermintPower(5))}
addr0Initial := keeper.ck.GetCoins(ctx, addrs[0])
addr1Initial := keeper.ck.GetCoins(ctx, addrs[1])
// require.True(t, addr0Initial.IsEqual(sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 42)}))
require.Equal(t, sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 42)}, addr0Initial)
expTokens := staking.TokensFromTendermintPower(42)
require.Equal(t, sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, expTokens)}, addr0Initial)
require.True(t, proposal.GetTotalDeposit().IsEqual(sdk.Coins{}))
// Check no deposits at beginning

6
x/gov/msgs_test.go
View File

@ -8,14 +8,14 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/mock"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
"github.com/cosmos/cosmos-sdk/x/staking"
)
var (
coinsPos = sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 1000)}
coinsPos = sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 1000)}
coinsZero = sdk.Coins{}
coinsPosNotAtoms = sdk.Coins{sdk.NewInt64Coin("foo", 10000)}
coinsMulti = sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 1000), sdk.NewInt64Coin("foo", 10000)}
coinsMulti = sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 1000), sdk.NewInt64Coin("foo", 10000)}
)
func init() {

18
x/gov/proposals.go
View File

@ -362,6 +362,24 @@ type TallyResult struct {
NoWithVeto sdk.Dec `json:"no_with_veto"`
}
func NewTallyResult(yes, abstain, no, noWithVeto sdk.Dec) TallyResult {
return TallyResult{
Yes: yes,
Abstain: abstain,
No: no,
NoWithVeto: noWithVeto,
}
}
func NewTallyResultFromMap(results map[VoteOption]sdk.Dec) TallyResult {
return TallyResult{
Yes: results[OptionYes],
Abstain: results[OptionAbstain],
No: results[OptionNo],
NoWithVeto: results[OptionNoWithVeto],
}
}
// checks if two proposals are equal
func EmptyTallyResult() TallyResult {
return TallyResult{

7
x/gov/simulation/msgs.go
View File

@ -11,11 +11,6 @@ import (
"github.com/cosmos/cosmos-sdk/x/gov"
"github.com/cosmos/cosmos-sdk/x/mock/simulation"
"github.com/cosmos/cosmos-sdk/x/staking"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
)
const (
denom = stakingTypes.DefaultBondDenom
)
// SimulateSubmittingVotingAndSlashingForProposal simulates creating a msg Submit Proposal
@ -183,7 +178,7 @@ func operationSimulateMsgVote(k gov.Keeper, acc simulation.Account, proposalID u
func randomDeposit(r *rand.Rand) sdk.Coins {
// TODO Choose based on account balance and min deposit
amount := int64(r.Intn(20)) + 1
return sdk.Coins{sdk.NewInt64Coin(denom, amount)}
return sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, amount)}
}
// Pick a random proposal ID

40
x/gov/tally.go
View File

@ -7,12 +7,24 @@ import (
// validatorGovInfo used for tallying
type validatorGovInfo struct {
Address sdk.ValAddress // address of the validator operator
Power sdk.Int // Power of a Validator
BondedTokens sdk.Int // Power of a Validator
DelegatorShares sdk.Dec // Total outstanding delegator shares
Minus sdk.Dec // Minus of validator, used to compute validator's voting power
Vote VoteOption // Vote of the validator
}
func newValidatorGovInfo(address sdk.ValAddress, bondedTokens sdk.Int, delegatorShares,
minus sdk.Dec, vote VoteOption) validatorGovInfo {
return validatorGovInfo{
Address: address,
BondedTokens: bondedTokens,
DelegatorShares: delegatorShares,
Minus: minus,
Vote: vote,
}
}
func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tallyResults TallyResult) {
results := make(map[VoteOption]sdk.Dec)
results[OptionYes] = sdk.ZeroDec()
@ -24,13 +36,13 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
currValidators := make(map[string]validatorGovInfo)
keeper.vs.IterateBondedValidatorsByPower(ctx, func(index int64, validator sdk.Validator) (stop bool) {
currValidators[validator.GetOperator().String()] = validatorGovInfo{
Address: validator.GetOperator(),
Power: validator.GetPower(),
DelegatorShares: validator.GetDelegatorShares(),
Minus: sdk.ZeroDec(),
Vote: OptionEmpty,
}
currValidators[validator.GetOperator().String()] = newValidatorGovInfo(
validator.GetOperator(),
validator.GetBondedTokens(),
validator.GetDelegatorShares(),
sdk.ZeroDec(),
OptionEmpty,
)
return false
})
@ -57,7 +69,7 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
currValidators[valAddrStr] = val
delegatorShare := delegation.GetShares().Quo(val.DelegatorShares)
votingPower := delegatorShare.MulInt(val.Power)
votingPower := delegatorShare.MulInt(val.BondedTokens)
results[vote.Option] = results[vote.Option].Add(votingPower)
totalVotingPower = totalVotingPower.Add(votingPower)
@ -78,20 +90,14 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
sharesAfterMinus := val.DelegatorShares.Sub(val.Minus)
percentAfterMinus := sharesAfterMinus.Quo(val.DelegatorShares)
votingPower := percentAfterMinus.MulInt(val.Power)
votingPower := percentAfterMinus.MulInt(val.BondedTokens)
results[val.Vote] = results[val.Vote].Add(votingPower)
totalVotingPower = totalVotingPower.Add(votingPower)
}
tallyParams := keeper.GetTallyParams(ctx)
tallyResults = TallyResult{
Yes: results[OptionYes],
Abstain: results[OptionAbstain],
No: results[OptionNo],
NoWithVeto: results[OptionNoWithVeto],
}
tallyResults = NewTallyResultFromMap(results)
// If there is no staked coins, the proposal fails
if keeper.vs.TotalPower(ctx).IsZero() {

39
x/gov/tally_test.go
View File

@ -10,9 +10,7 @@ import (
"github.com/tendermint/tendermint/crypto/ed25519"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/staking"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
)
var (
@ -22,12 +20,15 @@ var (
testCommissionMsg = staking.NewCommissionMsg(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec())
)
func createValidators(t *testing.T, stakingHandler sdk.Handler, ctx sdk.Context, addrs []sdk.ValAddress, coinAmt []int64) {
func createValidators(t *testing.T, stakingHandler sdk.Handler, ctx sdk.Context, addrs []sdk.ValAddress, powerAmt []int64) {
require.True(t, len(addrs) <= len(pubkeys), "Not enough pubkeys specified at top of file.")
for i := 0; i < len(addrs); i++ {
valTokens := staking.TokensFromTendermintPower(powerAmt[i])
valCreateMsg := staking.NewMsgCreateValidator(
addrs[i], pubkeys[i], sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, coinAmt[i]), testDescription, testCommissionMsg,
addrs[i], pubkeys[i], sdk.NewCoin(staking.DefaultBondDenom, valTokens),
testDescription, testCommissionMsg,
)
res := stakingHandler(ctx, valCreateMsg)
@ -317,7 +318,8 @@ func TestTallyDelgatorOverride(t *testing.T) {
createValidators(t, stakingHandler, ctx, valAddrs, []int64{5, 6, 7})
staking.EndBlocker(ctx, sk)
delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 30))
delTokens := staking.TokensFromTendermintPower(30)
delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
stakingHandler(ctx, delegator1Msg)
proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
@ -354,7 +356,8 @@ func TestTallyDelgatorInherit(t *testing.T) {
createValidators(t, stakingHandler, ctx, valAddrs, []int64{5, 6, 7})
staking.EndBlocker(ctx, sk)
delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 30))
delTokens := staking.TokensFromTendermintPower(30)
delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
stakingHandler(ctx, delegator1Msg)
proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
@ -389,9 +392,10 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) {
createValidators(t, stakingHandler, ctx, valAddrs, []int64{5, 6, 7})
staking.EndBlocker(ctx, sk)
delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10))
delTokens := staking.TokensFromTendermintPower(10)
delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
stakingHandler(ctx, delegator1Msg)
delegator1Msg2 := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10))
delegator1Msg2 := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
stakingHandler(ctx, delegator1Msg2)
proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
@ -420,25 +424,29 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) {
ctx := mapp.BaseApp.NewContext(false, abci.Header{})
stakingHandler := staking.NewHandler(sk)
valTokens1 := staking.TokensFromTendermintPower(25)
val1CreateMsg := staking.NewMsgCreateValidator(
sdk.ValAddress(addrs[0]), ed25519.GenPrivKey().PubKey(), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 25), testDescription, testCommissionMsg,
sdk.ValAddress(addrs[0]), ed25519.GenPrivKey().PubKey(), sdk.NewCoin(staking.DefaultBondDenom, valTokens1), testDescription, testCommissionMsg,
)
stakingHandler(ctx, val1CreateMsg)
valTokens2 := staking.TokensFromTendermintPower(6)
val2CreateMsg := staking.NewMsgCreateValidator(
sdk.ValAddress(addrs[1]), ed25519.GenPrivKey().PubKey(), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 6), testDescription, testCommissionMsg,
sdk.ValAddress(addrs[1]), ed25519.GenPrivKey().PubKey(), sdk.NewCoin(staking.DefaultBondDenom, valTokens2), testDescription, testCommissionMsg,
)
stakingHandler(ctx, val2CreateMsg)
valTokens3 := staking.TokensFromTendermintPower(7)
val3CreateMsg := staking.NewMsgCreateValidator(
sdk.ValAddress(addrs[2]), ed25519.GenPrivKey().PubKey(), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 7), testDescription, testCommissionMsg,
sdk.ValAddress(addrs[2]), ed25519.GenPrivKey().PubKey(), sdk.NewCoin(staking.DefaultBondDenom, valTokens3), testDescription, testCommissionMsg,
)
stakingHandler(ctx, val3CreateMsg)
delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10))
delTokens := staking.TokensFromTendermintPower(10)
delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
stakingHandler(ctx, delegator1Msg)
delegator1Msg2 := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10))
delegator1Msg2 := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
stakingHandler(ctx, delegator1Msg2)
staking.EndBlocker(ctx, sk)
@ -475,10 +483,11 @@ func TestTallyJailedValidator(t *testing.T) {
createValidators(t, stakingHandler, ctx, valAddrs, []int64{25, 6, 7})
staking.EndBlocker(ctx, sk)
delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10))
delTokens := staking.TokensFromTendermintPower(10)
delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
stakingHandler(ctx, delegator1Msg)
delegator1Msg2 := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10))
delegator1Msg2 := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
stakingHandler(ctx, delegator1Msg2)
val2, found := sk.GetValidator(ctx, sdk.ValAddress(addrs[1]))

14
x/gov/test_common.go
View File

@ -16,11 +16,14 @@ import (
"github.com/cosmos/cosmos-sdk/x/bank"
"github.com/cosmos/cosmos-sdk/x/mock"
"github.com/cosmos/cosmos-sdk/x/staking"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
"github.com/cosmos/cosmos-sdk/x/staking/types"
)
// initialize the mock application for this module
func getMockApp(t *testing.T, numGenAccs int, genState GenesisState, genAccs []auth.Account) (mapp *mock.App, keeper Keeper, sk staking.Keeper, addrs []sdk.AccAddress, pubKeys []crypto.PubKey, privKeys []crypto.PrivKey) {
func getMockApp(t *testing.T, numGenAccs int, genState GenesisState, genAccs []auth.Account) (
mapp *mock.App, keeper Keeper, sk staking.Keeper, addrs []sdk.AccAddress,
pubKeys []crypto.PubKey, privKeys []crypto.PrivKey) {
mapp = mock.NewApp()
staking.RegisterCodec(mapp.Cdc)
@ -43,8 +46,10 @@ func getMockApp(t *testing.T, numGenAccs int, genState GenesisState, genAccs []a
require.NoError(t, mapp.CompleteSetup(keyStaking, tkeyStaking, keyGov))
valTokens := staking.TokensFromTendermintPower(42)
if genAccs == nil || len(genAccs) == 0 {
genAccs, addrs, pubKeys, privKeys = mock.CreateGenAccounts(numGenAccs, sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 42)})
genAccs, addrs, pubKeys, privKeys = mock.CreateGenAccounts(numGenAccs,
sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, valTokens)})
}
mock.SetGenesis(mapp, genAccs)
@ -68,7 +73,8 @@ func getInitChainer(mapp *mock.App, keeper Keeper, stakingKeeper staking.Keeper,
mapp.InitChainer(ctx, req)
stakingGenesis := staking.DefaultGenesisState()
stakingGenesis.Pool.NotBondedTokens = sdk.NewInt(100000)
tokens := types.TokensFromTendermintPower(100000)
stakingGenesis.Pool.NotBondedTokens = tokens
validators, err := staking.InitGenesis(ctx, stakingKeeper, stakingGenesis)
if err != nil {

5
x/mint/params.go
View File

@ -3,9 +3,8 @@ package mint
import (
"fmt"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/staking"
)
// mint parameters
@ -34,7 +33,7 @@ func NewParams(mintDenom string, inflationRateChange, inflationMax,
// default minting module parameters
func DefaultParams() Params {
return Params{
MintDenom: stakingTypes.DefaultBondDenom,
MintDenom: staking.DefaultBondDenom,
InflationRateChange: sdk.NewDecWithPrec(13, 2),
InflationMax: sdk.NewDecWithPrec(20, 2),
InflationMin: sdk.NewDecWithPrec(7, 2),

22
x/mock/app.go
View File

@ -59,10 +59,10 @@ func NewApp() *App {
Cdc: cdc,
KeyMain: sdk.NewKVStoreKey(bam.MainStoreKey),
KeyAccount: sdk.NewKVStoreKey(auth.StoreKey),
TotalCoinsSupply: sdk.Coins{},
KeyFeeCollection: sdk.NewKVStoreKey("fee"),
KeyParams: sdk.NewKVStoreKey("params"),
TKeyParams: sdk.NewTransientStoreKey("transient_params"),
TotalCoinsSupply: sdk.Coins{},
}
app.ParamsKeeper = params.NewKeeper(app.Cdc, app.KeyParams, app.TKeyParams)
@ -135,6 +135,16 @@ type AddrKeys struct {
PrivKey crypto.PrivKey
}
func NewAddrKeys(address sdk.AccAddress, pubKey crypto.PubKey,
privKey crypto.PrivKey) AddrKeys {
return AddrKeys{
Address: address,
PubKey: pubKey,
PrivKey: privKey,
}
}
// implement `Interface` in sort package.
type AddrKeysSlice []AddrKeys
@ -161,7 +171,9 @@ func (b AddrKeysSlice) Swap(i, j int) {
// CreateGenAccounts generates genesis accounts loaded with coins, and returns
// their addresses, pubkeys, and privkeys.
func CreateGenAccounts(numAccs int, genCoins sdk.Coins) (genAccs []auth.Account, addrs []sdk.AccAddress, pubKeys []crypto.PubKey, privKeys []crypto.PrivKey) {
func CreateGenAccounts(numAccs int, genCoins sdk.Coins) (genAccs []auth.Account,
addrs []sdk.AccAddress, pubKeys []crypto.PubKey, privKeys []crypto.PrivKey) {
addrKeysSlice := AddrKeysSlice{}
for i := 0; i < numAccs; i++ {
@ -169,11 +181,7 @@ func CreateGenAccounts(numAccs int, genCoins sdk.Coins) (genAccs []auth.Account,
pubKey := privKey.PubKey()
addr := sdk.AccAddress(pubKey.Address())
addrKeysSlice = append(addrKeysSlice, AddrKeys{
Address: addr,
PubKey: pubKey,
PrivKey: privKey,
})
addrKeysSlice = append(addrKeysSlice, NewAddrKeys(addr, pubKey, privKey))
}
sort.Sort(addrKeysSlice)

8
x/mock/test_utils.go
View File

@ -72,10 +72,10 @@ func CheckGenTx(
// block commitment with the given transaction. A test assertion is made using
// the parameter 'expPass' against the result. A corresponding result is
// returned.
func SignCheckDeliver(
t *testing.T, cdc *codec.Codec, app *baseapp.BaseApp, msgs []sdk.Msg,
accNums []uint64, seq []uint64, expSimPass, expPass bool, priv ...crypto.PrivKey,
) sdk.Result {
func SignCheckDeliver(t *testing.T, cdc *codec.Codec, app *baseapp.BaseApp,
msgs []sdk.Msg, accNums, seq []uint64, expSimPass, expPass bool,
priv ...crypto.PrivKey) sdk.Result {
tx := GenTx(msgs, accNums, seq, priv...)
txBytes, err := cdc.MarshalBinaryLengthPrefixed(tx)

14
x/slashing/app_test.go
View File

@ -12,7 +12,6 @@ import (
"github.com/cosmos/cosmos-sdk/x/bank"
"github.com/cosmos/cosmos-sdk/x/mock"
"github.com/cosmos/cosmos-sdk/x/staking"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
)
var (
@ -26,7 +25,7 @@ func getMockApp(t *testing.T) (*mock.App, staking.Keeper, Keeper) {
mapp := mock.NewApp()
RegisterCodec(mapp.Cdc)
stakingTypes.RegisterCodec(mapp.Cdc)
staking.RegisterCodec(mapp.Cdc)
keyStaking := sdk.NewKVStoreKey(staking.StoreKey)
tkeyStaking := sdk.NewTransientStoreKey(staking.TStoreKey)
@ -62,7 +61,8 @@ func getInitChainer(mapp *mock.App, keeper staking.Keeper) sdk.InitChainer {
return func(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain {
mapp.InitChainer(ctx, req)
stakingGenesis := staking.DefaultGenesisState()
stakingGenesis.Pool.NotBondedTokens = sdk.NewInt(100000)
tokens := staking.TokensFromTendermintPower(100000)
stakingGenesis.Pool.NotBondedTokens = tokens
validators, err := staking.InitGenesis(ctx, keeper, stakingGenesis)
if err != nil {
panic(err)
@ -93,8 +93,10 @@ func checkValidatorSigningInfo(t *testing.T, mapp *mock.App, keeper Keeper,
func TestSlashingMsgs(t *testing.T) {
mapp, stakingKeeper, keeper := getMockApp(t)
genCoin := sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 42)
bondCoin := sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10)
genTokens := staking.TokensFromTendermintPower(42)
bondTokens := staking.TokensFromTendermintPower(10)
genCoin := sdk.NewCoin(staking.DefaultBondDenom, genTokens)
bondCoin := sdk.NewCoin(staking.DefaultBondDenom, bondTokens)
acc1 := &auth.BaseAccount{
Address: addr1,
@ -116,7 +118,7 @@ func TestSlashingMsgs(t *testing.T) {
validator := checkValidator(t, mapp, stakingKeeper, addr1, true)
require.Equal(t, sdk.ValAddress(addr1), validator.OperatorAddr)
require.Equal(t, sdk.Bonded, validator.Status)
require.True(sdk.IntEq(t, sdk.NewInt(10), validator.BondedTokens()))
require.True(sdk.IntEq(t, bondTokens, validator.BondedTokens()))
unjailMsg := MsgUnjail{ValidatorAddr: sdk.ValAddress(validator.ConsPubKey.Address())}
// no signing info yet

22
x/slashing/handler_test.go
View File

@ -8,24 +8,25 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/staking"
"github.com/cosmos/cosmos-sdk/x/staking/types"
)
func TestCannotUnjailUnlessJailed(t *testing.T) {
// initial setup
ctx, ck, sk, _, keeper := createTestInput(t, DefaultParams())
slh := NewHandler(keeper)
amtInt := int64(100)
addr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
amt := types.TokensFromTendermintPower(100)
addr, val := addrs[0], pks[0]
msg := NewTestMsgCreateValidator(addr, val, amt)
got := staking.NewHandler(sk)(ctx, msg)
require.True(t, got.IsOK())
require.True(t, got.IsOK(), "%v", got)
staking.EndBlocker(ctx, sk)
require.Equal(
t, ck.GetCoins(ctx, sdk.AccAddress(addr)),
sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))},
)
require.True(sdk.IntEq(t, amt, sk.Validator(ctx, addr).GetPower()))
require.Equal(t, amt, sk.Validator(ctx, addr).GetBondedTokens())
// assert non-jailed validator can't be unjailed
got = slh(ctx, NewMsgUnjail(addr))
@ -42,8 +43,8 @@ func TestJailedValidatorDelegations(t *testing.T) {
stakingKeeper.SetParams(ctx, stakingParams)
// create a validator
amount := int64(10)
valPubKey, bondAmount := pks[0], sdk.NewInt(amount)
bondAmount := staking.TokensFromTendermintPower(10)
valPubKey := pks[0]
valAddr, consAddr := addrs[1], sdk.ConsAddress(addrs[0])
msgCreateVal := NewTestMsgCreateValidator(valAddr, valPubKey, bondAmount)
@ -54,12 +55,7 @@ func TestJailedValidatorDelegations(t *testing.T) {
staking.EndBlocker(ctx, stakingKeeper)
// set dummy signing info
newInfo := ValidatorSigningInfo{
StartHeight: int64(0),
IndexOffset: int64(0),
JailedUntil: time.Unix(0, 0),
MissedBlocksCounter: int64(0),
}
newInfo := NewValidatorSigningInfo(0, 0, time.Unix(0, 0), false, 0)
slashingKeeper.SetValidatorSigningInfo(ctx, consAddr, newInfo)
// delegate tokens to the validator
@ -68,7 +64,7 @@ func TestJailedValidatorDelegations(t *testing.T) {
got = staking.NewHandler(stakingKeeper)(ctx, msgDelegate)
require.True(t, got.IsOK(), "expected delegation to be ok, got %v", got)
unbondShares := sdk.NewDec(10)
unbondShares := sdk.NewDecFromInt(bondAmount)
// unbond validator total self-delegations (which should jail the validator)
msgUndelegate := staking.NewMsgUndelegate(sdk.AccAddress(valAddr), valAddr, unbondShares)

5
x/slashing/keeper.go
View File

@ -9,7 +9,7 @@ import (
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/params"
staking "github.com/cosmos/cosmos-sdk/x/staking/types"
staking "github.com/cosmos/cosmos-sdk/x/staking"
)
// Keeper of the slashing store
@ -49,7 +49,8 @@ func (k Keeper) handleDoubleSign(ctx sdk.Context, addr crypto.Address, infractio
// Reject evidence if the double is too old
if age > k.MaxEvidenceAge(ctx) {
logger.Info(fmt.Sprintf("Ignored double sign from %s at height %d, age of %d past max age of %d", pubkey.Address(), infractionHeight, age, k.MaxEvidenceAge(ctx)))
logger.Info(fmt.Sprintf("Ignored double sign from %s at height %d, age of %d past max age of %d",
pubkey.Address(), infractionHeight, age, k.MaxEvidenceAge(ctx)))
return
}

110
x/slashing/keeper_test.go
View File

@ -9,6 +9,7 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/staking"
"github.com/cosmos/cosmos-sdk/x/staking/types"
)
// Have to change these parameters for tests
@ -30,8 +31,9 @@ func TestHandleDoubleSign(t *testing.T) {
ctx, ck, sk, _, keeper := createTestInput(t, keeperTestParams())
// validator added pre-genesis
ctx = ctx.WithBlockHeight(-1)
amtInt := int64(100)
operatorAddr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
power := int64(100)
amt := staking.TokensFromTendermintPower(power)
operatorAddr, val := addrs[0], pks[0]
got := staking.NewHandler(sk)(ctx, NewTestMsgCreateValidator(operatorAddr, val, amt))
require.True(t, got.IsOK())
staking.EndBlocker(ctx, sk)
@ -39,15 +41,15 @@ func TestHandleDoubleSign(t *testing.T) {
t, ck.GetCoins(ctx, sdk.AccAddress(operatorAddr)),
sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))},
)
require.True(sdk.IntEq(t, amt, sk.Validator(ctx, operatorAddr).GetPower()))
require.Equal(t, amt, sk.Validator(ctx, operatorAddr).GetBondedTokens())
// handle a signature to set signing info
keeper.handleValidatorSignature(ctx, val.Address(), amtInt, true)
keeper.handleValidatorSignature(ctx, val.Address(), amt.Int64(), true)
oldTokens := sk.Validator(ctx, operatorAddr).GetTokens()
// double sign less than max age
keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), amtInt)
keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), power)
// should be jailed
require.True(t, sk.Validator(ctx, operatorAddr).GetJailed())
@ -57,7 +59,7 @@ func TestHandleDoubleSign(t *testing.T) {
require.True(t, newTokens.LT(oldTokens))
// New evidence
keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), amtInt)
keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), power)
// tokens should be the same (capped slash)
require.True(t, sk.Validator(ctx, operatorAddr).GetTokens().Equal(newTokens))
@ -87,8 +89,9 @@ func TestPastMaxEvidenceAge(t *testing.T) {
ctx, ck, sk, _, keeper := createTestInput(t, keeperTestParams())
// validator added pre-genesis
ctx = ctx.WithBlockHeight(-1)
amtInt := int64(100)
operatorAddr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
power := int64(100)
amt := staking.TokensFromTendermintPower(power)
operatorAddr, val := addrs[0], pks[0]
got := staking.NewHandler(sk)(ctx, NewTestMsgCreateValidator(operatorAddr, val, amt))
require.True(t, got.IsOK())
staking.EndBlocker(ctx, sk)
@ -96,23 +99,23 @@ func TestPastMaxEvidenceAge(t *testing.T) {
t, ck.GetCoins(ctx, sdk.AccAddress(operatorAddr)),
sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))},
)
require.True(sdk.IntEq(t, amt, sk.Validator(ctx, operatorAddr).GetPower()))
require.Equal(t, amt, sk.Validator(ctx, operatorAddr).GetBondedTokens())
// handle a signature to set signing info
keeper.handleValidatorSignature(ctx, val.Address(), amtInt, true)
keeper.handleValidatorSignature(ctx, val.Address(), power, true)
ctx = ctx.WithBlockHeader(abci.Header{Time: time.Unix(1, 0).Add(keeper.MaxEvidenceAge(ctx))})
oldPower := sk.Validator(ctx, operatorAddr).GetPower()
oldPower := sk.Validator(ctx, operatorAddr).GetTendermintPower()
// double sign past max age
keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), amtInt)
keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), power)
// should still be bonded
require.True(t, sk.Validator(ctx, operatorAddr).GetStatus() == sdk.Bonded)
// should still have same power
require.True(t, sk.Validator(ctx, operatorAddr).GetPower().Equal(oldPower))
require.Equal(t, oldPower, sk.Validator(ctx, operatorAddr).GetTendermintPower())
}
// Test a validator through uptime, downtime, revocation,
@ -121,8 +124,9 @@ func TestHandleAbsentValidator(t *testing.T) {
// initial setup
ctx, ck, sk, _, keeper := createTestInput(t, keeperTestParams())
amtInt64 := int64(100)
addr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt64)
power := int64(100)
amt := staking.TokensFromTendermintPower(power)
addr, val := addrs[0], pks[0]
sh := staking.NewHandler(sk)
slh := NewHandler(keeper)
got := sh(ctx, NewTestMsgCreateValidator(addr, val, amt))
@ -133,7 +137,7 @@ func TestHandleAbsentValidator(t *testing.T) {
t, ck.GetCoins(ctx, sdk.AccAddress(addr)),
sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))},
)
require.True(sdk.IntEq(t, amt, sk.Validator(ctx, addr).GetPower()))
require.Equal(t, amt, sk.Validator(ctx, addr).GetBondedTokens())
// will exist since the validator has been bonded
info, found := keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
@ -147,7 +151,7 @@ func TestHandleAbsentValidator(t *testing.T) {
// 1000 first blocks OK
for ; height < keeper.SignedBlocksWindow(ctx); height++ {
ctx = ctx.WithBlockHeight(height)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, true)
keeper.handleValidatorSignature(ctx, val.Address(), power, true)
}
info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
require.True(t, found)
@ -157,7 +161,7 @@ func TestHandleAbsentValidator(t *testing.T) {
// 500 blocks missed
for ; height < keeper.SignedBlocksWindow(ctx)+(keeper.SignedBlocksWindow(ctx)-keeper.MinSignedPerWindow(ctx)); height++ {
ctx = ctx.WithBlockHeight(height)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
keeper.handleValidatorSignature(ctx, val.Address(), power, false)
}
info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
require.True(t, found)
@ -172,7 +176,7 @@ func TestHandleAbsentValidator(t *testing.T) {
// 501st block missed
ctx = ctx.WithBlockHeight(height)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
keeper.handleValidatorSignature(ctx, val.Address(), power, false)
info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
require.True(t, found)
require.Equal(t, int64(0), info.StartHeight)
@ -186,15 +190,15 @@ func TestHandleAbsentValidator(t *testing.T) {
validator, _ = sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
require.Equal(t, sdk.Unbonding, validator.GetStatus())
slashAmt := sdk.NewDec(amtInt64).Mul(keeper.SlashFractionDowntime(ctx)).RoundInt64()
slashAmt := sdk.NewDecFromInt(amt).Mul(keeper.SlashFractionDowntime(ctx)).RoundInt64()
// validator should have been slashed
require.Equal(t, amtInt64-slashAmt, validator.GetTokens().Int64())
require.Equal(t, amt.Int64()-slashAmt, validator.GetTokens().Int64())
// 502nd block *also* missed (since the LastCommit would have still included the just-unbonded validator)
height++
ctx = ctx.WithBlockHeight(height)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
keeper.handleValidatorSignature(ctx, val.Address(), power, false)
info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
require.True(t, found)
require.Equal(t, int64(0), info.StartHeight)
@ -205,7 +209,7 @@ func TestHandleAbsentValidator(t *testing.T) {
// validator should not have been slashed any more, since it was already jailed
validator, _ = sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
require.Equal(t, amtInt64-slashAmt, validator.GetTokens().Int64())
require.Equal(t, amt.Int64()-slashAmt, validator.GetTokens().Int64())
// unrevocation should fail prior to jail expiration
got = slh(ctx, NewMsgUnjail(addr))
@ -225,7 +229,7 @@ func TestHandleAbsentValidator(t *testing.T) {
// validator should have been slashed
pool = sk.GetPool(ctx)
require.Equal(t, amtInt64-slashAmt, pool.BondedTokens.Int64())
require.Equal(t, amt.Int64()-slashAmt, pool.BondedTokens.Int64())
// Validator start height should not have been changed
info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
@ -237,7 +241,7 @@ func TestHandleAbsentValidator(t *testing.T) {
// validator should not be immediately jailed again
height++
ctx = ctx.WithBlockHeight(height)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
keeper.handleValidatorSignature(ctx, val.Address(), power, false)
validator, _ = sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
require.Equal(t, sdk.Bonded, validator.GetStatus())
@ -245,7 +249,7 @@ func TestHandleAbsentValidator(t *testing.T) {
nextHeight := height + keeper.MinSignedPerWindow(ctx) + 1
for ; height < nextHeight; height++ {
ctx = ctx.WithBlockHeight(height)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
keeper.handleValidatorSignature(ctx, val.Address(), power, false)
}
// end block
@ -255,7 +259,7 @@ func TestHandleAbsentValidator(t *testing.T) {
nextHeight = height + keeper.MinSignedPerWindow(ctx) + 1
for ; height <= nextHeight; height++ {
ctx = ctx.WithBlockHeight(height)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
keeper.handleValidatorSignature(ctx, val.Address(), power, false)
}
// end block
@ -271,22 +275,23 @@ func TestHandleAbsentValidator(t *testing.T) {
func TestHandleNewValidator(t *testing.T) {
// initial setup
ctx, ck, sk, _, keeper := createTestInput(t, keeperTestParams())
addr, val, amt := addrs[0], pks[0], int64(100)
addr, val := addrs[0], pks[0]
amt := staking.TokensFromTendermintPower(100)
sh := staking.NewHandler(sk)
// 1000 first blocks not a validator
ctx = ctx.WithBlockHeight(keeper.SignedBlocksWindow(ctx) + 1)
// Validator created
got := sh(ctx, NewTestMsgCreateValidator(addr, val, sdk.NewInt(amt)))
got := sh(ctx, NewTestMsgCreateValidator(addr, val, amt))
require.True(t, got.IsOK())
staking.EndBlocker(ctx, sk)
require.Equal(
t, ck.GetCoins(ctx, sdk.AccAddress(addr)),
sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.SubRaw(amt))},
sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))},
)
require.Equal(t, amt, sk.Validator(ctx, addr).GetPower().Int64())
require.Equal(t, amt, sk.Validator(ctx, addr).GetBondedTokens())
// Now a validator, for two blocks
keeper.handleValidatorSignature(ctx, val.Address(), 100, true)
@ -304,7 +309,8 @@ func TestHandleNewValidator(t *testing.T) {
validator, _ := sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
require.Equal(t, sdk.Bonded, validator.GetStatus())
pool := sk.GetPool(ctx)
require.Equal(t, int64(100), pool.BondedTokens.Int64())
expTokens := staking.TokensFromTendermintPower(100)
require.Equal(t, expTokens, pool.BondedTokens)
}
// Test a jailed validator being "down" twice
@ -313,8 +319,9 @@ func TestHandleAlreadyJailed(t *testing.T) {
// initial setup
ctx, _, sk, _, keeper := createTestInput(t, DefaultParams())
amtInt := int64(100)
addr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
power := int64(100)
amt := staking.TokensFromTendermintPower(power)
addr, val := addrs[0], pks[0]
sh := staking.NewHandler(sk)
got := sh(ctx, NewTestMsgCreateValidator(addr, val, amt))
require.True(t, got.IsOK())
@ -324,13 +331,13 @@ func TestHandleAlreadyJailed(t *testing.T) {
height := int64(0)
for ; height < keeper.SignedBlocksWindow(ctx); height++ {
ctx = ctx.WithBlockHeight(height)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt, true)
keeper.handleValidatorSignature(ctx, val.Address(), power, true)
}
// 501 blocks missed
for ; height < keeper.SignedBlocksWindow(ctx)+(keeper.SignedBlocksWindow(ctx)-keeper.MinSignedPerWindow(ctx))+1; height++ {
ctx = ctx.WithBlockHeight(height)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt, false)
keeper.handleValidatorSignature(ctx, val.Address(), power, false)
}
// end block
@ -341,15 +348,16 @@ func TestHandleAlreadyJailed(t *testing.T) {
require.Equal(t, sdk.Unbonding, validator.GetStatus())
// validator should have been slashed
require.Equal(t, amtInt-1, validator.GetTokens().Int64())
resultingTokens := amt.Sub(staking.TokensFromTendermintPower(1))
require.Equal(t, resultingTokens, validator.GetTokens())
// another block missed
ctx = ctx.WithBlockHeight(height)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt, false)
keeper.handleValidatorSignature(ctx, val.Address(), power, false)
// validator should not have been slashed twice
validator, _ = sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
require.Equal(t, amtInt-1, validator.GetTokens().Int64())
require.Equal(t, resultingTokens, validator.GetTokens())
}
@ -364,8 +372,9 @@ func TestValidatorDippingInAndOut(t *testing.T) {
params := sk.GetParams(ctx)
params.MaxValidators = 1
sk.SetParams(ctx, params)
amtInt := int64(100)
addr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
power := int64(100)
amt := staking.TokensFromTendermintPower(power)
addr, val := addrs[0], pks[0]
consAddr := sdk.ConsAddress(addr)
sh := staking.NewHandler(sk)
got := sh(ctx, NewTestMsgCreateValidator(addr, val, amt))
@ -376,12 +385,12 @@ func TestValidatorDippingInAndOut(t *testing.T) {
height := int64(0)
for ; height < int64(100); height++ {
ctx = ctx.WithBlockHeight(height)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt, true)
keeper.handleValidatorSignature(ctx, val.Address(), power, true)
}
// validator kicked out of validator set
newAmt := int64(101)
got = sh(ctx, NewTestMsgCreateValidator(addrs[1], pks[1], sdk.NewInt(newAmt)))
newAmt := staking.TokensFromTendermintPower(101)
got = sh(ctx, NewTestMsgCreateValidator(addrs[1], pks[1], newAmt))
require.True(t, got.IsOK())
validatorUpdates, _ := staking.EndBlocker(ctx, sk)
require.Equal(t, 2, len(validatorUpdates))
@ -393,16 +402,17 @@ func TestValidatorDippingInAndOut(t *testing.T) {
ctx = ctx.WithBlockHeight(height)
// validator added back in
got = sh(ctx, newTestMsgDelegate(sdk.AccAddress(addrs[2]), addrs[0], sdk.NewInt(3)))
delTokens := types.TokensFromTendermintPower(3)
got = sh(ctx, newTestMsgDelegate(sdk.AccAddress(addrs[2]), addrs[0], delTokens))
require.True(t, got.IsOK())
validatorUpdates, _ = staking.EndBlocker(ctx, sk)
require.Equal(t, 2, len(validatorUpdates))
validator, _ = sk.GetValidator(ctx, addr)
require.Equal(t, sdk.Bonded, validator.Status)
newAmt = int64(103)
newPower := int64(103)
// validator misses a block
keeper.handleValidatorSignature(ctx, val.Address(), newAmt, false)
keeper.handleValidatorSignature(ctx, val.Address(), newPower, false)
height++
// shouldn't be jailed/kicked yet
@ -413,7 +423,7 @@ func TestValidatorDippingInAndOut(t *testing.T) {
latest := height
for ; height < latest+500; height++ {
ctx = ctx.WithBlockHeight(height)
keeper.handleValidatorSignature(ctx, val.Address(), newAmt, false)
keeper.handleValidatorSignature(ctx, val.Address(), newPower, false)
}
// should now be jailed & kicked
@ -438,7 +448,7 @@ func TestValidatorDippingInAndOut(t *testing.T) {
// validator rejoins and starts signing again
sk.Unjail(ctx, consAddr)
keeper.handleValidatorSignature(ctx, val.Address(), newAmt, true)
keeper.handleValidatorSignature(ctx, val.Address(), newPower, true)
height++
// validator should not be kicked since we reset counter/array when it was jailed
@ -450,7 +460,7 @@ func TestValidatorDippingInAndOut(t *testing.T) {
latest = height
for ; height < latest+501; height++ {
ctx = ctx.WithBlockHeight(height)
keeper.handleValidatorSignature(ctx, val.Address(), newAmt, false)
keeper.handleValidatorSignature(ctx, val.Address(), newPower, false)
}
// validator should now be jailed & kicked

11
x/slashing/params.go
View File

@ -81,11 +81,13 @@ func DefaultParams() Params {
// TODO Temporarily set to 10 minutes for testnets
DowntimeJailDuration: 60 * 10 * time.Second,
// CONTRACT must be less than 1
// TODO enforce this contract https://github.com/cosmos/cosmos-sdk/issues/3474
MinSignedPerWindow: sdk.NewDecWithPrec(5, 1),
SlashFractionDoubleSign: sdk.NewDec(1).Quo(sdk.NewDec(20)),
SlashFractionDoubleSign: sdk.NewDec(1).QuoInt64(20),
SlashFractionDowntime: sdk.NewDec(1).Quo(sdk.NewDec(100)),
SlashFractionDowntime: sdk.NewDec(1).QuoInt64(100),
}
}
@ -107,7 +109,10 @@ func (k Keeper) MinSignedPerWindow(ctx sdk.Context) int64 {
var minSignedPerWindow sdk.Dec
k.paramspace.Get(ctx, KeyMinSignedPerWindow, &minSignedPerWindow)
signedBlocksWindow := k.SignedBlocksWindow(ctx)
return sdk.NewDec(signedBlocksWindow).Mul(minSignedPerWindow).RoundInt64()
// NOTE: RoundInt64 will never panic as minSignedPerWindow is
// less than 1.
return minSignedPerWindow.MulInt64(signedBlocksWindow).RoundInt64()
}
// Downtime unbond duration

24
x/slashing/signing_info.go
View File

@ -90,17 +90,6 @@ func (k Keeper) clearValidatorMissedBlockBitArray(ctx sdk.Context, address sdk.C
}
}
// Construct a new `ValidatorSigningInfo` struct
func NewValidatorSigningInfo(startHeight int64, indexOffset int64, jailedUntil time.Time, tombstoned bool, missedBlocksCounter int64) ValidatorSigningInfo {
return ValidatorSigningInfo{
StartHeight: startHeight,
IndexOffset: indexOffset,
JailedUntil: jailedUntil,
Tombstoned: tombstoned,
MissedBlocksCounter: missedBlocksCounter,
}
}
// Signing info for a validator
type ValidatorSigningInfo struct {
StartHeight int64 `json:"start_height"` // height at which validator was first a candidate OR was unjailed
@ -110,6 +99,19 @@ type ValidatorSigningInfo struct {
MissedBlocksCounter int64 `json:"missed_blocks_counter"` // missed blocks counter (to avoid scanning the array every time)
}
// Construct a new `ValidatorSigningInfo` struct
func NewValidatorSigningInfo(startHeight, indexOffset int64, jailedUntil time.Time,
tombstoned bool, missedBlocksCounter int64) ValidatorSigningInfo {
return ValidatorSigningInfo{
StartHeight: startHeight,
IndexOffset: indexOffset,
JailedUntil: jailedUntil,
Tombstoned: tombstoned,
MissedBlocksCounter: missedBlocksCounter,
}
}
// Return human readable signing info
func (i ValidatorSigningInfo) String() string {
return fmt.Sprintf(`Start Height: %d

7
x/slashing/test_common.go
View File

@ -21,7 +21,6 @@ import (
"github.com/cosmos/cosmos-sdk/x/bank"
"github.com/cosmos/cosmos-sdk/x/params"
"github.com/cosmos/cosmos-sdk/x/staking"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
)
// TODO remove dependencies on staking (should only refer to validator set type from sdk)
@ -37,7 +36,7 @@ var (
sdk.ValAddress(pks[1].Address()),
sdk.ValAddress(pks[2].Address()),
}
initCoins = sdk.NewInt(200)
initCoins = staking.TokensFromTendermintPower(200)
)
func createTestCodec() *codec.Codec {
@ -76,7 +75,7 @@ func createTestInput(t *testing.T, defaults Params) (sdk.Context, bank.Keeper, s
sk := staking.NewKeeper(cdc, keyStaking, tkeyStaking, ck, paramsKeeper.Subspace(staking.DefaultParamspace), staking.DefaultCodespace)
genesis := staking.DefaultGenesisState()
genesis.Pool.NotBondedTokens = sdk.NewInt(initCoins.MulRaw(int64(len(addrs))).Int64())
genesis.Pool.NotBondedTokens = initCoins.MulRaw(int64(len(addrs)))
_, err = staking.InitGenesis(ctx, sk, genesis)
require.Nil(t, err)
@ -116,7 +115,7 @@ func testAddr(addr string) sdk.AccAddress {
func NewTestMsgCreateValidator(address sdk.ValAddress, pubKey crypto.PubKey, amt sdk.Int) staking.MsgCreateValidator {
commission := staking.NewCommissionMsg(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec())
return staking.NewMsgCreateValidator(
address, pubKey, sdk.NewCoin(stakingTypes.DefaultBondDenom, amt),
address, pubKey, sdk.NewCoin(staking.DefaultBondDenom, amt),
staking.Description{}, commission,
)
}

7
x/slashing/tick_test.go
View File

@ -10,11 +10,14 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/staking"
"github.com/cosmos/cosmos-sdk/x/staking/types"
)
func TestBeginBlocker(t *testing.T) {
ctx, ck, sk, _, keeper := createTestInput(t, DefaultParams())
addr, pk, amt := addrs[2], pks[2], sdk.NewInt(100)
power := int64(100)
amt := types.TokensFromTendermintPower(power)
addr, pk := addrs[2], pks[2]
// bond the validator
got := staking.NewHandler(sk)(ctx, NewTestMsgCreateValidator(addr, pk, amt))
@ -24,7 +27,7 @@ func TestBeginBlocker(t *testing.T) {
t, ck.GetCoins(ctx, sdk.AccAddress(addr)),
sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))},
)
require.True(sdk.IntEq(t, amt, sk.Validator(ctx, addr).GetPower()))
require.Equal(t, amt, sk.Validator(ctx, addr).GetBondedTokens())
val := abci.Validator{
Address: pk.Address(),

20
x/staking/app_test.go
View File

@ -10,7 +10,6 @@ import (
"github.com/cosmos/cosmos-sdk/x/auth"
"github.com/cosmos/cosmos-sdk/x/bank"
"github.com/cosmos/cosmos-sdk/x/mock"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
)
// getMockApp returns an initialized mock application for this module.
@ -52,7 +51,8 @@ func getInitChainer(mapp *mock.App, keeper Keeper) sdk.InitChainer {
mapp.InitChainer(ctx, req)
stakingGenesis := DefaultGenesisState()
stakingGenesis.Pool.NotBondedTokens = sdk.NewInt(100000)
tokens := TokensFromTendermintPower(100000)
stakingGenesis.Pool.NotBondedTokens = tokens
validators, err := InitGenesis(ctx, keeper, stakingGenesis)
if err != nil {
@ -97,8 +97,10 @@ func checkDelegation(
func TestStakingMsgs(t *testing.T) {
mApp, keeper := getMockApp(t)
genCoin := sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 42)
bondCoin := sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10)
genTokens := TokensFromTendermintPower(42)
bondTokens := TokensFromTendermintPower(10)
genCoin := sdk.NewCoin(DefaultBondDenom, genTokens)
bondCoin := sdk.NewCoin(DefaultBondDenom, bondTokens)
acc1 := &auth.BaseAccount{
Address: addr1,
@ -127,7 +129,7 @@ func TestStakingMsgs(t *testing.T) {
validator := checkValidator(t, mApp, keeper, sdk.ValAddress(addr1), true)
require.Equal(t, sdk.ValAddress(addr1), validator.OperatorAddr)
require.Equal(t, sdk.Bonded, validator.Status)
require.True(sdk.IntEq(t, sdk.NewInt(10), validator.BondedTokens()))
require.True(sdk.IntEq(t, bondTokens, validator.BondedTokens()))
// addr1 create validator on behalf of addr2
createValidatorMsgOnBehalfOf := NewMsgCreateValidatorOnBehalfOf(
@ -141,10 +143,10 @@ func TestStakingMsgs(t *testing.T) {
validator = checkValidator(t, mApp, keeper, sdk.ValAddress(addr2), true)
require.Equal(t, sdk.ValAddress(addr2), validator.OperatorAddr)
require.Equal(t, sdk.Bonded, validator.Status)
require.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
require.True(sdk.IntEq(t, bondTokens, validator.Tokens))
// check the bond that should have been created as well
checkDelegation(t, mApp, keeper, addr1, sdk.ValAddress(addr1), true, sdk.NewDec(10))
checkDelegation(t, mApp, keeper, addr1, sdk.ValAddress(addr1), true, sdk.NewDecFromInt(bondTokens))
// edit the validator
description = NewDescription("bar_moniker", "", "", "")
@ -160,10 +162,10 @@ func TestStakingMsgs(t *testing.T) {
mock.SignCheckDeliver(t, mApp.Cdc, mApp.BaseApp, []sdk.Msg{delegateMsg}, []uint64{0}, []uint64{1}, true, true, priv2)
mock.CheckBalance(t, mApp, addr2, sdk.Coins{genCoin.Minus(bondCoin)})
checkDelegation(t, mApp, keeper, addr2, sdk.ValAddress(addr1), true, sdk.NewDec(10))
checkDelegation(t, mApp, keeper, addr2, sdk.ValAddress(addr1), true, sdk.NewDecFromInt(bondTokens))
// begin unbonding
beginUnbondingMsg := NewMsgUndelegate(addr2, sdk.ValAddress(addr1), sdk.NewDec(10))
beginUnbondingMsg := NewMsgUndelegate(addr2, sdk.ValAddress(addr1), sdk.NewDecFromInt(bondTokens))
mock.SignCheckDeliver(t, mApp.Cdc, mApp.BaseApp, []sdk.Msg{beginUnbondingMsg}, []uint64{0}, []uint64{2}, true, true, priv2)
// delegation should exist anymore

6
x/staking/genesis.go
View File

@ -77,7 +77,7 @@ func InitGenesis(ctx sdk.Context, keeper Keeper, data types.GenesisState) (res [
panic("expected validator, not found")
}
update := validator.ABCIValidatorUpdate()
update.Power = lv.Power.Int64() // keep the next-val-set offset, use the last power for the first block
update.Power = lv.Power // keep the next-val-set offset, use the last power for the first block
res = append(res, update)
}
} else {
@ -107,7 +107,7 @@ func ExportGenesis(ctx sdk.Context, keeper Keeper) types.GenesisState {
return false
})
var lastValidatorPowers []types.LastValidatorPower
keeper.IterateLastValidatorPowers(ctx, func(addr sdk.ValAddress, power sdk.Int) (stop bool) {
keeper.IterateLastValidatorPowers(ctx, func(addr sdk.ValAddress, power int64) (stop bool) {
lastValidatorPowers = append(lastValidatorPowers, types.LastValidatorPower{addr, power})
return false
})
@ -130,7 +130,7 @@ func WriteValidators(ctx sdk.Context, keeper Keeper) (vals []tmtypes.GenesisVali
keeper.IterateLastValidators(ctx, func(_ int64, validator sdk.Validator) (stop bool) {
vals = append(vals, tmtypes.GenesisValidator{
PubKey: validator.GetConsPubKey(),
Power: validator.GetPower().Int64(),
Power: validator.GetTendermintPower(),
Name: validator.GetMoniker(),
})

31
x/staking/genesis_test.go
View File

@ -20,7 +20,8 @@ func TestInitGenesis(t *testing.T) {
ctx, _, keeper := keep.CreateTestInput(t, false, 1000)
pool := keeper.GetPool(ctx)
pool.BondedTokens = sdk.NewInt(2)
pool.BondedTokens = TokensFromTendermintPower(2)
valTokens := TokensFromTendermintPower(1)
params := keeper.GetParams(ctx)
validators := make([]Validator, 2)
@ -29,16 +30,16 @@ func TestInitGenesis(t *testing.T) {
// initialize the validators
validators[0].OperatorAddr = sdk.ValAddress(keep.Addrs[0])
validators[0].ConsPubKey = keep.PKs[0]
validators[0].Description = Description{Moniker: "hoop"}
validators[0].Description = NewDescription("hoop", "", "", "")
validators[0].Status = sdk.Bonded
validators[0].Tokens = sdk.OneInt()
validators[0].DelegatorShares = sdk.OneDec()
validators[0].Tokens = valTokens
validators[0].DelegatorShares = sdk.NewDecFromInt(valTokens)
validators[1].OperatorAddr = sdk.ValAddress(keep.Addrs[1])
validators[1].ConsPubKey = keep.PKs[1]
validators[1].Description = Description{Moniker: "bloop"}
validators[1].Description = NewDescription("bloop", "", "", "")
validators[1].Status = sdk.Bonded
validators[1].Tokens = sdk.OneInt()
validators[1].DelegatorShares = sdk.OneDec()
validators[1].Tokens = valTokens
validators[1].DelegatorShares = sdk.NewDecFromInt(valTokens)
genesisState := types.NewGenesisState(pool, params, validators, delegations)
vals, err := InitGenesis(ctx, keeper, genesisState)
@ -75,23 +76,25 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) {
// Assigning 2 to the first 100 vals, 1 to the rest
pool := keeper.GetPool(ctx)
pool.BondedTokens = sdk.NewInt(int64(200 + (size - 100)))
bondedTokens := TokensFromTendermintPower(int64(200 + (size - 100)))
pool.BondedTokens = bondedTokens
params := keeper.GetParams(ctx)
delegations := []Delegation{}
validators := make([]Validator, size)
for i := range validators {
validators[i] = NewValidator(sdk.ValAddress(keep.Addrs[i]), keep.PKs[i], Description{Moniker: fmt.Sprintf("#%d", i)})
validators[i] = NewValidator(sdk.ValAddress(keep.Addrs[i]),
keep.PKs[i], NewDescription(fmt.Sprintf("#%d", i), "", "", ""))
validators[i].Status = sdk.Bonded
tokens := TokensFromTendermintPower(1)
if i < 100 {
validators[i].Tokens = sdk.NewInt(2)
validators[i].DelegatorShares = sdk.NewDec(2)
} else {
validators[i].Tokens = sdk.OneInt()
validators[i].DelegatorShares = sdk.OneDec()
tokens = TokensFromTendermintPower(2)
}
validators[i].Tokens = tokens
validators[i].DelegatorShares = sdk.NewDecFromInt(tokens)
}
genesisState := types.NewGenesisState(pool, params, validators, delegations)

286
x/staking/handler_test.go
View File

@ -31,8 +31,9 @@ func setInstantUnbondPeriod(keeper keep.Keeper, ctx sdk.Context) types.Params {
func TestValidatorByPowerIndex(t *testing.T) {
validatorAddr, validatorAddr3 := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1])
initBond := int64(1000000)
ctx, _, keeper := keep.CreateTestInput(t, false, initBond)
initPower := int64(1000000)
initBond := TokensFromTendermintPower(initPower)
ctx, _, keeper := keep.CreateTestInput(t, false, initPower)
_ = setInstantUnbondPeriod(keeper, ctx)
// create validator
@ -47,10 +48,8 @@ func TestValidatorByPowerIndex(t *testing.T) {
// verify the self-delegation exists
bond, found := keeper.GetDelegation(ctx, sdk.AccAddress(validatorAddr), validatorAddr)
require.True(t, found)
gotBond := bond.Shares.RoundInt64()
require.Equal(t, initBond, gotBond,
"initBond: %v\ngotBond: %v\nbond: %v\n",
initBond, gotBond, bond)
gotBond := bond.Shares.RoundInt()
require.Equal(t, initBond, gotBond)
// verify that the by power index exists
validator, found := keeper.GetValidator(ctx, validatorAddr)
@ -59,7 +58,7 @@ func TestValidatorByPowerIndex(t *testing.T) {
require.True(t, keep.ValidatorByPowerIndexExists(ctx, keeper, power))
// create a second validator keep it bonded
msgCreateValidator = NewTestMsgCreateValidator(validatorAddr3, keep.PKs[2], int64(1000000))
msgCreateValidator = NewTestMsgCreateValidator(validatorAddr3, keep.PKs[2], initBond)
got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected create-validator to be ok, got %v", got)
@ -69,13 +68,13 @@ func TestValidatorByPowerIndex(t *testing.T) {
// slash and jail the first validator
consAddr0 := sdk.ConsAddress(keep.PKs[0].Address())
keeper.Slash(ctx, consAddr0, 0, initBond, sdk.NewDecWithPrec(5, 1))
keeper.Slash(ctx, consAddr0, 0, initPower, sdk.NewDecWithPrec(5, 1))
keeper.Jail(ctx, consAddr0)
keeper.ApplyAndReturnValidatorSetUpdates(ctx)
validator, found = keeper.GetValidator(ctx, validatorAddr)
require.True(t, found)
require.Equal(t, sdk.Unbonding, validator.Status) // ensure is unbonding
require.Equal(t, int64(500000), validator.Tokens.Int64()) // ensure tokens slashed
require.Equal(t, sdk.Unbonding, validator.Status) // ensure is unbonding
require.Equal(t, initBond.DivRaw(2), validator.Tokens) // ensure tokens slashed
keeper.Unjail(ctx, consAddr0)
// the old power record should have been deleted as the power changed
@ -92,7 +91,7 @@ func TestValidatorByPowerIndex(t *testing.T) {
require.Equal(t, power2, power3)
// unbond self-delegation
msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDec(1000000))
msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDecFromInt(initBond))
got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
require.True(t, got.IsOK(), "expected msg to be ok, got %v", got)
var finishTime time.Time
@ -114,7 +113,8 @@ func TestDuplicatesMsgCreateValidator(t *testing.T) {
addr1, addr2 := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1])
pk1, pk2 := keep.PKs[0], keep.PKs[1]
msgCreateValidator1 := NewTestMsgCreateValidator(addr1, pk1, 10)
valTokens := types.TokensFromTendermintPower(10)
msgCreateValidator1 := NewTestMsgCreateValidator(addr1, pk1, valTokens)
got := handleMsgCreateValidator(ctx, msgCreateValidator1, keeper)
require.True(t, got.IsOK(), "%v", got)
@ -125,22 +125,22 @@ func TestDuplicatesMsgCreateValidator(t *testing.T) {
assert.Equal(t, sdk.Bonded, validator.Status)
assert.Equal(t, addr1, validator.OperatorAddr)
assert.Equal(t, pk1, validator.ConsPubKey)
assert.Equal(t, int64(10), validator.BondedTokens().Int64())
assert.Equal(t, sdk.NewDec(10), validator.DelegatorShares)
assert.Equal(t, valTokens, validator.BondedTokens())
assert.Equal(t, sdk.NewDecFromInt(valTokens), validator.DelegatorShares)
assert.Equal(t, Description{}, validator.Description)
// two validators can't have the same operator address
msgCreateValidator2 := NewTestMsgCreateValidator(addr1, pk2, 10)
msgCreateValidator2 := NewTestMsgCreateValidator(addr1, pk2, valTokens)
got = handleMsgCreateValidator(ctx, msgCreateValidator2, keeper)
require.False(t, got.IsOK(), "%v", got)
// two validators can't have the same pubkey
msgCreateValidator3 := NewTestMsgCreateValidator(addr2, pk1, 10)
msgCreateValidator3 := NewTestMsgCreateValidator(addr2, pk1, valTokens)
got = handleMsgCreateValidator(ctx, msgCreateValidator3, keeper)
require.False(t, got.IsOK(), "%v", got)
// must have different pubkey and operator
msgCreateValidator4 := NewTestMsgCreateValidator(addr2, pk2, 10)
msgCreateValidator4 := NewTestMsgCreateValidator(addr2, pk2, valTokens)
got = handleMsgCreateValidator(ctx, msgCreateValidator4, keeper)
require.True(t, got.IsOK(), "%v", got)
@ -154,8 +154,8 @@ func TestDuplicatesMsgCreateValidator(t *testing.T) {
assert.Equal(t, sdk.Bonded, validator.Status)
assert.Equal(t, addr2, validator.OperatorAddr)
assert.Equal(t, pk2, validator.ConsPubKey)
assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.DelegatorShares))
assert.True(sdk.IntEq(t, valTokens, validator.Tokens))
assert.True(sdk.DecEq(t, sdk.NewDecFromInt(valTokens), validator.DelegatorShares))
assert.Equal(t, Description{}, validator.Description)
}
@ -166,7 +166,7 @@ func TestInvalidPubKeyTypeMsgCreateValidator(t *testing.T) {
invalidPk := secp256k1.GenPrivKey().PubKey()
// invalid pukKey type should not be allowed
msgCreateValidator := NewTestMsgCreateValidator(addr, invalidPk, 10)
msgCreateValidator := NewTestMsgCreateValidator(addr, invalidPk, sdk.NewInt(10))
got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.False(t, got.IsOK(), "%v", got)
@ -184,7 +184,8 @@ func TestDuplicatesMsgCreateValidatorOnBehalfOf(t *testing.T) {
validatorAddr := sdk.ValAddress(keep.Addrs[0])
delegatorAddr := keep.Addrs[1]
pk := keep.PKs[0]
msgCreateValidatorOnBehalfOf := NewTestMsgCreateValidatorOnBehalfOf(delegatorAddr, validatorAddr, pk, 10)
valTokens := types.TokensFromTendermintPower(10)
msgCreateValidatorOnBehalfOf := NewTestMsgCreateValidatorOnBehalfOf(delegatorAddr, validatorAddr, pk, valTokens)
got := handleMsgCreateValidator(ctx, msgCreateValidatorOnBehalfOf, keeper)
require.True(t, got.IsOK(), "%v", got)
@ -198,8 +199,8 @@ func TestDuplicatesMsgCreateValidatorOnBehalfOf(t *testing.T) {
assert.Equal(t, sdk.Bonded, validator.Status)
assert.Equal(t, validatorAddr, validator.OperatorAddr)
assert.Equal(t, pk, validator.ConsPubKey)
assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.DelegatorShares))
assert.True(sdk.IntEq(t, valTokens, validator.Tokens))
assert.True(sdk.DecEq(t, sdk.NewDecFromInt(valTokens), validator.DelegatorShares))
assert.Equal(t, Description{}, validator.Description)
// one validator cannot be created twice even from different delegator
@ -213,7 +214,7 @@ func TestLegacyValidatorDelegations(t *testing.T) {
ctx, _, keeper := keep.CreateTestInput(t, false, int64(1000))
setInstantUnbondPeriod(keeper, ctx)
bondAmount := int64(10)
bondAmount := TokensFromTendermintPower(10)
valAddr := sdk.ValAddress(keep.Addrs[0])
valConsPubKey, valConsAddr := keep.PKs[0], sdk.ConsAddress(keep.PKs[0].Address())
delAddr := keep.Addrs[1]
@ -231,8 +232,8 @@ func TestLegacyValidatorDelegations(t *testing.T) {
validator, found := keeper.GetValidator(ctx, valAddr)
require.True(t, found)
require.Equal(t, sdk.Bonded, validator.Status)
require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt64())
require.Equal(t, bondAmount, validator.BondedTokens().Int64())
require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt())
require.Equal(t, bondAmount, validator.BondedTokens())
// delegate tokens to the validator
msgDelegate := NewTestMsgDelegate(delAddr, valAddr, bondAmount)
@ -242,12 +243,12 @@ func TestLegacyValidatorDelegations(t *testing.T) {
// verify validator bonded shares
validator, found = keeper.GetValidator(ctx, valAddr)
require.True(t, found)
require.Equal(t, bondAmount*2, validator.DelegatorShares.RoundInt64())
require.Equal(t, bondAmount*2, validator.BondedTokens().Int64())
require.Equal(t, bondAmount.MulRaw(2), validator.DelegatorShares.RoundInt())
require.Equal(t, bondAmount.MulRaw(2), validator.BondedTokens())
// unbond validator total self-delegations (which should jail the validator)
unbondShares := sdk.NewDec(10)
msgUndelegate := NewMsgUndelegate(sdk.AccAddress(valAddr), valAddr, unbondShares)
unbondShares := types.TokensFromTendermintPower(10)
msgUndelegate := NewMsgUndelegate(sdk.AccAddress(valAddr), valAddr, sdk.NewDecFromInt(unbondShares))
got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
require.True(t, got.IsOK(), "expected begin unbonding validator msg to be ok, got %v", got)
@ -261,13 +262,13 @@ func TestLegacyValidatorDelegations(t *testing.T) {
validator, found = keeper.GetValidator(ctx, valAddr)
require.True(t, found)
require.True(t, validator.Jailed)
require.Equal(t, int64(10), validator.Tokens.Int64())
require.Equal(t, bondAmount, validator.Tokens)
// verify delegation still exists
bond, found := keeper.GetDelegation(ctx, delAddr, valAddr)
require.True(t, found)
require.Equal(t, bondAmount, bond.Shares.RoundInt64())
require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt64())
require.Equal(t, bondAmount, bond.Shares.RoundInt())
require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt())
// verify a delegator cannot create a new delegation to the now jailed validator
msgDelegate = NewTestMsgDelegate(delAddr, valAddr, bondAmount)
@ -282,8 +283,8 @@ func TestLegacyValidatorDelegations(t *testing.T) {
// verify validator bonded shares
validator, found = keeper.GetValidator(ctx, valAddr)
require.True(t, found)
require.Equal(t, bondAmount*2, validator.DelegatorShares.RoundInt64())
require.Equal(t, bondAmount*2, validator.Tokens.Int64())
require.Equal(t, bondAmount.MulRaw(2), validator.DelegatorShares.RoundInt())
require.Equal(t, bondAmount.MulRaw(2), validator.Tokens)
// unjail the validator now that is has non-zero self-delegated shares
keeper.Unjail(ctx, valConsAddr)
@ -296,22 +297,23 @@ func TestLegacyValidatorDelegations(t *testing.T) {
// verify validator bonded shares
validator, found = keeper.GetValidator(ctx, valAddr)
require.True(t, found)
require.Equal(t, bondAmount*3, validator.DelegatorShares.RoundInt64())
require.Equal(t, bondAmount*3, validator.Tokens.Int64())
require.Equal(t, bondAmount.MulRaw(3), validator.DelegatorShares.RoundInt())
require.Equal(t, bondAmount.MulRaw(3), validator.Tokens)
// verify new delegation
bond, found = keeper.GetDelegation(ctx, delAddr, valAddr)
require.True(t, found)
require.Equal(t, bondAmount*2, bond.Shares.RoundInt64())
require.Equal(t, bondAmount*3, validator.DelegatorShares.RoundInt64())
require.Equal(t, bondAmount.MulRaw(2), bond.Shares.RoundInt())
require.Equal(t, bondAmount.MulRaw(3), validator.DelegatorShares.RoundInt())
}
func TestIncrementsMsgDelegate(t *testing.T) {
initBond := int64(1000)
ctx, accMapper, keeper := keep.CreateTestInput(t, false, initBond)
initPower := int64(1000)
initBond := TokensFromTendermintPower(initPower)
ctx, accMapper, keeper := keep.CreateTestInput(t, false, initPower)
params := keeper.GetParams(ctx)
bondAmount := int64(10)
bondAmount := TokensFromTendermintPower(10)
validatorAddr, delegatorAddr := sdk.ValAddress(keep.Addrs[0]), keep.Addrs[1]
// first create validator
@ -325,25 +327,25 @@ func TestIncrementsMsgDelegate(t *testing.T) {
validator, found := keeper.GetValidator(ctx, validatorAddr)
require.True(t, found)
require.Equal(t, sdk.Bonded, validator.Status)
require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt64())
require.Equal(t, bondAmount, validator.BondedTokens().Int64(), "validator: %v", validator)
require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt())
require.Equal(t, bondAmount, validator.BondedTokens(), "validator: %v", validator)
_, found = keeper.GetDelegation(ctx, delegatorAddr, validatorAddr)
require.False(t, found)
bond, found := keeper.GetDelegation(ctx, sdk.AccAddress(validatorAddr), validatorAddr)
require.True(t, found)
require.Equal(t, bondAmount, bond.Shares.RoundInt64())
require.Equal(t, bondAmount, bond.Shares.RoundInt())
pool := keeper.GetPool(ctx)
exRate := validator.DelegatorShareExRate()
require.True(t, exRate.Equal(sdk.OneDec()), "expected exRate 1 got %v", exRate)
require.Equal(t, bondAmount, pool.BondedTokens.Int64())
require.Equal(t, bondAmount, pool.BondedTokens)
// just send the same msgbond multiple times
msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, bondAmount)
for i := 0; i < 5; i++ {
for i := int64(0); i < 5; i++ {
ctx = ctx.WithBlockHeight(int64(i))
got := handleMsgDelegate(ctx, msgDelegate, keeper)
@ -358,12 +360,12 @@ func TestIncrementsMsgDelegate(t *testing.T) {
exRate := validator.DelegatorShareExRate()
require.True(t, exRate.Equal(sdk.OneDec()), "expected exRate 1 got %v, i = %v", exRate, i)
expBond := int64(i+1) * bondAmount
expDelegatorShares := int64(i+2) * bondAmount // (1 self delegation)
expDelegatorAcc := sdk.NewInt(initBond - expBond)
expBond := bondAmount.MulRaw(i + 1)
expDelegatorShares := bondAmount.MulRaw(i + 2) // (1 self delegation)
expDelegatorAcc := initBond.Sub(expBond)
gotBond := bond.Shares.RoundInt64()
gotDelegatorShares := validator.DelegatorShares.RoundInt64()
gotBond := bond.Shares.RoundInt()
gotDelegatorShares := validator.DelegatorShares.RoundInt()
gotDelegatorAcc := accMapper.GetAccount(ctx, delegatorAddr).GetCoins().AmountOf(params.BondDenom)
require.Equal(t, expBond, gotBond,
@ -379,8 +381,9 @@ func TestIncrementsMsgDelegate(t *testing.T) {
}
func TestIncrementsMsgUnbond(t *testing.T) {
initBond := int64(1000)
ctx, accMapper, keeper := keep.CreateTestInput(t, false, initBond)
initPower := int64(1000)
initBond := TokensFromTendermintPower(initPower)
ctx, accMapper, keeper := keep.CreateTestInput(t, false, initPower)
params := setInstantUnbondPeriod(keeper, ctx)
denom := params.BondDenom
@ -400,22 +403,22 @@ func TestIncrementsMsgUnbond(t *testing.T) {
// balance should have been subtracted after delegation
amt2 := accMapper.GetAccount(ctx, delegatorAddr).GetCoins().AmountOf(denom)
require.Equal(t, amt1.Sub(sdk.NewInt(initBond)).Int64(), amt2.Int64(), "expected coins to be subtracted")
require.True(sdk.IntEq(t, amt1.Sub(initBond), amt2))
// apply TM updates
keeper.ApplyAndReturnValidatorSetUpdates(ctx)
validator, found := keeper.GetValidator(ctx, validatorAddr)
require.True(t, found)
require.Equal(t, initBond*2, validator.DelegatorShares.RoundInt64())
require.Equal(t, initBond*2, validator.BondedTokens().Int64())
require.Equal(t, initBond.MulRaw(2), validator.DelegatorShares.RoundInt())
require.Equal(t, initBond.MulRaw(2), validator.BondedTokens())
// just send the same msgUnbond multiple times
// TODO use decimals here
unbondShares := sdk.NewDec(10)
msgUndelegate := NewMsgUndelegate(delegatorAddr, validatorAddr, unbondShares)
numUnbonds := 5
for i := 0; i < numUnbonds; i++ {
numUnbonds := int64(5)
for i := int64(0); i < numUnbonds; i++ {
got := handleMsgUndelegate(ctx, msgUndelegate, keeper)
require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
@ -430,12 +433,12 @@ func TestIncrementsMsgUnbond(t *testing.T) {
bond, found := keeper.GetDelegation(ctx, delegatorAddr, validatorAddr)
require.True(t, found)
expBond := initBond - int64(i+1)*unbondShares.RoundInt64()
expDelegatorShares := 2*initBond - int64(i+1)*unbondShares.RoundInt64()
expDelegatorAcc := sdk.NewInt(initBond - expBond)
expBond := initBond.Sub(unbondShares.MulInt64(i + 1).RoundInt())
expDelegatorShares := (initBond.MulRaw(2)).Sub(unbondShares.MulInt64(i + 1).RoundInt())
expDelegatorAcc := initBond.Sub(expBond)
gotBond := bond.Shares.RoundInt64()
gotDelegatorShares := validator.DelegatorShares.RoundInt64()
gotBond := bond.Shares.RoundInt()
gotDelegatorShares := validator.DelegatorShares.RoundInt()
gotDelegatorAcc := accMapper.GetAccount(ctx, delegatorAddr).GetCoins().AmountOf(params.BondDenom)
require.Equal(t, expBond, gotBond,
@ -450,31 +453,31 @@ func TestIncrementsMsgUnbond(t *testing.T) {
}
// these are more than we have bonded now
errorCases := []int64{
//1<<64 - 1, // more than int64
//1<<63 + 1, // more than int64
1<<63 - 1,
1 << 31,
errorCases := []sdk.Int{
//1<<64 - 1, // more than int64 power
//1<<63 + 1, // more than int64 power
types.TokensFromTendermintPower(1<<63 - 1),
types.TokensFromTendermintPower(1 << 31),
initBond,
}
for _, c := range errorCases {
unbondShares := sdk.NewDec(c)
for i, c := range errorCases {
unbondShares := sdk.NewDecFromInt(c)
msgUndelegate := NewMsgUndelegate(delegatorAddr, validatorAddr, unbondShares)
got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
require.False(t, got.IsOK(), "expected unbond msg to fail")
require.False(t, got.IsOK(), "expected unbond msg to fail, index: %v", i)
}
leftBonded := initBond - int64(numUnbonds)*unbondShares.RoundInt64()
leftBonded := initBond.Sub(unbondShares.MulInt64(numUnbonds).RoundInt())
// should be unable to unbond one more than we have
unbondShares = sdk.NewDec(leftBonded + 1)
unbondShares = sdk.NewDecFromInt(leftBonded.AddRaw(1))
msgUndelegate = NewMsgUndelegate(delegatorAddr, validatorAddr, unbondShares)
got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
require.False(t, got.IsOK(),
"got: %v\nmsgUnbond: %v\nshares: %v\nleftBonded: %v\n", got, msgUndelegate, unbondShares.String(), leftBonded)
// should be able to unbond just what we have
unbondShares = sdk.NewDec(leftBonded)
unbondShares = sdk.NewDecFromInt(leftBonded)
msgUndelegate = NewMsgUndelegate(delegatorAddr, validatorAddr, unbondShares)
got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
require.True(t, got.IsOK(),
@ -482,16 +485,27 @@ func TestIncrementsMsgUnbond(t *testing.T) {
}
func TestMultipleMsgCreateValidator(t *testing.T) {
initBond := int64(1000)
ctx, accMapper, keeper := keep.CreateTestInput(t, false, initBond)
initPower := int64(1000)
initTokens := types.TokensFromTendermintPower(initPower)
ctx, accMapper, keeper := keep.CreateTestInput(t, false, initPower)
params := setInstantUnbondPeriod(keeper, ctx)
validatorAddrs := []sdk.ValAddress{sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1]), sdk.ValAddress(keep.Addrs[2])}
delegatorAddrs := []sdk.AccAddress{keep.Addrs[3], keep.Addrs[4], keep.Addrs[5]}
validatorAddrs := []sdk.ValAddress{
sdk.ValAddress(keep.Addrs[0]),
sdk.ValAddress(keep.Addrs[1]),
sdk.ValAddress(keep.Addrs[2]),
}
delegatorAddrs := []sdk.AccAddress{
keep.Addrs[3],
keep.Addrs[4],
keep.Addrs[5],
}
// bond them all
for i, validatorAddr := range validatorAddrs {
msgCreateValidatorOnBehalfOf := NewTestMsgCreateValidatorOnBehalfOf(delegatorAddrs[i], validatorAddr, keep.PKs[i], 10)
valTokens := types.TokensFromTendermintPower(10)
msgCreateValidatorOnBehalfOf := NewTestMsgCreateValidatorOnBehalfOf(
delegatorAddrs[i], validatorAddr, keep.PKs[i], valTokens)
got := handleMsgCreateValidator(ctx, msgCreateValidatorOnBehalfOf, keeper)
require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
@ -499,10 +513,10 @@ func TestMultipleMsgCreateValidator(t *testing.T) {
validators := keeper.GetValidators(ctx, 100)
require.Equal(t, (i + 1), len(validators))
val := validators[i]
balanceExpd := sdk.NewInt(initBond - 10)
balanceExpd := initTokens.Sub(valTokens)
balanceGot := accMapper.GetAccount(ctx, delegatorAddrs[i]).GetCoins().AmountOf(params.BondDenom)
require.Equal(t, i+1, len(validators), "expected %d validators got %d, validators: %v", i+1, len(validators), validators)
require.Equal(t, 10, int(val.DelegatorShares.RoundInt64()), "expected %d shares, got %d", 10, val.DelegatorShares)
require.Equal(t, valTokens, val.DelegatorShares.RoundInt(), "expected %d shares, got %d", 10, val.DelegatorShares)
require.Equal(t, balanceExpd, balanceGot, "expected account to have %d, got %d", balanceExpd, balanceGot)
}
@ -510,7 +524,8 @@ func TestMultipleMsgCreateValidator(t *testing.T) {
for i, validatorAddr := range validatorAddrs {
_, found := keeper.GetValidator(ctx, validatorAddr)
require.True(t, found)
msgUndelegate := NewMsgUndelegate(delegatorAddrs[i], validatorAddr, sdk.NewDec(10)) // remove delegation
unbondingTokens := types.TokensFromTendermintPower(10)
msgUndelegate := NewMsgUndelegate(delegatorAddrs[i], validatorAddr, sdk.NewDecFromInt(unbondingTokens)) // remove delegation
got := handleMsgUndelegate(ctx, msgUndelegate, keeper)
require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
var finishTime time.Time
@ -527,9 +542,8 @@ func TestMultipleMsgCreateValidator(t *testing.T) {
_, found = keeper.GetValidator(ctx, validatorAddr)
require.False(t, found)
expBalance := sdk.NewInt(initBond)
gotBalance := accMapper.GetAccount(ctx, delegatorAddrs[i]).GetCoins().AmountOf(params.BondDenom)
require.Equal(t, expBalance, gotBalance, "expected account to have %d, got %d", expBalance, gotBalance)
require.Equal(t, initTokens, gotBalance, "expected account to have %d, got %d", initTokens, gotBalance)
}
}
@ -539,13 +553,13 @@ func TestMultipleMsgDelegate(t *testing.T) {
_ = setInstantUnbondPeriod(keeper, ctx)
//first make a validator
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], sdk.NewInt(10))
got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected msg to be ok, got %v", got)
// delegate multiple parties
for i, delegatorAddr := range delegatorAddrs {
msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, 10)
msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, sdk.NewInt(10))
got := handleMsgDelegate(ctx, msgDelegate, keeper)
require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
@ -577,12 +591,12 @@ func TestJailValidator(t *testing.T) {
_ = setInstantUnbondPeriod(keeper, ctx)
// create the validator
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], sdk.NewInt(10))
got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
// bond a delegator
msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, 10)
msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, sdk.NewInt(10))
got = handleMsgDelegate(ctx, msgDelegate, keeper)
require.True(t, got.IsOK(), "expected ok, got %v", got)
@ -626,19 +640,22 @@ func TestValidatorQueue(t *testing.T) {
keeper.SetParams(ctx, params)
// create the validator
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
valTokens := types.TokensFromTendermintPower(10)
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], valTokens)
got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
// bond a delegator
msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, 10)
delTokens := types.TokensFromTendermintPower(10)
msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, delTokens)
got = handleMsgDelegate(ctx, msgDelegate, keeper)
require.True(t, got.IsOK(), "expected ok, got %v", got)
EndBlocker(ctx, keeper)
// unbond the all self-delegation to put validator in unbonding state
msgUndelegateValidator := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDec(10))
msgUndelegateValidator := NewMsgUndelegate(sdk.AccAddress(validatorAddr),
validatorAddr, sdk.NewDecFromInt(delTokens))
got = handleMsgUndelegate(ctx, msgUndelegateValidator, keeper)
require.True(t, got.IsOK(), "expected no error: %v", got)
var finishTime time.Time
@ -676,14 +693,17 @@ func TestUnbondingPeriod(t *testing.T) {
keeper.SetParams(ctx, params)
// create the validator
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
valTokens := types.TokensFromTendermintPower(10)
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], valTokens)
got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
EndBlocker(ctx, keeper)
// begin unbonding
msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDec(10))
unbondingTokens := types.TokensFromTendermintPower(10)
msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr),
validatorAddr, sdk.NewDecFromInt(unbondingTokens))
got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
require.True(t, got.IsOK(), "expected no error")
origHeader := ctx.BlockHeader()
@ -714,12 +734,12 @@ func TestUnbondingFromUnbondingValidator(t *testing.T) {
validatorAddr, delegatorAddr := sdk.ValAddress(keep.Addrs[0]), keep.Addrs[1]
// create the validator
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], sdk.NewInt(10))
got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
// bond a delegator
msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, 10)
msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, sdk.NewInt(10))
got = handleMsgDelegate(ctx, msgDelegate, keeper)
require.True(t, got.IsOK(), "expected ok, got %v", got)
@ -761,7 +781,7 @@ func TestRedelegationPeriod(t *testing.T) {
keeper.SetParams(ctx, params)
// create the validators
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], sdk.NewInt(10))
// initial balance
amt1 := AccMapper.GetAccount(ctx, sdk.AccAddress(validatorAddr)).GetCoins().AmountOf(denom)
@ -773,7 +793,7 @@ func TestRedelegationPeriod(t *testing.T) {
amt2 := AccMapper.GetAccount(ctx, sdk.AccAddress(validatorAddr)).GetCoins().AmountOf(denom)
require.Equal(t, amt1.Sub(sdk.NewInt(10)).Int64(), amt2.Int64(), "expected coins to be subtracted")
msgCreateValidator = NewTestMsgCreateValidator(validatorAddr2, keep.PKs[1], 10)
msgCreateValidator = NewTestMsgCreateValidator(validatorAddr2, keep.PKs[1], sdk.NewInt(10))
got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
@ -820,15 +840,15 @@ func TestTransitiveRedelegation(t *testing.T) {
keeper.SetParams(ctx, params)
// create the validators
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], sdk.NewInt(10))
got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
msgCreateValidator = NewTestMsgCreateValidator(validatorAddr2, keep.PKs[1], 10)
msgCreateValidator = NewTestMsgCreateValidator(validatorAddr2, keep.PKs[1], sdk.NewInt(10))
got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
msgCreateValidator = NewTestMsgCreateValidator(validatorAddr3, keep.PKs[2], 10)
msgCreateValidator = NewTestMsgCreateValidator(validatorAddr3, keep.PKs[2], sdk.NewInt(10))
got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
@ -861,11 +881,12 @@ func TestMultipleRedelegationAtSameTime(t *testing.T) {
keeper.SetParams(ctx, params)
// create the validators
msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], 10)
valTokens := types.TokensFromTendermintPower(10)
msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], valTokens)
got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
msgCreateValidator = NewTestMsgCreateValidator(valAddr2, keep.PKs[1], 10)
msgCreateValidator = NewTestMsgCreateValidator(valAddr2, keep.PKs[1], valTokens)
got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
@ -875,7 +896,7 @@ func TestMultipleRedelegationAtSameTime(t *testing.T) {
// begin a redelegate
selfDelAddr := sdk.AccAddress(valAddr) // (the validator is it's own delegator)
msgBeginRedelegate := NewMsgBeginRedelegate(selfDelAddr,
valAddr, valAddr2, sdk.NewDec(5))
valAddr, valAddr2, sdk.NewDecFromInt(valTokens.DivRaw(2)))
got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
require.True(t, got.IsOK(), "expected no error, %v", got)
@ -912,11 +933,12 @@ func TestMultipleRedelegationAtUniqueTimes(t *testing.T) {
keeper.SetParams(ctx, params)
// create the validators
msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], 10)
valTokens := types.TokensFromTendermintPower(10)
msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], valTokens)
got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
msgCreateValidator = NewTestMsgCreateValidator(valAddr2, keep.PKs[1], 10)
msgCreateValidator = NewTestMsgCreateValidator(valAddr2, keep.PKs[1], valTokens)
got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
@ -926,7 +948,7 @@ func TestMultipleRedelegationAtUniqueTimes(t *testing.T) {
// begin a redelegate
selfDelAddr := sdk.AccAddress(valAddr) // (the validator is it's own delegator)
msgBeginRedelegate := NewMsgBeginRedelegate(selfDelAddr,
valAddr, valAddr2, sdk.NewDec(5))
valAddr, valAddr2, sdk.NewDecFromInt(valTokens.DivRaw(2)))
got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
require.True(t, got.IsOK(), "expected no error, %v", got)
@ -964,7 +986,8 @@ func TestMultipleUnbondingDelegationAtSameTime(t *testing.T) {
keeper.SetParams(ctx, params)
// create the validator
msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], 10)
valTokens := types.TokensFromTendermintPower(10)
msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], valTokens)
got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
@ -973,7 +996,7 @@ func TestMultipleUnbondingDelegationAtSameTime(t *testing.T) {
// begin an unbonding delegation
selfDelAddr := sdk.AccAddress(valAddr) // (the validator is it's own delegator)
msgUndelegate := NewMsgUndelegate(selfDelAddr, valAddr, sdk.NewDec(5))
msgUndelegate := NewMsgUndelegate(selfDelAddr, valAddr, sdk.NewDecFromInt(valTokens.DivRaw(2)))
got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
require.True(t, got.IsOK(), "expected no error, %v", got)
@ -1009,7 +1032,8 @@ func TestMultipleUnbondingDelegationAtUniqueTimes(t *testing.T) {
keeper.SetParams(ctx, params)
// create the validator
msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], 10)
valTokens := types.TokensFromTendermintPower(10)
msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], valTokens)
got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
@ -1018,7 +1042,7 @@ func TestMultipleUnbondingDelegationAtUniqueTimes(t *testing.T) {
// begin an unbonding delegation
selfDelAddr := sdk.AccAddress(valAddr) // (the validator is it's own delegator)
msgUndelegate := NewMsgUndelegate(selfDelAddr, valAddr, sdk.NewDec(5))
msgUndelegate := NewMsgUndelegate(selfDelAddr, valAddr, sdk.NewDecFromInt(valTokens.DivRaw(2)))
got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
require.True(t, got.IsOK(), "expected no error, %v", got)
@ -1064,21 +1088,24 @@ func TestUnbondingWhenExcessValidators(t *testing.T) {
keeper.SetParams(ctx, params)
// add three validators
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr1, keep.PKs[0], 50)
valTokens1 := types.TokensFromTendermintPower(50)
msgCreateValidator := NewTestMsgCreateValidator(validatorAddr1, keep.PKs[0], valTokens1)
got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
// apply TM updates
keeper.ApplyAndReturnValidatorSetUpdates(ctx)
require.Equal(t, 1, len(keeper.GetLastValidators(ctx)))
msgCreateValidator = NewTestMsgCreateValidator(validatorAddr2, keep.PKs[1], 30)
valTokens2 := types.TokensFromTendermintPower(30)
msgCreateValidator = NewTestMsgCreateValidator(validatorAddr2, keep.PKs[1], valTokens2)
got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
// apply TM updates
keeper.ApplyAndReturnValidatorSetUpdates(ctx)
require.Equal(t, 2, len(keeper.GetLastValidators(ctx)))
msgCreateValidator = NewTestMsgCreateValidator(validatorAddr3, keep.PKs[2], 10)
valTokens3 := types.TokensFromTendermintPower(10)
msgCreateValidator = NewTestMsgCreateValidator(validatorAddr3, keep.PKs[2], valTokens3)
got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
// apply TM updates
@ -1086,7 +1113,7 @@ func TestUnbondingWhenExcessValidators(t *testing.T) {
require.Equal(t, 2, len(keeper.GetLastValidators(ctx)))
// unbond the valdator-2
msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr2), validatorAddr2, sdk.NewDec(30))
msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr2), validatorAddr2, sdk.NewDecFromInt(valTokens2))
got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgUndelegate")
@ -1108,16 +1135,17 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
valA, valB, del := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1]), keep.Addrs[2]
consAddr0 := sdk.ConsAddress(keep.PKs[0].Address())
msgCreateValidator := NewTestMsgCreateValidator(valA, keep.PKs[0], 10)
valTokens := types.TokensFromTendermintPower(10)
msgCreateValidator := NewTestMsgCreateValidator(valA, keep.PKs[0], valTokens)
got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
msgCreateValidator = NewTestMsgCreateValidator(valB, keep.PKs[1], 10)
msgCreateValidator = NewTestMsgCreateValidator(valB, keep.PKs[1], valTokens)
got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
// delegate 10 stake
msgDelegate := NewTestMsgDelegate(del, valA, 10)
msgDelegate := NewTestMsgDelegate(del, valA, valTokens)
got = handleMsgDelegate(ctx, msgDelegate, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgDelegate")
@ -1129,19 +1157,21 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
ctx = ctx.WithBlockHeight(1)
// begin unbonding 4 stake
msgUndelegate := NewMsgUndelegate(del, valA, sdk.NewDec(4))
ubdTokens := types.TokensFromTendermintPower(4)
msgUndelegate := NewMsgUndelegate(del, valA, sdk.NewDecFromInt(ubdTokens))
got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgUndelegate")
// begin redelegate 6 stake
msgBeginRedelegate := NewMsgBeginRedelegate(del, valA, valB, sdk.NewDec(6))
rdTokens := types.TokensFromTendermintPower(6)
msgBeginRedelegate := NewMsgBeginRedelegate(del, valA, valB, sdk.NewDecFromInt(rdTokens))
got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
require.True(t, got.IsOK(), "expected no error on runMsgBeginRedelegate")
// destination delegation should have 6 shares
delegation, found := keeper.GetDelegation(ctx, del, valB)
require.True(t, found)
require.Equal(t, sdk.NewDec(6), delegation.Shares)
require.Equal(t, sdk.NewDecFromInt(rdTokens), delegation.Shares)
// must apply validator updates
updates = keeper.ApplyAndReturnValidatorSetUpdates(ctx)
@ -1154,23 +1184,23 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
ubd, found := keeper.GetUnbondingDelegation(ctx, del, valA)
require.True(t, found)
require.Len(t, ubd.Entries, 1)
require.Equal(t, int64(2), ubd.Entries[0].Balance.Amount.Int64())
require.Equal(t, ubdTokens.DivRaw(2), ubd.Entries[0].Balance.Amount)
// redelegation should have been slashed by half
redelegation, found := keeper.GetRedelegation(ctx, del, valA, valB)
require.True(t, found)
require.Len(t, redelegation.Entries, 1)
require.Equal(t, int64(3), redelegation.Entries[0].Balance.Amount.Int64())
require.Equal(t, rdTokens.DivRaw(2), redelegation.Entries[0].Balance.Amount)
// destination delegation should have been slashed by half
delegation, found = keeper.GetDelegation(ctx, del, valB)
require.True(t, found)
require.Equal(t, sdk.NewDec(3), delegation.Shares)
require.Equal(t, sdk.NewDecFromInt(rdTokens.DivRaw(2)), delegation.Shares)
// validator power should have been reduced by half
validator, found := keeper.GetValidator(ctx, valA)
require.True(t, found)
require.Equal(t, int64(5), validator.GetPower().Int64())
require.Equal(t, valTokens.DivRaw(2), validator.GetBondedTokens())
// slash the validator for an infraction committed after the unbonding and redelegation begin
ctx = ctx.WithBlockHeight(3)
@ -1180,18 +1210,18 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
ubd, found = keeper.GetUnbondingDelegation(ctx, del, valA)
require.True(t, found)
require.Len(t, ubd.Entries, 1)
require.Equal(t, int64(2), ubd.Entries[0].Balance.Amount.Int64())
require.Equal(t, ubdTokens.DivRaw(2), ubd.Entries[0].Balance.Amount)
// redelegation should be unchanged
redelegation, found = keeper.GetRedelegation(ctx, del, valA, valB)
require.True(t, found)
require.Len(t, redelegation.Entries, 1)
require.Equal(t, int64(3), redelegation.Entries[0].Balance.Amount.Int64())
require.Equal(t, rdTokens.DivRaw(2), redelegation.Entries[0].Balance.Amount)
// destination delegation should be unchanged
delegation, found = keeper.GetDelegation(ctx, del, valB)
require.True(t, found)
require.Equal(t, sdk.NewDec(3), delegation.Shares)
require.Equal(t, sdk.NewDecFromInt(rdTokens.DivRaw(2)), delegation.Shares)
// end blocker
EndBlocker(ctx, keeper)

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

@ -1,7 +1,6 @@
package keeper
import (
"fmt"
"testing"
"time"
@ -32,11 +31,7 @@ func TestDelegation(t *testing.T) {
// first add a validators[0] to delegate too
bond1to1 := types.Delegation{
DelegatorAddr: addrDels[0],
ValidatorAddr: addrVals[0],
Shares: sdk.NewDec(9),
}
bond1to1 := types.NewDelegation(addrDels[0], addrVals[0], sdk.NewDec(9))
// check the empty keeper first
_, found := keeper.GetDelegation(ctx, addrDels[0], addrVals[0])
@ -56,11 +51,11 @@ func TestDelegation(t *testing.T) {
require.True(t, bond1to1.Equal(resBond))
// add some more records
bond1to2 := types.Delegation{addrDels[0], addrVals[1], sdk.NewDec(9)}
bond1to3 := types.Delegation{addrDels[0], addrVals[2], sdk.NewDec(9)}
bond2to1 := types.Delegation{addrDels[1], addrVals[0], sdk.NewDec(9)}
bond2to2 := types.Delegation{addrDels[1], addrVals[1], sdk.NewDec(9)}
bond2to3 := types.Delegation{addrDels[1], addrVals[2], sdk.NewDec(9)}
bond1to2 := types.NewDelegation(addrDels[0], addrVals[1], sdk.NewDec(9))
bond1to3 := types.NewDelegation(addrDels[0], addrVals[2], sdk.NewDec(9))
bond2to1 := types.NewDelegation(addrDels[1], addrVals[0], sdk.NewDec(9))
bond2to2 := types.NewDelegation(addrDels[1], addrVals[1], sdk.NewDec(9))
bond2to3 := types.NewDelegation(addrDels[1], addrVals[2], sdk.NewDec(9))
keeper.SetDelegation(ctx, bond1to2)
keeper.SetDelegation(ctx, bond1to3)
keeper.SetDelegation(ctx, bond2to1)
@ -176,29 +171,27 @@ func TestUnbondingDelegation(t *testing.T) {
func TestUnbondDelegation(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.NotBondedTokens = sdk.NewInt(10)
startTokens := types.TokensFromTendermintPower(10)
pool.NotBondedTokens = startTokens
//create a validator and a delegator to that validator
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
validator, pool, issuedShares := validator.AddTokensFromDel(pool, startTokens)
require.Equal(t, startTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
require.Equal(t, int64(10), pool.BondedTokens.Int64())
require.Equal(t, int64(10), validator.BondedTokens().Int64())
require.Equal(t, startTokens, pool.BondedTokens)
require.Equal(t, startTokens, validator.BondedTokens())
delegation := types.Delegation{
DelegatorAddr: addrDels[0],
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
amount, err := keeper.unbond(ctx, addrDels[0], addrVals[0], sdk.NewDec(6))
bondTokens := types.TokensFromTendermintPower(6)
amount, err := keeper.unbond(ctx, addrDels[0], addrVals[0], sdk.NewDecFromInt(bondTokens))
require.NoError(t, err)
require.Equal(t, int64(6), amount.Int64()) // shares to be added to an unbonding delegation
require.Equal(t, bondTokens, amount) // shares to be added to an unbonding delegation
delegation, found := keeper.GetDelegation(ctx, addrDels[0], addrVals[0])
require.True(t, found)
@ -206,33 +199,31 @@ func TestUnbondDelegation(t *testing.T) {
require.True(t, found)
pool = keeper.GetPool(ctx)
require.Equal(t, int64(4), delegation.Shares.RoundInt64())
require.Equal(t, int64(4), validator.BondedTokens().Int64())
require.Equal(t, int64(6), pool.NotBondedTokens.Int64(), "%v", pool)
require.Equal(t, int64(4), pool.BondedTokens.Int64())
remainingTokens := startTokens.Sub(bondTokens)
require.Equal(t, remainingTokens, delegation.Shares.RoundInt())
require.Equal(t, remainingTokens, validator.BondedTokens())
require.Equal(t, bondTokens, pool.NotBondedTokens, "%v", pool)
require.Equal(t, remainingTokens, pool.BondedTokens)
}
func TestUnbondingDelegationsMaxEntries(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.NotBondedTokens = sdk.NewInt(10)
startTokens := types.TokensFromTendermintPower(10)
pool.NotBondedTokens = startTokens
// create a validator and a delegator to that validator
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
validator, pool, issuedShares := validator.AddTokensFromDel(pool, startTokens)
require.Equal(t, startTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
require.Equal(t, int64(10), pool.BondedTokens.Int64())
require.Equal(t, int64(10), validator.BondedTokens().Int64())
require.Equal(t, startTokens, pool.BondedTokens)
require.Equal(t, startTokens, validator.BondedTokens())
delegation := types.Delegation{
DelegatorAddr: addrDels[0],
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
maxEntries := keeper.MaxEntries(ctx)
@ -262,41 +253,35 @@ func TestUnbondingDelegationsMaxEntries(t *testing.T) {
// test removing all self delegation from a validator which should
// shift it from the bonded to unbonded state
func TestUndelegateSelfDelegation(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.NotBondedTokens = sdk.NewInt(20)
startTokens := types.TokensFromTendermintPower(20)
pool.NotBondedTokens = startTokens
//create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
valTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
selfDelegation := types.Delegation{
DelegatorAddr: sdk.AccAddress(addrVals[0].Bytes()),
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
selfDelegation := types.NewDelegation(sdk.AccAddress(addrVals[0].Bytes()), addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second delegation to this validator
keeper.DeleteValidatorByPowerIndex(ctx, validator)
validator, pool, issuedShares = validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
delTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens)
require.Equal(t, delTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
delegation := types.Delegation{
DelegatorAddr: addrDels[0],
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(valTokens))
require.NoError(t, err)
// end block
@ -305,42 +290,37 @@ func TestUndelegateSelfDelegation(t *testing.T) {
validator, found := keeper.GetValidator(ctx, addrVals[0])
require.True(t, found)
require.Equal(t, int64(10), validator.Tokens.Int64())
require.Equal(t, delTokens, validator.Tokens)
require.Equal(t, sdk.Unbonding, validator.Status)
}
func TestUndelegateFromUnbondingValidator(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.NotBondedTokens = sdk.NewInt(20)
startTokens := types.TokensFromTendermintPower(20)
pool.NotBondedTokens = startTokens
//create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
valTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
selfDelegation := types.Delegation{
DelegatorAddr: sdk.AccAddress(addrVals[0].Bytes()),
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
selfDelegation := types.NewDelegation(sdk.AccAddress(addrVals[0].Bytes()), addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second delegation to this validator
keeper.DeleteValidatorByPowerIndex(ctx, validator)
validator, pool, issuedShares = validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
delTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens)
require.Equal(t, delTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
delegation := types.Delegation{
DelegatorAddr: addrDels[0],
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
header := ctx.BlockHeader()
@ -352,7 +332,7 @@ func TestUndelegateFromUnbondingValidator(t *testing.T) {
// unbond the all self-delegation to put validator in unbonding state
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(valTokens))
require.NoError(t, err)
// end block
@ -389,43 +369,38 @@ func TestUndelegateFromUnbondingValidator(t *testing.T) {
func TestUndelegateFromUnbondedValidator(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.NotBondedTokens = sdk.NewInt(20)
startTokens := types.TokensFromTendermintPower(20)
pool.NotBondedTokens = startTokens
//create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
valTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
selfDelegation := types.Delegation{
DelegatorAddr: val0AccAddr,
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second delegation to this validator
keeper.DeleteValidatorByPowerIndex(ctx, validator)
validator, pool, issuedShares = validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
delTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens)
require.Equal(t, delTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
delegation := types.Delegation{
DelegatorAddr: addrDels[0],
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
ctx = ctx.WithBlockHeight(10)
ctx = ctx.WithBlockTime(time.Unix(333, 0))
// unbond the all self-delegation to put validator in unbonding state
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(valTokens))
require.NoError(t, err)
// end block
@ -448,7 +423,8 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
require.Equal(t, validator.Status, sdk.Unbonded)
// unbond some of the other delegation's shares
_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDec(6))
unbondTokens := types.TokensFromTendermintPower(6)
_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDecFromInt(unbondTokens))
require.NoError(t, err)
// no ubd should have been found, coins should have been returned direcly to account
@ -456,55 +432,50 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
require.False(t, found, "%v", ubd)
// unbond rest of the other delegation's shares
_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDec(4))
remainingTokens := delTokens.Sub(unbondTokens)
_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDecFromInt(remainingTokens))
require.NoError(t, err)
// now validator should now be deleted from state
validator, found = keeper.GetValidator(ctx, addrVals[0])
fmt.Println(validator)
require.False(t, found)
require.False(t, found, "%v", validator)
}
func TestUnbondingAllDelegationFromValidator(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.NotBondedTokens = sdk.NewInt(20)
startTokens := types.TokensFromTendermintPower(20)
pool.NotBondedTokens = startTokens
//create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
valTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
selfDelegation := types.Delegation{
DelegatorAddr: val0AccAddr,
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second delegation to this validator
keeper.DeleteValidatorByPowerIndex(ctx, validator)
validator, pool, issuedShares = validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
delTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens)
require.Equal(t, delTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
delegation := types.Delegation{
DelegatorAddr: addrDels[0],
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
ctx = ctx.WithBlockHeight(10)
ctx = ctx.WithBlockTime(time.Unix(333, 0))
// unbond the all self-delegation to put validator in unbonding state
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(valTokens))
require.NoError(t, err)
// end block
@ -512,7 +483,7 @@ func TestUnbondingAllDelegationFromValidator(t *testing.T) {
require.Equal(t, 1, len(updates))
// unbond all the remaining delegation
_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDec(10))
_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDecFromInt(delTokens))
require.NoError(t, err)
// validator should still be in state and still be in unbonding state
@ -618,21 +589,19 @@ func TestRedelegation(t *testing.T) {
func TestRedelegateToSameValidator(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.NotBondedTokens = sdk.NewInt(30)
startTokens := types.TokensFromTendermintPower(30)
pool.NotBondedTokens = startTokens
// create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
valTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
selfDelegation := types.Delegation{
DelegatorAddr: val0AccAddr,
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
_, err := keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[0], sdk.NewDec(5))
@ -643,28 +612,26 @@ func TestRedelegateToSameValidator(t *testing.T) {
func TestRedelegationMaxEntries(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.NotBondedTokens = sdk.NewInt(20)
startTokens := types.TokensFromTendermintPower(20)
pool.NotBondedTokens = startTokens
// create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
valTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
selfDelegation := types.Delegation{
DelegatorAddr: val0AccAddr,
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second validator
validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{})
validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
pool.BondedTokens = pool.BondedTokens.Add(sdk.NewInt(10))
validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
pool.BondedTokens = pool.BondedTokens.Add(valTokens)
keeper.SetPool(ctx, pool)
validator2 = TestingUpdateValidator(keeper, ctx, validator2, true)
require.Equal(t, sdk.Bonded, validator2.Status)
@ -696,46 +663,42 @@ func TestRedelegationMaxEntries(t *testing.T) {
func TestRedelegateSelfDelegation(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.NotBondedTokens = sdk.NewInt(30)
startTokens := types.TokensFromTendermintPower(30)
pool.NotBondedTokens = startTokens
//create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
valTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
selfDelegation := types.Delegation{
DelegatorAddr: val0AccAddr,
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second validator
validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{})
validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
pool.BondedTokens = pool.BondedTokens.Add(sdk.NewInt(10))
validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
pool.BondedTokens = pool.BondedTokens.Add(valTokens)
keeper.SetPool(ctx, pool)
validator2 = TestingUpdateValidator(keeper, ctx, validator2, true)
require.Equal(t, sdk.Bonded, validator2.Status)
// create a second delegation to this validator
validator, pool, issuedShares = validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
// create a second delegation to validator 1
delTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens)
require.Equal(t, delTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
delegation := types.Delegation{
DelegatorAddr: addrDels[0],
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
_, err := keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], sdk.NewDec(10))
_, err := keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], sdk.NewDecFromInt(delTokens))
require.NoError(t, err)
// end block
@ -744,49 +707,44 @@ func TestRedelegateSelfDelegation(t *testing.T) {
validator, found := keeper.GetValidator(ctx, addrVals[0])
require.True(t, found)
require.Equal(t, int64(10), validator.Tokens.Int64())
require.Equal(t, valTokens, validator.Tokens)
require.Equal(t, sdk.Unbonding, validator.Status)
}
func TestRedelegateFromUnbondingValidator(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.NotBondedTokens = sdk.NewInt(30)
startTokens := types.TokensFromTendermintPower(30)
pool.NotBondedTokens = startTokens
//create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
valTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
selfDelegation := types.Delegation{
DelegatorAddr: val0AccAddr,
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second delegation to this validator
keeper.DeleteValidatorByPowerIndex(ctx, validator)
validator, pool, issuedShares = validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
delTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens)
require.Equal(t, delTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
delegation := types.Delegation{
DelegatorAddr: addrDels[0],
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
// create a second validator
validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{})
validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator2 = TestingUpdateValidator(keeper, ctx, validator2, true)
@ -798,7 +756,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
ctx = ctx.WithBlockHeader(header)
// unbond the all self-delegation to put validator in unbonding state
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(delTokens))
require.NoError(t, err)
// end block
@ -820,14 +778,15 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
ctx = ctx.WithBlockHeader(header)
// unbond some of the other delegation's shares
_, err = keeper.BeginRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1], sdk.NewDec(6))
redelegateTokens := types.TokensFromTendermintPower(6)
_, err = keeper.BeginRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1], sdk.NewDecFromInt(redelegateTokens))
require.NoError(t, err)
// retrieve the unbonding delegation
ubd, found := keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1])
require.True(t, found)
require.Len(t, ubd.Entries, 1)
require.True(t, ubd.Entries[0].Balance.IsEqual(sdk.NewInt64Coin(params.BondDenom, 6)))
require.True(t, ubd.Entries[0].Balance.IsEqual(sdk.NewCoin(params.BondDenom, redelegateTokens)))
assert.Equal(t, blockHeight, ubd.Entries[0].CreationHeight)
assert.True(t, blockTime.Add(params.UnbondingTime).Equal(ubd.Entries[0].CompletionTime))
}
@ -835,42 +794,37 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
func TestRedelegateFromUnbondedValidator(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.NotBondedTokens = sdk.NewInt(30)
startTokens := types.TokensFromTendermintPower(30)
pool.NotBondedTokens = startTokens
//create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
valTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
selfDelegation := types.Delegation{
DelegatorAddr: val0AccAddr,
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
keeper.SetDelegation(ctx, selfDelegation)
// create a second delegation to this validator
keeper.DeleteValidatorByPowerIndex(ctx, validator)
validator, pool, issuedShares = validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
delTokens := types.TokensFromTendermintPower(10)
validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens)
require.Equal(t, delTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
delegation := types.Delegation{
DelegatorAddr: addrDels[0],
ValidatorAddr: addrVals[0],
Shares: issuedShares,
}
delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
keeper.SetDelegation(ctx, delegation)
// create a second validator
validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{})
validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, int64(10), issuedShares.RoundInt64())
validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, valTokens)
require.Equal(t, valTokens, issuedShares.RoundInt())
keeper.SetPool(ctx, pool)
validator2 = TestingUpdateValidator(keeper, ctx, validator2, true)
require.Equal(t, sdk.Bonded, validator2.Status)
@ -879,7 +833,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
ctx = ctx.WithBlockTime(time.Unix(333, 0))
// unbond the all self-delegation to put validator in unbonding state
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(delTokens))
require.NoError(t, err)
// end block
@ -896,7 +850,8 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
keeper.unbondingToUnbonded(ctx, validator)
// redelegate some of the delegation's shares
_, err = keeper.BeginRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1], sdk.NewDec(6))
redelegationTokens := types.TokensFromTendermintPower(6)
_, err = keeper.BeginRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1], sdk.NewDecFromInt(redelegationTokens))
require.NoError(t, err)
// no red should have been found

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

@ -114,20 +114,22 @@ func (k Keeper) GetLastValidatorPower(ctx sdk.Context, operator sdk.ValAddress)
}
// Set the last validator power.
func (k Keeper) SetLastValidatorPower(ctx sdk.Context, operator sdk.ValAddress, power sdk.Int) {
func (k Keeper) SetLastValidatorPower(ctx sdk.Context, operator sdk.ValAddress, power int64) {
store := ctx.KVStore(k.storeKey)
bz := k.cdc.MustMarshalBinaryLengthPrefixed(power)
store.Set(GetLastValidatorPowerKey(operator), bz)
}
// Iterate over last validator powers.
func (k Keeper) IterateLastValidatorPowers(ctx sdk.Context, handler func(operator sdk.ValAddress, power sdk.Int) (stop bool)) {
func (k Keeper) IterateLastValidatorPowers(ctx sdk.Context,
handler func(operator sdk.ValAddress, power int64) (stop bool)) {
store := ctx.KVStore(k.storeKey)
iter := sdk.KVStorePrefixIterator(store, LastValidatorPowerKey)
defer iter.Close()
for ; iter.Valid(); iter.Next() {
addr := sdk.ValAddress(iter.Key()[len(LastValidatorPowerKey):])
var power sdk.Int
var power int64
k.cdc.MustUnmarshalBinaryLengthPrefixed(iter.Value(), &power)
if handler(addr, power) {
break

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

@ -29,7 +29,8 @@ func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeigh
}
// Amount of slashing = slash slashFactor * power at time of infraction
slashAmountDec := sdk.NewDec(power).Mul(slashFactor)
amount := types.TokensFromTendermintPower(power)
slashAmountDec := sdk.NewDecFromInt(amount).Mul(slashFactor)
slashAmount := slashAmountDec.TruncateInt()
// ref https://github.com/cosmos/cosmos-sdk/issues/1348

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

@ -14,20 +14,21 @@ import (
// TODO integrate with test_common.go helper (CreateTestInput)
// setup helper function - creates two validators
func setupHelper(t *testing.T, amt int64) (sdk.Context, Keeper, types.Params) {
func setupHelper(t *testing.T, power int64) (sdk.Context, Keeper, types.Params) {
// setup
ctx, _, keeper := CreateTestInput(t, false, amt)
ctx, _, keeper := CreateTestInput(t, false, power)
params := keeper.GetParams(ctx)
pool := keeper.GetPool(ctx)
numVals := 3
pool.NotBondedTokens = sdk.NewInt(amt * int64(numVals))
numVals := int64(3)
amt := types.TokensFromTendermintPower(power)
pool.NotBondedTokens = amt.MulRaw(numVals)
// add numVals validators
for i := 0; i < numVals; i++ {
for i := int64(0); i < numVals; i++ {
validator := types.NewValidator(addrVals[i], PKs[i], types.Description{})
validator, pool, _ = validator.AddTokensFromDel(pool, sdk.NewInt(amt))
pool.BondedTokens = pool.BondedTokens.Add(sdk.NewInt(amt))
validator, pool, _ = validator.AddTokensFromDel(pool, amt)
pool.BondedTokens = pool.BondedTokens.Add(amt)
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
keeper.SetValidatorByConsAddr(ctx, validator)
@ -120,11 +121,7 @@ func TestSlashRedelegation(t *testing.T) {
keeper.SetRedelegation(ctx, rd)
// set the associated delegation
del := types.Delegation{
DelegatorAddr: addrDels[0],
ValidatorAddr: addrVals[1],
Shares: sdk.NewDec(10),
}
del := types.NewDelegation(addrDels[0], addrVals[1], sdk.NewDec(10))
keeper.SetDelegation(ctx, del)
// started redelegating prior to the current height, stake didn't contribute to infraction
@ -204,9 +201,9 @@ func TestSlashAtNegativeHeight(t *testing.T) {
validator = keeper.mustGetValidator(ctx, validator.OperatorAddr)
// power decreased
require.True(sdk.IntEq(t, sdk.NewInt(5), validator.GetPower()))
require.Equal(t, int64(5), validator.GetTendermintPower())
// pool bonded shares decreased
require.Equal(t, int64(5), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
require.Equal(t, types.TokensFromTendermintPower(5), oldPool.BondedTokens.Sub(newPool.BondedTokens))
}
// tests Slash at the current height
@ -231,9 +228,9 @@ func TestSlashValidatorAtCurrentHeight(t *testing.T) {
validator = keeper.mustGetValidator(ctx, validator.OperatorAddr)
// power decreased
require.True(sdk.IntEq(t, sdk.NewInt(5), validator.GetPower()))
require.Equal(t, int64(5), validator.GetTendermintPower())
// pool bonded shares decreased
require.Equal(t, int64(5), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
require.Equal(t, types.TokensFromTendermintPower(5), oldPool.BondedTokens.Sub(newPool.BondedTokens))
}
// tests Slash at a previous height with an unbonding delegation
@ -244,8 +241,9 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
// set an unbonding delegation with expiration timestamp beyond which the
// unbonding delegation shouldn't be slashed
ubdTokens := types.TokensFromTendermintPower(4)
ubd := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11,
time.Unix(0, 0), sdk.NewInt64Coin(params.BondDenom, 4))
time.Unix(0, 0), sdk.NewCoin(params.BondDenom, ubdTokens))
keeper.SetUnbondingDelegation(ctx, ubd)
// slash validator for the first time
@ -264,11 +262,11 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
require.True(t, found)
require.Len(t, ubd.Entries, 1)
// balance decreased
require.Equal(t, sdk.NewInt(2), ubd.Entries[0].Balance.Amount)
require.Equal(t, types.TokensFromTendermintPower(2), ubd.Entries[0].Balance.Amount)
// read updated pool
newPool := keeper.GetPool(ctx)
// bonded tokens burned
require.Equal(t, int64(3), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
require.Equal(t, types.TokensFromTendermintPower(3), oldPool.BondedTokens.Sub(newPool.BondedTokens))
// read updated validator
validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
require.True(t, found)
@ -276,7 +274,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.True(sdk.IntEq(t, sdk.NewInt(7), validator.GetPower()))
require.Equal(t, int64(7), validator.GetTendermintPower())
// slash validator again
ctx = ctx.WithBlockHeight(13)
@ -289,12 +287,12 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
// read updated pool
newPool = keeper.GetPool(ctx)
// bonded tokens burned again
require.Equal(t, int64(6), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
require.Equal(t, types.TokensFromTendermintPower(6), oldPool.BondedTokens.Sub(newPool.BondedTokens))
// read updated validator
validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
require.True(t, found)
// power decreased by 3 again
require.True(sdk.IntEq(t, sdk.NewInt(4), validator.GetPower()))
require.Equal(t, int64(4), validator.GetTendermintPower())
// slash validator again
// all originally bonded stake has been slashed, so this will have no effect
@ -310,12 +308,12 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
// read updated pool
newPool = keeper.GetPool(ctx)
// bonded tokens burned again
require.Equal(t, int64(9), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
require.Equal(t, types.TokensFromTendermintPower(9), oldPool.BondedTokens.Sub(newPool.BondedTokens))
// read updated validator
validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
require.True(t, found)
// power decreased by 3 again
require.True(sdk.IntEq(t, sdk.NewInt(1), validator.GetPower()))
require.Equal(t, int64(1), validator.GetTendermintPower())
// slash validator again
// all originally bonded stake has been slashed, so this will have no effect
@ -331,7 +329,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
// read updated pool
newPool = keeper.GetPool(ctx)
// just 1 bonded token burned again since that's all the validator now has
require.Equal(t, int64(10), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
require.Equal(t, types.TokensFromTendermintPower(10), oldPool.BondedTokens.Sub(newPool.BondedTokens))
// apply TM updates
keeper.ApplyAndReturnValidatorSetUpdates(ctx)
// read updated validator
@ -348,22 +346,19 @@ func TestSlashWithRedelegation(t *testing.T) {
fraction := sdk.NewDecWithPrec(5, 1)
// set a redelegation
rdTokens := types.TokensFromTendermintPower(6)
rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11,
time.Unix(0, 0), sdk.NewInt64Coin(params.BondDenom, 6), sdk.NewDec(6),
sdk.NewDec(6))
time.Unix(0, 0), sdk.NewCoin(params.BondDenom, rdTokens), sdk.NewDecFromInt(rdTokens),
sdk.NewDecFromInt(rdTokens))
keeper.SetRedelegation(ctx, rd)
// set the associated delegation
del := types.Delegation{
DelegatorAddr: addrDels[0],
ValidatorAddr: addrVals[1],
Shares: sdk.NewDec(6),
}
del := types.NewDelegation(addrDels[0], addrVals[1], sdk.NewDecFromInt(rdTokens))
keeper.SetDelegation(ctx, del)
// update bonded tokens
pool := keeper.GetPool(ctx)
pool.BondedTokens = pool.BondedTokens.Add(sdk.NewInt(6))
pool.BondedTokens = pool.BondedTokens.Add(rdTokens)
keeper.SetPool(ctx, pool)
// slash validator
@ -378,11 +373,11 @@ func TestSlashWithRedelegation(t *testing.T) {
require.True(t, found)
require.Len(t, rd.Entries, 1)
// balance decreased
require.Equal(t, sdk.NewInt(3), rd.Entries[0].Balance.Amount)
require.Equal(t, types.TokensFromTendermintPower(3), rd.Entries[0].Balance.Amount)
// read updated pool
newPool := keeper.GetPool(ctx)
// bonded tokens burned
require.Equal(t, int64(5), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
require.Equal(t, types.TokensFromTendermintPower(5), oldPool.BondedTokens.Sub(newPool.BondedTokens))
// read updated validator
validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
require.True(t, found)
@ -390,7 +385,7 @@ 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.True(sdk.IntEq(t, sdk.NewInt(8), validator.GetPower()))
require.Equal(t, int64(8), validator.GetTendermintPower())
// slash the validator again
ctx = ctx.WithBlockHeight(12)
@ -407,12 +402,12 @@ func TestSlashWithRedelegation(t *testing.T) {
// read updated pool
newPool = keeper.GetPool(ctx)
// seven bonded tokens burned
require.Equal(t, int64(12), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
require.Equal(t, types.TokensFromTendermintPower(12), oldPool.BondedTokens.Sub(newPool.BondedTokens))
// read updated validator
validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
require.True(t, found)
// power decreased by 4
require.True(sdk.IntEq(t, sdk.NewInt(4), validator.GetPower()))
require.Equal(t, int64(4), validator.GetTendermintPower())
// slash the validator again, by 100%
ctx = ctx.WithBlockHeight(12)
@ -429,7 +424,7 @@ func TestSlashWithRedelegation(t *testing.T) {
// read updated pool
newPool = keeper.GetPool(ctx)
// four more bonded tokens burned
require.Equal(t, int64(16), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
require.Equal(t, types.TokensFromTendermintPower(16), oldPool.BondedTokens.Sub(newPool.BondedTokens))
// apply TM updates
keeper.ApplyAndReturnValidatorSetUpdates(ctx)
// read updated validator
@ -454,7 +449,7 @@ func TestSlashWithRedelegation(t *testing.T) {
// read updated pool
newPool = keeper.GetPool(ctx)
// no more bonded tokens burned
require.Equal(t, int64(16), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
require.Equal(t, types.TokensFromTendermintPower(16), oldPool.BondedTokens.Sub(newPool.BondedTokens))
// read updated validator
// power still zero, still in unbonding period
validator, _ = keeper.GetValidatorByConsAddr(ctx, consAddr)
@ -468,23 +463,21 @@ func TestSlashBoth(t *testing.T) {
// set a redelegation with expiration timestamp beyond which the
// redelegation shouldn't be slashed
rdATokens := types.TokensFromTendermintPower(6)
rdA := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11,
time.Unix(0, 0), sdk.NewInt64Coin(params.BondDenom, 6), sdk.NewDec(6),
sdk.NewDec(6))
time.Unix(0, 0), sdk.NewCoin(params.BondDenom, rdATokens),
sdk.NewDecFromInt(rdATokens), sdk.NewDecFromInt(rdATokens))
keeper.SetRedelegation(ctx, rdA)
// set the associated delegation
delA := types.Delegation{
DelegatorAddr: addrDels[0],
ValidatorAddr: addrVals[1],
Shares: sdk.NewDec(6),
}
delA := types.NewDelegation(addrDels[0], addrVals[1], sdk.NewDecFromInt(rdATokens))
keeper.SetDelegation(ctx, delA)
// set an unbonding delegation with expiration timestamp (beyond which the
// unbonding delegation shouldn't be slashed)
ubdATokens := types.TokensFromTendermintPower(4)
ubdA := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11,
time.Unix(0, 0), sdk.NewInt64Coin(params.BondDenom, 4))
time.Unix(0, 0), sdk.NewCoin(params.BondDenom, ubdATokens))
keeper.SetUnbondingDelegation(ctx, ubdA)
// slash validator
@ -500,16 +493,16 @@ func TestSlashBoth(t *testing.T) {
require.True(t, found)
require.Len(t, rdA.Entries, 1)
// balance decreased
require.Equal(t, sdk.NewInt(3), rdA.Entries[0].Balance.Amount)
require.Equal(t, types.TokensFromTendermintPower(3), rdA.Entries[0].Balance.Amount)
// read updated pool
newPool := keeper.GetPool(ctx)
// not-bonded tokens burned
require.Equal(t, int64(2), oldPool.NotBondedTokens.Sub(newPool.NotBondedTokens).Int64())
require.Equal(t, types.TokensFromTendermintPower(2), oldPool.NotBondedTokens.Sub(newPool.NotBondedTokens))
// bonded tokens burned
require.Equal(t, int64(3), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
require.Equal(t, types.TokensFromTendermintPower(3), oldPool.BondedTokens.Sub(newPool.BondedTokens))
// read updated validator
validator, found = keeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(PKs[0]))
require.True(t, found)
// power not decreased, all stake was bonded since
require.True(sdk.IntEq(t, sdk.NewInt(10), validator.GetPower()))
require.Equal(t, int64(10), validator.GetTendermintPower())
}

9
x/staking/keeper/test_common.go
View File

@ -75,7 +75,10 @@ func MakeTestCodec() *codec.Codec {
}
// hogpodge of all sorts of input required for testing
func CreateTestInput(t *testing.T, isCheckTx bool, initCoins int64) (sdk.Context, auth.AccountKeeper, Keeper) {
// init power is converted to an amount of tokens
func CreateTestInput(t *testing.T, isCheckTx bool, initPower int64) (sdk.Context, auth.AccountKeeper, Keeper) {
initCoins := types.TokensFromTendermintPower(initPower)
keyStaking := sdk.NewKVStoreKey(types.StoreKey)
tkeyStaking := sdk.NewTransientStoreKey(types.TStoreKey)
@ -126,10 +129,10 @@ func CreateTestInput(t *testing.T, isCheckTx bool, initCoins int64) (sdk.Context
for _, addr := range Addrs {
pool := keeper.GetPool(ctx)
_, _, err := ck.AddCoins(ctx, addr, sdk.Coins{
{keeper.BondDenom(ctx), sdk.NewInt(initCoins)},
{keeper.BondDenom(ctx), initCoins},
})
require.Nil(t, err)
pool.NotBondedTokens = pool.NotBondedTokens.Add(sdk.NewInt(initCoins))
pool.NotBondedTokens = pool.NotBondedTokens.Add(initCoins)
keeper.SetPool(ctx, pool)
}

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

@ -50,7 +50,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.Tokens.IsZero() {
if validator.PotentialTendermintPower() == 0 {
break
}
@ -72,8 +72,8 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab
oldPowerBytes, found := last[valAddrBytes]
// calculate the new power bytes
newPower := validator.BondedTokens().Int64()
newPowerBytes := k.cdc.MustMarshalBinaryLengthPrefixed(sdk.NewInt(newPower))
newPower := validator.TendermintPower()
newPowerBytes := k.cdc.MustMarshalBinaryLengthPrefixed(newPower)
// update the validator set if power has changed
if !found || !bytes.Equal(oldPowerBytes, newPowerBytes) {
updates = append(updates, validator.ABCIValidatorUpdate())
@ -85,7 +85,7 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab
}
// set validator power on lookup index.
k.SetLastValidatorPower(ctx, valAddr, sdk.NewInt(newPower))
k.SetLastValidatorPower(ctx, valAddr, newPower)
}
// validator still in the validator set, so delete from the copy

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

@ -18,6 +18,13 @@ type cachedValidator struct {
marshalled string // marshalled amino bytes for the validator object (not operator address)
}
func newCachedValidator(val types.Validator, marshalled string) cachedValidator {
return cachedValidator{
val: val,
marshalled: marshalled,
}
}
// get a single validator
func (k Keeper) GetValidator(ctx sdk.Context, addr sdk.ValAddress) (validator types.Validator, found bool) {
store := ctx.KVStore(k.storeKey)
@ -37,8 +44,8 @@ func (k Keeper) GetValidator(ctx sdk.Context, addr sdk.ValAddress) (validator ty
// amino bytes weren't found in cache, so amino unmarshal and add it to the cache
validator = types.MustUnmarshalValidator(k.cdc, value)
cachedVal := cachedValidator{validator, strValue}
k.validatorCache[strValue] = cachedValidator{validator, strValue}
cachedVal := newCachedValidator(validator, strValue)
k.validatorCache[strValue] = newCachedValidator(validator, strValue)
k.validatorCacheList.PushBack(cachedVal)
// if the cache is too big, pop off the last element from it

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

@ -22,13 +22,14 @@ func TestSetValidator(t *testing.T) {
valPubKey := PKs[0]
valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
valTokens := types.TokensFromTendermintPower(10)
// test how the validator is set from a purely unbonbed pool
validator := types.NewValidator(valAddr, valPubKey, types.Description{})
validator, pool, _ = validator.AddTokensFromDel(pool, sdk.NewInt(10))
validator, pool, _ = validator.AddTokensFromDel(pool, valTokens)
require.Equal(t, sdk.Unbonded, validator.Status)
assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.DelegatorShares))
assert.Equal(t, valTokens, validator.Tokens)
assert.Equal(t, valTokens, validator.DelegatorShares.RoundInt())
keeper.SetPool(ctx, pool)
keeper.SetValidator(ctx, validator)
keeper.SetValidatorByPowerIndex(ctx, validator)
@ -42,8 +43,8 @@ func TestSetValidator(t *testing.T) {
// after the save the validator should be bonded
require.Equal(t, sdk.Bonded, validator.Status)
assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.DelegatorShares))
assert.Equal(t, valTokens, validator.Tokens)
assert.Equal(t, valTokens, validator.DelegatorShares.RoundInt())
// Check each store for being saved
resVal, found := keeper.GetValidator(ctx, valAddr)
@ -123,8 +124,8 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
keeper.SetParams(ctx, params)
// create a random pool
pool.NotBondedTokens = sdk.NewInt(10000)
pool.BondedTokens = sdk.NewInt(1234)
pool.NotBondedTokens = types.TokensFromTendermintPower(10000)
pool.BondedTokens = types.TokensFromTendermintPower(1234)
keeper.SetPool(ctx, pool)
validators := make([]types.Validator, numVals)
@ -132,7 +133,8 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
moniker := fmt.Sprintf("val#%d", int64(i))
val := types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{Moniker: moniker})
val.BondHeight = int64(i)
val, pool, _ = val.AddTokensFromDel(pool, sdk.NewInt(int64((i+1)*10)))
delTokens := types.TokensFromTendermintPower(int64((i + 1) * 10))
val, pool, _ = val.AddTokensFromDel(pool, delTokens)
keeper.SetPool(ctx, pool)
val = TestingUpdateValidator(keeper, ctx, val, true)
@ -144,7 +146,8 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
// remove enough tokens to kick out the validator below the current cliff
// validator and next in line cliff validator
keeper.DeleteValidatorByPowerIndex(ctx, nextCliffVal)
nextCliffVal, pool, _ = nextCliffVal.RemoveDelShares(pool, sdk.NewDec(21))
shares := types.TokensFromTendermintPower(21)
nextCliffVal, pool, _ = nextCliffVal.RemoveDelShares(pool, sdk.NewDecFromInt(shares))
keeper.SetPool(ctx, pool)
nextCliffVal = TestingUpdateValidator(keeper, ctx, nextCliffVal, true)
@ -173,13 +176,14 @@ func TestSlashToZeroPowerRemoved(t *testing.T) {
// add a validator
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
validator, pool, _ = validator.AddTokensFromDel(pool, sdk.NewInt(100))
valTokens := types.TokensFromTendermintPower(100)
validator, pool, _ = validator.AddTokensFromDel(pool, valTokens)
require.Equal(t, sdk.Unbonded, validator.Status)
require.Equal(t, int64(100), validator.Tokens.Int64())
require.Equal(t, valTokens, validator.Tokens)
keeper.SetPool(ctx, pool)
keeper.SetValidatorByConsAddr(ctx, validator)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
require.Equal(t, int64(100), validator.Tokens.Int64(), "\nvalidator %v\npool %v", validator, pool)
require.Equal(t, valTokens, validator.Tokens, "\nvalidator %v\npool %v", validator, pool)
// slash the validator by 100%
consAddr0 := sdk.ConsAddress(PKs[0].Address())
@ -198,17 +202,18 @@ func TestValidatorBasics(t *testing.T) {
//construct the validators
var validators [3]types.Validator
amts := []int64{9, 8, 7}
for i, amt := range amts {
powers := []int64{9, 8, 7}
for i, power := range powers {
validators[i] = types.NewValidator(addrVals[i], PKs[i], types.Description{})
validators[i].Status = sdk.Unbonded
validators[i].Tokens = sdk.ZeroInt()
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
tokens := types.TokensFromTendermintPower(power)
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
}
assert.True(sdk.IntEq(t, sdk.NewInt(9), validators[0].Tokens))
assert.True(sdk.IntEq(t, sdk.NewInt(8), validators[1].Tokens))
assert.True(sdk.IntEq(t, sdk.NewInt(7), validators[2].Tokens))
assert.Equal(t, types.TokensFromTendermintPower(9), validators[0].Tokens)
assert.Equal(t, types.TokensFromTendermintPower(8), validators[1].Tokens)
assert.Equal(t, types.TokensFromTendermintPower(7), validators[2].Tokens)
// check the empty keeper first
_, found := keeper.GetValidator(ctx, addrVals[0])
@ -241,15 +246,15 @@ func TestValidatorBasics(t *testing.T) {
require.Equal(t, 1, len(resVals))
assert.True(ValEq(t, validators[0], resVals[0]))
assert.Equal(t, sdk.Bonded, validators[0].Status)
assert.True(sdk.IntEq(t, sdk.NewInt(9), validators[0].BondedTokens()))
assert.True(sdk.IntEq(t, types.TokensFromTendermintPower(9), validators[0].BondedTokens()))
pool = keeper.GetPool(ctx)
assert.True(sdk.IntEq(t, pool.BondedTokens, validators[0].BondedTokens()))
// modify a records, save, and retrieve
validators[0].Status = sdk.Bonded
validators[0].Tokens = sdk.NewInt(10)
validators[0].DelegatorShares = sdk.NewDec(10)
validators[0].Tokens = types.TokensFromTendermintPower(10)
validators[0].DelegatorShares = sdk.NewDecFromInt(validators[0].Tokens)
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true)
resVal, found = keeper.GetValidator(ctx, addrVals[0])
require.True(t, found)
@ -437,18 +442,19 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
keeper.SetParams(ctx, params)
// initialize some validators into the state
amts := []int64{0, 100, 400, 400}
powers := []int64{0, 100, 400, 400}
var validators [4]types.Validator
for i, amt := range amts {
for i, power := range powers {
pool := keeper.GetPool(ctx)
moniker := fmt.Sprintf("val#%d", int64(i))
validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{Moniker: moniker})
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
tokens := types.TokensFromTendermintPower(power)
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
validators[i] = TestingUpdateValidator(keeper, ctx, validators[i], true)
}
for i := range amts {
for i := range powers {
validators[i], found = keeper.GetValidator(ctx, validators[i].OperatorAddr)
require.True(t, found)
}
@ -459,7 +465,8 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
pool := keeper.GetPool(ctx)
keeper.DeleteValidatorByPowerIndex(ctx, validators[0])
validators[0], pool, _ = validators[0].AddTokensFromDel(pool, sdk.NewInt(500))
delTokens := types.TokensFromTendermintPower(500)
validators[0], pool, _ = validators[0].AddTokensFromDel(pool, delTokens)
keeper.SetPool(ctx, pool)
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true)
resValidators = keeper.GetBondedValidatorsByPower(ctx)
@ -524,9 +531,12 @@ func TestValidatorBondHeight(t *testing.T) {
validators[1] = types.NewValidator(sdk.ValAddress(Addrs[1]), PKs[1], types.Description{})
validators[2] = types.NewValidator(sdk.ValAddress(Addrs[2]), PKs[2], types.Description{})
validators[0], pool, _ = validators[0].AddTokensFromDel(pool, sdk.NewInt(200))
validators[1], pool, _ = validators[1].AddTokensFromDel(pool, sdk.NewInt(100))
validators[2], pool, _ = validators[2].AddTokensFromDel(pool, sdk.NewInt(100))
tokens0 := types.TokensFromTendermintPower(200)
tokens1 := types.TokensFromTendermintPower(100)
tokens2 := types.TokensFromTendermintPower(100)
validators[0], pool, _ = validators[0].AddTokensFromDel(pool, tokens0)
validators[1], pool, _ = validators[1].AddTokensFromDel(pool, tokens1)
validators[2], pool, _ = validators[2].AddTokensFromDel(pool, tokens2)
keeper.SetPool(ctx, pool)
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true)
@ -546,8 +556,9 @@ func TestValidatorBondHeight(t *testing.T) {
assert.True(ValEq(t, validators[1], resValidators[1]))
keeper.DeleteValidatorByPowerIndex(ctx, validators[1])
keeper.DeleteValidatorByPowerIndex(ctx, validators[2])
validators[1], pool, _ = validators[1].AddTokensFromDel(pool, sdk.NewInt(50))
validators[2], pool, _ = validators[2].AddTokensFromDel(pool, sdk.NewInt(50))
delTokens := types.TokensFromTendermintPower(50)
validators[1], pool, _ = validators[1].AddTokensFromDel(pool, delTokens)
validators[2], pool, _ = validators[2].AddTokensFromDel(pool, delTokens)
keeper.SetPool(ctx, pool)
validators[2] = TestingUpdateValidator(keeper, ctx, validators[2], true)
resValidators = keeper.GetBondedValidatorsByPower(ctx)
@ -565,16 +576,17 @@ func TestFullValidatorSetPowerChange(t *testing.T) {
keeper.SetParams(ctx, params)
// initialize some validators into the state
amts := []int64{0, 100, 400, 400, 200}
powers := []int64{0, 100, 400, 400, 200}
var validators [5]types.Validator
for i, amt := range amts {
for i, power := range powers {
pool := keeper.GetPool(ctx)
validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
tokens := types.TokensFromTendermintPower(power)
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
TestingUpdateValidator(keeper, ctx, validators[i], true)
}
for i := range amts {
for i := range powers {
var found bool
validators[i], found = keeper.GetValidator(ctx, validators[i].OperatorAddr)
require.True(t, found)
@ -591,7 +603,8 @@ func TestFullValidatorSetPowerChange(t *testing.T) {
// test a swap in voting power
pool := keeper.GetPool(ctx)
validators[0], pool, _ = validators[0].AddTokensFromDel(pool, sdk.NewInt(600))
tokens := types.TokensFromTendermintPower(600)
validators[0], pool, _ = validators[0].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true)
resValidators = keeper.GetBondedValidatorsByPower(ctx)
@ -603,16 +616,17 @@ func TestFullValidatorSetPowerChange(t *testing.T) {
func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 1000)
amts := []int64{10, 20}
powers := []int64{10, 20}
var validators [2]types.Validator
for i, amt := range amts {
for i, power := range powers {
pool := keeper.GetPool(ctx)
valPubKey := PKs[i+1]
valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
validators[i] = types.NewValidator(valAddr, valPubKey, types.Description{})
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
tokens := types.TokensFromTendermintPower(power)
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
}
@ -635,12 +649,14 @@ func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) {
func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 1000)
amts := []int64{10, 20}
powers := []int64{10, 20}
var validators [2]types.Validator
for i, amt := range amts {
for i, power := range powers {
pool := keeper.GetPool(ctx)
validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
tokens := types.TokensFromTendermintPower(power)
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
}
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
@ -657,12 +673,14 @@ func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) {
func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 1000)
amts := []int64{10, 20}
powers := []int64{10, 20}
var validators [2]types.Validator
for i, amt := range amts {
for i, power := range powers {
pool := keeper.GetPool(ctx)
validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
tokens := types.TokensFromTendermintPower(power)
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
}
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
@ -672,7 +690,7 @@ func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) {
// test single value change
// tendermintUpdate set: {} -> {c1'}
validators[0].Status = sdk.Bonded
validators[0].Tokens = sdk.NewInt(600)
validators[0].Tokens = types.TokensFromTendermintPower(600)
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx)
@ -684,12 +702,14 @@ func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) {
func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 1000)
amts := []int64{10, 20}
powers := []int64{10, 20}
var validators [2]types.Validator
for i, amt := range amts {
for i, power := range powers {
pool := keeper.GetPool(ctx)
validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
tokens := types.TokensFromTendermintPower(power)
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
}
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
@ -699,8 +719,10 @@ func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) {
// test multiple value change
// tendermintUpdate set: {c1, c3} -> {c1', c3'}
pool := keeper.GetPool(ctx)
validators[0], pool, _ = validators[0].AddTokensFromDel(pool, sdk.NewInt(190))
validators[1], pool, _ = validators[1].AddTokensFromDel(pool, sdk.NewInt(80))
delTokens1 := types.TokensFromTendermintPower(190)
delTokens2 := types.TokensFromTendermintPower(80)
validators[0], pool, _ = validators[0].AddTokensFromDel(pool, delTokens1)
validators[1], pool, _ = validators[1].AddTokensFromDel(pool, delTokens2)
keeper.SetPool(ctx, pool)
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], false)
@ -714,14 +736,17 @@ func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) {
func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 1000)
amts := []int64{10, 20, 5, 15, 25}
powers := []int64{10, 20, 5, 15, 25}
var validators [5]types.Validator
for i, amt := range amts {
for i, power := range powers {
pool := keeper.GetPool(ctx)
validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
tokens := types.TokensFromTendermintPower(power)
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
}
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], false)
require.Equal(t, 2, len(keeper.ApplyAndReturnValidatorSetUpdates(ctx)))
@ -760,12 +785,14 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
params.MaxValidators = 2
keeper.SetParams(ctx, params)
amts := []int64{10, 20, 5}
powers := []int64{10, 20, 5}
var validators [5]types.Validator
for i, amt := range amts {
for i, power := range powers {
pool := keeper.GetPool(ctx)
validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
tokens := types.TokensFromTendermintPower(power)
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
}
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
@ -783,7 +810,8 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
require.Equal(t, 0, len(keeper.ApplyAndReturnValidatorSetUpdates(ctx)))
pool := keeper.GetPool(ctx)
validators[2], pool, _ = validators[2].AddTokensFromDel(pool, sdk.NewInt(10))
tokens := types.TokensFromTendermintPower(10)
validators[2], pool, _ = validators[2].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
keeper.SetValidator(ctx, validators[2])
keeper.SetValidatorByPowerIndex(ctx, validators[2])
@ -797,12 +825,14 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 1000)
amts := []int64{100, 100}
powers := []int64{100, 100}
var validators [2]types.Validator
for i, amt := range amts {
for i, power := range powers {
pool := keeper.GetPool(ctx)
validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
tokens := types.TokensFromTendermintPower(power)
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
}
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
@ -810,21 +840,23 @@ func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
require.Equal(t, 2, len(keeper.ApplyAndReturnValidatorSetUpdates(ctx)))
// check initial power
require.Equal(t, int64(100), validators[0].GetPower().Int64())
require.Equal(t, int64(100), validators[1].GetPower().Int64())
require.Equal(t, int64(100), validators[0].GetTendermintPower())
require.Equal(t, int64(100), validators[1].GetTendermintPower())
// test multiple value change
// tendermintUpdate set: {c1, c3} -> {c1', c3'}
pool := keeper.GetPool(ctx)
validators[0], pool, _ = validators[0].RemoveDelShares(pool, sdk.NewDec(20))
validators[1], pool, _ = validators[1].RemoveDelShares(pool, sdk.NewDec(30))
delTokens1 := types.TokensFromTendermintPower(20)
delTokens2 := types.TokensFromTendermintPower(30)
validators[0], pool, _ = validators[0].RemoveDelShares(pool, sdk.NewDecFromInt(delTokens1))
validators[1], pool, _ = validators[1].RemoveDelShares(pool, sdk.NewDecFromInt(delTokens2))
keeper.SetPool(ctx, pool)
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], false)
// power has changed
require.Equal(t, int64(80), validators[0].GetPower().Int64())
require.Equal(t, int64(70), validators[1].GetPower().Int64())
require.Equal(t, int64(80), validators[0].GetTendermintPower())
require.Equal(t, int64(70), validators[1].GetTendermintPower())
// Tendermint updates should reflect power change
updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx)
@ -840,17 +872,18 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
keeper.SetParams(ctx, params)
amts := []int64{100, 100}
powers := []int64{100, 100}
var validators [2]types.Validator
// initialize some validators into the state
for i, amt := range amts {
for i, power := range powers {
pool := keeper.GetPool(ctx)
valPubKey := PKs[i+1]
valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
validators[i] = types.NewValidator(valAddr, valPubKey, types.Description{})
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
tokens := types.TokensFromTendermintPower(power)
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
keeper.SetValidator(ctx, validators[i])
@ -868,10 +901,11 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
require.Equal(t, 0, len(keeper.ApplyAndReturnValidatorSetUpdates(ctx)))
// update initial validator set
for i, amt := range amts {
for i, power := range powers {
pool := keeper.GetPool(ctx)
keeper.DeleteValidatorByPowerIndex(ctx, validators[i])
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
tokens := types.TokensFromTendermintPower(power)
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
keeper.SetValidator(ctx, validators[i])
@ -900,7 +934,8 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
valAddr = sdk.ValAddress(valPubKey.Address().Bytes())
validator = types.NewValidator(valAddr, valPubKey, types.Description{})
validator, pool, _ = validator.AddTokensFromDel(pool, sdk.NewInt(500))
tokens := types.TokensFromTendermintPower(500)
validator, pool, _ = validator.AddTokensFromDel(pool, tokens)
keeper.SetValidator(ctx, validator)
keeper.SetValidatorByPowerIndex(ctx, validator)
keeper.SetPool(ctx, pool)
@ -923,18 +958,19 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
keeper.SetParams(ctx, params)
amts := []int64{100, 200, 300}
powers := []int64{100, 200, 300}
var validators [3]types.Validator
// initialize some validators into the state
for i, amt := range amts {
for i, power := range powers {
pool := keeper.GetPool(ctx)
moniker := fmt.Sprintf("%d", i)
valPubKey := PKs[i+1]
valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
validators[i] = types.NewValidator(valAddr, valPubKey, types.Description{Moniker: moniker})
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
tokens := types.TokensFromTendermintPower(power)
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
keeper.SetValidator(ctx, validators[i])
keeper.SetValidatorByPowerIndex(ctx, validators[i])
@ -959,7 +995,8 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
require.True(t, found)
keeper.DeleteValidatorByPowerIndex(ctx, validators[0])
validators[0], pool, _ = validators[0].AddTokensFromDel(pool, sdk.NewInt(1))
tokens := types.TokensFromTendermintPower(1)
validators[0], pool, _ = validators[0].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
keeper.SetValidator(ctx, validators[0])
keeper.SetValidatorByPowerIndex(ctx, validators[0])
@ -984,7 +1021,8 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
require.Equal(t, 0, len(updates))
keeper.DeleteValidatorByPowerIndex(ctx, validators[1])
validators[1], pool, _ = validators[1].AddTokensFromDel(pool, sdk.NewInt(250))
tokens = types.TokensFromTendermintPower(250)
validators[1], pool, _ = validators[1].AddTokensFromDel(pool, tokens)
keeper.SetPool(ctx, pool)
keeper.SetValidator(ctx, validators[1])
keeper.SetValidatorByPowerIndex(ctx, validators[1])

16
x/staking/querier/querier_test.go
View File

@ -177,7 +177,8 @@ func TestQueryDelegation(t *testing.T) {
keeper.SetValidator(ctx, val2)
keeper.SetValidatorByPowerIndex(ctx, val2)
keeper.Delegate(ctx, addrAcc2, sdk.NewCoin(types.DefaultBondDenom, sdk.NewInt(20)), val1, true)
delTokens := types.TokensFromTendermintPower(20)
keeper.Delegate(ctx, addrAcc2, sdk.NewCoin(types.DefaultBondDenom, delTokens), val1, true)
// apply TM updates
keeper.ApplyAndReturnValidatorSetUpdates(ctx)
@ -296,7 +297,8 @@ func TestQueryDelegation(t *testing.T) {
require.Equal(t, delegationsRes[0], delegation)
// Query unbonging delegation
_, err = keeper.Undelegate(ctx, addrAcc2, val1.OperatorAddr, sdk.NewDec(10))
unbondingTokens := types.TokensFromTendermintPower(10)
_, err = keeper.Undelegate(ctx, addrAcc2, val1.OperatorAddr, sdk.NewDecFromInt(unbondingTokens))
require.Nil(t, err)
queryBondParams = NewQueryBondsParams(addrAcc2, addrVal1)
@ -348,7 +350,9 @@ func TestQueryDelegation(t *testing.T) {
require.NotNil(t, err)
// Query redelegation
_, err = keeper.BeginRedelegation(ctx, addrAcc2, val1.OperatorAddr, val2.OperatorAddr, sdk.NewDec(10))
redelegationTokens := types.TokensFromTendermintPower(10)
_, err = keeper.BeginRedelegation(ctx, addrAcc2, val1.OperatorAddr,
val2.OperatorAddr, sdk.NewDecFromInt(redelegationTokens))
require.Nil(t, err)
redel, found := keeper.GetRedelegation(ctx, addrAcc2, val1.OperatorAddr, val2.OperatorAddr)
require.True(t, found)
@ -381,10 +385,12 @@ func TestQueryRedelegations(t *testing.T) {
keeper.SetValidator(ctx, val1)
keeper.SetValidator(ctx, val2)
keeper.Delegate(ctx, addrAcc2, sdk.NewCoin(types.DefaultBondDenom, sdk.NewInt(100)), val1, true)
delAmount := types.TokensFromTendermintPower(100)
keeper.Delegate(ctx, addrAcc2, sdk.NewCoin(types.DefaultBondDenom, delAmount), val1, true)
_ = keeper.ApplyAndReturnValidatorSetUpdates(ctx)
keeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(), val2.GetOperator(), sdk.NewDec(20))
rdAmount := types.TokensFromTendermintPower(20)
keeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(), val2.GetOperator(), sdk.NewDecFromInt(rdAmount))
keeper.ApplyAndReturnValidatorSetUpdates(ctx)
redelegation, found := keeper.GetRedelegation(ctx, addrAcc2, val1.OperatorAddr, val2.OperatorAddr)

14
x/staking/simulation/invariants.go
View File

@ -11,7 +11,6 @@ import (
"github.com/cosmos/cosmos-sdk/x/mock/simulation"
"github.com/cosmos/cosmos-sdk/x/staking"
"github.com/cosmos/cosmos-sdk/x/staking/keeper"
stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
)
// AllInvariants runs all invariants of the staking module.
@ -55,7 +54,7 @@ func SupplyInvariants(ck bank.Keeper, k staking.Keeper,
loose := sdk.ZeroDec()
bonded := sdk.ZeroDec()
am.IterateAccounts(ctx, func(acc auth.Account) bool {
loose = loose.Add(sdk.NewDecFromInt(acc.GetCoins().AmountOf(stakingTypes.DefaultBondDenom)))
loose = loose.Add(sdk.NewDecFromInt(acc.GetCoins().AmountOf(staking.DefaultBondDenom)))
return false
})
k.IterateUnbondingDelegations(ctx, func(_ int64, ubd staking.UnbondingDelegation) bool {
@ -67,7 +66,7 @@ func SupplyInvariants(ck bank.Keeper, k staking.Keeper,
k.IterateValidators(ctx, func(_ int64, validator sdk.Validator) bool {
switch validator.GetStatus() {
case sdk.Bonded:
bonded = bonded.Add(sdk.NewDecFromInt(validator.GetPower()))
bonded = bonded.Add(sdk.NewDecFromInt(validator.GetBondedTokens()))
case sdk.Unbonding, sdk.Unbonded:
loose = loose.Add(sdk.NewDecFromInt(validator.GetTokens()))
}
@ -77,13 +76,13 @@ func SupplyInvariants(ck bank.Keeper, k staking.Keeper,
feePool := d.GetFeePool(ctx)
// add outstanding fees
loose = loose.Add(sdk.NewDecFromInt(f.GetCollectedFees(ctx).AmountOf(stakingTypes.DefaultBondDenom)))
loose = loose.Add(sdk.NewDecFromInt(f.GetCollectedFees(ctx).AmountOf(staking.DefaultBondDenom)))
// add community pool
loose = loose.Add(feePool.CommunityPool.AmountOf(stakingTypes.DefaultBondDenom))
loose = loose.Add(feePool.CommunityPool.AmountOf(staking.DefaultBondDenom))
// add yet-to-be-withdrawn
loose = loose.Add(d.GetOutstandingRewards(ctx).AmountOf(stakingTypes.DefaultBondDenom))
loose = loose.Add(d.GetOutstandingRewards(ctx).AmountOf(staking.DefaultBondDenom))
// Not-bonded tokens should equal coin supply plus unbonding delegations
// plus tokens on unbonded validators
@ -119,7 +118,8 @@ func NonNegativePowerInvariant(k staking.Keeper) simulation.Invariant {
if !bytes.Equal(iterator.Key(), powerKey) {
return fmt.Errorf("power store invariance:\n\tvalidator.Power: %v"+
"\n\tkey should be: %v\n\tkey in store: %v", validator.GetPower(), powerKey, iterator.Key())
"\n\tkey should be: %v\n\tkey in store: %v",
validator.GetTendermintPower(), powerKey, iterator.Key())
}
if validator.Tokens.IsNegative() {

5
x/staking/staking.go
View File

@ -14,6 +14,7 @@ type (
Validators = types.Validators
Description = types.Description
Commission = types.Commission
CommissionMsg = types.CommissionMsg
Delegation = types.Delegation
Delegations = types.Delegations
UnbondingDelegation = types.UnbondingDelegation
@ -82,6 +83,10 @@ var (
DefaultGenesisState = types.DefaultGenesisState
RegisterCodec = types.RegisterCodec
ValidatorUpdateDelay = types.ValidatorUpdateDelay
TokensToTendermintPower = types.TokensToTendermintPower
TokensFromTendermintPower = types.TokensFromTendermintPower
NewMsgCreateValidator = types.NewMsgCreateValidator
NewMsgCreateValidatorOnBehalfOf = types.NewMsgCreateValidatorOnBehalfOf
NewMsgEditValidator = types.NewMsgEditValidator

18
x/staking/test_common.go
View File

@ -26,28 +26,30 @@ var (
commissionMsg = NewCommissionMsg(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec())
)
func NewTestMsgCreateValidator(address sdk.ValAddress, pubKey crypto.PubKey, amt int64) MsgCreateValidator {
func NewTestMsgCreateValidator(address sdk.ValAddress, pubKey crypto.PubKey, amt sdk.Int) MsgCreateValidator {
return types.NewMsgCreateValidator(
address, pubKey, sdk.NewCoin(types.DefaultBondDenom, sdk.NewInt(amt)), Description{}, commissionMsg,
address, pubKey, sdk.NewCoin(types.DefaultBondDenom, amt), Description{}, commissionMsg,
)
}
func NewTestMsgCreateValidatorWithCommission(address sdk.ValAddress, pubKey crypto.PubKey,
amt int64, commissionRate sdk.Dec) MsgCreateValidator {
amt sdk.Int, commissionRate sdk.Dec) MsgCreateValidator {
commission := NewCommissionMsg(commissionRate, sdk.OneDec(), sdk.ZeroDec())
return types.NewMsgCreateValidator(
address, pubKey, sdk.NewCoin(types.DefaultBondDenom, sdk.NewInt(amt)), Description{}, commission,
address, pubKey, sdk.NewCoin(types.DefaultBondDenom, amt), Description{}, commission,
)
}
func NewTestMsgDelegate(delAddr sdk.AccAddress, valAddr sdk.ValAddress, amt int64) MsgDelegate {
amount := sdk.NewCoin(types.DefaultBondDenom, sdk.NewInt(amt))
func NewTestMsgDelegate(delAddr sdk.AccAddress, valAddr sdk.ValAddress, amt sdk.Int) MsgDelegate {
amount := sdk.NewCoin(types.DefaultBondDenom, amt)
return NewMsgDelegate(delAddr, valAddr, amount)
}
func NewTestMsgCreateValidatorOnBehalfOf(delAddr sdk.AccAddress, valAddr sdk.ValAddress, valPubKey crypto.PubKey, amt int64) MsgCreateValidator {
amount := sdk.NewCoin(types.DefaultBondDenom, sdk.NewInt(amt))
func NewTestMsgCreateValidatorOnBehalfOf(delAddr sdk.AccAddress, valAddr sdk.ValAddress,
valPubKey crypto.PubKey, amt sdk.Int) MsgCreateValidator {
amount := sdk.NewCoin(types.DefaultBondDenom, amt)
return NewMsgCreateValidatorOnBehalfOf(delAddr, valAddr, valPubKey, amount, Description{}, commissionMsg)
}

30
x/staking/types/commission.go
View File

@ -7,23 +7,21 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
)
type (
// Commission defines a commission parameters for a given validator.
Commission struct {
Rate sdk.Dec `json:"rate"` // the commission rate charged to delegators
MaxRate sdk.Dec `json:"max_rate"` // maximum commission rate which this validator can ever charge
MaxChangeRate sdk.Dec `json:"max_change_rate"` // maximum daily increase of the validator commission
UpdateTime time.Time `json:"update_time"` // the last time the commission rate was changed
}
// Commission defines a commission parameters for a given validator.
type Commission struct {
Rate sdk.Dec `json:"rate"` // the commission rate charged to delegators
MaxRate sdk.Dec `json:"max_rate"` // maximum commission rate which this validator can ever charge
MaxChangeRate sdk.Dec `json:"max_change_rate"` // maximum daily increase of the validator commission
UpdateTime time.Time `json:"update_time"` // the last time the commission rate was changed
}
// CommissionMsg defines a commission message to be used for creating a
// validator.
CommissionMsg struct {
Rate sdk.Dec `json:"rate"` // the commission rate charged to delegators
MaxRate sdk.Dec `json:"max_rate"` // maximum commission rate which validator can ever charge
MaxChangeRate sdk.Dec `json:"max_change_rate"` // maximum daily increase of the validator commission
}
)
// CommissionMsg defines a commission message to be used for creating a
// validator.
type CommissionMsg struct {
Rate sdk.Dec `json:"rate"` // the commission rate charged to delegators
MaxRate sdk.Dec `json:"max_rate"` // maximum commission rate which validator can ever charge
MaxChangeRate sdk.Dec `json:"max_change_rate"` // maximum daily increase of the validator commission
}
// NewCommissionMsg returns an initialized validator commission message.
func NewCommissionMsg(rate, maxRate, maxChangeRate sdk.Dec) CommissionMsg {

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

@ -20,7 +20,7 @@ type GenesisState struct {
// Last validator power, needed for validator set update logic
type LastValidatorPower struct {
Address sdk.ValAddress
Power sdk.Int
Power int64
}
func NewGenesisState(pool Pool, params Params, validators []Validator, bonds []Delegation) GenesisState {

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

@ -3,6 +3,7 @@ package types
import (
"bytes"
"fmt"
"math/big"
"strings"
"time"
@ -264,7 +265,7 @@ func (d Description) EnsureLength() (Description, sdk.Error) {
func (v Validator) ABCIValidatorUpdate() abci.ValidatorUpdate {
return abci.ValidatorUpdate{
PubKey: tmtypes.TM2PB.PubKey(v.ConsPubKey),
Power: v.BondedTokens().Int64(),
Power: v.TendermintPower(),
}
}
@ -400,7 +401,7 @@ func (v Validator) DelegatorShareExRate() sdk.Dec {
return sdk.NewDecFromInt(v.Tokens).Quo(v.DelegatorShares)
}
// Get the bonded tokens which the validator holds
// get the bonded tokens which the validator holds
func (v Validator) BondedTokens() sdk.Int {
if v.Status == sdk.Bonded {
return v.Tokens
@ -408,6 +409,34 @@ func (v Validator) BondedTokens() sdk.Int {
return sdk.ZeroInt()
}
// get the Tendermint Power
// a reduction of 10^9 from validator tokens is applied
func (v Validator) TendermintPower() int64 {
if v.Status == sdk.Bonded {
return v.PotentialTendermintPower()
}
return 0
}
var powerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(6), nil))
// potential Tendermint power
func (v Validator) PotentialTendermintPower() int64 {
return (v.Tokens.Div(powerReduction)).Int64()
}
// utility functions
// TokensToTendermintPower - convert input tokens to potential tendermint power
func TokensToTendermintPower(tokens sdk.Int) int64 {
return (tokens.Div(powerReduction)).Int64()
}
// TokensFromTendermintPower - convert input power to tokens
func TokensFromTendermintPower(power int64) sdk.Int {
return sdk.NewInt(power).Mul(powerReduction)
}
//______________________________________________________________________
// ensure fulfills the sdk validator types
@ -420,8 +449,9 @@ func (v Validator) GetStatus() sdk.BondStatus { return v.Status }
func (v Validator) GetOperator() sdk.ValAddress { return v.OperatorAddr }
func (v Validator) GetConsPubKey() crypto.PubKey { return v.ConsPubKey }
func (v Validator) GetConsAddr() sdk.ConsAddress { return sdk.ConsAddress(v.ConsPubKey.Address()) }
func (v Validator) GetPower() sdk.Int { return v.BondedTokens() }
func (v Validator) GetTokens() sdk.Int { return v.Tokens }
func (v Validator) GetBondedTokens() sdk.Int { return v.BondedTokens() }
func (v Validator) GetTendermintPower() int64 { return v.TendermintPower() }
func (v Validator) GetCommission() sdk.Dec { return v.Commission.Rate }
func (v Validator) GetDelegatorShares() sdk.Dec { return v.DelegatorShares }
func (v Validator) GetBondHeight() int64 { return v.BondHeight }