Skip to content

Commit

Permalink
blocked: see #751
Browse files Browse the repository at this point in the history
  • Loading branch information
@mossid
mossid committed Mar 30, 2018
1 parent 66a1130 commit d5601e3
Show file tree
Hide file tree
Showing 2 changed files with 146 additions and 118 deletions.
13 changes: 9 additions & 4 deletions x/stake/tick.go
View file
Original file line number Diff line number Diff line change
@@ -1,6 +1,8 @@
package stake

import (
"fmt"

sdk "github.com/cosmos/cosmos-sdk/types"
abci "github.com/tendermint/abci/types"
)
Expand All @@ -17,12 +19,11 @@ func (k Keeper) Tick(ctx sdk.Context) (change []*abci.Validator, err error) {

// retrieve params
p := k.GetPool(ctx)
height := ctx.BlockHeight()
time := ctx.BlockHeader().Time

// Process Validator Provisions
// XXX right now just process every 5 blocks, in new SDK make hourly
if p.InflationLastTime+5 <= height {
p.InflationLastTime = height
if p.InflationLastTime+3600 <= time {
p.InflationLastTime = time
k.processProvisions(ctx)
}

Expand Down Expand Up @@ -64,10 +65,14 @@ func (k Keeper) nextInflation(ctx sdk.Context) (inflation sdk.Rat) {

// (1 - bondedRatio/GoalBonded) * InflationRateChange
inflationRateChangePerYear := sdk.OneRat.Sub(pool.bondedRatio().Quo(params.GoalBonded)).Mul(params.InflationRateChange)
fmt.Printf("pyr: %+v\n", inflationRateChangePerYear)
inflationRateChange := inflationRateChangePerYear.Quo(hrsPerYrRat)
fmt.Printf("cha: %+v\n", inflationRateChange)
fmt.Printf("pin: %+v\n", pool.Inflation)

// increase the new annual inflation for this next cycle
inflation = pool.Inflation.Add(inflationRateChange)
fmt.Printf("ori: %+v\n", inflation)
if inflation.GT(params.InflationMax) {
inflation = params.InflationMax
}
Expand Down
251 changes: 137 additions & 114 deletions x/stake/tick_test.go
View file
Original file line number Diff line number Diff line change
@@ -1,116 +1,139 @@
package stake

//import (
//"testing"

//sdk "github.com/cosmos/cosmos-sdk/types"
//"github.com/stretchr/testify/assert"
//)

//func TestGetInflation(t *testing.T) {
//ctx, _, keeper := createTestInput(t, nil, false, 0)
//params := defaultParams()
//keeper.setParams(ctx, params)
//gs := keeper.GetPool(ctx)

//// Governing Mechanism:
//// bondedRatio = BondedPool / TotalSupply
//// inflationRateChangePerYear = (1- bondedRatio/ GoalBonded) * MaxInflationRateChange

//tests := []struct {
//setBondedPool, setTotalSupply int64
//setInflation, expectedChange sdk.Rat
//}{
//// with 0% bonded atom supply the inflation should increase by InflationRateChange
//{0, 0, sdk.NewRat(7, 100), params.InflationRateChange.Quo(hrsPerYr)},

//// 100% bonded, starting at 20% inflation and being reduced
//{1, 1, sdk.NewRat(20, 100), sdk.OneRat.Sub(sdk.OneRat.Quo(params.GoalBonded)).Mul(params.InflationRateChange).Quo(hrsPerYr)},

//// 50% bonded, starting at 10% inflation and being increased
//{1, 2, sdk.NewRat(10, 100), sdk.OneRat.Sub(sdk.NewRat(1, 2).Quo(params.GoalBonded)).Mul(params.InflationRateChange).Quo(hrsPerYr)},

//// test 7% minimum stop (testing with 100% bonded)
//{1, 1, sdk.NewRat(7, 100), sdk.ZeroRat},
//{1, 1, sdk.NewRat(70001, 1000000), sdk.NewRat(-1, 1000000)},

//// test 20% maximum stop (testing with 0% bonded)
//{0, 0, sdk.NewRat(20, 100), sdk.ZeroRat},
//{0, 0, sdk.NewRat(199999, 1000000), sdk.NewRat(1, 1000000)},

//// perfect balance shouldn't change inflation
//{67, 100, sdk.NewRat(15, 100), sdk.ZeroRat},
//}
//for _, tc := range tests {
//gs.BondedPool, p.TotalSupply = tc.setBondedPool, tc.setTotalSupply
//gs.Inflation = tc.setInflation

//inflation := nextInflation(gs, params)
//diffInflation := inflation.Sub(tc.setInflation)

//assert.True(t, diffInflation.Equal(tc.expectedChange),
//"%v, %v", diffInflation, tc.expectedChange)
//}
//}

//func TestProcessProvisions(t *testing.T) {
//ctx, _, keeper := createTestInput(t, nil, false, 0)
//params := defaultParams()
//keeper.setParams(ctx, params)
//gs := keeper.GetPool(ctx)

//// create some candidates some bonded, some unbonded
//candidates := candidatesFromAddrsEmpty(addrs)
//for i, candidate := range candidates {
//if i < 5 {
//candidate.Status = Bonded
//}
//mintedTokens := int64((i + 1) * 10000000)
//gs.TotalSupply += mintedTokens
//keeper.candidateAddTokens(ctx, candidate, mintedTokens)
//keeper.setCandidate(ctx, candidate)
//}
//var totalSupply int64 = 550000000
//var bondedShares int64 = 150000000
//var unbondedShares int64 = 400000000

//// initial bonded ratio ~ 27%
//assert.True(t, p.bondedRatio().Equal(sdk.NewRat(bondedShares, totalSupply)), "%v", p.bondedRatio())

//// Supplies
//assert.Equal(t, totalSupply, p.TotalSupply)
//assert.Equal(t, bondedShares, p.BondedPool)
//assert.Equal(t, unbondedShares, p.UnbondedPool)

//// test the value of candidate shares
//assert.True(t, p.bondedShareExRate().Equal(sdk.OneRat), "%v", p.bondedShareExRate())

//initialSupply := p.TotalSupply
//initialUnbonded := p.TotalSupply - p.BondedPool

//// process the provisions a year
//for hr := 0; hr < 8766; hr++ {
//expInflation := nextInflation(gs, params).Round(1000000000)
//expProvisions := (expInflation.Mul(sdk.NewRat(gs.TotalSupply)).Quo(hrsPerYr)).Evaluate()
//startBondedPool := p.BondedPool
//startTotalSupply := p.TotalSupply
//processProvisions(ctx, keeper, p, params)
//assert.Equal(t, startBondedPool+expProvisions, p.BondedPool)
//assert.Equal(t, startTotalSupply+expProvisions, p.TotalSupply)
//}
//assert.NotEqual(t, initialSupply, p.TotalSupply)
//assert.Equal(t, initialUnbonded, p.UnbondedPool)
////panic(fmt.Sprintf("debug total %v, bonded %v, diff %v\n", p.TotalSupply, p.BondedPool, p.TotalSupply-gs.BondedPool))

//// initial bonded ratio ~ 35% ~ 30% increase for bonded holders
//assert.True(t, p.bondedRatio().Equal(sdk.NewRat(105906511, 305906511)), "%v", p.bondedRatio())

//// global supply
//assert.Equal(t, int64(611813022), p.TotalSupply)
//assert.Equal(t, int64(211813022), p.BondedPool)
//assert.Equal(t, unbondedShares, p.UnbondedPool)

//// test the value of candidate shares
//assert.True(t, p.bondedShareExRate().Mul(sdk.NewRat(bondedShares)).Equal(sdk.NewRat(211813022)), "%v", p.bondedShareExRate())

//}
import (
"fmt"
"testing"

sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/stretchr/testify/assert"
)

func TestGetInflation(t *testing.T) {
ctx, _, keeper := createTestInput(t, nil, false, 0)
params := defaultParams()
keeper.setParams(ctx, params)
gs := keeper.GetPool(ctx)

// Governing Mechanism:
// bondedRatio = BondedPool / TotalSupply
// inflationRateChangePerYear = (1- bondedRatio/ GoalBonded) * MaxInflationRateChange

tests := []struct {
setBondedPool, setTotalSupply int64
setInflation, expectedChange sdk.Rat
}{
// with 0% bonded atom supply the inflation should increase by InflationRateChange
{0, 0, sdk.NewRat(7, 100), params.InflationRateChange.Quo(hrsPerYrRat)},

// 100% bonded, starting at 20% inflation and being reduced
{1, 1, sdk.NewRat(20, 100), sdk.OneRat.Sub(sdk.OneRat.Quo(params.GoalBonded)).Mul(params.InflationRateChange).Quo(hrsPerYrRat)},

// 50% bonded, starting at 10% inflation and being increased
{1, 2, sdk.NewRat(10, 100), sdk.OneRat.Sub(sdk.NewRat(1, 2).Quo(params.GoalBonded)).Mul(params.InflationRateChange).Quo(hrsPerYrRat)},

// test 7% minimum stop (testing with 100% bonded)
{1, 1, sdk.NewRat(7, 100), sdk.ZeroRat},
{1, 1, sdk.NewRat(70001, 1000000), sdk.NewRat(-1, 1000000)},

// test 20% maximum stop (testing with 0% bonded)
{0, 0, sdk.NewRat(20, 100), sdk.ZeroRat},
{0, 0, sdk.NewRat(199999, 1000000), sdk.NewRat(1, 1000000)},

// perfect balance shouldn't change inflation
{67, 100, sdk.NewRat(15, 100), sdk.ZeroRat},
}
for _, tc := range tests {
gs.BondedPool, gs.TotalSupply = tc.setBondedPool, tc.setTotalSupply
gs.Inflation = tc.setInflation

keeper.setPool(ctx, gs)

inflation := keeper.nextInflation(ctx)
diffInflation := inflation.Sub(tc.setInflation)

assert.True(t, diffInflation.Equal(tc.expectedChange),
"%v, %v", diffInflation, tc.expectedChange)
}
}

func TestProcessProvisions(t *testing.T) {
ctx, _, keeper := createTestInput(t, nil, false, 0)
params := defaultParams()
keeper.setParams(ctx, params)
//gs := keeper.GetPool(ctx)

totalSupply := int64(0)
// create some candidates some bonded, some unbonded
for i := 0; i < len(addrs); i++ {
mintedTokens := int64((i + 1) * 10000000)
c := Candidate{
Status: Unbonded,
PubKey: pks[i],
Address: addrs[i],
Assets: sdk.NewRat(mintedTokens),
Liabilities: sdk.NewRat(mintedTokens),
}
if i < 5 {
c.Status = Bonded
keeper.addTokensBonded(ctx, mintedTokens)
} else {
keeper.addTokensUnbonded(ctx, mintedTokens)
}
totalSupply += mintedTokens
keeper.candidateAddTokens(ctx, c, mintedTokens)
keeper.setCandidate(ctx, c)
}
var bondedShares int64 = 150000000
var unbondedShares int64 = 400000000

gs := keeper.GetPool(ctx)
gs.TotalSupply = totalSupply
keeper.setPool(ctx, gs)

// initial bonded ratio ~ 27%
assert.True(t, gs.bondedRatio().Equal(sdk.NewRat(bondedShares, totalSupply)), "%v", gs.bondedRatio())

// Supplies
assert.Equal(t, totalSupply, gs.TotalSupply)
assert.Equal(t, bondedShares, gs.BondedPool)
assert.Equal(t, unbondedShares, gs.UnbondedPool)

// test the value of candidate shares
assert.True(t, gs.bondedShareExRate().Equal(sdk.OneRat), "%v", gs.bondedShareExRate())

initialSupply := gs.TotalSupply
initialUnbonded := gs.TotalSupply - gs.BondedPool

// process the provisions a year
for hr := 0; hr < 10; hr++ {
fmt.Printf("start\n")
expInflation := keeper.nextInflation(ctx).Round(1000000000)
expProvisions := (expInflation.Mul(sdk.NewRat(gs.TotalSupply)).Quo(hrsPerYrRat)).Evaluate()

fmt.Printf("gs: %+v\n", gs)
fmt.Printf("inf: %+v\n", expInflation)
fmt.Printf("pro: %+v\n", expProvisions)

startBondedPool := gs.BondedPool
startTotalSupply := gs.TotalSupply
keeper.processProvisions(ctx)
gs = keeper.GetPool(ctx)
assert.Equal(t, startBondedPool+expProvisions, gs.BondedPool)
assert.Equal(t, startTotalSupply+expProvisions, gs.TotalSupply)
}
assert.NotEqual(t, initialSupply, gs.TotalSupply)
assert.Equal(t, initialUnbonded, gs.UnbondedPool)
//panic(fmt.Sprintf("debug total %v, bonded %v, diff %v\n", p.TotalSupply, p.BondedPool, p.TotalSupply-gs.BondedPool))

// initial bonded ratio ~ 35% ~ 30% increase for bonded holders
assert.True(t, gs.bondedRatio().Equal(sdk.NewRat(105906511, 305906511)), "%v", gs.bondedRatio())

// global supply
assert.Equal(t, int64(611813022), gs.TotalSupply)
assert.Equal(t, int64(211813022), gs.BondedPool)
assert.Equal(t, unbondedShares, gs.UnbondedPool)

// test the value of candidate shares
assert.True(t, gs.bondedShareExRate().Mul(sdk.NewRat(bondedShares)).Equal(sdk.NewRat(211813022)), "%v", gs.bondedShareExRate())

}

0 comments on commit d5601e3

Please sign in to comment.