Allow zero precision for ft tokens

integration-tests/modules/assetft_test.go

@@ -92,6 +92,96 @@ func TestAssetFTIssue(t *testing.T) {
 	})
 	requireT.NoError(err)
 	requireT.Equal(chain.NewCoin(sdkmath.ZeroInt()).String(), resp.Balance.String())
+
+	// check metadata
+	denom := assetfttypes.BuildDenom(issueMsg.Subunit, issuer)
+	metadata, err := bankClient.DenomMetadata(ctx, &banktypes.QueryDenomMetadataRequest{Denom: denom})
+	requireT.NoError(err)
+	expectedMetadata := banktypes.Metadata{
+		Description: issueMsg.Description,
+		DenomUnits: []*banktypes.DenomUnit{
+			{Denom: denom, Exponent: 0},
+			{Denom: issueMsg.Symbol, Exponent: issueMsg.Precision},
+		},
+		Base:    denom,
+		Display: issueMsg.Symbol,
+		Name:    issueMsg.Symbol,
+		Symbol:  issueMsg.Symbol,
+		URI:     issueMsg.URI,
+		URIHash: issueMsg.URIHash,
+	}
+	requireT.EqualValues(expectedMetadata, metadata.Metadata)
+}
+
+// TestAssetFTIssue tests issue functionality of fungible tokens.
+func TestAssetFTIssue_ZeroPrecision(t *testing.T) {
+	t.Parallel()
+
+	ctx, chain := integrationtests.NewCoreumTestingContext(t)
+
+	requireT := require.New(t)
+	issuer := chain.GenAccount()
+
+	chain.FundAccountWithOptions(ctx, t, issuer, integration.BalancesOptions{
+		Messages: []sdk.Msg{
+			&assetfttypes.MsgIssue{},
+		},
+		Amount: chain.QueryAssetFTParams(ctx, t).IssueFee.Amount,
+	})
+
+	issueMsg := &assetfttypes.MsgIssue{
+		Issuer:        issuer.String(),
+		Symbol:        "ABC",
+		Subunit:       "uabc",
+		Precision:     0,
+		Description:   "ABC Description",
+		InitialAmount: sdkmath.NewInt(1000),
+		Features:      []assetfttypes.Feature{},
+		URI:           "https://my-class-meta.invalid/1",
+		URIHash:       "content-hash",
+	}
+
+	res, err := client.BroadcastTx(
+		ctx,
+		chain.ClientContext.WithFromAddress(issuer),
+		chain.TxFactory().WithGas(chain.GasLimitByMsgs(issueMsg)),
+		issueMsg,
+	)
+
+	requireT.NoError(err)
+
+	// verify issue fee was burnt
+	burntStr, err := event.FindStringEventAttribute(res.Events, banktypes.EventTypeCoinBurn, sdk.AttributeKeyAmount)
+	requireT.NoError(err)
+	requireT.Equal(chain.QueryAssetFTParams(ctx, t).IssueFee.String(), burntStr)
+
+	// check that balance is 0 meaning issue fee was taken
+
+	bankClient := banktypes.NewQueryClient(chain.ClientContext)
+	resp, err := bankClient.Balance(ctx, &banktypes.QueryBalanceRequest{
+		Address: issuer.String(),
+		Denom:   chain.ChainSettings.Denom,
+	})
+	requireT.NoError(err)
+	requireT.Equal(chain.NewCoin(sdkmath.ZeroInt()).String(), resp.Balance.String())
+
+	// check metadata
+	denom := assetfttypes.BuildDenom(issueMsg.Subunit, issuer)
+	metadata, err := bankClient.DenomMetadata(ctx, &banktypes.QueryDenomMetadataRequest{Denom: denom})
+	requireT.NoError(err)
+	expectedMetadata := banktypes.Metadata{
+		Description: issueMsg.Description,
+		DenomUnits: []*banktypes.DenomUnit{
+			{Denom: denom, Exponent: 0},
+		},
+		Base:    denom,
+		Display: denom,
+		Name:    issueMsg.Symbol,
+		Symbol:  issueMsg.Symbol,
+		URI:     issueMsg.URI,
+		URIHash: issueMsg.URIHash,
+	}
+	requireT.EqualValues(expectedMetadata, metadata.Metadata)
 }
 
 // TestAssetFTIssueInvalidFeatures tests issue functionality of fungible tokens with invalid features.

x/asset/ft/keeper/keeper.go

@@ -314,6 +314,19 @@ func (k Keeper) SetDenomMetadata(
 		URIHash: uriHash,
 	}
 
+	// in case the precision is zero, we cannot 2 zero exponents in denom units, so
+	// we are force to have single entry in denom units and also Display must be the
+	// same as Base.
+	if precision == 0 {
+		denomMetadata.DenomUnits = []*banktypes.DenomUnit{
+			{
+				Denom:    denom,
+				Exponent: uint32(0),
+			},
+		}
+		denomMetadata.Display = denom
+	}
+
 	if err := denomMetadata.Validate(); err != nil {
 		return sdkerrors.Wrapf(types.ErrInvalidInput, "failed to validate denom metadata: %s", err)
 	}

x/asset/ft/types/token.go

@@ -137,8 +137,8 @@ func ValidateAssetCoins(coins sdk.Coins) error {
 
 // ValidatePrecision checks the provided precision is valid.
 func ValidatePrecision(precision uint32) error {
-	if precision == 0 || precision > MaxPrecision {
-		return sdkerrors.Wrapf(ErrInvalidInput, "precision must be between 1 and %d", MaxPrecision)
+	if precision > MaxPrecision {
+		return sdkerrors.Wrapf(ErrInvalidInput, "precision must be between 0 and %d", MaxPrecision)
 	}
 	return nil
 }

x/asset/ft/types/token_test.go

@@ -32,7 +32,7 @@ func TestValidatePrecision(t *testing.T) {
 		{precision: 3},
 		{precision: 10},
 		{precision: types.MaxPrecision},
-		{precision: 0, expectError: true},
+		{precision: 0},
 		{precision: types.MaxPrecision + 1, expectError: true},
 		{precision: 100_000, expectError: true},
 	}