x/bank: Allow way to restrict MintCoins function from app.go

[ValarDragon]

Problem Definition

We often want to give modules the ability to MintCoins. However we rarely want to be giving them permissions to mint any coin on the network. E.g. its reasonable for x/distribution to be able to mint the chains native coin (ATOM, OSMO, etc.), but it shouldn't be able to mint any arbitrary coin. In the event of a bug, we should be able to limit the failure to only tokens it should have mint permissions for, not arbitrary IBC denoms that may be present on the chain. Ditto for x/gamm on Osmosis, we'd like it to only have permissions to mint/burn LP shares (tokens with denoms that start with gamm/..., not arbitrary denoms)

We should be able to restrict these permissions from the app.go. And we should be able to permission this very flexibly per module. (e.g. maybe we want to limit this module to be capped to {X units of emission at once}). This is effectively defining what is the worst case wrt Chain supplies, if this module had a catastrophic bug.

Summary & Proposal

Make the BankKeeper implementation have a function in its struct called mintCoinsRestrictionFn : func(ctx sdk.Context, coins sdk.Coins) error, that by default is a no-op. Then make a function on bank keeper's struct called

(bk BankKeeper) WithMintCoinsRestriction(NewRestrictionFn func(ctx sdk.Context, coins sdk.Coins) error) {
  priorFn := bk.mintCoinsRestrictionFn
  bk.mintCoinsRestrictionFn = func(ctx sdk.Context, coins sdk.Coins) error {
    err := NewRestrictionFn(ctx, coins)
    if err != nil {
      return err
    }
    return priorFn(ctx, coins)
  }
}

Then in your app.go, you can do something like:

	app.DistrKeeper = distrkeeper.NewKeeper(
		appCodec, keys[distrtypes.StoreKey], app.GetSubspace(distrtypes.ModuleName), app.AccountKeeper, app.BankKeeper.WithMintCoinsRestriction(DistributionMintingRestriction),
		&stakingKeeper, authtypes.FeeCollectorName, app.ModuleAccountAddrs(),
	)

and then a function defined elsewhere called for DistributionMintingRestriction that does:

func DistributionMintingRestriction(ctx sdk.Context, coins sdk.Coins) {
  for _, coin := range coins {
    if coin.Denom != ctx.NativeStakingDenom {
       return errors.New(fmt.Sprintf("Distribution can only print denom %s, tried minting %s", ctx.NativeStakingDenom, coin.Denom))
     }
  }
}

Such a feature will go a long way at mitigating risk of a software bug having catastrophic failures across the chain in terms of minting.

The mintcoins funtion would now look like

(bk BankKeeper) MintCoins(ctx. sdk.Context, modulename string, coins sdk.Coins) error {
    err := bk.mintCoinsRestrictionFn(ctx, coins)
    if err != nil {
        ctx.Logger().Error("Module %s attempted minting coins %s it did not have permission for", modulename, coins)
        return err
     }
    {Do old mint coins logic}
}

---

For Admin Use

• Not duplicate issue
• Appropriate labels applied
• Appropriate contributors tagged
• Contributor assigned/self-assigned