feat(x/mint): Add max supply param

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/proto/cosmos/mint/v1beta1/mint.proto

@@ -59,4 +59,10 @@ message Params {
   ];
   // expected blocks per year
   uint64 blocks_per_year = 6;
+  // maximum supply for the token
+  string max_supply = 7 [
+    (cosmos_proto.scalar)  = "cosmos.Int",
+    (gogoproto.customtype) = "cosmossdk.io/math.Int",
+    (gogoproto.nullable)   = 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)