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

test compile fixes for poolshares

This commit is contained in:
rigelrozanski 2018-05-15 23:59:27 -04:00
parent 1ab432a7e1
commit 423917f352
7 changed files with 105 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -409,7 +409,7 @@ func TestStakeMsgs(t *testing.T) {
require.True(t, found)
require.Equal(t, addr1, validator.Address)
require.Equal(t, sdk.Bonded, validator.Status)
require.True(sdk.RatEq(t, sdk.NewRat(10), validator.BondedShares))
require.True(sdk.RatEq(t, sdk.NewRat(10), validator.PShares.Bonded()))
// check the bond that should have been created as well
bond, found := gapp.stakeKeeper.GetDelegation(ctxDeliver, addr1, addr1)

19
x/stake/handler.go
View File

@ -118,38 +118,26 @@ func handleMsgEditCandidacy(ctx sdk.Context, msg MsgEditCandidacy, k Keeper) sdk
}
func handleMsgDelegate(ctx sdk.Context, msg MsgDelegate, k Keeper) sdk.Result {
fmt.Println("wackydebugoutput handleMsgDelegate 0")
validator, found := k.GetValidator(ctx, msg.ValidatorAddr)
if !found {
fmt.Println("wackydebugoutput handleMsgDelegate 1")
return ErrBadValidatorAddr(k.codespace).Result()
}
fmt.Println("wackydebugoutput handleMsgDelegate 2")
if msg.Bond.Denom != k.GetParams(ctx).BondDenom {
fmt.Println("wackydebugoutput handleMsgDelegate 3")
return ErrBadBondingDenom(k.codespace).Result()
}
fmt.Println("wackydebugoutput handleMsgDelegate 4")
if validator.Status == sdk.Revoked {
fmt.Println("wackydebugoutput handleMsgDelegate 5")
return ErrValidatorRevoked(k.codespace).Result()
}
fmt.Println("wackydebugoutput handleMsgDelegate 6")
if ctx.IsCheckTx() {
fmt.Println("wackydebugoutput handleMsgDelegate 7")
return sdk.Result{
GasUsed: GasDelegate,
}
fmt.Println("wackydebugoutput handleMsgDelegate 9")
}
fmt.Println("wackydebugoutput handleMsgDelegate 10")
tags, err := delegate(ctx, k, msg.DelegatorAddr, msg.Bond, validator)
if err != nil {
fmt.Println("wackydebugoutput handleMsgDelegate 11")
return err.Result()
}
fmt.Println("wackydebugoutput handleMsgDelegate 12")
return sdk.Result{
Tags: tags,
}
@ -158,30 +146,23 @@ func handleMsgDelegate(ctx sdk.Context, msg MsgDelegate, k Keeper) sdk.Result {
// common functionality between handlers
func delegate(ctx sdk.Context, k Keeper, delegatorAddr sdk.Address,
bondAmt sdk.Coin, validator Validator) (sdk.Tags, sdk.Error) {
fmt.Println("wackydebugoutput delegate 0")
// Get or create the delegator bond
bond, found := k.GetDelegation(ctx, delegatorAddr, validator.Address)
if !found {
fmt.Println("wackydebugoutput delegate 1")
bond = Delegation{
DelegatorAddr: delegatorAddr,
ValidatorAddr: validator.Address,
Shares: sdk.ZeroRat(),
}
fmt.Println("wackydebugoutput delegate 3")
}
fmt.Println("wackydebugoutput delegate 4")
// Account new shares, save
pool := k.GetPool(ctx)
_, _, err := k.coinKeeper.SubtractCoins(ctx, bond.DelegatorAddr, sdk.Coins{bondAmt})
fmt.Println("wackydebugoutput delegate 5")
if err != nil {
fmt.Println("wackydebugoutput delegate 6")
return nil, err
}
fmt.Println("wackydebugoutput delegate 7")
validator, pool, newShares := validator.addTokensFromDel(pool, bondAmt.Amount)
fmt.Printf("debug newShares: %v\n", newShares)
bond.Shares = bond.Shares.Add(newShares)

6
x/stake/handler_test.go
View File

@ -47,7 +47,7 @@ func TestDuplicatesMsgDeclareCandidacy(t *testing.T) {
assert.Equal(t, sdk.Bonded, validator.Status)
assert.Equal(t, validatorAddr, validator.Address)
assert.Equal(t, pk, validator.PubKey)
assert.Equal(t, sdk.NewRat(10), validator.BondedShares)
assert.Equal(t, sdk.NewRat(10), validator.PShares.Bonded())
assert.Equal(t, sdk.NewRat(10), validator.DelegatorShares)
assert.Equal(t, Description{}, validator.Description)
@ -74,7 +74,7 @@ func TestIncrementsMsgDelegate(t *testing.T) {
require.True(t, found)
require.Equal(t, sdk.Bonded, validator.Status)
assert.Equal(t, bondAmount, validator.DelegatorShares.Evaluate())
assert.Equal(t, bondAmount, validator.BondedShares.Evaluate(), "validator: %v", validator)
assert.Equal(t, bondAmount, validator.PShares.Bonded().Evaluate(), "validator: %v", validator)
_, found = keeper.GetDelegation(ctx, delegatorAddr, validatorAddr)
require.False(t, found)
@ -150,7 +150,7 @@ func TestIncrementsMsgUnbond(t *testing.T) {
validator, found := keeper.GetValidator(ctx, validatorAddr)
require.True(t, found)
assert.Equal(t, initBond*2, validator.DelegatorShares.Evaluate())
assert.Equal(t, initBond*2, validator.BondedShares.Evaluate())
assert.Equal(t, initBond*2, validator.PShares.Bonded().Evaluate())
// just send the same msgUnbond multiple times
// TODO use decimals here

96
x/stake/keeper_test.go
View File

@ -31,7 +31,7 @@ func TestSetValidator(t *testing.T) {
validator := NewValidator(addrVals[0], pks[0], Description{})
validator, pool, _ = validator.addTokensFromDel(pool, 10)
require.Equal(t, sdk.Unbonded, validator.Status)
assert.True(sdk.RatEq(t, sdk.NewRat(10), validator.UnbondedShares))
assert.True(sdk.RatEq(t, sdk.NewRat(10), validator.PShares.Unbonded()))
assert.True(sdk.RatEq(t, sdk.NewRat(10), validator.DelegatorShares))
keeper.setPool(ctx, pool)
keeper.setValidator(ctx, validator)
@ -39,7 +39,7 @@ func TestSetValidator(t *testing.T) {
validator, found := keeper.GetValidator(ctx, addrVals[0])
require.True(t, found)
require.Equal(t, sdk.Bonded, validator.Status)
assert.True(sdk.RatEq(t, sdk.NewRat(10), validator.BondedShares))
assert.True(sdk.RatEq(t, sdk.NewRat(10), validator.PShares.Bonded()))
assert.True(sdk.RatEq(t, sdk.NewRat(10), validator.DelegatorShares))
}
@ -75,7 +75,7 @@ func TestValidatorBasics(t *testing.T) {
assert.True(ValEq(t, validators[0], resVals[0]))
// modify a records, save, and retrieve
validators[0].BondedShares = sdk.NewRat(10)
validators[0].PShares = NewBondedShares(sdk.NewRat(10))
validators[0].DelegatorShares = sdk.NewRat(10)
keeper.setValidator(ctx, validators[0])
resVal, found = keeper.GetValidator(ctx, addrVals[0])
@ -118,7 +118,7 @@ func GetValidatorSortingUnmixed(t *testing.T) {
var validators [5]Validator
for i, amt := range amts {
validators[i] = NewValidator(addrs[i], pks[i], Description{})
validators[i].BondedShares = sdk.NewRat(amt)
validators[i].PShares = NewBondedShares(sdk.NewRat(amt))
validators[i].DelegatorShares = sdk.NewRat(amt)
keeper.setValidator(ctx, validators[i])
}
@ -126,11 +126,11 @@ func GetValidatorSortingUnmixed(t *testing.T) {
// first make sure everything made it in to the gotValidator group
gotValidators := keeper.GetValidatorsBondedByPower(ctx)
require.Equal(t, n, len(gotValidators))
assert.Equal(t, sdk.NewRat(400), gotValidators[0].BondedShares, "%v", gotValidators)
assert.Equal(t, sdk.NewRat(200), gotValidators[1].BondedShares, "%v", gotValidators)
assert.Equal(t, sdk.NewRat(100), gotValidators[2].BondedShares, "%v", gotValidators)
assert.Equal(t, sdk.NewRat(1), gotValidators[3].BondedShares, "%v", gotValidators)
assert.Equal(t, sdk.NewRat(0), gotValidators[4].BondedShares, "%v", gotValidators)
assert.Equal(t, sdk.NewRat(400), gotValidators[0].PShares.Bonded(), "%v", gotValidators)
assert.Equal(t, sdk.NewRat(200), gotValidators[1].PShares.Bonded(), "%v", gotValidators)
assert.Equal(t, sdk.NewRat(100), gotValidators[2].PShares.Bonded(), "%v", gotValidators)
assert.Equal(t, sdk.NewRat(1), gotValidators[3].PShares.Bonded(), "%v", gotValidators)
assert.Equal(t, sdk.NewRat(0), gotValidators[4].PShares.Bonded(), "%v", gotValidators)
assert.Equal(t, validators[3].Address, gotValidators[0].Address, "%v", gotValidators)
assert.Equal(t, validators[4].Address, gotValidators[1].Address, "%v", gotValidators)
assert.Equal(t, validators[1].Address, gotValidators[2].Address, "%v", gotValidators)
@ -138,14 +138,14 @@ func GetValidatorSortingUnmixed(t *testing.T) {
assert.Equal(t, validators[0].Address, gotValidators[4].Address, "%v", gotValidators)
// test a basic increase in voting power
validators[3].BondedShares = sdk.NewRat(500)
validators[3].PShares = NewBondedShares(sdk.NewRat(500))
keeper.setValidator(ctx, validators[3])
gotValidators = keeper.GetValidatorsBondedByPower(ctx)
require.Equal(t, len(gotValidators), n)
assert.True(ValEq(t, validators[3], gotValidators[0]))
// test a decrease in voting power
validators[3].BondedShares = sdk.NewRat(300)
validators[3].PShares = NewBondedShares(sdk.NewRat(300))
keeper.setValidator(ctx, validators[3])
gotValidators = keeper.GetValidatorsBondedByPower(ctx)
require.Equal(t, len(gotValidators), n)
@ -153,7 +153,7 @@ func GetValidatorSortingUnmixed(t *testing.T) {
assert.True(ValEq(t, validators[4], gotValidators[1]))
// test equal voting power, different age
validators[3].BondedShares = sdk.NewRat(200)
validators[3].PShares = NewBondedShares(sdk.NewRat(200))
ctx = ctx.WithBlockHeight(10)
keeper.setValidator(ctx, validators[3])
gotValidators = keeper.GetValidatorsBondedByPower(ctx)
@ -172,8 +172,8 @@ func GetValidatorSortingUnmixed(t *testing.T) {
assert.True(ValEq(t, validators[4], gotValidators[1]))
// change in voting power of both validators, both still in v-set, no age change
validators[3].BondedShares = sdk.NewRat(300)
validators[4].BondedShares = sdk.NewRat(300)
validators[3].PShares = NewBondedShares(sdk.NewRat(300))
validators[4].PShares = NewBondedShares(sdk.NewRat(300))
keeper.setValidator(ctx, validators[3])
gotValidators = keeper.GetValidatorsBondedByPower(ctx)
require.Equal(t, len(gotValidators), n)
@ -202,11 +202,11 @@ func GetValidatorSortingMixed(t *testing.T) {
validators[i] = NewValidator(addrs[i], pks[i], Description{})
validators[i].DelegatorShares = sdk.NewRat(amt)
}
validators[0].UnbondedShares = sdk.NewRat(amts[0])
validators[1].UnbondedShares = sdk.NewRat(amts[1])
validators[2].UnbondedShares = sdk.NewRat(amts[2])
validators[3].BondedShares = sdk.NewRat(amts[3])
validators[4].BondedShares = sdk.NewRat(amts[4])
validators[0].PShares = NewUnbondedShares(sdk.NewRat(amts[0]))
validators[1].PShares = NewUnbondedShares(sdk.NewRat(amts[1]))
validators[2].PShares = NewUnbondedShares(sdk.NewRat(amts[2]))
validators[3].PShares = NewBondedShares(sdk.NewRat(amts[3]))
validators[4].PShares = NewBondedShares(sdk.NewRat(amts[4]))
for i := range amts {
keeper.setValidator(ctx, validators[i])
}
@ -229,11 +229,11 @@ func GetValidatorSortingMixed(t *testing.T) {
// first make sure everything made it in to the gotValidator group
gotValidators := keeper.GetValidatorsBondedByPower(ctx)
require.Equal(t, n, len(gotValidators))
assert.Equal(t, sdk.NewRat(400), gotValidators[0].BondedShares, "%v", gotValidators)
assert.Equal(t, sdk.NewRat(200), gotValidators[1].BondedShares, "%v", gotValidators)
assert.Equal(t, sdk.NewRat(100), gotValidators[2].BondedShares, "%v", gotValidators)
assert.Equal(t, sdk.NewRat(1), gotValidators[3].BondedShares, "%v", gotValidators)
assert.Equal(t, sdk.NewRat(0), gotValidators[4].BondedShares, "%v", gotValidators)
assert.Equal(t, sdk.NewRat(400), gotValidators[0].PShares.Bonded(), "%v", gotValidators)
assert.Equal(t, sdk.NewRat(200), gotValidators[1].PShares.Bonded(), "%v", gotValidators)
assert.Equal(t, sdk.NewRat(100), gotValidators[2].PShares.Bonded(), "%v", gotValidators)
assert.Equal(t, sdk.NewRat(1), gotValidators[3].PShares.Bonded(), "%v", gotValidators)
assert.Equal(t, sdk.NewRat(0), gotValidators[4].PShares.Bonded(), "%v", gotValidators)
assert.Equal(t, validators[3].Address, gotValidators[0].Address, "%v", gotValidators)
assert.Equal(t, validators[4].Address, gotValidators[1].Address, "%v", gotValidators)
assert.Equal(t, validators[1].Address, gotValidators[2].Address, "%v", gotValidators)
@ -258,15 +258,15 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
validators[i] = NewValidator(addrs[i], pks[i], Description{})
validators[i].DelegatorShares = sdk.NewRat(amt)
}
validators[0].UnbondedShares = sdk.NewRat(amts[0])
validators[1].UnbondedShares = sdk.NewRat(amts[1])
validators[2].BondedShares = sdk.NewRat(amts[2])
validators[3].BondedShares = sdk.NewRat(amts[3])
validators[0].PShares = NewUnbondedShares(sdk.NewRat(amts[0]))
validators[1].PShares = NewUnbondedShares(sdk.NewRat(amts[1]))
validators[2].PShares = NewBondedShares(sdk.NewRat(amts[2]))
validators[3].PShares = NewBondedShares(sdk.NewRat(amts[3]))
for i := range amts {
keeper.setValidator(ctx, validators[i])
}
validators[0].UnbondedShares = sdk.NewRat(500)
validators[0].PShares = NewUnbondedShares(sdk.NewRat(500))
keeper.setValidator(ctx, validators[0])
gotValidators := keeper.GetValidatorsBondedByPower(ctx)
require.Equal(t, nMax, uint16(len(gotValidators)))
@ -279,7 +279,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
// then increases to the original voting power, does not get its spot back in the
// case of a tie.
// ref https://github.com/cosmos/cosmos-sdk/issues/582#issuecomment-380757108
validators[3].BondedShares = sdk.NewRat(401)
validators[3].PShares = NewBondedShares(sdk.NewRat(401))
keeper.setValidator(ctx, validators[3])
gotValidators = keeper.GetValidatorsBondedByPower(ctx)
require.Equal(t, nMax, uint16(len(gotValidators)))
@ -288,7 +288,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
ctx = ctx.WithBlockHeight(40)
// validator 3 kicked out temporarily
validators[3].BondedShares = sdk.NewRat(200)
validators[3].PShares = NewBondedShares(sdk.NewRat(200))
keeper.setValidator(ctx, validators[3])
gotValidators = keeper.GetValidatorsBondedByPower(ctx)
require.Equal(t, nMax, uint16(len(gotValidators)))
@ -296,7 +296,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
assert.True(ValEq(t, validators[2], gotValidators[1]))
// validator 4 does not get spot back
validators[3].BondedShares = sdk.NewRat(400)
validators[3].PShares = NewBondedShares(sdk.NewRat(400))
keeper.setValidator(ctx, validators[3])
gotValidators = keeper.GetValidatorsBondedByPower(ctx)
require.Equal(t, nMax, uint16(len(gotValidators)))
@ -319,14 +319,14 @@ func TestValidatorBondHeight(t *testing.T) {
// initialize some validators into the state
var validators [3]Validator
validators[0] = NewValidator(addrs[0], pks[0], Description{})
validators[0].BondedShares = sdk.NewRat(200)
validators[0].PShares = NewBondedShares(sdk.NewRat(200))
validators[0].DelegatorShares = sdk.NewRat(200)
keeper.setValidator(ctx, validators[0])
validators[1] = NewValidator(addrs[1], pks[1], Description{})
validators[1].BondedShares = sdk.NewRat(100)
validators[1].PShares = NewBondedShares(sdk.NewRat(100))
validators[1].DelegatorShares = sdk.NewRat(100)
validators[2] = NewValidator(addrs[2], pks[2], Description{})
validators[2].UnbondedShares = sdk.NewRat(100)
validators[2].PShares = NewUnbondedShares(sdk.NewRat(100))
validators[2].DelegatorShares = sdk.NewRat(100)
////////////////////////////////////////
@ -338,8 +338,8 @@ func TestValidatorBondHeight(t *testing.T) {
require.Equal(t, uint16(len(gotValidators)), params.MaxValidators)
assert.True(ValEq(t, validators[0], gotValidators[0]))
assert.True(ValEq(t, validators[1], gotValidators[1]))
validators[1].BondedShares = sdk.NewRat(1100)
validators[2].BondedShares = sdk.NewRat(1100)
validators[1].PShares = NewBondedShares(sdk.NewRat(1100))
validators[2].PShares = NewBondedShares(sdk.NewRat(1100))
keeper.setValidator(ctx, validators[2])
keeper.setValidator(ctx, validators[1])
gotValidators = keeper.GetValidatorsBondedByPower(ctx)
@ -363,13 +363,13 @@ func TestGetValidatorsEdgeCases2(t *testing.T) {
var validators [5]Validator
for i, amt := range amts {
validators[i] = NewValidator(addrs[i], pks[i], Description{})
validators[i].BondedShares = sdk.NewRat(amt)
validators[i].PShares = NewBondedShares(sdk.NewRat(amt))
validators[i].DelegatorShares = sdk.NewRat(amt)
keeper.setValidator(ctx, validators[i])
}
// test a swap in voting power
validators[0].BondedShares = sdk.NewRat(600)
validators[0].PShares = NewBondedShares(sdk.NewRat(600))
keeper.setValidator(ctx, validators[0])
gotValidators := keeper.GetValidatorsBondedByPower(ctx)
require.Equal(t, len(gotValidators), n)
@ -395,7 +395,7 @@ func TestClearTendermintUpdates(t *testing.T) {
validators := make([]Validator, len(amts))
for i, amt := range amts {
validators[i] = NewValidator(addrs[i], pks[i], Description{})
validators[i].BondedShares = sdk.NewRat(amt)
validators[i].PShares = NewBondedShares(sdk.NewRat(amt))
validators[i].DelegatorShares = sdk.NewRat(amt)
keeper.setValidator(ctx, validators[i])
}
@ -423,7 +423,7 @@ func TestGetTendermintUpdates(t *testing.T) {
var validatorsIn [5]Validator
for i, amt := range amts {
validatorsIn[i] = NewValidator(addrs[i], pks[i], Description{})
validatorsIn[i].BondedShares = sdk.NewRat(amt)
validatorsIn[i].PShares = NewBondedShares(sdk.NewRat(amt))
validatorsIn[i].DelegatorShares = sdk.NewRat(amt)
}
@ -469,12 +469,12 @@ func TestGetTendermintUpdates(t *testing.T) {
assert.Equal(t, 2, len(keeper.GetValidatorsBonded(ctx)))
assert.Equal(t, 0, len(keeper.getTendermintUpdates(ctx)))
validators[0].BondedShares = sdk.NewRat(600)
validators[0].PShares = NewBondedShares(sdk.NewRat(600))
keeper.setValidator(ctx, validators[0])
validators = keeper.GetValidatorsBonded(ctx)
require.Equal(t, 2, len(validators))
assert.True(t, validators[0].BondedShares.Equal(sdk.NewRat(600)))
assert.True(t, validators[0].PShares.Bonded().Equal(sdk.NewRat(600)))
updates = keeper.getTendermintUpdates(ctx)
require.Equal(t, 1, len(updates))
assert.Equal(t, validators[0].abciValidator(keeper.cdc), updates[0])
@ -486,8 +486,8 @@ func TestGetTendermintUpdates(t *testing.T) {
assert.Equal(t, 2, len(keeper.GetValidatorsBonded(ctx)))
assert.Equal(t, 0, len(keeper.getTendermintUpdates(ctx)))
validators[0].BondedShares = sdk.NewRat(200)
validators[1].BondedShares = sdk.NewRat(100)
validators[0].PShares = NewBondedShares(sdk.NewRat(200))
validators[1].PShares = NewBondedShares(sdk.NewRat(100))
keeper.setValidator(ctx, validators[0])
keeper.setValidator(ctx, validators[1])
@ -550,7 +550,7 @@ func TestGetTendermintUpdates(t *testing.T) {
assert.Equal(t, 4, len(keeper.GetValidatorsBonded(ctx)))
assert.Equal(t, 0, len(keeper.getTendermintUpdates(ctx)))
validatorsIn[4].BondedShares = sdk.NewRat(1)
validatorsIn[4].PShares = NewBondedShares(sdk.NewRat(1))
keeper.setValidator(ctx, validatorsIn[4])
assert.Equal(t, 5, len(keeper.GetValidatorsBonded(ctx)))
@ -566,7 +566,7 @@ func TestGetTendermintUpdates(t *testing.T) {
assert.Equal(t, 4, len(keeper.GetValidatorsBonded(ctx)))
assert.Equal(t, 0, len(keeper.getTendermintUpdates(ctx)))
validatorsIn[4].BondedShares = sdk.NewRat(1000)
validatorsIn[4].PShares = NewBondedShares(sdk.NewRat(1000))
keeper.setValidator(ctx, validatorsIn[4])
validators = keeper.GetValidatorsBonded(ctx)
@ -625,7 +625,7 @@ func TestBond(t *testing.T) {
var validators [3]Validator
for i, amt := range amts {
validators[i] = NewValidator(addrVals[i], pks[i], Description{})
validators[i].BondedShares = sdk.NewRat(amt)
validators[i].PShares = NewBondedShares(sdk.NewRat(amt))
validators[i].DelegatorShares = sdk.NewRat(amt)
}

3
x/stake/tick_test.go
View File

@ -72,11 +72,12 @@ func TestProcessProvisions(t *testing.T) {
Status: sdk.Unbonded,
PubKey: pks[i],
Address: addrs[i],
BondedShares: sdk.NewRat(0),
PShares: NewUnbondedShares(sdk.NewRat(0)),
DelegatorShares: sdk.NewRat(0),
}
if i < 5 {
v.Status = sdk.Bonded
v.PShares.Kind = ShareBonded
}
mintedTokens := int64((i + 1) * 10000000)
pool.TotalSupply += mintedTokens

96
x/stake/validator_test.go
View File

@ -24,7 +24,7 @@ func TestAddTokensValidatorBonded(t *testing.T) {
assert.Equal(t, sdk.OneRat(), pool.unbondedShareExRate())
assert.True(sdk.RatEq(t, sdk.NewRat(10), delShares))
assert.True(sdk.RatEq(t, sdk.NewRat(10), val.BondedShares))
assert.True(sdk.RatEq(t, sdk.NewRat(10), val.PShares.Bonded()))
}
func TestAddTokensValidatorUnbonding(t *testing.T) {
@ -41,7 +41,7 @@ func TestAddTokensValidatorUnbonding(t *testing.T) {
assert.Equal(t, sdk.OneRat(), pool.unbondedShareExRate())
assert.True(sdk.RatEq(t, sdk.NewRat(10), delShares))
assert.True(sdk.RatEq(t, sdk.NewRat(10), val.UnbondingShares))
assert.True(sdk.RatEq(t, sdk.NewRat(10), val.PShares.Unbonding()))
}
func TestAddTokensValidatorUnbonded(t *testing.T) {
@ -58,7 +58,7 @@ func TestAddTokensValidatorUnbonded(t *testing.T) {
assert.Equal(t, sdk.OneRat(), pool.unbondedShareExRate())
assert.True(sdk.RatEq(t, sdk.NewRat(10), delShares))
assert.True(sdk.RatEq(t, sdk.NewRat(10), val.UnbondedShares))
assert.True(sdk.RatEq(t, sdk.NewRat(10), val.PShares.Unbonded()))
}
// TODO refactor to make simpler like the AddToken tests above
@ -70,11 +70,11 @@ func TestRemoveShares(t *testing.T) {
Status: sdk.Bonded,
Address: addrs[0],
PubKey: pks[0],
BondedShares: sdk.NewRat(9),
PShares: NewBondedShares(sdk.NewRat(9)),
DelegatorShares: sdk.NewRat(9),
}
poolA.BondedTokens = valA.BondedShares.Evaluate()
poolA.BondedShares = valA.BondedShares
poolA.BondedTokens = valA.PShares.Bonded().Evaluate()
poolA.BondedShares = valA.PShares.Bonded()
assert.Equal(t, valA.DelegatorShareExRate(poolA), sdk.OneRat())
assert.Equal(t, poolA.bondedShareExRate(), sdk.OneRat())
assert.Equal(t, poolA.unbondedShareExRate(), sdk.OneRat())
@ -83,7 +83,7 @@ func TestRemoveShares(t *testing.T) {
// coins were created
assert.Equal(t, coinsB, int64(10))
// pool shares were removed
assert.Equal(t, valB.BondedShares, valA.BondedShares.Sub(sdk.NewRat(10).Mul(valA.DelegatorShareExRate(poolA))))
assert.Equal(t, valB.PShares.Bonded(), valA.PShares.Bonded().Sub(sdk.NewRat(10).Mul(valA.DelegatorShareExRate(poolA))))
// conservation of tokens
assert.Equal(t, poolB.UnbondedTokens+poolB.BondedTokens+coinsB, poolA.UnbondedTokens+poolA.BondedTokens)
@ -94,7 +94,7 @@ func TestRemoveShares(t *testing.T) {
Status: sdk.Bonded,
Address: addrs[0],
PubKey: pks[0],
BondedShares: assets,
PShares: NewBondedShares(assets),
DelegatorShares: liabilities,
}
pool := Pool{
@ -108,7 +108,7 @@ func TestRemoveShares(t *testing.T) {
}
shares := sdk.NewRat(29)
msg := fmt.Sprintf("validator %s (status: %d, assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(pool))
val.Address, val.Status, val.PShares.Bonded(), val.DelegatorShares, val.DelegatorShareExRate(pool))
msg = fmt.Sprintf("Removed %v shares from %s", shares, msg)
_, newPool, tokens := val.removeDelShares(pool, shares)
require.Equal(t,
@ -124,28 +124,28 @@ func TestUpdateSharesLocation(t *testing.T) {
val := NewValidator(addrs[0], pks[0], Description{})
val.Status = sdk.Unbonded
val, pool, _ = val.addTokensFromDel(pool, 100)
assert.Equal(t, int64(0), val.BondedShares.Evaluate())
assert.Equal(t, int64(0), val.UnbondingShares.Evaluate())
assert.Equal(t, int64(100), val.UnbondedShares.Evaluate())
assert.Equal(t, int64(0), val.PShares.Bonded().Evaluate())
assert.Equal(t, int64(0), val.PShares.Unbonding().Evaluate())
assert.Equal(t, int64(100), val.PShares.Unbonded().Evaluate())
assert.Equal(t, int64(0), pool.BondedTokens)
assert.Equal(t, int64(0), pool.UnbondingTokens)
assert.Equal(t, int64(100), pool.UnbondedTokens)
val.Status = sdk.Unbonding
val, pool = val.UpdateSharesLocation(pool)
//require.Fail(t, "", "%v", val.BondedShares.IsZero())
assert.Equal(t, int64(0), val.BondedShares.Evaluate())
assert.Equal(t, int64(100), val.UnbondingShares.Evaluate())
assert.Equal(t, int64(0), val.UnbondedShares.Evaluate())
//require.Fail(t, "", "%v", val.PShares.Bonded().IsZero())
assert.Equal(t, int64(0), val.PShares.Bonded().Evaluate())
assert.Equal(t, int64(100), val.PShares.Unbonding().Evaluate())
assert.Equal(t, int64(0), val.PShares.Unbonded().Evaluate())
assert.Equal(t, int64(0), pool.BondedTokens)
assert.Equal(t, int64(100), pool.UnbondingTokens)
assert.Equal(t, int64(0), pool.UnbondedTokens)
val.Status = sdk.Bonded
val, pool = val.UpdateSharesLocation(pool)
assert.Equal(t, int64(100), val.BondedShares.Evaluate())
assert.Equal(t, int64(0), val.UnbondingShares.Evaluate())
assert.Equal(t, int64(0), val.UnbondedShares.Evaluate())
assert.Equal(t, int64(100), val.PShares.Bonded().Evaluate())
assert.Equal(t, int64(0), val.PShares.Unbonding().Evaluate())
assert.Equal(t, int64(0), val.PShares.Unbonded().Evaluate())
assert.Equal(t, int64(100), pool.BondedTokens)
assert.Equal(t, int64(0), pool.UnbondingTokens)
assert.Equal(t, int64(0), pool.UnbondedTokens)
@ -168,7 +168,7 @@ func randomValidator(r *rand.Rand) Validator {
Status: status,
Address: addrs[0],
PubKey: pks[0],
BondedShares: assets,
PShares: NewBondedShares(assets),
DelegatorShares: liabilities,
}
}
@ -189,11 +189,11 @@ func randomSetup(r *rand.Rand, numValidators int) (Pool, Validators) {
for i := 0; i < numValidators; i++ {
validator := randomValidator(r)
if validator.Status == sdk.Bonded {
pool.BondedShares = pool.BondedShares.Add(validator.BondedShares)
pool.BondedTokens += validator.BondedShares.Evaluate()
pool.BondedShares = pool.BondedShares.Add(validator.PShares.Bonded())
pool.BondedTokens += validator.PShares.Bonded().Evaluate()
} else if validator.Status == sdk.Unbonded {
pool.UnbondedShares = pool.UnbondedShares.Add(validator.BondedShares)
pool.UnbondedTokens += validator.BondedShares.Evaluate()
pool.UnbondedShares = pool.UnbondedShares.Add(validator.PShares.Bonded())
pool.UnbondedTokens += validator.PShares.Bonded().Evaluate()
}
validators[i] = validator
}
@ -210,11 +210,11 @@ func OpBondOrUnbond(r *rand.Rand, p Pool, val Validator) (Pool, Validator, int64
var msg string
if val.Status == sdk.Bonded {
msg = fmt.Sprintf("sdk.Unbonded previously bonded validator %s (assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
val.Address, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(p))
val.Address, val.PShares.Bonded(), val.DelegatorShares, val.DelegatorShareExRate(p))
val.Status = sdk.Unbonded
} else if val.Status == sdk.Unbonded {
msg = fmt.Sprintf("sdk.Bonded previously unbonded validator %s (assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
val.Address, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(p))
val.Address, val.PShares.Bonded(), val.DelegatorShares, val.DelegatorShareExRate(p))
val.Status = sdk.Bonded
}
val, p = val.UpdateSharesLocation(p)
@ -225,7 +225,7 @@ func OpBondOrUnbond(r *rand.Rand, p Pool, val Validator) (Pool, Validator, int64
func OpAddTokens(r *rand.Rand, p Pool, val Validator) (Pool, Validator, int64, string) {
tokens := int64(r.Int31n(1000))
msg := fmt.Sprintf("validator %s (status: %d, assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(p))
val.Address, val.Status, val.PShares.Bonded(), val.DelegatorShares, val.DelegatorShareExRate(p))
val, p, _ = val.addTokensFromDel(p, tokens)
msg = fmt.Sprintf("Added %d tokens to %s", tokens, msg)
return p, val, -1 * tokens, msg // tokens are removed so for accounting must be negative
@ -242,7 +242,7 @@ func OpRemoveShares(r *rand.Rand, p Pool, val Validator) (Pool, Validator, int64
}
msg := fmt.Sprintf("Removed %v shares from validator %s (status: %d, assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
shares, val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(p))
shares, val.Address, val.Status, val.PShares.Bonded(), val.DelegatorShares, val.DelegatorShareExRate(p))
val, p, tokens := val.removeDelShares(p, shares)
return p, val, tokens, msg
@ -263,13 +263,13 @@ func randomOperation(r *rand.Rand) Operation {
// ensure invariants that should always be true are true
func assertInvariants(t *testing.T, msg string,
pOrig Pool, cOrig Validators, pMod Pool, cMods Validators, tokens int64) {
pOrig Pool, cOrig Validators, pMod Pool, vMods Validators, tokens int64) {
// total tokens conserved
require.Equal(t,
pOrig.UnbondedTokens+pOrig.BondedTokens,
pMod.UnbondedTokens+pMod.BondedTokens+tokens,
"Tokens not conserved - msg: %v\n, pOrig.BondedShares: %v, pOrig.UnbondedShares: %v, pMod.BondedShares: %v, pMod.UnbondedShares: %v, pOrig.UnbondedTokens: %v, pOrig.BondedTokens: %v, pMod.UnbondedTokens: %v, pMod.BondedTokens: %v, tokens: %v\n",
"Tokens not conserved - msg: %v\n, pOrig.PShares.Bonded(): %v, pOrig.PShares.Unbonded(): %v, pMod.PShares.Bonded(): %v, pMod.PShares.Unbonded(): %v, pOrig.UnbondedTokens: %v, pOrig.BondedTokens: %v, pMod.UnbondedTokens: %v, pMod.BondedTokens: %v, tokens: %v\n",
msg,
pOrig.BondedShares, pOrig.UnbondedShares,
pMod.BondedShares, pMod.UnbondedShares,
@ -296,34 +296,34 @@ func assertInvariants(t *testing.T, msg string,
"Applying operation \"%s\" resulted in negative unbondedShareExRate: %d",
msg, pMod.unbondedShareExRate().Evaluate())
for _, cMod := range cMods {
for _, vMod := range vMods {
// nonnegative ex rate
require.False(t, cMod.DelegatorShareExRate(pMod).LT(sdk.ZeroRat()),
require.False(t, vMod.DelegatorShareExRate(pMod).LT(sdk.ZeroRat()),
"Applying operation \"%s\" resulted in negative validator.DelegatorShareExRate(): %v (validator.Address: %s)",
msg,
cMod.DelegatorShareExRate(pMod),
cMod.Address,
vMod.DelegatorShareExRate(pMod),
vMod.Address,
)
// nonnegative assets
require.False(t, cMod.BondedShares.LT(sdk.ZeroRat()),
"Applying operation \"%s\" resulted in negative validator.BondedShares: %v (validator.DelegatorShares: %v, validator.DelegatorShareExRate: %v, validator.Address: %s)",
require.False(t, vMod.PShares.Bonded().LT(sdk.ZeroRat()),
"Applying operation \"%s\" resulted in negative validator.PShares.Bonded(): %v (validator.DelegatorShares: %v, validator.DelegatorShareExRate: %v, validator.Address: %s)",
msg,
cMod.BondedShares,
cMod.DelegatorShares,
cMod.DelegatorShareExRate(pMod),
cMod.Address,
vMod.PShares.Bonded(),
vMod.DelegatorShares,
vMod.DelegatorShareExRate(pMod),
vMod.Address,
)
// nonnegative liabilities
require.False(t, cMod.DelegatorShares.LT(sdk.ZeroRat()),
"Applying operation \"%s\" resulted in negative validator.DelegatorShares: %v (validator.BondedShares: %v, validator.DelegatorShareExRate: %v, validator.Address: %s)",
require.False(t, vMod.DelegatorShares.LT(sdk.ZeroRat()),
"Applying operation \"%s\" resulted in negative validator.DelegatorShares: %v (validator.PShares.Bonded(): %v, validator.DelegatorShareExRate: %v, validator.Address: %s)",
msg,
cMod.DelegatorShares,
cMod.BondedShares,
cMod.DelegatorShareExRate(pMod),
cMod.Address,
vMod.DelegatorShares,
vMod.PShares.Bonded(),
vMod.DelegatorShareExRate(pMod),
vMod.Address,
)
}
@ -337,7 +337,7 @@ func TestPossibleOverflow(t *testing.T) {
Status: sdk.Bonded,
Address: addrs[0],
PubKey: pks[0],
BondedShares: assets,
PShares: NewBondedShares(assets),
DelegatorShares: liabilities,
}
pool := Pool{
@ -351,7 +351,7 @@ func TestPossibleOverflow(t *testing.T) {
}
tokens := int64(71)
msg := fmt.Sprintf("validator %s (status: %d, assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(pool))
val.Address, val.Status, val.PShares.Bonded(), val.DelegatorShares, val.DelegatorShareExRate(pool))
newValidator, _, _ := val.addTokensFromDel(pool, tokens)
msg = fmt.Sprintf("Added %d tokens to %s", tokens, msg)

6
x/stake/view_slash_keeper_test.go
View File

@ -18,9 +18,9 @@ func TestViewSlashBond(t *testing.T) {
var validators [3]Validator
for i, amt := range amts {
validators[i] = Validator{
Address: addrVals[i],
PubKey: pks[i],
BondedShares: sdk.NewRat(amt),
Address: addrVals[i],
PubKey: pks[i],
PShares: NewBondedShares(sdk.NewRat(amt)),
DelegatorShares: sdk.NewRat(amt),
}
}