R4R: blockly minting

PENDING.md

@@ -13,6 +13,7 @@ BREAKING CHANGES
   * [cli] [\#2874](https://github.com/cosmos/cosmos-sdk/pull/2874) `gaiacli tx sign` takes an optional `--output-document` flag to support output redirection.
 
 * Gaia
+  * [mint] [\#2825] minting now occurs every block, inflation parameter updates still hourly
 
 * SDK
   * [\#2752](https://github.com/cosmos/cosmos-sdk/pull/2752) Don't hardcode bondable denom.
@@ -71,6 +72,7 @@ IMPROVEMENTS
  - #2821 Codespaces are now strings
  - #2779 Introduce `ValidateBasic` to the `Tx` interface and call it in the ante
  handler.
+  - #2825 More staking and distribution invariants
 
 * Tendermint
  - #2796 Update to go-amino 0.14.1

cmd/gaia/app/sim_test.go

@@ -59,7 +59,9 @@ func appStateFn(r *rand.Rand, accs []simulation.Account) json.RawMessage {
 	if numInitiallyBonded > numAccs {
 		numInitiallyBonded = numAccs
 	}
-	fmt.Printf("Selected randomly generated parameters for simulated genesis: {amount of steak per account: %v, initially bonded validators: %v}\n", amount, numInitiallyBonded)
+	fmt.Printf("Selected randomly generated parameters for simulated genesis:\n"+
+		"\t{amount of steak per account: %v, initially bonded validators: %v}\n",
+		amount, numInitiallyBonded)
 
 	// Randomly generate some genesis accounts
 	for _, acc := range accs {
@@ -86,7 +88,8 @@ func appStateFn(r *rand.Rand, accs []simulation.Account) json.RawMessage {
 			GovernancePenalty: sdk.NewDecWithPrec(1, 2),
 		},
 	}
-	fmt.Printf("Selected randomly generated governance parameters: %+v\n", govGenesis)
+	fmt.Printf("Selected randomly generated governance parameters:\n\t%+v\n", govGenesis)
+
 	stakeGenesis := stake.GenesisState{
 		Pool: stake.InitialPool(),
 		Params: stake.Params{
@@ -95,7 +98,8 @@ func appStateFn(r *rand.Rand, accs []simulation.Account) json.RawMessage {
 			BondDenom:     stakeTypes.DefaultBondDenom,
 		},
 	}
-	fmt.Printf("Selected randomly generated staking parameters: %+v\n", stakeGenesis)
+	fmt.Printf("Selected randomly generated staking parameters:\n\t%+v\n", stakeGenesis)
+
 	slashingGenesis := slashing.GenesisState{
 		Params: slashing.Params{
 			MaxEvidenceAge:           stakeGenesis.Params.UnbondingTime,
@@ -107,21 +111,21 @@ func appStateFn(r *rand.Rand, accs []simulation.Account) json.RawMessage {
 			SlashFractionDowntime:    sdk.NewDec(1).Quo(sdk.NewDec(int64(r.Intn(200) + 1))),
 		},
 	}
-	fmt.Printf("Selected randomly generated slashing parameters: %+v\n", slashingGenesis)
+	fmt.Printf("Selected randomly generated slashing parameters:\n\t%+v\n", slashingGenesis)
+
 	mintGenesis := mint.GenesisState{
-		Minter: mint.Minter{
-			InflationLastTime: time.Unix(0, 0),
-			Inflation:         sdk.NewDecWithPrec(int64(r.Intn(99)), 2),
-		},
-		Params: mint.Params{
-			MintDenom:           stakeTypes.DefaultBondDenom,
-			InflationRateChange: sdk.NewDecWithPrec(int64(r.Intn(99)), 2),
-			InflationMax:        sdk.NewDecWithPrec(20, 2),
-			InflationMin:        sdk.NewDecWithPrec(7, 2),
-			GoalBonded:          sdk.NewDecWithPrec(67, 2),
-		},
+		Minter: mint.InitialMinter(
+			sdk.NewDecWithPrec(int64(r.Intn(99)), 2)),
+		Params: mint.NewParams(
+			stakeTypes.DefaultBondDenom,
+			sdk.NewDecWithPrec(int64(r.Intn(99)), 2),
+			sdk.NewDecWithPrec(20, 2),
+			sdk.NewDecWithPrec(7, 2),
+			sdk.NewDecWithPrec(67, 2),
+			uint64(60*60*8766/5)),
 	}
-	fmt.Printf("Selected randomly generated minting parameters: %v\n", mintGenesis)
+	fmt.Printf("Selected randomly generated minting parameters:\n\t%+v\n", mintGenesis)
+
 	var validators []stake.Validator
 	var delegations []stake.Delegation
 

docs/spec/mint/begin_block.md

@@ -1,18 +1,18 @@
 # Begin-Block
 
-## Inflation 
+Inflation occurs at the beginning of each block, however minting parameters
+are only calculated once per hour.
 
-Inflation occurs at the beginning of each block. 
+## NextInflationRate
 
-### NextInflation
+The target annual inflation rate is recalculated at the first block of each new
+hour. The inflation is also subject to a rate change (positive or negative)
+depending on the distance from the desired ratio (67%). The maximum rate change
+possible is defined to be 13% per year, however the annual inflation is capped
+as between 7% and 20%.
 
-The target annual inflation rate is recalculated for each provisions cycle. The
-inflation is also subject to a rate change (positive or negative) depending on
-the distance from the desired ratio (67%). The maximum rate change possible is
-defined to be 13% per year, however the annual inflation is capped as between
-7% and 20%.
-
-NextInflation(params Params, bondedRatio sdk.Dec) (inflation sdk.Dec) {
+```
+NextInflationRate(params Params, bondedRatio sdk.Dec) (inflation sdk.Dec) {
 	inflationRateChangePerYear = (1 - bondedRatio/params.GoalBonded) * params.InflationRateChange
 	inflationRateChange = inflationRateChangePerYear/hrsPerYr
 
@@ -26,3 +26,25 @@ NextInflation(params Params, bondedRatio sdk.Dec) (inflation sdk.Dec) {
 	}
 
 	return inflation
+```
+
+## NextAnnualProvisions
+
+Calculate the annual provisions based on current total supply and inflation
+rate. This parameter is calculated once per block. 
+
+```
+NextAnnualProvisions(params Params, totalSupply sdk.Dec) (provisions sdk.Dec) {
+	return Inflation * totalSupply
+```
+
+## BlockProvision
+
+Calculate the provisions generated for each block based on current 
+annual provisions 
+
+```
+BlockProvision(params Params) sdk.Coin {
+	provisionAmt = AnnualProvisions/ params.BlocksPerYear
+	return sdk.NewCoin(params.MintDenom, provisionAmt.Truncate())
+```

docs/spec/mint/state.md

@@ -8,8 +8,9 @@ The minter is a space for holding current inflation information.
 
 ```golang
 type Minter struct {
-	InflationLastTime time.Time // block time which the last inflation was processed
-	Inflation         sdk.Dec   // current annual inflation rate
+	LastUpdate       time.Time // time which the last update was made to the minter
+	Inflation        sdk.Dec   // current annual inflation rate
+	AnnualProvisions sdk.Dec   // current annual exptected provisions
 }
 ```
 
@@ -26,6 +27,7 @@ type Params struct {
 	InflationMax        sdk.Dec // maximum inflation rate
 	InflationMin        sdk.Dec // minimum inflation rate
 	GoalBonded          sdk.Dec // goal of percent bonded atoms
+	BlocksPerYear       uint64   // expected blocks per year
 }
 ```
 

types/coin.go

@@ -28,7 +28,7 @@ type Coin struct {
 // the amount is negative.
 func NewCoin(denom string, amount Int) Coin {
 	if amount.LT(ZeroInt()) {
-		panic("negative coin amount")
+		panic(fmt.Sprintf("negative coin amount: %v\n", amount))
 	}
 
 	return Coin{

types/decimal.go

@@ -172,10 +172,21 @@ func NewDecFromStr(str string) (d Dec, err Error) {
 	return Dec{combined}, nil
 }
 
+// Decimal from string, panic on error
+func MustNewDecFromStr(s string) Dec {
+	dec, err := NewDecFromStr(s)
+	if err != nil {
+		panic(err)
+	}
+	return dec
+}
+
 //______________________________________________________________________________________________
 //nolint
 func (d Dec) IsNil() bool       { return d.Int == nil }                 // is decimal nil
 func (d Dec) IsZero() bool      { return (d.Int).Sign() == 0 }          // is equal to zero
+func (d Dec) IsNegative() bool  { return (d.Int).Sign() == -1 }         // is negative
+func (d Dec) IsPositive() bool  { return (d.Int).Sign() == 1 }          // is positive
 func (d Dec) Equal(d2 Dec) bool { return (d.Int).Cmp(d2.Int) == 0 }     // equal decimals
 func (d Dec) GT(d2 Dec) bool    { return (d.Int).Cmp(d2.Int) > 0 }      // greater than
 func (d Dec) GTE(d2 Dec) bool   { return (d.Int).Cmp(d2.Int) >= 0 }     // greater than or equal
@@ -252,6 +263,14 @@ func (d Dec) IsInteger() bool {
 	return new(big.Int).Rem(d.Int, precisionReuse).Sign() == 0
 }
 
+// format decimal state
+func (d Dec) Format(s fmt.State, verb rune) {
+	_, err := s.Write([]byte(d.String()))
+	if err != nil {
+		panic(err)
+	}
+}
+
 func (d Dec) String() string {
 	bz, err := d.Int.MarshalText()
 	if err != nil {

x/distribution/keeper/hooks.go

@@ -10,6 +10,11 @@ import (
 // Create a new validator distribution record
 func (k Keeper) onValidatorCreated(ctx sdk.Context, valAddr sdk.ValAddress) {
 
+	// defensive check for existence
+	if k.HasValidatorDistInfo(ctx, valAddr) {
+		panic("validator dist info already exists (not cleaned up properly)")
+	}
+
 	height := ctx.BlockHeight()
 	vdi := types.ValidatorDistInfo{
 		OperatorAddr:            valAddr,

x/distribution/keeper/test_common.go

@@ -162,7 +162,8 @@ func (fck DummyFeeCollectionKeeper) ClearCollectedFees(_ sdk.Context) {
 //__________________________________________________________________________________
 // used in simulation
 
-// iterate over all the validator distribution infos (inefficient, just used to check invariants)
+// iterate over all the validator distribution infos (inefficient, just used to
+// check invariants)
 func (k Keeper) IterateValidatorDistInfos(ctx sdk.Context,
 	fn func(index int64, distInfo types.ValidatorDistInfo) (stop bool)) {
 
@@ -179,3 +180,22 @@ func (k Keeper) IterateValidatorDistInfos(ctx sdk.Context,
 		index++
 	}
 }
+
+// iterate over all the delegation distribution infos (inefficient, just used
+// to check invariants)
+func (k Keeper) IterateDelegationDistInfos(ctx sdk.Context,
+	fn func(index int64, distInfo types.DelegationDistInfo) (stop bool)) {
+
+	store := ctx.KVStore(k.storeKey)
+	iter := sdk.KVStorePrefixIterator(store, DelegationDistInfoKey)
+	defer iter.Close()
+	index := int64(0)
+	for ; iter.Valid(); iter.Next() {
+		var ddi types.DelegationDistInfo
+		k.cdc.MustUnmarshalBinaryLengthPrefixed(iter.Value(), &ddi)
+		if fn(index, ddi) {
+			return
+		}
+		index++
+	}
+}

x/distribution/keeper/validator.go

@@ -36,6 +36,13 @@ func (k Keeper) SetValidatorDistInfo(ctx sdk.Context, vdi types.ValidatorDistInf
 
 // remove a validator distribution info
 func (k Keeper) RemoveValidatorDistInfo(ctx sdk.Context, valAddr sdk.ValAddress) {
+
+	// defensive check
+	vdi := k.GetValidatorDistInfo(ctx, valAddr)
+	if vdi.DelAccum.Accum.IsPositive() {
+		panic("Should not delete validator with unwithdrawn delegator accum")
+	}
+
 	store := ctx.KVStore(k.storeKey)
 	store.Delete(GetValidatorDistInfoKey(valAddr))
 }

x/distribution/simulation/invariants.go

@@ -18,6 +18,10 @@ func AllInvariants(d distr.Keeper, sk distr.StakeKeeper) simulation.Invariant {
 		if err != nil {
 			return err
 		}
+		err = DelAccumInvariants(d, sk)(app)
+		if err != nil {
+			return err
+		}
 		return nil
 	}
 }
@@ -48,3 +52,81 @@ func ValAccumInvariants(k distr.Keeper, sk distr.StakeKeeper) simulation.Invaria
 		return nil
 	}
 }
+
+// DelAccumInvariants checks that each validator del accum == sum all delegators' accum
+func DelAccumInvariants(k distr.Keeper, sk distr.StakeKeeper) simulation.Invariant {
+
+	return func(app *baseapp.BaseApp) error {
+		mockHeader := abci.Header{Height: app.LastBlockHeight() + 1}
+		ctx := app.NewContext(false, mockHeader)
+		height := ctx.BlockHeight()
+
+		totalDelAccumFromVal := make(map[string]sdk.Dec) // key is the valOpAddr string
+		totalDelAccum := make(map[string]sdk.Dec)
+
+		// iterate the validators
+		iterVal := func(_ int64, vdi distr.ValidatorDistInfo) bool {
+			key := vdi.OperatorAddr.String()
+			validator := sk.Validator(ctx, vdi.OperatorAddr)
+			totalDelAccumFromVal[key] = vdi.GetTotalDelAccum(height,
+				validator.GetDelegatorShares())
+
+			// also initialize the delegation map
+			totalDelAccum[key] = sdk.ZeroDec()
+
+			return false
+		}
+		k.IterateValidatorDistInfos(ctx, iterVal)
+
+		// iterate the delegations
+		iterDel := func(_ int64, ddi distr.DelegationDistInfo) bool {
+			key := ddi.ValOperatorAddr.String()
+			delegation := sk.Delegation(ctx, ddi.DelegatorAddr, ddi.ValOperatorAddr)
+			totalDelAccum[key] = totalDelAccum[key].Add(
+				ddi.GetDelAccum(height, delegation.GetShares()))
+			return false
+		}
+		k.IterateDelegationDistInfos(ctx, iterDel)
+
+		// compare
+		for key, delAccumFromVal := range totalDelAccumFromVal {
+			sumDelAccum := totalDelAccum[key]
+
+			if !sumDelAccum.Equal(delAccumFromVal) {
+
+				logDelAccums := ""
+				iterDel := func(_ int64, ddi distr.DelegationDistInfo) bool {
+					keyLog := ddi.ValOperatorAddr.String()
+					if keyLog == key {
+						delegation := sk.Delegation(ctx, ddi.DelegatorAddr, ddi.ValOperatorAddr)
+						accum := ddi.GetDelAccum(height, delegation.GetShares())
+						if accum.IsPositive() {
+							logDelAccums += fmt.Sprintf("\n\t\tdel: %v, accum: %v",
+								ddi.DelegatorAddr.String(),
+								accum.String())
+						}
+					}
+					return false
+				}
+				k.IterateDelegationDistInfos(ctx, iterDel)
+
+				operAddr, err := sdk.ValAddressFromBech32(key)
+				if err != nil {
+					panic(err)
+				}
+				validator := sk.Validator(ctx, operAddr)
+
+				return fmt.Errorf("delegator accum invariance: \n"+
+					"\tvalidator key: %v\n"+
+					"\tvalidator: %+v\n"+
+					"\tsum delegator accum: %v\n"+
+					"\tvalidator's total delegator accum: %v\n"+
+					"\tlog of delegations with accum: %v\n",
+					key, validator, sumDelAccum.String(),
+					delAccumFromVal.String(), logDelAccums)
+			}
+		}
+
+		return nil
+	}
+}

x/distribution/types/dec_coin.go

@@ -20,6 +20,13 @@ func NewDecCoin(denom string, amount int64) DecCoin {
 	}
 }
 
+func NewDecCoinFromDec(denom string, amount sdk.Dec) DecCoin {
+	return DecCoin{
+		Denom:  denom,
+		Amount: amount,
+	}
+}
+
 func NewDecCoinFromCoin(coin sdk.Coin) DecCoin {
 	return DecCoin{
 		Denom:  coin.Denom,
@@ -140,7 +147,7 @@ func (coins DecCoins) MulDec(d sdk.Dec) DecCoins {
 	return res
 }
 
-// divide all the coins by a multiple
+// divide all the coins by a decimal
 func (coins DecCoins) QuoDec(d sdk.Dec) DecCoins {
 	res := make([]DecCoin, len(coins))
 	for i, coin := range coins {
@@ -176,3 +183,13 @@ func (coins DecCoins) AmountOf(denom string) sdk.Dec {
 		}
 	}
 }
+
+// returns the amount of a denom from deccoins
+func (coins DecCoins) HasNegative() bool {
+	for _, coin := range coins {
+		if coin.Amount.IsNegative() {
+			return true
+		}
+	}
+	return false
+}