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

Merge PR #2958: Validator Power Dec-> Int 

* Validator Power Dec-> Int, working

* non-test code compiles

* working, many test compile fixes

* all test compile errors resolved

* ...

* slashing test fixes minor

* test cover passes

* invariant rounding issue

* comment update

* PENDING and doc updates

* @cwgoes comments

* RemoveDelShares trimmings to the final delegation share

* fixes

* ...

* fix the oopsie

* @alexanderbez comments

* merge fixes

* address @cwgoes comments
This commit is contained in:
frog power 4000 2019-01-02 15:29:47 -05:00 committed by GitHub
parent 67a1e47c6e
commit a98a5a056a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
51 changed files with 413 additions and 382 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
PENDING.md
View File

@ -18,6 +18,7 @@ BREAKING CHANGES
in order to trigger a simulation of the tx before the actual execution.
* SDK
* [stake] \#2513 Validator power type from Dec -> Int
* [\#3064](https://github.com/cosmos/cosmos-sdk/issues/3064) Sanitize `sdk.Coin` denom. Coins denoms are now case insensitive, i.e. 100fooToken equals to 100FOOTOKEN.
* \#3207 - Fix token printing bug

6
client/lcd/lcd_test.go
View File

@ -347,9 +347,9 @@ func TestPoolParamsQuery(t *testing.T) {
pool := getStakePool(t, port)
initialPool := stake.InitialPool()
initialPool.LooseTokens = initialPool.LooseTokens.Add(sdk.NewDec(100))
initialPool.BondedTokens = initialPool.BondedTokens.Add(sdk.NewDec(100)) // Delegate tx on GaiaAppGenState
initialPool.LooseTokens = initialPool.LooseTokens.Add(sdk.NewDec(int64(50))) // freeFermionsAcc = 50 on GaiaAppGenState
initialPool.LooseTokens = initialPool.LooseTokens.Add(sdk.NewInt(100))
initialPool.BondedTokens = initialPool.BondedTokens.Add(sdk.NewInt(100)) // Delegate tx on GaiaAppGenState
initialPool.LooseTokens = initialPool.LooseTokens.Add(sdk.NewInt(50)) // freeFermionsAcc = 50 on GaiaAppGenState
require.Equal(t, initialPool.BondedTokens, pool.BondedTokens)
require.Equal(t, initialPool.LooseTokens, pool.LooseTokens)

2
client/lcd/test_helpers.go
View File

@ -291,7 +291,7 @@ func InitializeTestLCD(
accAuth.Coins = sdk.Coins{sdk.NewInt64Coin(stakeTypes.DefaultBondDenom, 100)}
acc := gapp.NewGenesisAccount(&accAuth)
genesisState.Accounts = append(genesisState.Accounts, acc)
genesisState.StakeData.Pool.LooseTokens = genesisState.StakeData.Pool.LooseTokens.Add(sdk.NewDec(100))
genesisState.StakeData.Pool.LooseTokens = genesisState.StakeData.Pool.LooseTokens.Add(sdk.NewInt(100))
}
appState, err := codec.MarshalJSONIndent(cdc, genesisState)

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

@ -130,7 +130,7 @@ func GaiaAppGenState(cdc *codec.Codec, genDoc tmtypes.GenesisDoc, appGenTxs []js
for _, coin := range acc.Coins {
if coin.Denom == bondDenom {
stakeData.Pool.LooseTokens = stakeData.Pool.LooseTokens.
Add(sdk.NewDecFromInt(coin.Amount)) // increase the supply
Add(coin.Amount) // increase the supply
}
}
}

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

@ -43,7 +43,7 @@ func makeGenesisState(t *testing.T, genTxs []auth.StdTx) GenesisState {
acc := auth.NewBaseAccountWithAddress(sdk.AccAddress(msg.ValidatorAddr))
acc.Coins = sdk.Coins{sdk.NewInt64Coin(bondDenom, 150)}
genAccs[i] = NewGenesisAccount(&acc)
stakeData.Pool.LooseTokens = stakeData.Pool.LooseTokens.Add(sdk.NewDec(150)) // increase the supply
stakeData.Pool.LooseTokens = stakeData.Pool.LooseTokens.Add(sdk.NewInt(150)) // increase the supply
}
// create the final app state

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

@ -151,13 +151,13 @@ func appStateFn(r *rand.Rand, accs []simulation.Account) json.RawMessage {
valAddrs[i] = valAddr
validator := stake.NewValidator(valAddr, accs[i].PubKey, stake.Description{})
validator.Tokens = sdk.NewDec(amount)
validator.Tokens = sdk.NewInt(amount)
validator.DelegatorShares = sdk.NewDec(amount)
delegation := stake.Delegation{accs[i].Address, valAddr, sdk.NewDec(amount)}
validators = append(validators, validator)
delegations = append(delegations, delegation)
}
stakeGenesis.Pool.LooseTokens = sdk.NewDec((amount * numAccs) + (numInitiallyBonded * amount))
stakeGenesis.Pool.LooseTokens = sdk.NewInt((amount * numAccs) + (numInitiallyBonded * amount))
stakeGenesis.Validators = validators
stakeGenesis.Bonds = delegations

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

@ -232,7 +232,7 @@ func TestGaiaCLICreateValidator(t *testing.T) {
defaultParams := stake.DefaultParams()
initialPool := stake.InitialPool()
initialPool.BondedTokens = initialPool.BondedTokens.Add(sdk.NewDec(100)) // Delegate tx on GaiaAppGenState
initialPool.BondedTokens = initialPool.BondedTokens.Add(sdk.NewInt(100)) // Delegate tx on GaiaAppGenState
// create validator
cvStr := fmt.Sprintf("gaiacli tx stake create-validator %v", flags)
@ -244,7 +244,7 @@ func TestGaiaCLICreateValidator(t *testing.T) {
cvStr += fmt.Sprintf(" --commission-max-rate=%v", "0.20")
cvStr += fmt.Sprintf(" --commission-max-change-rate=%v", "0.10")
initialPool.BondedTokens = initialPool.BondedTokens.Add(sdk.NewDec(1))
initialPool.BondedTokens = initialPool.BondedTokens.Add(sdk.NewInt(1))
// Test --generate-only
success, stdout, stderr := executeWriteRetStdStreams(t, cvStr+" --generate-only", app.DefaultKeyPass)
@ -268,7 +268,7 @@ func TestGaiaCLICreateValidator(t *testing.T) {
validator := executeGetValidator(t, fmt.Sprintf("gaiacli query stake validator %s %v", sdk.ValAddress(barAddr), flags))
require.Equal(t, validator.OperatorAddr, sdk.ValAddress(barAddr))
require.True(sdk.DecEq(t, sdk.NewDec(2), validator.Tokens))
require.True(sdk.IntEq(t, sdk.NewInt(2), validator.Tokens))
validatorDelegations := executeGetValidatorDelegations(t, fmt.Sprintf("gaiacli query stake delegations-to %s %v", sdk.ValAddress(barAddr), flags))
require.Len(t, validatorDelegations, 1)
@ -289,7 +289,7 @@ func TestGaiaCLICreateValidator(t *testing.T) {
require.Equal(t, int64(9), barAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64(), "%v", barAcc)
*/
validator = executeGetValidator(t, fmt.Sprintf("gaiacli query stake validator %s %v", sdk.ValAddress(barAddr), flags))
require.Equal(t, "1.0000000000", validator.Tokens.String())
require.Equal(t, "1", validator.Tokens.String())
validatorUbds := executeGetValidatorUnbondingDelegations(t,
fmt.Sprintf("gaiacli query stake unbonding-delegations-from %s %v", sdk.ValAddress(barAddr), flags))

12
docs/examples/democoin/mock/validator.go
View File

@ -11,7 +11,7 @@ import (
// Validator implements sdk.Validator
type Validator struct {
Address sdk.ValAddress
Power sdk.Dec
Power sdk.Int
}
// Implements sdk.Validator
@ -35,12 +35,12 @@ func (v Validator) GetConsAddr() sdk.ConsAddress {
}
// Implements sdk.Validator
func (v Validator) GetTokens() sdk.Dec {
return sdk.ZeroDec()
func (v Validator) GetTokens() sdk.Int {
return sdk.ZeroInt()
}
// Implements sdk.Validator
func (v Validator) GetPower() sdk.Dec {
func (v Validator) GetPower() sdk.Int {
return v.Power
}
@ -114,8 +114,8 @@ func (vs *ValidatorSet) ValidatorByConsAddr(_ sdk.Context, _ sdk.ConsAddress) sd
}
// TotalPower implements sdk.ValidatorSet
func (vs *ValidatorSet) TotalPower(ctx sdk.Context) sdk.Dec {
res := sdk.ZeroDec()
func (vs *ValidatorSet) TotalPower(ctx sdk.Context) sdk.Int {
res := sdk.ZeroInt()
for _, val := range vs.Validators {
res = res.Add(val.Power)
}

4
docs/examples/democoin/x/assoc/validator_set_test.go
View File

@ -32,8 +32,8 @@ func TestValidatorSet(t *testing.T) {
addr2 := []byte("addr2")
base := &mock.ValidatorSet{[]mock.Validator{
{addr1, sdk.NewDec(1)},
{addr2, sdk.NewDec(2)},
{addr1, sdk.NewInt(1)},
{addr2, sdk.NewInt(2)},
}}
valset := NewValidatorSet(codec.New(), ctx.KVStore(key).Prefix([]byte("assoc")), base, 1, 5)

6
docs/examples/democoin/x/oracle/handler.go
View File

@ -14,7 +14,7 @@ func (keeper Keeper) update(ctx sdk.Context, val sdk.Validator, valset sdk.Valid
// Return if the voted power is not bigger than required power
totalPower := valset.TotalPower(ctx)
requiredPower := totalPower.Mul(keeper.supermaj)
requiredPower := keeper.supermaj.MulInt(totalPower).RoundInt()
if !info.Power.GT(requiredPower) {
return info
}
@ -23,7 +23,7 @@ func (keeper Keeper) update(ctx sdk.Context, val sdk.Validator, valset sdk.Valid
// and recalculate voted power
hash := ctx.BlockHeader().ValidatorsHash
if !bytes.Equal(hash, info.Hash) {
info.Power = sdk.ZeroDec()
info.Power = sdk.ZeroInt()
info.Hash = hash
prefix := GetSignPrefix(p, keeper.cdc)
store := ctx.KVStore(keeper.key)
@ -36,7 +36,7 @@ func (keeper Keeper) update(ctx sdk.Context, val sdk.Validator, valset sdk.Valid
}
info.Power = info.Power.Add(val.GetPower())
}
if !info.Power.GT(totalPower.Mul(keeper.supermaj)) {
if !info.Power.GT(keeper.supermaj.MulInt(totalPower).RoundInt()) {
return info
}
}

4
docs/examples/democoin/x/oracle/keeper.go
View File

@ -46,7 +46,7 @@ const (
// Info for each payload
type Info struct {
Power sdk.Dec
Power sdk.Int
Hash []byte
LastSigned int64
Status InfoStatus
@ -55,7 +55,7 @@ type Info struct {
// EmptyInfo construct an empty Info
func EmptyInfo(ctx sdk.Context) Info {
return Info{
Power: sdk.ZeroDec(),
Power: sdk.ZeroInt(),
Hash: ctx.BlockHeader().ValidatorsHash,
LastSigned: ctx.BlockHeight(),
Status: Pending,

8
docs/examples/democoin/x/oracle/oracle_test.go
View File

@ -110,9 +110,9 @@ func TestOracle(t *testing.T) {
addr3 := []byte("addr3")
addr4 := []byte("addr4")
valset := &mock.ValidatorSet{[]mock.Validator{
{addr1, sdk.NewDec(7)},
{addr2, sdk.NewDec(7)},
{addr3, sdk.NewDec(1)},
{addr1, sdk.NewInt(7)},
{addr2, sdk.NewInt(7)},
{addr3, sdk.NewInt(1)},
}}
key := sdk.NewKVStoreKey("testkey")
@ -174,7 +174,7 @@ func TestOracle(t *testing.T) {
require.Equal(t, 1, getSequence(ctx, key))
// Should handle mock.Validator set change
valset.AddValidator(mock.Validator{addr4, sdk.NewDec(12)})
valset.AddValidator(mock.Validator{addr4, sdk.NewInt(12)})
bz, err = json.Marshal(valset)
require.Nil(t, err)
ctx = ctx.WithBlockHeader(abci.Header{ValidatorsHash: bz})

7
docs/spec/staking/state.md
View File

@ -10,8 +10,8 @@ inflation information, etc.
```golang
type Pool struct {
LooseTokens int64 // tokens not associated with any bonded validator
BondedTokens int64 // reserve of bonded tokens
LooseTokens sdk.Int // tokens not associated with any bonded validator
BondedTokens sdk.Int // reserve of bonded tokens
}
```
@ -65,9 +65,8 @@ type Validator struct {
Jailed bool // has the validator been jailed?
Status sdk.BondStatus // validator status (bonded/unbonding/unbonded)
Tokens sdk.Dec // delegated tokens (incl. self-delegation)
Tokens sdk.Int // delegated tokens (incl. self-delegation)
DelegatorShares sdk.Dec // total shares issued to a validator's delegators
SlashRatio sdk.Dec // increases each time the validator is slashed
Description Description // description terms for the validator

1
docs/spec/staking/transactions.md
View File

@ -20,6 +20,7 @@ Other notes:
* `getXxx`, `setXxx`, and `removeXxx` functions are used to retrieve and
modify objects from the store
* `sdk.Dec` refers to a decimal type specified by the SDK.
* `sdk.Int` refers to an integer type specified by the SDK.
## TxCreateValidator

24
types/int.go
View File

@ -40,6 +40,13 @@ func min(i *big.Int, i2 *big.Int) *big.Int {
return new(big.Int).Set(i)
}
func max(i *big.Int, i2 *big.Int) *big.Int {
if i.Cmp(i2) == 1 {
return new(big.Int).Set(i)
}
return new(big.Int).Set(i2)
}
// MarshalAmino for custom encoding scheme
func marshalAmino(i *big.Int) (string, error) {
bz, err := i.MarshalText()
@ -153,6 +160,16 @@ func (i Int) IsZero() bool {
return i.i.Sign() == 0
}
// IsNegative returns true if Int is negative
func (i Int) IsNegative() bool {
return i.i.Sign() == -1
}
// IsPositive returns true if Int is positive
func (i Int) IsPositive() bool {
return i.i.Sign() == 1
}
// Sign returns sign of Int
func (i Int) Sign() int {
return i.i.Sign()
@ -254,11 +271,16 @@ func (i Int) Neg() (res Int) {
return Int{neg(i.i)}
}
// Return the minimum of the ints
// return the minimum of the ints
func MinInt(i1, i2 Int) Int {
return Int{min(i1.BigInt(), i2.BigInt())}
}
// return the maximum of the ints
func MaxInt(i1, i2 Int) Int {
return Int{max(i1.BigInt(), i2.BigInt())}
}
// Human readable string
func (i Int) String() string {
return i.i.String()

8
types/stake.go
View File

@ -42,8 +42,8 @@ type Validator interface {
GetOperator() ValAddress // operator address to receive/return validators coins
GetConsPubKey() crypto.PubKey // validation consensus pubkey
GetConsAddr() ConsAddress // validation consensus address
GetPower() Dec // validation power
GetTokens() Dec // validation tokens
GetPower() Int // validation power
GetTokens() Int // validation tokens
GetCommission() Dec // validator commission rate
GetDelegatorShares() Dec // Total out standing delegator shares
GetBondHeight() int64 // height in which the validator became active
@ -53,7 +53,7 @@ type Validator interface {
func ABCIValidator(v Validator) abci.Validator {
return abci.Validator{
Address: v.GetConsPubKey().Address(),
Power: v.GetPower().RoundInt64(),
Power: v.GetPower().Int64(),
}
}
@ -73,7 +73,7 @@ type ValidatorSet interface {
Validator(Context, ValAddress) Validator // get a particular validator by operator address
ValidatorByConsAddr(Context, ConsAddress) Validator // get a particular validator by consensus address
TotalPower(Context) Dec // total power of the validator set
TotalPower(Context) Int // total power of the validator set
// slash the validator and delegators of the validator, specifying offence height, offence power, and slash fraction
Slash(Context, ConsAddress, int64, int64, Dec)

8
x/distribution/keeper/allocation_test.go
View File

@ -19,7 +19,7 @@ func TestAllocateTokensBasic(t *testing.T) {
//first make a validator
totalPower := int64(10)
totalPowerDec := sdk.NewDec(totalPower)
totalPowerInt := sdk.NewInt(totalPower)
msgCreateValidator := stake.NewTestMsgCreateValidator(valOpAddr1, valConsPk1, totalPower)
got := stakeHandler(ctx, msgCreateValidator)
require.True(t, got.IsOK(), "expected msg to be ok, got %v", got)
@ -29,10 +29,10 @@ func TestAllocateTokensBasic(t *testing.T) {
validator, found := sk.GetValidator(ctx, valOpAddr1)
require.True(t, found)
require.Equal(t, sdk.Bonded, validator.Status)
assert.True(sdk.DecEq(t, totalPowerDec, validator.Tokens))
assert.True(sdk.DecEq(t, totalPowerDec, validator.DelegatorShares))
assert.True(sdk.IntEq(t, totalPowerInt, validator.Tokens))
assert.True(sdk.DecEq(t, sdk.NewDec(totalPower), validator.DelegatorShares))
bondedTokens := sk.TotalPower(ctx)
assert.True(sdk.DecEq(t, totalPowerDec, bondedTokens))
assert.True(sdk.IntEq(t, totalPowerInt, bondedTokens))
// initial fee pool should be empty
feePool := keeper.GetFeePool(ctx)

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

@ -122,7 +122,7 @@ func CreateTestInputAdvanced(t *testing.T, isCheckTx bool, initCoins int64,
{sk.GetParams(ctx).BondDenom, sdk.NewInt(initCoins)},
})
require.Nil(t, err)
pool.LooseTokens = pool.LooseTokens.Add(sdk.NewDec(initCoins))
pool.LooseTokens = pool.LooseTokens.Add(sdk.NewInt(initCoins))
sk.SetPool(ctx, pool)
}

2
x/distribution/types/keepers.go
View File

@ -9,7 +9,7 @@ type StakeKeeper interface {
Delegation(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) sdk.Delegation
Validator(ctx sdk.Context, valAddr sdk.ValAddress) sdk.Validator
ValidatorByConsAddr(ctx sdk.Context, consAddr sdk.ConsAddress) sdk.Validator
TotalPower(ctx sdk.Context) sdk.Dec
TotalPower(ctx sdk.Context) sdk.Int
GetLastTotalPower(ctx sdk.Context) sdk.Int
GetLastValidatorPower(ctx sdk.Context, valAddr sdk.ValAddress) sdk.Int
}

7
x/gov/tally.go
View File

@ -26,7 +26,7 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
keeper.vs.IterateBondedValidatorsByPower(ctx, func(index int64, validator sdk.Validator) (stop bool) {
currValidators[validator.GetOperator().String()] = validatorGovInfo{
Address: validator.GetOperator(),
Power: validator.GetPower(),
Power: sdk.NewDecFromInt(validator.GetPower()),
DelegatorShares: validator.GetDelegatorShares(),
Minus: sdk.ZeroDec(),
Vote: OptionEmpty,
@ -94,11 +94,12 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
}
// If there is no staked coins, the proposal fails
if keeper.vs.TotalPower(ctx).Equal(sdk.ZeroDec()) {
if keeper.vs.TotalPower(ctx).IsZero() {
return false, tallyResults
}
// If there is not enough quorum of votes, the proposal fails
if totalVotingPower.Quo(keeper.vs.TotalPower(ctx)).LT(tallyParams.Quorum) {
percentVoting := totalVotingPower.Quo(sdk.NewDecFromInt(keeper.vs.TotalPower(ctx)))
if percentVoting.LT(tallyParams.Quorum) {
return false, tallyResults
}
// If no one votes (everyone abstains), proposal fails

2
x/gov/test_common.go
View File

@ -65,7 +65,7 @@ func getInitChainer(mapp *mock.App, keeper Keeper, stakeKeeper stake.Keeper) sdk
mapp.InitChainer(ctx, req)
stakeGenesis := stake.DefaultGenesisState()
stakeGenesis.Pool.LooseTokens = sdk.NewDec(100000)
stakeGenesis.Pool.LooseTokens = sdk.NewInt(100000)
validators, err := stake.InitGenesis(ctx, stakeKeeper, stakeGenesis)
if err != nil {

2
x/mint/abci_app.go
View File

@ -21,6 +21,6 @@ func BeginBlocker(ctx sdk.Context, k Keeper) {
// mint coins, add to collected fees, update supply
mintedCoin := minter.BlockProvision(params)
k.fck.AddCollectedFees(ctx, sdk.Coins{mintedCoin})
k.sk.InflateSupply(ctx, sdk.NewDecFromInt(mintedCoin.Amount))
k.sk.InflateSupply(ctx, mintedCoin.Amount)
}

4
x/mint/expected_keepers.go
View File

@ -6,9 +6,9 @@ import (
// expected stake keeper
type StakeKeeper interface {
TotalPower(ctx sdk.Context) sdk.Dec
TotalPower(ctx sdk.Context) sdk.Int
BondedRatio(ctx sdk.Context) sdk.Dec
InflateSupply(ctx sdk.Context, newTokens sdk.Dec)
InflateSupply(ctx sdk.Context, newTokens sdk.Int)
}
// expected fee collection keeper interface

4
x/mint/minter.go
View File

@ -74,10 +74,10 @@ func (m Minter) NextInflationRate(params Params, bondedRatio sdk.Dec) (
}
// calculate the annual provisions based on current total supply and inflation rate
func (m Minter) NextAnnualProvisions(params Params, totalSupply sdk.Dec) (
func (m Minter) NextAnnualProvisions(params Params, totalSupply sdk.Int) (
provisions sdk.Dec) {
return m.Inflation.Mul(totalSupply)
return m.Inflation.MulInt(totalSupply)
}
// get the provisions for a block based on the annual provisions rate

2
x/mint/minter_test.go
View File

@ -121,7 +121,7 @@ func BenchmarkNextInflation(b *testing.B) {
func BenchmarkNextAnnualProvisions(b *testing.B) {
minter := InitialMinter(sdk.NewDecWithPrec(1, 1))
params := DefaultParams()
totalSupply := sdk.NewDec(100000000000000)
totalSupply := sdk.NewInt(100000000000000)
// run the NextAnnualProvisions function b.N times
for n := 0; n < b.N; n++ {

4
x/slashing/app_test.go
View File

@ -60,7 +60,7 @@ func getInitChainer(mapp *mock.App, keeper stake.Keeper) sdk.InitChainer {
return func(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain {
mapp.InitChainer(ctx, req)
stakeGenesis := stake.DefaultGenesisState()
stakeGenesis.Pool.LooseTokens = sdk.NewDec(100000)
stakeGenesis.Pool.LooseTokens = sdk.NewInt(100000)
validators, err := stake.InitGenesis(ctx, keeper, stakeGenesis)
if err != nil {
panic(err)
@ -114,7 +114,7 @@ func TestSlashingMsgs(t *testing.T) {
validator := checkValidator(t, mapp, stakeKeeper, addr1, true)
require.Equal(t, sdk.ValAddress(addr1), validator.OperatorAddr)
require.Equal(t, sdk.Bonded, validator.Status)
require.True(sdk.DecEq(t, sdk.NewDec(10), validator.BondedTokens()))
require.True(sdk.IntEq(t, sdk.NewInt(10), validator.BondedTokens()))
unjailMsg := MsgUnjail{ValidatorAddr: sdk.ValAddress(validator.ConsPubKey.Address())}
// no signing info yet

2
x/slashing/handler_test.go
View File

@ -25,7 +25,7 @@ func TestCannotUnjailUnlessJailed(t *testing.T) {
t, ck.GetCoins(ctx, sdk.AccAddress(addr)),
sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))},
)
require.True(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, addr).GetPower()))
require.True(sdk.IntEq(t, amt, sk.Validator(ctx, addr).GetPower()))
// assert non-jailed validator can't be unjailed
got = slh(ctx, NewMsgUnjail(addr))

72
x/slashing/keeper_test.go
View File

@ -40,7 +40,7 @@ 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(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, operatorAddr).GetPower()))
require.True(sdk.IntEq(t, amt, sk.Validator(ctx, operatorAddr).GetPower()))
// handle a signature to set signing info
keeper.handleValidatorSignature(ctx, val.Address(), amtInt, true)
@ -53,18 +53,18 @@ func TestHandleDoubleSign(t *testing.T) {
// unjail to measure power
sk.Unjail(ctx, sdk.ConsAddress(val.Address()))
// power should be reduced
require.Equal(
t, sdk.NewDecFromInt(amt).Mul(sdk.NewDec(19).Quo(sdk.NewDec(20))),
require.True(sdk.IntEq(
t, amt.Mul(sdk.NewInt(19)).Div(sdk.NewInt(20)),
sk.Validator(ctx, operatorAddr).GetPower(),
)
))
ctx = ctx.WithBlockHeader(abci.Header{Time: time.Unix(1, 0).Add(keeper.MaxEvidenceAge(ctx))})
// double sign past max age
keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), amtInt)
require.Equal(
t, sdk.NewDecFromInt(amt).Mul(sdk.NewDec(19).Quo(sdk.NewDec(20))),
require.True(sdk.IntEq(
t, amt.Mul(sdk.NewInt(19)).Div(sdk.NewInt(20)),
sk.Validator(ctx, operatorAddr).GetPower(),
)
))
}
// Test that the amount a validator is slashed for multiple double signs
@ -84,7 +84,7 @@ func TestSlashingPeriodCap(t *testing.T) {
t, ck.GetCoins(ctx, sdk.AccAddress(operatorAddr)),
sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))},
)
require.True(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, operatorAddr).GetPower()))
require.True(sdk.IntEq(t, amt, sk.Validator(ctx, operatorAddr).GetPower()))
// handle a signature to set signing info
keeper.handleValidatorSignature(ctx, valConsAddr, amtInt, true)
@ -102,8 +102,8 @@ func TestSlashingPeriodCap(t *testing.T) {
// end block
stake.EndBlocker(ctx, sk)
// power should be reduced
expectedPower := sdk.NewDecFromInt(amt).Mul(sdk.NewDec(19).Quo(sdk.NewDec(20)))
require.Equal(t, expectedPower, sk.Validator(ctx, operatorAddr).GetPower())
expectedPower := amt.Mul(sdk.NewInt(19)).Div(sdk.NewInt(20))
require.True(sdk.IntEq(t, expectedPower, sk.Validator(ctx, operatorAddr).GetPower()))
// double sign again, same slashing period
keeper.handleDoubleSign(ctx, valConsAddr, 1, time.Unix(0, 0), amtInt)
@ -118,8 +118,8 @@ func TestSlashingPeriodCap(t *testing.T) {
// end block
stake.EndBlocker(ctx, sk)
// power should be equal, no more should have been slashed
expectedPower = sdk.NewDecFromInt(amt).Mul(sdk.NewDec(19).Quo(sdk.NewDec(20)))
require.Equal(t, expectedPower, sk.Validator(ctx, operatorAddr).GetPower())
expectedPower = amt.Mul(sdk.NewInt(19)).Div(sdk.NewInt(20))
require.True(sdk.IntEq(t, expectedPower, sk.Validator(ctx, operatorAddr).GetPower()))
// double sign again, new slashing period
keeper.handleDoubleSign(ctx, valConsAddr, 3, time.Unix(0, 0), amtInt)
@ -130,8 +130,8 @@ func TestSlashingPeriodCap(t *testing.T) {
// end block
stake.EndBlocker(ctx, sk)
// power should be reduced
expectedPower = sdk.NewDecFromInt(amt).Mul(sdk.NewDec(18).Quo(sdk.NewDec(20)))
require.Equal(t, expectedPower, sk.Validator(ctx, operatorAddr).GetPower())
expectedPower = amt.Mul(sdk.NewInt(18)).Div(sdk.NewInt(20))
require.True(sdk.IntEq(t, expectedPower, sk.Validator(ctx, operatorAddr).GetPower()))
}
// Test a validator through uptime, downtime, revocation,
@ -140,8 +140,8 @@ func TestHandleAbsentValidator(t *testing.T) {
// initial setup
ctx, ck, sk, _, keeper := createTestInput(t, keeperTestParams())
amtInt := int64(100)
addr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
amtInt64 := int64(100)
addr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt64)
sh := stake.NewHandler(sk)
slh := NewHandler(keeper)
got := sh(ctx, NewTestMsgCreateValidator(addr, val, amt))
@ -152,7 +152,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(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, addr).GetPower()))
require.True(sdk.IntEq(t, amt, sk.Validator(ctx, addr).GetPower()))
// will exist since the validator has been bonded
info, found := keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
@ -166,7 +166,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(), amtInt, true)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, true)
}
info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
require.True(t, found)
@ -176,7 +176,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(), amtInt, false)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
}
info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
require.True(t, found)
@ -187,11 +187,11 @@ func TestHandleAbsentValidator(t *testing.T) {
validator, _ := sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
require.Equal(t, sdk.Bonded, validator.GetStatus())
pool := sk.GetPool(ctx)
require.Equal(t, amtInt, pool.BondedTokens.RoundInt64())
require.True(sdk.IntEq(t, amt, pool.BondedTokens))
// 501st block missed
ctx = ctx.WithBlockHeight(height)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt, false)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
require.True(t, found)
require.Equal(t, int64(0), info.StartHeight)
@ -205,15 +205,15 @@ func TestHandleAbsentValidator(t *testing.T) {
validator, _ = sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
require.Equal(t, sdk.Unbonding, validator.GetStatus())
slashAmt := sdk.NewDec(amtInt).Mul(keeper.SlashFractionDowntime(ctx)).RoundInt64()
slashAmt := sdk.NewDec(amtInt64).Mul(keeper.SlashFractionDowntime(ctx)).RoundInt64()
// validator should have been slashed
require.Equal(t, amtInt-slashAmt, validator.GetTokens().RoundInt64())
require.Equal(t, amtInt64-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(), amtInt, false)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
require.True(t, found)
require.Equal(t, int64(0), info.StartHeight)
@ -224,15 +224,15 @@ 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, amtInt-slashAmt, validator.GetTokens().RoundInt64())
require.Equal(t, amtInt64-slashAmt, validator.GetTokens().Int64())
// 502nd block *double signed* (oh no!)
keeper.handleDoubleSign(ctx, val.Address(), height, ctx.BlockHeader().Time, amtInt)
keeper.handleDoubleSign(ctx, val.Address(), height, ctx.BlockHeader().Time, amtInt64)
// validator should have been slashed
validator, _ = sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
secondSlashAmt := sdk.NewDec(amtInt).Mul(keeper.SlashFractionDoubleSign(ctx)).RoundInt64()
require.Equal(t, amtInt-slashAmt-secondSlashAmt, validator.GetTokens().RoundInt64())
secondSlashAmt := sdk.NewDec(amtInt64).Mul(keeper.SlashFractionDoubleSign(ctx)).RoundInt64()
require.Equal(t, amtInt64-slashAmt-secondSlashAmt, validator.GetTokens().Int64())
// unrevocation should fail prior to jail expiration
got = slh(ctx, NewMsgUnjail(addr))
@ -252,7 +252,7 @@ func TestHandleAbsentValidator(t *testing.T) {
// validator should have been slashed
pool = sk.GetPool(ctx)
require.Equal(t, amtInt-slashAmt-secondSlashAmt, pool.BondedTokens.RoundInt64())
require.Equal(t, amtInt64-slashAmt-secondSlashAmt, pool.BondedTokens.Int64())
// validator start height should not have been changed
info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
@ -264,7 +264,7 @@ func TestHandleAbsentValidator(t *testing.T) {
// validator should not be immediately jailed again
height++
ctx = ctx.WithBlockHeight(height)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt, false)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
validator, _ = sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
require.Equal(t, sdk.Bonded, validator.GetStatus())
@ -272,7 +272,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(), amtInt, false)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
}
// end block
@ -282,7 +282,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(), amtInt, false)
keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
}
// end block
@ -313,7 +313,7 @@ func TestHandleNewValidator(t *testing.T) {
t, ck.GetCoins(ctx, sdk.AccAddress(addr)),
sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.SubRaw(amt))},
)
require.Equal(t, sdk.NewDec(amt), sk.Validator(ctx, addr).GetPower())
require.Equal(t, amt, sk.Validator(ctx, addr).GetPower().Int64())
// Now a validator, for two blocks
keeper.handleValidatorSignature(ctx, val.Address(), 100, true)
@ -331,7 +331,7 @@ 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.RoundInt64())
require.Equal(t, int64(100), pool.BondedTokens.Int64())
}
// Test a jailed validator being "down" twice
@ -368,7 +368,7 @@ func TestHandleAlreadyJailed(t *testing.T) {
require.Equal(t, sdk.Unbonding, validator.GetStatus())
// validator should have been slashed
require.Equal(t, amtInt-1, validator.GetTokens().RoundInt64())
require.Equal(t, amtInt-1, validator.GetTokens().Int64())
// another block missed
ctx = ctx.WithBlockHeight(height)
@ -376,7 +376,7 @@ func TestHandleAlreadyJailed(t *testing.T) {
// validator should not have been slashed twice
validator, _ = sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
require.Equal(t, amtInt-1, validator.GetTokens().RoundInt64())
require.Equal(t, amtInt-1, validator.GetTokens().Int64())
}

2
x/slashing/test_common.go
View File

@ -76,7 +76,7 @@ func createTestInput(t *testing.T, defaults Params) (sdk.Context, bank.Keeper, s
sk := stake.NewKeeper(cdc, keyStake, tkeyStake, ck, paramsKeeper.Subspace(stake.DefaultParamspace), stake.DefaultCodespace)
genesis := stake.DefaultGenesisState()
genesis.Pool.LooseTokens = sdk.NewDec(initCoins.MulRaw(int64(len(addrs))).Int64())
genesis.Pool.LooseTokens = sdk.NewInt(initCoins.MulRaw(int64(len(addrs))).Int64())
_, err = stake.InitGenesis(ctx, sk, genesis)
require.Nil(t, err)

2
x/slashing/tick_test.go
View File

@ -24,7 +24,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(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, addr).GetPower()))
require.True(sdk.IntEq(t, amt, sk.Validator(ctx, addr).GetPower()))
val := abci.Validator{
Address: pk.Address(),

6
x/stake/app_test.go
View File

@ -52,7 +52,7 @@ func getInitChainer(mapp *mock.App, keeper Keeper) sdk.InitChainer {
mapp.InitChainer(ctx, req)
stakeGenesis := DefaultGenesisState()
stakeGenesis.Pool.LooseTokens = sdk.NewDec(100000)
stakeGenesis.Pool.LooseTokens = sdk.NewInt(100000)
validators, err := InitGenesis(ctx, keeper, stakeGenesis)
if err != nil {
@ -127,7 +127,7 @@ func TestStakeMsgs(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.DecEq(t, sdk.NewDec(10), validator.BondedTokens()))
require.True(sdk.IntEq(t, sdk.NewInt(10), validator.BondedTokens()))
// addr1 create validator on behalf of addr2
createValidatorMsgOnBehalfOf := NewMsgCreateValidatorOnBehalfOf(
@ -141,7 +141,7 @@ func TestStakeMsgs(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.DecEq(t, sdk.NewDec(10), validator.Tokens))
require.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
// check the bond that should have been created as well
checkDelegation(t, mApp, keeper, addr1, sdk.ValAddress(addr1), true, sdk.NewDec(10))

2
x/stake/genesis.go
View File

@ -124,7 +124,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().RoundInt64(),
Power: validator.GetPower().Int64(),
Name: validator.GetMoniker(),
})

14
x/stake/genesis_test.go
View File

@ -20,7 +20,7 @@ func TestInitGenesis(t *testing.T) {
ctx, _, keeper := keep.CreateTestInput(t, false, 1000)
pool := keeper.GetPool(ctx)
pool.BondedTokens = sdk.NewDec(2)
pool.BondedTokens = sdk.NewInt(2)
params := keeper.GetParams(ctx)
validators := make([]Validator, 2)
@ -31,13 +31,13 @@ func TestInitGenesis(t *testing.T) {
validators[0].ConsPubKey = keep.PKs[0]
validators[0].Description = Description{Moniker: "hoop"}
validators[0].Status = sdk.Bonded
validators[0].Tokens = sdk.OneDec()
validators[0].Tokens = sdk.OneInt()
validators[0].DelegatorShares = sdk.OneDec()
validators[1].OperatorAddr = sdk.ValAddress(keep.Addrs[1])
validators[1].ConsPubKey = keep.PKs[1]
validators[1].Description = Description{Moniker: "bloop"}
validators[1].Status = sdk.Bonded
validators[1].Tokens = sdk.OneDec()
validators[1].Tokens = sdk.OneInt()
validators[1].DelegatorShares = sdk.OneDec()
genesisState := types.NewGenesisState(pool, params, validators, delegations)
@ -75,7 +75,7 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) {
// Assigning 2 to the first 100 vals, 1 to the rest
pool := keeper.GetPool(ctx)
pool.BondedTokens = sdk.NewDec(int64(200 + (size - 100)))
pool.BondedTokens = sdk.NewInt(int64(200 + (size - 100)))
params := keeper.GetParams(ctx)
delegations := []Delegation{}
@ -86,10 +86,10 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) {
validators[i].Status = sdk.Bonded
if i < 100 {
validators[i].Tokens = sdk.NewDec(2)
validators[i].Tokens = sdk.NewInt(2)
validators[i].DelegatorShares = sdk.NewDec(2)
} else {
validators[i].Tokens = sdk.OneDec()
validators[i].Tokens = sdk.OneInt()
validators[i].DelegatorShares = sdk.OneDec()
}
}
@ -110,7 +110,7 @@ func TestValidateGenesis(t *testing.T) {
genValidators1 := make([]types.Validator, 1, 5)
pk := ed25519.GenPrivKey().PubKey()
genValidators1[0] = types.NewValidator(sdk.ValAddress(pk.Address()), pk, types.NewDescription("", "", "", ""))
genValidators1[0].Tokens = sdk.OneDec()
genValidators1[0].Tokens = sdk.OneInt()
genValidators1[0].DelegatorShares = sdk.OneDec()
tests := []struct {

28
x/stake/handler_test.go
View File

@ -74,8 +74,8 @@ func TestValidatorByPowerIndex(t *testing.T) {
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.RoundInt64()) // ensure tokens slashed
require.Equal(t, sdk.Unbonding, validator.Status) // ensure is unbonding
require.Equal(t, int64(500000), validator.Tokens.Int64()) // ensure tokens slashed
keeper.Unjail(ctx, consAddr0)
// the old power record should have been deleted as the power changed
@ -125,7 +125,7 @@ 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, sdk.NewDec(10), validator.BondedTokens())
assert.Equal(t, int64(10), validator.BondedTokens().Int64())
assert.Equal(t, sdk.NewDec(10), validator.DelegatorShares)
assert.Equal(t, Description{}, validator.Description)
@ -154,7 +154,7 @@ 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.DecEq(t, sdk.NewDec(10), validator.Tokens))
assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.DelegatorShares))
assert.Equal(t, Description{}, validator.Description)
}
@ -198,7 +198,7 @@ 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.DecEq(t, sdk.NewDec(10), validator.Tokens))
assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.DelegatorShares))
assert.Equal(t, Description{}, validator.Description)
@ -232,7 +232,7 @@ func TestLegacyValidatorDelegations(t *testing.T) {
require.True(t, found)
require.Equal(t, sdk.Bonded, validator.Status)
require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt64())
require.Equal(t, bondAmount, validator.BondedTokens().RoundInt64())
require.Equal(t, bondAmount, validator.BondedTokens().Int64())
// delegate tokens to the validator
msgDelegate := NewTestMsgDelegate(delAddr, valAddr, bondAmount)
@ -243,7 +243,7 @@ func TestLegacyValidatorDelegations(t *testing.T) {
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().RoundInt64())
require.Equal(t, bondAmount*2, validator.BondedTokens().Int64())
// unbond validator total self-delegations (which should jail the validator)
unbondShares := sdk.NewDec(10)
@ -261,7 +261,7 @@ func TestLegacyValidatorDelegations(t *testing.T) {
validator, found = keeper.GetValidator(ctx, valAddr)
require.True(t, found)
require.True(t, validator.Jailed)
require.Equal(t, sdk.NewDec(10), validator.Tokens)
require.Equal(t, int64(10), validator.Tokens.Int64())
// verify delegation still exists
bond, found := keeper.GetDelegation(ctx, delAddr, valAddr)
@ -283,7 +283,7 @@ func TestLegacyValidatorDelegations(t *testing.T) {
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.RoundInt64())
require.Equal(t, bondAmount*2, validator.Tokens.Int64())
// unjail the validator now that is has non-zero self-delegated shares
keeper.Unjail(ctx, valConsAddr)
@ -297,7 +297,7 @@ func TestLegacyValidatorDelegations(t *testing.T) {
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.RoundInt64())
require.Equal(t, bondAmount*3, validator.Tokens.Int64())
// verify new delegation
bond, found = keeper.GetDelegation(ctx, delAddr, valAddr)
@ -326,7 +326,7 @@ func TestIncrementsMsgDelegate(t *testing.T) {
require.True(t, found)
require.Equal(t, sdk.Bonded, validator.Status)
require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt64())
require.Equal(t, bondAmount, validator.BondedTokens().RoundInt64(), "validator: %v", validator)
require.Equal(t, bondAmount, validator.BondedTokens().Int64(), "validator: %v", validator)
_, found = keeper.GetDelegation(ctx, delegatorAddr, validatorAddr)
require.False(t, found)
@ -338,7 +338,7 @@ func TestIncrementsMsgDelegate(t *testing.T) {
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.RoundInt64())
require.Equal(t, bondAmount, pool.BondedTokens.Int64())
// just send the same msgbond multiple times
msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, bondAmount)
@ -408,7 +408,7 @@ func TestIncrementsMsgUnbond(t *testing.T) {
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().RoundInt64())
require.Equal(t, initBond*2, validator.BondedTokens().Int64())
// just send the same msgUnbond multiple times
// TODO use decimals here
@ -1008,7 +1008,7 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
// validator power should have been reduced by half
validator, found := keeper.GetValidator(ctx, valA)
require.True(t, found)
require.Equal(t, sdk.NewDec(5), validator.GetPower())
require.Equal(t, int64(5), validator.GetPower().Int64())
// slash the validator for an infraction committed after the unbonding and redelegation begin
ctx = ctx.WithBlockHeight(3)

32
x/stake/keeper/delegation.go
View File

@ -422,28 +422,25 @@ func (k Keeper) Delegate(ctx sdk.Context, delAddr sdk.AccAddress, bondAmt sdk.Co
// unbond the the delegation return
func (k Keeper) unbond(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress,
shares sdk.Dec) (amount sdk.Dec, err sdk.Error) {
shares sdk.Dec) (amount sdk.Int, err sdk.Error) {
// check if delegation has any shares in it unbond
delegation, found := k.GetDelegation(ctx, delAddr, valAddr)
if !found {
err = types.ErrNoDelegatorForAddress(k.Codespace())
return
return amount, types.ErrNoDelegatorForAddress(k.Codespace())
}
k.OnDelegationSharesModified(ctx, delAddr, valAddr)
// retrieve the amount to remove
if delegation.Shares.LT(shares) {
err = types.ErrNotEnoughDelegationShares(k.Codespace(), delegation.Shares.String())
return
return amount, types.ErrNotEnoughDelegationShares(k.Codespace(), delegation.Shares.String())
}
// get validator
validator, found := k.GetValidator(ctx, valAddr)
if !found {
err = types.ErrNoValidatorFound(k.Codespace())
return
return amount, types.ErrNoValidatorFound(k.Codespace())
}
// subtract shares from delegator
@ -522,15 +519,7 @@ func (k Keeper) BeginUnbonding(ctx sdk.Context,
if err != nil {
return types.UnbondingDelegation{}, err
}
rounded := returnAmount.TruncateInt()
balance := sdk.NewCoin(k.BondDenom(ctx), rounded)
change := returnAmount.Sub(sdk.NewDecFromInt(rounded))
// for now, change is just burned
pool := k.GetPool(ctx)
pool.LooseTokens = pool.LooseTokens.Sub(change)
k.SetPool(ctx, pool)
balance := sdk.NewCoin(k.BondDenom(ctx), returnAmount)
// no need to create the ubd object just complete now
if completeNow {
@ -597,17 +586,10 @@ func (k Keeper) BeginRedelegation(ctx sdk.Context, delAddr sdk.AccAddress,
return types.Redelegation{}, err
}
rounded := returnAmount.TruncateInt()
if rounded.IsZero() { //TODO design consideration
if returnAmount.IsZero() {
return types.Redelegation{}, types.ErrVerySmallRedelegation(k.Codespace())
}
returnCoin := sdk.NewCoin(k.BondDenom(ctx), rounded)
change := returnAmount.Sub(sdk.NewDecFromInt(rounded))
// for now, change is just burned
pool := k.GetPool(ctx)
pool.LooseTokens = pool.LooseTokens.Sub(change)
k.SetPool(ctx, pool)
returnCoin := sdk.NewCoin(k.BondDenom(ctx), returnAmount)
dstValidator, found := k.GetValidator(ctx, valDstAddr)
if !found {

38
x/stake/keeper/delegation_test.go
View File

@ -181,7 +181,7 @@ func TestUnbondingDelegation(t *testing.T) {
func TestUnbondDelegation(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.LooseTokens = sdk.NewDec(10)
pool.LooseTokens = sdk.NewInt(10)
//create a validator and a delegator to that validator
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
@ -191,8 +191,8 @@ func TestUnbondDelegation(t *testing.T) {
validator = TestingUpdateValidator(keeper, ctx, validator, true)
pool = keeper.GetPool(ctx)
require.Equal(t, int64(10), pool.BondedTokens.RoundInt64())
require.Equal(t, int64(10), validator.BondedTokens().RoundInt64())
require.Equal(t, int64(10), pool.BondedTokens.Int64())
require.Equal(t, int64(10), validator.BondedTokens().Int64())
delegation := types.Delegation{
DelegatorAddr: addrDels[0],
@ -203,7 +203,7 @@ func TestUnbondDelegation(t *testing.T) {
amount, err := keeper.unbond(ctx, addrDels[0], addrVals[0], sdk.NewDec(6))
require.NoError(t, err)
require.Equal(t, int64(6), amount.RoundInt64()) // shares to be added to an unbonding delegation / redelegation
require.Equal(t, int64(6), amount.Int64()) // shares to be added to an unbonding delegation / redelegation
delegation, found := keeper.GetDelegation(ctx, addrDels[0], addrVals[0])
require.True(t, found)
@ -212,9 +212,9 @@ func TestUnbondDelegation(t *testing.T) {
pool = keeper.GetPool(ctx)
require.Equal(t, int64(4), delegation.Shares.RoundInt64())
require.Equal(t, int64(4), validator.BondedTokens().RoundInt64())
require.Equal(t, int64(6), pool.LooseTokens.RoundInt64(), "%v", pool)
require.Equal(t, int64(4), pool.BondedTokens.RoundInt64())
require.Equal(t, int64(4), validator.BondedTokens().Int64())
require.Equal(t, int64(6), pool.LooseTokens.Int64(), "%v", pool)
require.Equal(t, int64(4), pool.BondedTokens.Int64())
}
// test removing all self delegation from a validator which should
@ -223,7 +223,7 @@ func TestUndelegateSelfDelegation(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.LooseTokens = sdk.NewDec(20)
pool.LooseTokens = sdk.NewInt(20)
//create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
@ -263,14 +263,14 @@ func TestUndelegateSelfDelegation(t *testing.T) {
validator, found := keeper.GetValidator(ctx, addrVals[0])
require.True(t, found)
require.Equal(t, int64(10), validator.Tokens.RoundInt64())
require.Equal(t, int64(10), validator.Tokens.Int64())
require.Equal(t, sdk.Unbonding, validator.Status)
}
func TestUndelegateFromUnbondingValidator(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.LooseTokens = sdk.NewDec(20)
pool.LooseTokens = sdk.NewInt(20)
//create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
@ -346,7 +346,7 @@ func TestUndelegateFromUnbondingValidator(t *testing.T) {
func TestUndelegateFromUnbondedValidator(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.LooseTokens = sdk.NewDec(20)
pool.LooseTokens = sdk.NewInt(20)
//create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
@ -425,7 +425,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
func TestUnbondingAllDelegationFromValidator(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.LooseTokens = sdk.NewDec(20)
pool.LooseTokens = sdk.NewInt(20)
//create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
@ -585,10 +585,9 @@ func TestRedelegation(t *testing.T) {
}
func TestRedelegateToSameValidator(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.LooseTokens = sdk.NewDec(30)
pool.LooseTokens = sdk.NewInt(30)
// create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
@ -611,10 +610,9 @@ func TestRedelegateToSameValidator(t *testing.T) {
}
func TestRedelegateSelfDelegation(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.LooseTokens = sdk.NewDec(30)
pool.LooseTokens = sdk.NewInt(30)
//create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
@ -635,7 +633,7 @@ func TestRedelegateSelfDelegation(t *testing.T) {
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.NewDec(10))
pool.BondedTokens = pool.BondedTokens.Add(sdk.NewInt(10))
keeper.SetPool(ctx, pool)
validator2 = TestingUpdateValidator(keeper, ctx, validator2, true)
require.Equal(t, sdk.Bonded, validator2.Status)
@ -662,14 +660,14 @@ func TestRedelegateSelfDelegation(t *testing.T) {
validator, found := keeper.GetValidator(ctx, addrVals[0])
require.True(t, found)
require.Equal(t, int64(10), validator.Tokens.RoundInt64())
require.Equal(t, int64(10), validator.Tokens.Int64())
require.Equal(t, sdk.Unbonding, validator.Status)
}
func TestRedelegateFromUnbondingValidator(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.LooseTokens = sdk.NewDec(30)
pool.LooseTokens = sdk.NewInt(30)
//create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
@ -752,7 +750,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
func TestRedelegateFromUnbondedValidator(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
pool := keeper.GetPool(ctx)
pool.LooseTokens = sdk.NewDec(30)
pool.LooseTokens = sdk.NewInt(30)
//create a validator with a self-delegation
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})

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

@ -33,7 +33,7 @@ func TestPool(t *testing.T) {
require.True(t, expPool.Equal(resPool))
//modify a params, save, and retrieve
expPool.BondedTokens = sdk.NewDec(777)
expPool.BondedTokens = sdk.NewInt(777)
keeper.SetPool(ctx, expPool)
resPool = keeper.GetPool(ctx)
require.True(t, expPool.Equal(resPool))

2
x/stake/keeper/key.go
View File

@ -78,7 +78,7 @@ func getValidatorPowerRank(validator types.Validator) []byte {
potentialPower := validator.Tokens
// todo: deal with cases above 2**64, ref https://github.com/cosmos/cosmos-sdk/issues/2439#issuecomment-427167556
tendermintPower := potentialPower.RoundInt64()
tendermintPower := potentialPower.Int64()
tendermintPowerBytes := make([]byte, 8)
binary.BigEndian.PutUint64(tendermintPowerBytes[:], uint64(tendermintPower))

8
x/stake/keeper/key_test.go
View File

@ -25,12 +25,12 @@ func TestGetValidatorPowerRank(t *testing.T) {
valAddr1 := sdk.ValAddress(addr1)
emptyDesc := types.Description{}
val1 := types.NewValidator(valAddr1, pk1, emptyDesc)
val1.Tokens = sdk.NewDec(0)
val1.Tokens = sdk.ZeroInt()
val2, val3, val4 := val1, val1, val1
val2.Tokens = sdk.NewDec(1)
val3.Tokens = sdk.NewDec(10)
val2.Tokens = sdk.NewInt(1)
val3.Tokens = sdk.NewInt(10)
x := new(big.Int).Exp(big.NewInt(2), big.NewInt(40), big.NewInt(0))
val4.Tokens = sdk.NewDecFromBigInt(x)
val4.Tokens = sdk.NewIntFromBigInt(x)
tests := []struct {
validator types.Validator

4
x/stake/keeper/sdk_types.go
View File

@ -89,7 +89,7 @@ func (k Keeper) ValidatorByConsAddr(ctx sdk.Context, addr sdk.ConsAddress) sdk.V
}
// total power from the bond (not last, but current)
func (k Keeper) TotalPower(ctx sdk.Context) sdk.Dec {
func (k Keeper) TotalPower(ctx sdk.Context) sdk.Int {
pool := k.GetPool(ctx)
return pool.BondedTokens
}
@ -101,7 +101,7 @@ func (k Keeper) BondedRatio(ctx sdk.Context) sdk.Dec {
}
// when minting new tokens
func (k Keeper) InflateSupply(ctx sdk.Context, newTokens sdk.Dec) {
func (k Keeper) InflateSupply(ctx sdk.Context, newTokens sdk.Int) {
pool := k.GetPool(ctx)
pool.LooseTokens = pool.LooseTokens.Add(newTokens)
k.SetPool(ctx, pool)

34
x/stake/keeper/slash.go
View File

@ -29,7 +29,9 @@ func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeigh
}
// Amount of slashing = slash slashFactor * power at time of infraction
slashAmount := sdk.NewDec(power).Mul(slashFactor)
slashAmountDec := sdk.NewDec(power).Mul(slashFactor)
slashAmount := slashAmountDec.TruncateInt()
// ref https://github.com/cosmos/cosmos-sdk/issues/1348
// ref https://github.com/cosmos/cosmos-sdk/issues/1471
@ -97,8 +99,8 @@ func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeigh
}
// cannot decrease balance below zero
tokensToBurn := sdk.MinDec(remainingSlashAmount, validator.Tokens)
tokensToBurn = sdk.MaxDec(tokensToBurn, sdk.ZeroDec()) // defensive.
tokensToBurn := sdk.MinInt(remainingSlashAmount, validator.Tokens)
tokensToBurn = sdk.MaxInt(tokensToBurn, sdk.ZeroInt()) // defensive.
// Deduct from validator's bonded tokens and update the validator.
// The deducted tokens are returned to pool.LooseTokens.
@ -143,29 +145,30 @@ func (k Keeper) Unjail(ctx sdk.Context, consAddr sdk.ConsAddress) {
// (the amount actually slashed may be less if there's
// insufficient stake remaining)
func (k Keeper) slashUnbondingDelegation(ctx sdk.Context, unbondingDelegation types.UnbondingDelegation,
infractionHeight int64, slashFactor sdk.Dec) (slashAmount sdk.Dec) {
infractionHeight int64, slashFactor sdk.Dec) (slashAmount sdk.Int) {
now := ctx.BlockHeader().Time
// If unbonding started before this height, stake didn't contribute to infraction
if unbondingDelegation.CreationHeight < infractionHeight {
return sdk.ZeroDec()
return sdk.ZeroInt()
}
if unbondingDelegation.MinTime.Before(now) {
// Unbonding delegation no longer eligible for slashing, skip it
// TODO Settle and delete it automatically?
return sdk.ZeroDec()
return sdk.ZeroInt()
}
// Calculate slash amount proportional to stake contributing to infraction
slashAmount = slashFactor.MulInt(unbondingDelegation.InitialBalance.Amount)
slashAmountDec := slashFactor.MulInt(unbondingDelegation.InitialBalance.Amount)
slashAmount = slashAmountDec.TruncateInt()
// Don't slash more tokens than held
// Possible since the unbonding delegation may already
// have been slashed, and slash amounts are calculated
// according to stake held at time of infraction
unbondingSlashAmount := sdk.MinInt(slashAmount.RoundInt(), unbondingDelegation.Balance.Amount)
unbondingSlashAmount := sdk.MinInt(slashAmount, unbondingDelegation.Balance.Amount)
// Update unbonding delegation if necessary
if !unbondingSlashAmount.IsZero() {
@ -175,11 +178,11 @@ func (k Keeper) slashUnbondingDelegation(ctx sdk.Context, unbondingDelegation ty
// Burn loose tokens
// Ref https://github.com/cosmos/cosmos-sdk/pull/1278#discussion_r198657760
pool.LooseTokens = pool.LooseTokens.Sub(sdk.NewDecFromInt(unbondingSlashAmount))
pool.LooseTokens = pool.LooseTokens.Sub(unbondingSlashAmount)
k.SetPool(ctx, pool)
}
return
return slashAmount
}
// slash a redelegation and update the pool
@ -189,29 +192,30 @@ func (k Keeper) slashUnbondingDelegation(ctx sdk.Context, unbondingDelegation ty
// insufficient stake remaining)
// nolint: unparam
func (k Keeper) slashRedelegation(ctx sdk.Context, validator types.Validator, redelegation types.Redelegation,
infractionHeight int64, slashFactor sdk.Dec) (slashAmount sdk.Dec) {
infractionHeight int64, slashFactor sdk.Dec) (slashAmount sdk.Int) {
now := ctx.BlockHeader().Time
// If redelegation started before this height, stake didn't contribute to infraction
if redelegation.CreationHeight < infractionHeight {
return sdk.ZeroDec()
return sdk.ZeroInt()
}
if redelegation.MinTime.Before(now) {
// Redelegation no longer eligible for slashing, skip it
// TODO Delete it automatically?
return sdk.ZeroDec()
return sdk.ZeroInt()
}
// Calculate slash amount proportional to stake contributing to infraction
slashAmount = slashFactor.MulInt(redelegation.InitialBalance.Amount)
slashAmountDec := slashFactor.MulInt(redelegation.InitialBalance.Amount)
slashAmount = slashAmountDec.TruncateInt()
// Don't slash more tokens than held
// Possible since the redelegation may already
// have been slashed, and slash amounts are calculated
// according to stake held at time of infraction
redelegationSlashAmount := sdk.MinInt(slashAmount.RoundInt(), redelegation.Balance.Amount)
redelegationSlashAmount := sdk.MinInt(slashAmount, redelegation.Balance.Amount)
// Update redelegation if necessary
if !redelegationSlashAmount.IsZero() {

62
x/stake/keeper/slash_test.go
View File

@ -21,13 +21,13 @@ func setupHelper(t *testing.T, amt int64) (sdk.Context, Keeper, types.Params) {
params := keeper.GetParams(ctx)
pool := keeper.GetPool(ctx)
numVals := 3
pool.LooseTokens = sdk.NewDec(amt * int64(numVals))
pool.LooseTokens = sdk.NewInt(amt * int64(numVals))
// add numVals validators
for i := 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.NewDec(amt))
pool.BondedTokens = pool.BondedTokens.Add(sdk.NewInt(amt))
keeper.SetPool(ctx, pool)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
keeper.SetValidatorByConsAddr(ctx, validator)
@ -84,20 +84,20 @@ func TestSlashUnbondingDelegation(t *testing.T) {
// unbonding started prior to the infraction height, stake didn't contribute
slashAmount := keeper.slashUnbondingDelegation(ctx, ubd, 1, fraction)
require.Equal(t, int64(0), slashAmount.RoundInt64())
require.Equal(t, int64(0), slashAmount.Int64())
// after the expiration time, no longer eligible for slashing
ctx = ctx.WithBlockHeader(abci.Header{Time: time.Unix(10, 0)})
keeper.SetUnbondingDelegation(ctx, ubd)
slashAmount = keeper.slashUnbondingDelegation(ctx, ubd, 0, fraction)
require.Equal(t, int64(0), slashAmount.RoundInt64())
require.Equal(t, int64(0), slashAmount.Int64())
// test valid slash, before expiration timestamp and to which stake contributed
oldPool := keeper.GetPool(ctx)
ctx = ctx.WithBlockHeader(abci.Header{Time: time.Unix(0, 0)})
keeper.SetUnbondingDelegation(ctx, ubd)
slashAmount = keeper.slashUnbondingDelegation(ctx, ubd, 0, fraction)
require.Equal(t, int64(5), slashAmount.RoundInt64())
require.Equal(t, int64(5), slashAmount.Int64())
ubd, found := keeper.GetUnbondingDelegation(ctx, addrDels[0], addrVals[0])
require.True(t, found)
@ -107,7 +107,7 @@ func TestSlashUnbondingDelegation(t *testing.T) {
// balance decreased
require.Equal(t, sdk.NewInt64Coin(params.BondDenom, 5), ubd.Balance)
newPool := keeper.GetPool(ctx)
require.Equal(t, int64(5), oldPool.LooseTokens.Sub(newPool.LooseTokens).RoundInt64())
require.Equal(t, int64(5), oldPool.LooseTokens.Sub(newPool.LooseTokens).Int64())
}
// tests slashRedelegation
@ -142,7 +142,7 @@ func TestSlashRedelegation(t *testing.T) {
validator, found := keeper.GetValidator(ctx, addrVals[1])
require.True(t, found)
slashAmount := keeper.slashRedelegation(ctx, validator, rd, 1, fraction)
require.Equal(t, int64(0), slashAmount.RoundInt64())
require.Equal(t, int64(0), slashAmount.Int64())
// after the expiration time, no longer eligible for slashing
ctx = ctx.WithBlockHeader(abci.Header{Time: time.Unix(10, 0)})
@ -150,7 +150,7 @@ func TestSlashRedelegation(t *testing.T) {
validator, found = keeper.GetValidator(ctx, addrVals[1])
require.True(t, found)
slashAmount = keeper.slashRedelegation(ctx, validator, rd, 0, fraction)
require.Equal(t, int64(0), slashAmount.RoundInt64())
require.Equal(t, int64(0), slashAmount.Int64())
// test valid slash, before expiration timestamp and to which stake contributed
oldPool := keeper.GetPool(ctx)
@ -159,7 +159,7 @@ func TestSlashRedelegation(t *testing.T) {
validator, found = keeper.GetValidator(ctx, addrVals[1])
require.True(t, found)
slashAmount = keeper.slashRedelegation(ctx, validator, rd, 0, fraction)
require.Equal(t, int64(5), slashAmount.RoundInt64())
require.Equal(t, int64(5), slashAmount.Int64())
rd, found = keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1])
require.True(t, found)
@ -180,7 +180,7 @@ func TestSlashRedelegation(t *testing.T) {
// pool bonded tokens decreased
newPool := keeper.GetPool(ctx)
require.Equal(t, int64(5), oldPool.BondedTokens.Sub(newPool.BondedTokens).RoundInt64())
require.Equal(t, int64(5), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
}
// tests Slash at a future height (must panic)
@ -214,9 +214,9 @@ func TestSlashAtNegativeHeight(t *testing.T) {
validator = keeper.mustGetValidator(ctx, validator.OperatorAddr)
// power decreased
require.Equal(t, sdk.NewDec(5), validator.GetPower())
require.True(sdk.IntEq(t, sdk.NewInt(5), validator.GetPower()))
// pool bonded shares decreased
require.Equal(t, sdk.NewDec(5).RoundInt64(), oldPool.BondedTokens.Sub(newPool.BondedTokens).RoundInt64())
require.Equal(t, int64(5), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
}
// tests Slash at the current height
@ -241,9 +241,9 @@ func TestSlashValidatorAtCurrentHeight(t *testing.T) {
validator = keeper.mustGetValidator(ctx, validator.OperatorAddr)
// power decreased
require.Equal(t, sdk.NewDec(5), validator.GetPower())
require.True(sdk.IntEq(t, sdk.NewInt(5), validator.GetPower()))
// pool bonded shares decreased
require.Equal(t, sdk.NewDec(5).RoundInt64(), oldPool.BondedTokens.Sub(newPool.BondedTokens).RoundInt64())
require.Equal(t, int64(5), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
}
// tests Slash at a previous height with an unbonding delegation
@ -283,7 +283,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
// read updated pool
newPool := keeper.GetPool(ctx)
// bonded tokens burned
require.Equal(t, int64(3), oldPool.BondedTokens.Sub(newPool.BondedTokens).RoundInt64())
require.Equal(t, int64(3), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
// read updated validator
validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
require.True(t, found)
@ -291,7 +291,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
// was still bonded at the time of discovery and was slashed by half, 4 stake
// bonded at the time of discovery hadn't been bonded at the time of infraction
// and wasn't slashed
require.Equal(t, sdk.NewDec(7), validator.GetPower())
require.True(sdk.IntEq(t, sdk.NewInt(7), validator.GetPower()))
// slash validator again
ctx = ctx.WithBlockHeight(13)
@ -303,12 +303,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).RoundInt64())
require.Equal(t, int64(6), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
// read updated validator
validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
require.True(t, found)
// power decreased by 3 again
require.Equal(t, sdk.NewDec(4), validator.GetPower())
require.True(sdk.IntEq(t, sdk.NewInt(4), validator.GetPower()))
// slash validator again
// all originally bonded stake has been slashed, so this will have no effect
@ -323,12 +323,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).RoundInt64())
require.Equal(t, int64(9), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
// read updated validator
validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
require.True(t, found)
// power decreased by 3 again
require.Equal(t, sdk.NewDec(1), validator.GetPower())
require.True(sdk.IntEq(t, sdk.NewInt(1), validator.GetPower()))
// slash validator again
// all originally bonded stake has been slashed, so this will have no effect
@ -343,7 +343,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).RoundInt64())
require.Equal(t, int64(10), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
// apply TM updates
keeper.ApplyAndReturnValidatorSetUpdates(ctx)
// read updated validator
@ -383,7 +383,7 @@ func TestSlashWithRedelegation(t *testing.T) {
// update bonded tokens
pool := keeper.GetPool(ctx)
pool.BondedTokens = pool.BondedTokens.Add(sdk.NewDec(6))
pool.BondedTokens = pool.BondedTokens.Add(sdk.NewInt(6))
keeper.SetPool(ctx, pool)
// slash validator
@ -401,7 +401,7 @@ func TestSlashWithRedelegation(t *testing.T) {
// read updated pool
newPool := keeper.GetPool(ctx)
// bonded tokens burned
require.Equal(t, int64(5), oldPool.BondedTokens.Sub(newPool.BondedTokens).RoundInt64())
require.Equal(t, int64(5), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
// read updated validator
validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
require.True(t, found)
@ -409,7 +409,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.Equal(t, sdk.NewDec(8), validator.GetPower())
require.True(sdk.IntEq(t, sdk.NewInt(8), validator.GetPower()))
// slash the validator again
ctx = ctx.WithBlockHeight(12)
@ -425,12 +425,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).RoundInt64())
require.Equal(t, int64(12), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
// read updated validator
validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
require.True(t, found)
// power decreased by 4
require.Equal(t, sdk.NewDec(4), validator.GetPower())
require.True(sdk.IntEq(t, sdk.NewInt(4), validator.GetPower()))
// slash the validator again, by 100%
ctx = ctx.WithBlockHeight(12)
@ -446,7 +446,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).RoundInt64())
require.Equal(t, int64(16), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
// apply TM updates
keeper.ApplyAndReturnValidatorSetUpdates(ctx)
// read updated validator
@ -470,7 +470,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).RoundInt64())
require.Equal(t, int64(16), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
// read updated validator
// power still zero, still in unbonding period
validator, _ = keeper.GetValidatorByConsAddr(ctx, consAddr)
@ -533,12 +533,12 @@ func TestSlashBoth(t *testing.T) {
// read updated pool
newPool := keeper.GetPool(ctx)
// loose tokens burned
require.Equal(t, int64(2), oldPool.LooseTokens.Sub(newPool.LooseTokens).RoundInt64())
require.Equal(t, int64(2), oldPool.LooseTokens.Sub(newPool.LooseTokens).Int64())
// bonded tokens burned
require.Equal(t, int64(3), oldPool.BondedTokens.Sub(newPool.BondedTokens).RoundInt64())
require.Equal(t, int64(3), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
// 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.Equal(t, sdk.NewDec(10), validator.GetPower())
require.True(sdk.IntEq(t, sdk.NewInt(10), validator.GetPower()))
}

2
x/stake/keeper/test_common.go
View File

@ -119,7 +119,7 @@ func CreateTestInput(t *testing.T, isCheckTx bool, initCoins int64) (sdk.Context
{keeper.BondDenom(ctx), sdk.NewInt(initCoins)},
})
require.Nil(t, err)
pool.LooseTokens = pool.LooseTokens.Add(sdk.NewDec(initCoins))
pool.LooseTokens = pool.LooseTokens.Add(sdk.NewInt(initCoins))
keeper.SetPool(ctx, pool)
}

5
x/stake/keeper/val_state_change.go
View File

@ -49,8 +49,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
// note: we must check the ABCI power, since we round before sending to Tendermint
if validator.Tokens.RoundInt64() == int64(0) {
if validator.Tokens.IsZero() {
break
}
@ -72,7 +71,7 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab
oldPowerBytes, found := last[valAddrBytes]
// calculate the new power bytes
newPower := validator.BondedTokens().RoundInt64()
newPower := validator.BondedTokens().Int64()
newPowerBytes := k.cdc.MustMarshalBinaryLengthPrefixed(sdk.NewInt(newPower))
// update the validator set if power has changed
if !found || !bytes.Equal(oldPowerBytes, newPowerBytes) {

19
x/stake/keeper/validator.go
View File

@ -132,7 +132,7 @@ func (k Keeper) AddValidatorTokensAndShares(ctx sdk.Context, validator types.Val
// Update the tokens of an existing validator, update the validators power index key
func (k Keeper) RemoveValidatorTokensAndShares(ctx sdk.Context, validator types.Validator,
sharesToRemove sdk.Dec) (valOut types.Validator, removedTokens sdk.Dec) {
sharesToRemove sdk.Dec) (valOut types.Validator, removedTokens sdk.Int) {
k.DeleteValidatorByPowerIndex(ctx, validator)
pool := k.GetPool(ctx)
@ -144,7 +144,8 @@ func (k Keeper) RemoveValidatorTokensAndShares(ctx sdk.Context, validator types.
}
// Update the tokens of an existing validator, update the validators power index key
func (k Keeper) RemoveValidatorTokens(ctx sdk.Context, validator types.Validator, tokensToRemove sdk.Dec) types.Validator {
func (k Keeper) RemoveValidatorTokens(ctx sdk.Context,
validator types.Validator, tokensToRemove sdk.Int) types.Validator {
k.DeleteValidatorByPowerIndex(ctx, validator)
pool := k.GetPool(ctx)
@ -157,7 +158,9 @@ func (k Keeper) RemoveValidatorTokens(ctx sdk.Context, validator types.Validator
// UpdateValidatorCommission attempts to update a validator's commission rate.
// An error is returned if the new commission rate is invalid.
func (k Keeper) UpdateValidatorCommission(ctx sdk.Context, validator types.Validator, newRate sdk.Dec) (types.Commission, sdk.Error) {
func (k Keeper) UpdateValidatorCommission(ctx sdk.Context,
validator types.Validator, newRate sdk.Dec) (types.Commission, sdk.Error) {
commission := validator.Commission
blockTime := ctx.BlockHeader().Time
@ -330,12 +333,13 @@ func (k Keeper) DeleteValidatorQueueTimeSlice(ctx sdk.Context, timestamp time.Ti
// Insert an validator address to the appropriate timeslice in the validator queue
func (k Keeper) InsertValidatorQueue(ctx sdk.Context, val types.Validator) {
timeSlice := k.GetValidatorQueueTimeSlice(ctx, val.UnbondingMinTime)
var keys []sdk.ValAddress
if len(timeSlice) == 0 {
k.SetValidatorQueueTimeSlice(ctx, val.UnbondingMinTime, []sdk.ValAddress{val.OperatorAddr})
keys = []sdk.ValAddress{val.OperatorAddr}
} else {
timeSlice = append(timeSlice, val.OperatorAddr)
k.SetValidatorQueueTimeSlice(ctx, val.UnbondingMinTime, timeSlice)
keys = append(timeSlice, val.OperatorAddr)
}
k.SetValidatorQueueTimeSlice(ctx, val.UnbondingMinTime, keys)
}
// Delete a validator address from the validator queue
@ -357,7 +361,8 @@ func (k Keeper) DeleteValidatorQueue(ctx sdk.Context, val types.Validator) {
// Returns all the validator queue timeslices from time 0 until endTime
func (k Keeper) ValidatorQueueIterator(ctx sdk.Context, endTime time.Time) sdk.Iterator {
store := ctx.KVStore(k.storeKey)
return store.Iterator(ValidatorQueueKey, sdk.InclusiveEndBytes(GetValidatorQueueTimeKey(endTime)))
return store.Iterator(ValidatorQueueKey,
sdk.InclusiveEndBytes(GetValidatorQueueTimeKey(endTime)))
}
// Returns a concatenated list of all the timeslices before currTime, and deletes the timeslices from the queue

90
x/stake/keeper/validator_test.go
View File

@ -27,7 +27,7 @@ func TestSetValidator(t *testing.T) {
validator := types.NewValidator(valAddr, valPubKey, types.Description{})
validator, pool, _ = validator.AddTokensFromDel(pool, sdk.NewInt(10))
require.Equal(t, sdk.Unbonded, validator.Status)
assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.Tokens))
assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.DelegatorShares))
keeper.SetPool(ctx, pool)
keeper.SetValidator(ctx, validator)
@ -42,7 +42,7 @@ func TestSetValidator(t *testing.T) {
// after the save the validator should be bonded
require.Equal(t, sdk.Bonded, validator.Status)
assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.Tokens))
assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.DelegatorShares))
// Check each store for being saved
@ -75,20 +75,20 @@ func TestUpdateValidatorByPowerIndex(t *testing.T) {
pool := keeper.GetPool(ctx)
// create a random pool
pool.LooseTokens = sdk.NewDec(10000)
pool.BondedTokens = sdk.NewDec(1234)
pool.LooseTokens = sdk.NewInt(10000)
pool.BondedTokens = sdk.NewInt(1234)
keeper.SetPool(ctx, pool)
// add a validator
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
validator, pool, delSharesCreated := validator.AddTokensFromDel(pool, sdk.NewInt(100))
require.Equal(t, sdk.Unbonded, validator.Status)
require.Equal(t, int64(100), validator.Tokens.RoundInt64())
require.Equal(t, int64(100), validator.Tokens.Int64())
keeper.SetPool(ctx, pool)
TestingUpdateValidator(keeper, ctx, validator, true)
validator, found := keeper.GetValidator(ctx, addrVals[0])
require.True(t, found)
require.Equal(t, int64(100), validator.Tokens.RoundInt64(), "\nvalidator %v\npool %v", validator, pool)
require.Equal(t, int64(100), validator.Tokens.Int64(), "\nvalidator %v\npool %v", validator, pool)
pool = keeper.GetPool(ctx)
power := GetValidatorsByPowerIndexKey(validator)
@ -97,7 +97,7 @@ func TestUpdateValidatorByPowerIndex(t *testing.T) {
// burn half the delegator shares
keeper.DeleteValidatorByPowerIndex(ctx, validator)
validator, pool, burned := validator.RemoveDelShares(pool, delSharesCreated.Quo(sdk.NewDec(2)))
require.Equal(t, int64(50), burned.RoundInt64())
require.Equal(t, int64(50), burned.Int64())
keeper.SetPool(ctx, pool) // update the pool
TestingUpdateValidator(keeper, ctx, validator, true) // update the validator, possibly kicking it out
require.False(t, validatorByPowerIndexExists(keeper, ctx, power))
@ -123,8 +123,8 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
keeper.SetParams(ctx, params)
// create a random pool
pool.LooseTokens = sdk.NewDec(10000)
pool.BondedTokens = sdk.NewDec(1234)
pool.LooseTokens = sdk.NewInt(10000)
pool.BondedTokens = sdk.NewInt(1234)
keeper.SetPool(ctx, pool)
validators := make([]types.Validator, numVals)
@ -175,11 +175,11 @@ func TestSlashToZeroPowerRemoved(t *testing.T) {
validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
validator, pool, _ = validator.AddTokensFromDel(pool, sdk.NewInt(100))
require.Equal(t, sdk.Unbonded, validator.Status)
require.Equal(t, int64(100), validator.Tokens.RoundInt64())
require.Equal(t, int64(100), validator.Tokens.Int64())
keeper.SetPool(ctx, pool)
keeper.SetValidatorByConsAddr(ctx, validator)
validator = TestingUpdateValidator(keeper, ctx, validator, true)
require.Equal(t, int64(100), validator.Tokens.RoundInt64(), "\nvalidator %v\npool %v", validator, pool)
require.Equal(t, int64(100), validator.Tokens.Int64(), "\nvalidator %v\npool %v", validator, pool)
// slash the validator by 100%
consAddr0 := sdk.ConsAddress(PKs[0].Address())
@ -202,13 +202,13 @@ func TestValidatorBasics(t *testing.T) {
for i, amt := range amts {
validators[i] = types.NewValidator(addrVals[i], PKs[i], types.Description{})
validators[i].Status = sdk.Unbonded
validators[i].Tokens = sdk.ZeroDec()
validators[i].Tokens = sdk.ZeroInt()
validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
keeper.SetPool(ctx, pool)
}
assert.True(sdk.DecEq(t, sdk.NewDec(9), validators[0].Tokens))
assert.True(sdk.DecEq(t, sdk.NewDec(8), validators[1].Tokens))
assert.True(sdk.DecEq(t, sdk.NewDec(7), validators[2].Tokens))
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))
// check the empty keeper first
_, found := keeper.GetValidator(ctx, addrVals[0])
@ -220,7 +220,7 @@ func TestValidatorBasics(t *testing.T) {
require.Zero(t, len(resVals))
pool = keeper.GetPool(ctx)
assert.True(sdk.DecEq(t, sdk.ZeroDec(), pool.BondedTokens))
assert.True(sdk.IntEq(t, sdk.ZeroInt(), pool.BondedTokens))
// set and retrieve a record
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true)
@ -241,14 +241,14 @@ 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.DecEq(t, sdk.NewDec(9), validators[0].BondedTokens()))
assert.True(sdk.IntEq(t, sdk.NewInt(9), validators[0].BondedTokens()))
pool = keeper.GetPool(ctx)
assert.True(sdk.DecEq(t, pool.BondedTokens, validators[0].BondedTokens()))
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.NewDec(10)
validators[0].Tokens = sdk.NewInt(10)
validators[0].DelegatorShares = sdk.NewDec(10)
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true)
resVal, found = keeper.GetValidator(ctx, addrVals[0])
@ -294,7 +294,7 @@ func GetValidatorSortingUnmixed(t *testing.T) {
for i, amt := range amts {
validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
validators[i].Status = sdk.Bonded
validators[i].Tokens = sdk.NewDec(amt)
validators[i].Tokens = sdk.NewInt(amt)
validators[i].DelegatorShares = sdk.NewDec(amt)
TestingUpdateValidator(keeper, ctx, validators[i], true)
}
@ -302,11 +302,11 @@ func GetValidatorSortingUnmixed(t *testing.T) {
// first make sure everything made it in to the gotValidator group
resValidators := keeper.GetBondedValidatorsByPower(ctx)
assert.Equal(t, n, len(resValidators))
assert.Equal(t, sdk.NewDec(400), resValidators[0].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewDec(200), resValidators[1].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewDec(100), resValidators[2].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewDec(1), resValidators[3].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewDec(0), resValidators[4].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(400), resValidators[0].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(200), resValidators[1].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(100), resValidators[2].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(1), resValidators[3].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(0), resValidators[4].BondedTokens(), "%v", resValidators)
assert.Equal(t, validators[3].OperatorAddr, resValidators[0].OperatorAddr, "%v", resValidators)
assert.Equal(t, validators[4].OperatorAddr, resValidators[1].OperatorAddr, "%v", resValidators)
assert.Equal(t, validators[1].OperatorAddr, resValidators[2].OperatorAddr, "%v", resValidators)
@ -314,14 +314,14 @@ func GetValidatorSortingUnmixed(t *testing.T) {
assert.Equal(t, validators[0].OperatorAddr, resValidators[4].OperatorAddr, "%v", resValidators)
// test a basic increase in voting power
validators[3].Tokens = sdk.NewDec(500)
validators[3].Tokens = sdk.NewInt(500)
TestingUpdateValidator(keeper, ctx, validators[3], true)
resValidators = keeper.GetBondedValidatorsByPower(ctx)
require.Equal(t, len(resValidators), n)
assert.True(ValEq(t, validators[3], resValidators[0]))
// test a decrease in voting power
validators[3].Tokens = sdk.NewDec(300)
validators[3].Tokens = sdk.NewInt(300)
TestingUpdateValidator(keeper, ctx, validators[3], true)
resValidators = keeper.GetBondedValidatorsByPower(ctx)
require.Equal(t, len(resValidators), n)
@ -329,7 +329,7 @@ func GetValidatorSortingUnmixed(t *testing.T) {
assert.True(ValEq(t, validators[4], resValidators[1]))
// test equal voting power, different age
validators[3].Tokens = sdk.NewDec(200)
validators[3].Tokens = sdk.NewInt(200)
ctx = ctx.WithBlockHeight(10)
TestingUpdateValidator(keeper, ctx, validators[3], true)
resValidators = keeper.GetBondedValidatorsByPower(ctx)
@ -348,8 +348,8 @@ func GetValidatorSortingUnmixed(t *testing.T) {
assert.True(ValEq(t, validators[4], resValidators[1]))
// change in voting power of both validators, both still in v-set, no age change
validators[3].Tokens = sdk.NewDec(300)
validators[4].Tokens = sdk.NewDec(300)
validators[3].Tokens = sdk.NewInt(300)
validators[4].Tokens = sdk.NewInt(300)
TestingUpdateValidator(keeper, ctx, validators[3], true)
resValidators = keeper.GetBondedValidatorsByPower(ctx)
require.Equal(t, len(resValidators), n)
@ -382,14 +382,14 @@ func GetValidatorSortingMixed(t *testing.T) {
validators[0].Status = sdk.Bonded
validators[1].Status = sdk.Bonded
validators[2].Status = sdk.Bonded
validators[0].Tokens = sdk.NewDec(amts[0])
validators[1].Tokens = sdk.NewDec(amts[1])
validators[2].Tokens = sdk.NewDec(amts[2])
validators[0].Tokens = sdk.NewInt(amts[0])
validators[1].Tokens = sdk.NewInt(amts[1])
validators[2].Tokens = sdk.NewInt(amts[2])
validators[3].Status = sdk.Bonded
validators[4].Status = sdk.Bonded
validators[3].Tokens = sdk.NewDec(amts[3])
validators[4].Tokens = sdk.NewDec(amts[4])
validators[3].Tokens = sdk.NewInt(amts[3])
validators[4].Tokens = sdk.NewInt(amts[4])
for i := range amts {
TestingUpdateValidator(keeper, ctx, validators[i], true)
@ -413,11 +413,11 @@ func GetValidatorSortingMixed(t *testing.T) {
// first make sure everything made it in to the gotValidator group
resValidators := keeper.GetBondedValidatorsByPower(ctx)
assert.Equal(t, n, len(resValidators))
assert.Equal(t, sdk.NewDec(400), resValidators[0].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewDec(200), resValidators[1].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewDec(100), resValidators[2].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewDec(1), resValidators[3].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewDec(0), resValidators[4].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(400), resValidators[0].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(200), resValidators[1].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(100), resValidators[2].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(1), resValidators[3].BondedTokens(), "%v", resValidators)
assert.Equal(t, sdk.NewInt(0), resValidators[4].BondedTokens(), "%v", resValidators)
assert.Equal(t, validators[3].OperatorAddr, resValidators[0].OperatorAddr, "%v", resValidators)
assert.Equal(t, validators[4].OperatorAddr, resValidators[1].OperatorAddr, "%v", resValidators)
assert.Equal(t, validators[1].OperatorAddr, resValidators[2].OperatorAddr, "%v", resValidators)
@ -672,7 +672,7 @@ func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) {
// test single value change
// tendermintUpdate set: {} -> {c1'}
validators[0].Status = sdk.Bonded
validators[0].Tokens = sdk.NewDec(600)
validators[0].Tokens = sdk.NewInt(600)
validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx)
@ -810,8 +810,8 @@ func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
require.Equal(t, 2, len(keeper.ApplyAndReturnValidatorSetUpdates(ctx)))
// check initial power
require.Equal(t, sdk.NewDec(100).RoundInt64(), validators[0].GetPower().RoundInt64())
require.Equal(t, sdk.NewDec(100).RoundInt64(), validators[1].GetPower().RoundInt64())
require.Equal(t, int64(100), validators[0].GetPower().Int64())
require.Equal(t, int64(100), validators[1].GetPower().Int64())
// test multiple value change
// tendermintUpdate set: {c1, c3} -> {c1', c3'}
@ -823,8 +823,8 @@ func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], false)
// power has changed
require.Equal(t, sdk.NewDec(80).RoundInt64(), validators[0].GetPower().RoundInt64())
require.Equal(t, sdk.NewDec(70).RoundInt64(), validators[1].GetPower().RoundInt64())
require.Equal(t, int64(80), validators[0].GetPower().Int64())
require.Equal(t, int64(70), validators[1].GetPower().Int64())
// Tendermint updates should reflect power change
updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx)

24
x/stake/simulation/invariants.go
View File

@ -65,11 +65,9 @@ func SupplyInvariants(ck bank.Keeper, k stake.Keeper,
k.IterateValidators(ctx, func(_ int64, validator sdk.Validator) bool {
switch validator.GetStatus() {
case sdk.Bonded:
bonded = bonded.Add(validator.GetPower())
case sdk.Unbonding:
loose = loose.Add(validator.GetTokens())
case sdk.Unbonded:
loose = loose.Add(validator.GetTokens())
bonded = bonded.Add(sdk.NewDecFromInt(validator.GetPower()))
case sdk.Unbonding, sdk.Unbonded:
loose = loose.Add(sdk.NewDecFromInt(validator.GetTokens()))
}
return false
})
@ -96,15 +94,17 @@ func SupplyInvariants(ck bank.Keeper, k stake.Keeper,
// Loose tokens should equal coin supply plus unbonding delegations
// plus tokens on unbonded validators
if !pool.LooseTokens.Equal(loose) {
return fmt.Errorf("loose token invariance:\n\tpool.LooseTokens: %v"+
"\n\tsum of account tokens: %v", pool.LooseTokens, loose)
if !sdk.NewDecFromInt(pool.LooseTokens).Equal(loose) {
return fmt.Errorf("loose token invariance:\n"+
"\tpool.LooseTokens: %v\n"+
"\tsum of account tokens: %v", pool.LooseTokens, loose)
}
// Bonded tokens should equal sum of tokens with bonded validators
if !pool.BondedTokens.Equal(bonded) {
return fmt.Errorf("bonded token invariance:\n\tpool.BondedTokens: %v"+
"\n\tsum of account tokens: %v", pool.BondedTokens, bonded)
if !sdk.NewDecFromInt(pool.BondedTokens).Equal(bonded) {
return fmt.Errorf("bonded token invariance:\n"+
"\tpool.BondedTokens: %v\n"+
"\tsum of account tokens: %v", pool.BondedTokens, bonded)
}
return nil
@ -129,7 +129,7 @@ func NonNegativePowerInvariant(k stake.Keeper) simulation.Invariant {
"\n\tkey should be: %v\n\tkey in store: %v", validator.GetPower(), powerKey, iterator.Key())
}
if validator.Tokens.LT(sdk.ZeroDec()) {
if validator.Tokens.IsNegative() {
return fmt.Errorf("negative tokens for validator: %v", validator)
}
}

23
x/stake/types/pool.go
View File

@ -10,8 +10,8 @@ import (
// Pool - dynamic parameters of the current state
type Pool struct {
LooseTokens sdk.Dec `json:"loose_tokens"` // tokens which are not bonded in a validator
BondedTokens sdk.Dec `json:"bonded_tokens"` // reserve of bonded tokens
LooseTokens sdk.Int `json:"loose_tokens"` // tokens which are not bonded in a validator
BondedTokens sdk.Int `json:"bonded_tokens"` // reserve of bonded tokens
}
// nolint
@ -24,15 +24,15 @@ func (p Pool) Equal(p2 Pool) bool {
// initial pool for testing
func InitialPool() Pool {
return Pool{
LooseTokens: sdk.ZeroDec(),
BondedTokens: sdk.ZeroDec(),
LooseTokens: sdk.ZeroInt(),
BondedTokens: sdk.ZeroInt(),
}
}
//____________________________________________________________________
// Sum total of all staking tokens in the pool
func (p Pool) TokenSupply() sdk.Dec {
func (p Pool) TokenSupply() sdk.Int {
return p.LooseTokens.Add(p.BondedTokens)
}
@ -41,27 +41,28 @@ func (p Pool) TokenSupply() sdk.Dec {
// get the bond ratio of the global state
func (p Pool) BondedRatio() sdk.Dec {
supply := p.TokenSupply()
if supply.GT(sdk.ZeroDec()) {
return p.BondedTokens.Quo(supply)
if supply.IsPositive() {
return sdk.NewDecFromInt(p.BondedTokens).
QuoInt(supply)
}
return sdk.ZeroDec()
}
//_______________________________________________________________________
func (p Pool) looseTokensToBonded(bondedTokens sdk.Dec) Pool {
func (p Pool) looseTokensToBonded(bondedTokens sdk.Int) Pool {
p.BondedTokens = p.BondedTokens.Add(bondedTokens)
p.LooseTokens = p.LooseTokens.Sub(bondedTokens)
if p.LooseTokens.LT(sdk.ZeroDec()) {
if p.LooseTokens.IsNegative() {
panic(fmt.Sprintf("sanity check: loose tokens negative, pool: %v", p))
}
return p
}
func (p Pool) bondedTokensToLoose(bondedTokens sdk.Dec) Pool {
func (p Pool) bondedTokensToLoose(bondedTokens sdk.Int) Pool {
p.BondedTokens = p.BondedTokens.Sub(bondedTokens)
p.LooseTokens = p.LooseTokens.Add(bondedTokens)
if p.BondedTokens.LT(sdk.ZeroDec()) {
if p.BondedTokens.IsNegative() {
panic(fmt.Sprintf("sanity check: bonded tokens negative, pool: %v", p))
}
return p

22
x/stake/types/pool_test.go
View File

@ -12,28 +12,28 @@ func TestPoolEqual(t *testing.T) {
p1 := InitialPool()
p2 := InitialPool()
require.True(t, p1.Equal(p2))
p2.BondedTokens = sdk.NewDec(3)
p2.BondedTokens = sdk.NewInt(3)
require.False(t, p1.Equal(p2))
}
func TestAddBondedTokens(t *testing.T) {
pool := InitialPool()
pool.LooseTokens = sdk.NewDec(10)
pool.BondedTokens = sdk.NewDec(10)
pool.LooseTokens = sdk.NewInt(10)
pool.BondedTokens = sdk.NewInt(10)
pool = pool.looseTokensToBonded(sdk.NewDec(10))
pool = pool.looseTokensToBonded(sdk.NewInt(10))
require.True(sdk.DecEq(t, sdk.NewDec(20), pool.BondedTokens))
require.True(sdk.DecEq(t, sdk.NewDec(0), pool.LooseTokens))
require.True(sdk.IntEq(t, sdk.NewInt(20), pool.BondedTokens))
require.True(sdk.IntEq(t, sdk.NewInt(0), pool.LooseTokens))
}
func TestRemoveBondedTokens(t *testing.T) {
pool := InitialPool()
pool.LooseTokens = sdk.NewDec(10)
pool.BondedTokens = sdk.NewDec(10)
pool.LooseTokens = sdk.NewInt(10)
pool.BondedTokens = sdk.NewInt(10)
pool = pool.bondedTokensToLoose(sdk.NewDec(5))
pool = pool.bondedTokensToLoose(sdk.NewInt(5))
require.True(sdk.DecEq(t, sdk.NewDec(5), pool.BondedTokens))
require.True(sdk.DecEq(t, sdk.NewDec(15), pool.LooseTokens))
require.True(sdk.IntEq(t, sdk.NewInt(5), pool.BondedTokens))
require.True(sdk.IntEq(t, sdk.NewInt(15), pool.LooseTokens))
}

73
x/stake/types/validator.go
View File

@ -26,7 +26,7 @@ type Validator struct {
Jailed bool `json:"jailed"` // has the validator been jailed from bonded status?
Status sdk.BondStatus `json:"status"` // validator status (bonded/unbonding/unbonded)
Tokens sdk.Dec `json:"tokens"` // delegated tokens (incl. self-delegation)
Tokens sdk.Int `json:"tokens"` // delegated tokens (incl. self-delegation)
DelegatorShares sdk.Dec `json:"delegator_shares"` // total shares issued to a validator's delegators
Description Description `json:"description"` // description terms for the validator
@ -45,7 +45,7 @@ func NewValidator(operator sdk.ValAddress, pubKey crypto.PubKey, description Des
ConsPubKey: pubKey,
Jailed: false,
Status: sdk.Unbonded,
Tokens: sdk.ZeroDec(),
Tokens: sdk.ZeroInt(),
DelegatorShares: sdk.ZeroDec(),
Description: description,
BondHeight: int64(0),
@ -60,7 +60,7 @@ type validatorValue struct {
ConsPubKey crypto.PubKey
Jailed bool
Status sdk.BondStatus
Tokens sdk.Dec
Tokens sdk.Int
DelegatorShares sdk.Dec
Description Description
BondHeight int64
@ -137,7 +137,7 @@ func (v Validator) HumanReadableString() (string, error) {
resp += fmt.Sprintf("Jailed: %v\n", v.Jailed)
resp += fmt.Sprintf("Status: %s\n", sdk.BondStatusToString(v.Status))
resp += fmt.Sprintf("Tokens: %s\n", v.Tokens)
resp += fmt.Sprintf("Delegator Shares: %s\n", v.DelegatorShares)
resp += fmt.Sprintf("Delegator Shares: %s\n", v.DelegatorShares.String())
resp += fmt.Sprintf("Description: %s\n", v.Description)
resp += fmt.Sprintf("Bond Height: %d\n", v.BondHeight)
resp += fmt.Sprintf("Unbonding Height: %d\n", v.UnbondingHeight)
@ -156,7 +156,7 @@ type bechValidator struct {
Jailed bool `json:"jailed"` // has the validator been jailed from bonded status?
Status sdk.BondStatus `json:"status"` // validator status (bonded/unbonding/unbonded)
Tokens sdk.Dec `json:"tokens"` // delegated tokens (incl. self-delegation)
Tokens sdk.Int `json:"tokens"` // delegated tokens (incl. self-delegation)
DelegatorShares sdk.Dec `json:"delegator_shares"` // total shares issued to a validator's delegators
Description Description `json:"description"` // description terms for the validator
@ -302,7 +302,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().RoundInt64(),
Power: v.BondedTokens().Int64(),
}
}
@ -351,7 +351,7 @@ func (v Validator) UpdateStatus(pool Pool, NewStatus sdk.BondStatus) (Validator,
}
// removes tokens from a validator
func (v Validator) RemoveTokens(pool Pool, tokens sdk.Dec) (Validator, Pool) {
func (v Validator) RemoveTokens(pool Pool, tokens sdk.Int) (Validator, Pool) {
if tokens.IsNegative() {
panic(fmt.Sprintf("should not happen: trying to remove negative tokens %v", tokens))
}
@ -383,29 +383,50 @@ func (v Validator) AddTokensFromDel(pool Pool, amount sdk.Int) (Validator, Pool,
// bondedShare/delegatedShare
exRate := v.DelegatorShareExRate()
amountDec := sdk.NewDecFromInt(amount)
if v.Status == sdk.Bonded {
pool = pool.looseTokensToBonded(amountDec)
}
if exRate.IsZero() {
panic("zero exRate should not happen")
}
v.Tokens = v.Tokens.Add(amountDec)
issuedShares := amountDec.Quo(exRate)
if v.Status == sdk.Bonded {
pool = pool.looseTokensToBonded(amount)
}
v.Tokens = v.Tokens.Add(amount)
issuedShares := sdk.NewDecFromInt(amount).Quo(exRate)
v.DelegatorShares = v.DelegatorShares.Add(issuedShares)
return v, pool, issuedShares
}
// RemoveDelShares removes delegator shares from a validator.
func (v Validator) RemoveDelShares(pool Pool, delShares sdk.Dec) (Validator, Pool, sdk.Dec) {
delTokens := v.DelegatorShareExRate().Mul(delShares)
delTokens = sdk.MinDec(delTokens, v.Tokens)
v, pool = v.RemoveTokens(pool, delTokens)
v.DelegatorShares = v.DelegatorShares.Sub(delShares)
return v, pool, delTokens
// NOTE: because token fractions are left in the valiadator,
// the exchange rate of future shares of this validator can increase.
func (v Validator) RemoveDelShares(pool Pool, delShares sdk.Dec) (Validator, Pool, sdk.Int) {
remainingShares := v.DelegatorShares.Sub(delShares)
var issuedTokens sdk.Int
if remainingShares.IsZero() {
// last delegation share gets any trimmings
issuedTokens = v.Tokens
v.Tokens = sdk.ZeroInt()
} else {
// leave excess tokens in the validator
// however fully use all the delegator shares
issuedTokens = v.DelegatorShareExRate().Mul(delShares).TruncateInt()
v.Tokens = v.Tokens.Sub(issuedTokens)
if v.Tokens.IsNegative() {
panic("attempting to remove more tokens than available in validator")
}
}
v.DelegatorShares = remainingShares
if v.Status == sdk.Bonded {
pool = pool.bondedTokensToLoose(issuedTokens)
}
return v, pool, issuedTokens
}
// DelegatorShareExRate gets the exchange rate of tokens over delegator shares.
@ -414,15 +435,15 @@ func (v Validator) DelegatorShareExRate() sdk.Dec {
if v.DelegatorShares.IsZero() {
return sdk.OneDec()
}
return v.Tokens.Quo(v.DelegatorShares)
return sdk.NewDecFromInt(v.Tokens).Quo(v.DelegatorShares)
}
// Get the bonded tokens which the validator holds
func (v Validator) BondedTokens() sdk.Dec {
func (v Validator) BondedTokens() sdk.Int {
if v.Status == sdk.Bonded {
return v.Tokens
}
return sdk.ZeroDec()
return sdk.ZeroInt()
}
//______________________________________________________________________
@ -437,8 +458,8 @@ 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.Dec { return v.BondedTokens() }
func (v Validator) GetTokens() sdk.Dec { return v.Tokens }
func (v Validator) GetPower() sdk.Int { return v.BondedTokens() }
func (v Validator) GetTokens() sdk.Int { return v.Tokens }
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 }

91
x/stake/types/validator_test.go
View File

@ -59,7 +59,7 @@ func TestABCIValidatorUpdate(t *testing.T) {
abciVal := validator.ABCIValidatorUpdate()
require.Equal(t, tmtypes.TM2PB.PubKey(validator.ConsPubKey), abciVal.PubKey)
require.Equal(t, validator.BondedTokens().RoundInt64(), abciVal.Power)
require.Equal(t, validator.BondedTokens().Int64(), abciVal.Power)
}
func TestABCIValidatorUpdateZero(t *testing.T) {
@ -76,38 +76,38 @@ func TestRemoveTokens(t *testing.T) {
OperatorAddr: addr1,
ConsPubKey: pk1,
Status: sdk.Bonded,
Tokens: sdk.NewDec(100),
Tokens: sdk.NewInt(100),
DelegatorShares: sdk.NewDec(100),
}
pool := InitialPool()
pool.LooseTokens = sdk.NewDec(10)
pool.LooseTokens = sdk.NewInt(10)
pool.BondedTokens = validator.BondedTokens()
validator, pool = validator.UpdateStatus(pool, sdk.Bonded)
require.Equal(t, sdk.Bonded, validator.Status)
// remove tokens and test check everything
validator, pool = validator.RemoveTokens(pool, sdk.NewDec(10))
require.Equal(t, int64(90), validator.Tokens.RoundInt64())
require.Equal(t, int64(90), pool.BondedTokens.RoundInt64())
require.Equal(t, int64(20), pool.LooseTokens.RoundInt64())
validator, pool = validator.RemoveTokens(pool, sdk.NewInt(10))
require.Equal(t, int64(90), validator.Tokens.Int64())
require.Equal(t, int64(90), pool.BondedTokens.Int64())
require.Equal(t, int64(20), pool.LooseTokens.Int64())
// update validator to unbonded and remove some more tokens
validator, pool = validator.UpdateStatus(pool, sdk.Unbonded)
require.Equal(t, sdk.Unbonded, validator.Status)
require.Equal(t, int64(0), pool.BondedTokens.RoundInt64())
require.Equal(t, int64(110), pool.LooseTokens.RoundInt64())
require.Equal(t, int64(0), pool.BondedTokens.Int64())
require.Equal(t, int64(110), pool.LooseTokens.Int64())
validator, pool = validator.RemoveTokens(pool, sdk.NewDec(10))
require.Equal(t, int64(80), validator.Tokens.RoundInt64())
require.Equal(t, int64(0), pool.BondedTokens.RoundInt64())
require.Equal(t, int64(110), pool.LooseTokens.RoundInt64())
validator, pool = validator.RemoveTokens(pool, sdk.NewInt(10))
require.Equal(t, int64(80), validator.Tokens.Int64())
require.Equal(t, int64(0), pool.BondedTokens.Int64())
require.Equal(t, int64(110), pool.LooseTokens.Int64())
}
func TestAddTokensValidatorBonded(t *testing.T) {
pool := InitialPool()
pool.LooseTokens = sdk.NewDec(10)
pool.LooseTokens = sdk.NewInt(10)
validator := NewValidator(addr1, pk1, Description{})
validator, pool = validator.UpdateStatus(pool, sdk.Bonded)
validator, pool, delShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
@ -115,12 +115,12 @@ func TestAddTokensValidatorBonded(t *testing.T) {
require.Equal(t, sdk.OneDec(), validator.DelegatorShareExRate())
assert.True(sdk.DecEq(t, sdk.NewDec(10), delShares))
assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.BondedTokens()))
assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.BondedTokens()))
}
func TestAddTokensValidatorUnbonding(t *testing.T) {
pool := InitialPool()
pool.LooseTokens = sdk.NewDec(10)
pool.LooseTokens = sdk.NewInt(10)
validator := NewValidator(addr1, pk1, Description{})
validator, pool = validator.UpdateStatus(pool, sdk.Unbonding)
validator, pool, delShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
@ -129,12 +129,12 @@ func TestAddTokensValidatorUnbonding(t *testing.T) {
assert.True(sdk.DecEq(t, sdk.NewDec(10), delShares))
assert.Equal(t, sdk.Unbonding, validator.Status)
assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.Tokens))
assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
}
func TestAddTokensValidatorUnbonded(t *testing.T) {
pool := InitialPool()
pool.LooseTokens = sdk.NewDec(10)
pool.LooseTokens = sdk.NewInt(10)
validator := NewValidator(addr1, pk1, Description{})
validator, pool = validator.UpdateStatus(pool, sdk.Unbonded)
validator, pool, delShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
@ -143,7 +143,7 @@ func TestAddTokensValidatorUnbonded(t *testing.T) {
assert.True(sdk.DecEq(t, sdk.NewDec(10), delShares))
assert.Equal(t, sdk.Unbonded, validator.Status)
assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.Tokens))
assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
}
// TODO refactor to make simpler like the AddToken tests above
@ -152,29 +152,29 @@ func TestRemoveDelShares(t *testing.T) {
OperatorAddr: addr1,
ConsPubKey: pk1,
Status: sdk.Bonded,
Tokens: sdk.NewDec(100),
Tokens: sdk.NewInt(100),
DelegatorShares: sdk.NewDec(100),
}
poolA := InitialPool()
poolA.LooseTokens = sdk.NewDec(10)
poolA.LooseTokens = sdk.NewInt(10)
poolA.BondedTokens = valA.BondedTokens()
require.Equal(t, valA.DelegatorShareExRate(), sdk.OneDec())
// Remove delegator shares
valB, poolB, coinsB := valA.RemoveDelShares(poolA, sdk.NewDec(10))
assert.Equal(t, int64(10), coinsB.RoundInt64())
assert.Equal(t, int64(90), valB.DelegatorShares.RoundInt64())
assert.Equal(t, int64(90), valB.BondedTokens().RoundInt64())
assert.Equal(t, int64(90), poolB.BondedTokens.RoundInt64())
assert.Equal(t, int64(20), poolB.LooseTokens.RoundInt64())
require.Equal(t, int64(10), coinsB.Int64())
require.Equal(t, int64(90), valB.DelegatorShares.RoundInt64())
require.Equal(t, int64(90), valB.BondedTokens().Int64())
require.Equal(t, int64(90), poolB.BondedTokens.Int64())
require.Equal(t, int64(20), poolB.LooseTokens.Int64())
// conservation of tokens
require.True(sdk.DecEq(t,
require.True(sdk.IntEq(t,
poolB.LooseTokens.Add(poolB.BondedTokens),
poolA.LooseTokens.Add(poolA.BondedTokens)))
// specific case from random tests
poolTokens := sdk.NewDec(5102)
poolTokens := sdk.NewInt(5102)
delShares := sdk.NewDec(115)
validator := Validator{
OperatorAddr: addr1,
@ -184,48 +184,45 @@ func TestRemoveDelShares(t *testing.T) {
DelegatorShares: delShares,
}
pool := Pool{
BondedTokens: sdk.NewDec(248305),
LooseTokens: sdk.NewDec(232147),
BondedTokens: sdk.NewInt(248305),
LooseTokens: sdk.NewInt(232147),
}
shares := sdk.NewDec(29)
_, newPool, tokens := validator.RemoveDelShares(pool, shares)
exp, err := sdk.NewDecFromStr("1286.5913043477")
require.NoError(t, err)
require.True(sdk.IntEq(t, sdk.NewInt(1286), tokens))
require.True(sdk.DecEq(t, exp, tokens))
require.True(sdk.DecEq(t,
require.True(sdk.IntEq(t,
newPool.LooseTokens.Add(newPool.BondedTokens),
pool.LooseTokens.Add(pool.BondedTokens)))
}
func TestUpdateStatus(t *testing.T) {
pool := InitialPool()
pool.LooseTokens = sdk.NewDec(100)
pool.LooseTokens = sdk.NewInt(100)
validator := NewValidator(addr1, pk1, Description{})
validator, pool, _ = validator.AddTokensFromDel(pool, sdk.NewInt(100))
require.Equal(t, sdk.Unbonded, validator.Status)
require.Equal(t, int64(100), validator.Tokens.RoundInt64())
require.Equal(t, int64(0), pool.BondedTokens.RoundInt64())
require.Equal(t, int64(100), pool.LooseTokens.RoundInt64())
require.Equal(t, int64(100), validator.Tokens.Int64())
require.Equal(t, int64(0), pool.BondedTokens.Int64())
require.Equal(t, int64(100), pool.LooseTokens.Int64())
validator, pool = validator.UpdateStatus(pool, sdk.Bonded)
require.Equal(t, sdk.Bonded, validator.Status)
require.Equal(t, int64(100), validator.Tokens.RoundInt64())
require.Equal(t, int64(100), pool.BondedTokens.RoundInt64())
require.Equal(t, int64(0), pool.LooseTokens.RoundInt64())
require.Equal(t, int64(100), validator.Tokens.Int64())
require.Equal(t, int64(100), pool.BondedTokens.Int64())
require.Equal(t, int64(0), pool.LooseTokens.Int64())
validator, pool = validator.UpdateStatus(pool, sdk.Unbonding)
require.Equal(t, sdk.Unbonding, validator.Status)
require.Equal(t, int64(100), validator.Tokens.RoundInt64())
require.Equal(t, int64(0), pool.BondedTokens.RoundInt64())
require.Equal(t, int64(100), pool.LooseTokens.RoundInt64())
require.Equal(t, int64(100), validator.Tokens.Int64())
require.Equal(t, int64(0), pool.BondedTokens.Int64())
require.Equal(t, int64(100), pool.LooseTokens.Int64())
}
func TestPossibleOverflow(t *testing.T) {
poolTokens := sdk.NewDec(2159)
poolTokens := sdk.NewInt(2159)
delShares := sdk.NewDec(391432570689183511).Quo(sdk.NewDec(40113011844664))
validator := Validator{
OperatorAddr: addr1,
@ -235,7 +232,7 @@ func TestPossibleOverflow(t *testing.T) {
DelegatorShares: delShares,
}
pool := Pool{
LooseTokens: sdk.NewDec(100),
LooseTokens: sdk.NewInt(100),
BondedTokens: poolTokens,
}
tokens := int64(71)