func (k ERC20Keeper) MintCoins(ctx context.Context, addr sdk.AccAddress, amount sdk.Coins) error {
	// ... snip ...

	for _, coin := range amount {
		denom := coin.Denom
		if types.IsERC20Denom(denom) {
			return moderrors.Wrapf(types.ErrInvalidRequest, "cannot mint erc20 coin: %s", coin.Denom)
		}

		// ... snip ...

		inputBz, err := k.ERC20ABI.Pack("sudoMint", evmAddr, coin.Amount.BigInt())
		if err != nil {
			return types.ErrFailedToPackABI.Wrap(err.Error())
		}

		// ... snip ...
	}

	// ... snip ...
}
func (k ERC20Keeper) BurnCoins(ctx context.Context, addr sdk.AccAddress, amount sdk.Coins) error {
	// ... snip ...

	for _, coin := range amount {
		// if a coin is not generated from 0x1, then send the coin to community pool
		// because we don't have burn capability.
		if types.IsERC20Denom(coin.Denom) {
			if err := k.communityPoolKeeper.FundCommunityPool(ctx, amount, evmAddr.Bytes()); err != nil {
				return err
			}

			continue
		}

		// ... snip ...
	}

	// ... snip ...
}
func Test_BurnTwice(t *testing.T) {
	ctx, input := createDefaultTestInput(t)
	_, _, addr := keyPubAddr()
	evmAddr := common.BytesToAddress(addr.Bytes())

	erc20Keeper, err := keeper.NewERC20Keeper(&input.EVMKeeper)
	require.NoError(t, err)

	fooContractAddr_1 := deployERC20(t, ctx, input, evmAddr, "foo")
	fooDenom_1, err := types.ContractAddrToDenom(ctx, &input.EVMKeeper, fooContractAddr_1)
	require.NoError(t, err)
	require.Equal(t, "evm/"+fooContractAddr_1.Hex()[2:], fooDenom_1)

	fooContractAddr_2 := deployERC20(t, ctx, input, evmAddr, "bar")
	fooDenom_2, err := types.ContractAddrToDenom(ctx, &input.EVMKeeper, fooContractAddr_2)
	require.NoError(t, err)
	require.Equal(t, "evm/"+fooContractAddr_2.Hex()[2:], fooDenom_2)

	cacheCtx, _ := ctx.CacheContext()
	err = erc20Keeper.MintCoins(cacheCtx, addr, sdk.NewCoins(
		sdk.NewCoin(fooDenom_1, math.NewInt(100)),
		sdk.NewCoin(fooDenom_2, math.NewInt(100)),
	))
	require.Error(t, err)

	mintERC20(t, ctx, input, evmAddr, evmAddr, sdk.NewCoin(fooDenom_1, math.NewInt(100)), false)
	mintERC20(t, ctx, input, evmAddr, evmAddr, sdk.NewCoin(fooDenom_2, math.NewInt(100)), false)

	amount, err := erc20Keeper.GetBalance(ctx, addr, fooDenom_1)
	require.NoError(t, err)
	require.Equal(t, math.NewInt(100), amount)

	amount, err = erc20Keeper.GetBalance(ctx, addr, fooDenom_2)
	require.NoError(t, err)
	require.Equal(t, math.NewInt(100), amount)

	// Community pool should have 0 balance
	require.Equal(t, math.NewInt(0), input.CommunityPoolKeeper.CommunityPool.AmountOf(fooDenom_1))
	require.Equal(t, math.NewInt(0), input.CommunityPoolKeeper.CommunityPool.AmountOf(fooDenom_2))

	// Burn 50 coins of each denom
	err = erc20Keeper.BurnCoins(ctx, addr, sdk.NewCoins(
		sdk.NewCoin(fooDenom_1, math.NewInt(50)),
		sdk.NewCoin(fooDenom_2, math.NewInt(50)),
	))
	require.NoError(t, err)

	// Community pool should have 100 (50*2) coins of each denom
	require.Equal(t, math.NewInt(100), input.CommunityPoolKeeper.CommunityPool.AmountOf(fooDenom_1))
	require.Equal(t, math.NewInt(100), input.CommunityPoolKeeper.CommunityPool.AmountOf(fooDenom_2))
}
	// BurnCoins implements IERC20Keeper.
	func (k ERC20Keeper) BurnCoins(ctx context.Context, addr sdk.AccAddress, amount sdk.Coins) error {
		// ... snip ...

		for _, coin := range amount {
			// if a coin is not generated from 0x1, then send the coin to community pool
			// because we don't have burn capability.
			if types.IsERC20Denom(coin.Denom) {
-				if err := k.communityPoolKeeper.FundCommunityPool(ctx, amount, evmAddr.Bytes()); err != nil {
+				if err := k.communityPoolKeeper.FundCommunityPool(ctx, sdk.NewCoins(coin), evmAddr.Bytes()); err != nil {
					return err
				}

				continue
			}

			// ... snip ...
		}

		return nil
	}
