wip

Author: likhita-809

tests/e2e/mint/grpc.go

@@ -29,7 +29,7 @@ func (s *E2ETestSuite) TestQueryGRPC() {
 			&minttypes.QueryParamsResponse{},
 			&minttypes.QueryParamsResponse{
 				Params: minttypes.NewParams("stake", math.LegacyNewDecWithPrec(13, 2), math.LegacyNewDecWithPrec(100, 2),
-					math.LegacyNewDec(1), math.LegacyNewDecWithPrec(67, 2), (60 * 60 * 8766 / 5)),
+					math.LegacyNewDec(1), math.LegacyNewDecWithPrec(67, 2), (60 * 60 * 8766 / 5), math.ZeroInt()),
 			},
 		},
 		{

x/mint/keeper/abci.go

@@ -37,19 +37,42 @@ func (k Keeper) BeginBlocker(ctx context.Context, ic types.InflationCalculationF
 		return err
 	}
 
+	// update minter's inflation and annual provisions
 	minter.Inflation = ic(ctx, minter, params, bondedRatio)
 	minter.AnnualProvisions = minter.NextAnnualProvisions(params, totalStakingSupply)
 	if err = k.Minter.Set(ctx, minter); err != nil {
 		return err
 	}
 
-	// mint coins, update supply
+	// calculate minted coins
 	mintedCoin := minter.BlockProvision(params)
 	mintedCoins := sdk.NewCoins(mintedCoin)
 
-	err = k.MintCoins(ctx, mintedCoins)
-	if err != nil {
-		return err
+	maxSupply := params.MaxSupply
+	// if maxSupply is not infinite, check against max_supply parameter
+	if !maxSupply.IsZero() {
+		if totalStakingSupply.Add(mintedCoins.AmountOf(params.MintDenom)).GT(maxSupply) {
+			// calculate the difference between maxSupply and totalStakingSupply
+			diff := maxSupply.Sub(totalStakingSupply)
+			// mint the difference
+			diffCoin := sdk.NewCoin(params.MintDenom, diff)
+			diffCoins := sdk.NewCoins(diffCoin)
+
+			// mint coins
+			if err := k.MintCoins(ctx, diffCoins); err != nil {
+				return err
+			}
+			mintedCoin = mintedCoin.Sub(diffCoin)
+			mintedCoins = sdk.NewCoins(mintedCoin)
+		}
+	}
+
+	// mint coins if maxSupply is infinite or total staking supply is less than maxSupply
+	if maxSupply.IsZero() || totalStakingSupply.LT(maxSupply) {
+		// mint coins
+		if err := k.MintCoins(ctx, mintedCoins); err != nil {
+			return err
+		}
 	}
 
 	// send the minted coins to the fee collector account

x/mint/keeper/genesis_test.go

@@ -71,6 +71,7 @@ func (s *GenesisTestSuite) TestImportExportGenesis() {
 		math.LegacyNewDecWithPrec(9, 2),
 		math.LegacyNewDecWithPrec(69, 2),
 		uint64(60*60*8766/5),
+		math.ZeroInt(),
 	)
 
 	err := s.keeper.InitGenesis(s.sdkCtx, s.accountKeeper, genesisState)

x/mint/keeper/msg_server_test.go

@@ -53,6 +53,7 @@ func (s *IntegrationTestSuite) TestUpdateParams() {
 					InflationMin:        sdkmath.LegacyNewDecWithPrec(2, 2),
 					GoalBonded:          sdkmath.LegacyNewDecWithPrec(37, 2),
 					BlocksPerYear:       uint64(60 * 60 * 8766 / 5),
+					MaxSupply:           sdkmath.ZeroInt(), // infinite supply
 				},
 			},
 			expectErr: false,

x/mint/simulation/genesis.go

@@ -66,7 +66,7 @@ func RandomizedGenState(simState *module.SimulationState) {
 
 	mintDenom := simState.BondDenom
 	blocksPerYear := uint64(60 * 60 * 8766 / 5)
-	params := types.NewParams(mintDenom, inflationRateChange, inflationMax, inflationMin, goalBonded, blocksPerYear)
+	params := types.NewParams(mintDenom, inflationRateChange, inflationMax, inflationMin, goalBonded, blocksPerYear, math.ZeroInt())
 
 	mintGenesis := types.NewGenesisState(types.InitialMinter(inflation), params)
 

x/mint/types/params.go

@@ -11,14 +11,15 @@ import (
 )
 
 // NewParams returns Params instance with the given values.
-func NewParams(mintDenom string, inflationRateChange, inflationMax, inflationMin, goalBonded math.LegacyDec, blocksPerYear uint64) Params {
+func NewParams(mintDenom string, inflationRateChange, inflationMax, inflationMin, goalBonded math.LegacyDec, blocksPerYear uint64, maxSupply math.Int) Params {
 	return Params{
 		MintDenom:           mintDenom,
 		InflationRateChange: inflationRateChange,
 		InflationMax:        inflationMax,
 		InflationMin:        inflationMin,
 		GoalBonded:          goalBonded,
 		BlocksPerYear:       blocksPerYear,
+		MaxSupply:           maxSupply,
 	}
 }
 
@@ -31,6 +32,7 @@ func DefaultParams() Params {
 		InflationMin:        math.LegacyNewDecWithPrec(7, 2),
 		GoalBonded:          math.LegacyNewDecWithPrec(67, 2),
 		BlocksPerYear:       uint64(60 * 60 * 8766 / 5), // assuming 5 second block times
+		MaxSupply:           math.ZeroInt(),             // assuming zero is infinite
 	}
 }
 
@@ -54,6 +56,9 @@ func (p Params) Validate() error {
 	if err := validateBlocksPerYear(p.BlocksPerYear); err != nil {
 		return err
 	}
+	if err := validateMaxSupply(p.MaxSupply); err != nil {
+		return err
+	}
 	if p.InflationMax.LT(p.InflationMin) {
 		return fmt.Errorf(
 			"max inflation (%s) must be greater than or equal to min inflation (%s)",
@@ -168,3 +173,16 @@ func validateBlocksPerYear(i interface{}) error {
 
 	return nil
 }
+
+func validateMaxSupply(i interface{}) error {
+	v, ok := i.(math.Int)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", i)
+	}
+
+	if v.IsNegative() {
+		return fmt.Errorf("max supply must be positive: %d", v)
+	}
+
+	return nil
+}