refactor: switch usage from DenomTrace to Denom (#6417)

* refactor: add Denom type and embed into Token

Adds Denom and Trace proto types
Makes use of Denom type in Token
Trace will be used in a later pr

* refactor: begin migrating DenomTrace -> Denom

* refactor: regenerate protos for genesis and query service

* refactor: finish switching DenomTrace -> Denom

* fix: self review

* lint

* Apply suggestions from code review

* Update modules/apps/transfer/types/trace.go

* chore: temporarily skips running unit tests on E2Es

* Apply suggestions from code review

* fix: build

* fix: various issues

* fix: Add back RPC endpoints

Add back DenomTrace/DenomTraces as dependency for 08-wasm e2e's depends on them. Mark as deprecated and implement them
to return nothing (to be replaced with sensible error).

Remove repeated cast from proto definition to reduce required boilerplate to get it compiling.

Remove hack in scripts/go-test-all.go to have e2e tests executing.

* lint: fix linting issues.

* Update proto/ibc/applications/transfer/v1/query.proto

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

* tests: fix failing test.

* fix: return error on unsupported grpc

---------

Co-authored-by: chatton <cian@interchain.io>
Co-authored-by: DimitrisJim <d.f.hilliard@gmail.com>
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

modules/apps/transfer/client/cli/cli.go

@@ -16,8 +16,8 @@ func GetQueryCmd() *cobra.Command {
 	}
 
 	queryCmd.AddCommand(
-		GetCmdQueryDenomTrace(),
-		GetCmdQueryDenomTraces(),
+		GetCmdQueryDenom(),
+		GetCmdQueryDenoms(),
 		GetCmdParams(),
 		GetCmdQueryEscrowAddress(),
 		GetCmdQueryDenomHash(),

modules/apps/transfer/client/cli/query.go

@@ -12,26 +12,26 @@ import (
 	"github.com/cosmos/ibc-go/v8/modules/apps/transfer/types"
 )
 
-// GetCmdQueryDenomTrace defines the command to query a denomination trace from a given trace hash or ibc denom.
-func GetCmdQueryDenomTrace() *cobra.Command {
+// GetCmdQueryDenom defines the command to query a denomination from a given hash or ibc denom.
+func GetCmdQueryDenom() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:     "denom-trace [hash/denom]",
-		Short:   "Query the denom trace info from a given trace hash or ibc denom",
-		Long:    "Query the denom trace info from a given trace hash or ibc denom",
-		Example: fmt.Sprintf("%s query ibc-transfer denom-trace 27A6394C3F9FF9C9DCF5DFFADF9BB5FE9A37C7E92B006199894CF1824DF9AC7C", version.AppName),
+		Use:     "denom [hash/denom]",
+		Short:   "Query the denom trace info from a given hash or ibc denom",
+		Long:    "Query the denom trace info from a given hash or ibc denom",
+		Example: fmt.Sprintf("%s query ibc-transfer denom 27A6394C3F9FF9C9DCF5DFFADF9BB5FE9A37C7E92B006199894CF1824DF9AC7C", version.AppName),
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			clientCtx, err := client.GetClientQueryContext(cmd)
 			if err != nil {
 				return err
 			}
-			queryClient := types.NewQueryClient(clientCtx)
+			queryClient := types.NewQueryV2Client(clientCtx)
 
-			req := &types.QueryDenomTraceRequest{
+			req := &types.QueryDenomRequest{
 				Hash: args[0],
 			}
 
-			res, err := queryClient.DenomTrace(cmd.Context(), req)
+			res, err := queryClient.Denom(cmd.Context(), req)
 			if err != nil {
 				return err
 			}
@@ -44,32 +44,31 @@ func GetCmdQueryDenomTrace() *cobra.Command {
 	return cmd
 }
 
-// GetCmdQueryDenomTraces defines the command to query all the denomination trace infos
-// that this chain maintains.
-func GetCmdQueryDenomTraces() *cobra.Command {
+// GetCmdQueryDenoms defines the command to query all the denominations that this chain maintains.
+func GetCmdQueryDenoms() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:     "denom-traces",
-		Short:   "Query the trace info for all token denominations",
-		Long:    "Query the trace info for all token denominations",
-		Example: fmt.Sprintf("%s query ibc-transfer denom-traces", version.AppName),
+		Use:     "denoms",
+		Short:   "Query for all token denominations",
+		Long:    "Query for all token denominations",
+		Example: fmt.Sprintf("%s query ibc-transfer denoms", version.AppName),
 		Args:    cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			clientCtx, err := client.GetClientQueryContext(cmd)
 			if err != nil {
 				return err
 			}
-			queryClient := types.NewQueryClient(clientCtx)
+			queryClient := types.NewQueryV2Client(clientCtx)
 
 			pageReq, err := client.ReadPageRequest(cmd.Flags())
 			if err != nil {
 				return err
 			}
 
-			req := &types.QueryDenomTracesRequest{
+			req := &types.QueryDenomsRequest{
 				Pagination: pageReq,
 			}
 
-			res, err := queryClient.DenomTraces(cmd.Context(), req)
+			res, err := queryClient.Denoms(cmd.Context(), req)
 			if err != nil {
 				return err
 			}
@@ -78,7 +77,7 @@ func GetCmdQueryDenomTraces() *cobra.Command {
 		},
 	}
 	flags.AddQueryFlagsToCmd(cmd)
-	flags.AddPaginationFlagsToCmd(cmd, "denominations trace")
+	flags.AddPaginationFlagsToCmd(cmd, "denominations")
 
 	return cmd
 }

modules/apps/transfer/keeper/export_test.go

@@ -0,0 +1,28 @@
+package keeper
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/cosmos/ibc-go/v8/modules/apps/transfer/types"
+)
+
+// SetDenomTraces is a wrapper around iterateDenomTraces for testing purposes.
+func (k Keeper) SetDenomTrace(ctx sdk.Context, denomTrace types.DenomTrace) {
+	k.setDenomTrace(ctx, denomTrace)
+}
+
+// IterateDenomTraces is a wrapper around iterateDenomTraces for testing purposes.
+func (k Keeper) IterateDenomTraces(ctx sdk.Context, cb func(denomTrace types.DenomTrace) bool) {
+	k.iterateDenomTraces(ctx, cb)
+}
+
+// GetAllDenomTraces returns the trace information for all the denominations.
+func (k Keeper) GetAllDenomTraces(ctx sdk.Context) []types.DenomTrace {
+	var traces []types.DenomTrace
+	k.iterateDenomTraces(ctx, func(denomTrace types.DenomTrace) bool {
+		traces = append(traces, denomTrace)
+		return false
+	})
+
+	return traces
+}

modules/apps/transfer/keeper/genesis.go

@@ -12,9 +12,9 @@ import (
 func (k Keeper) InitGenesis(ctx sdk.Context, state types.GenesisState) {
 	k.SetPort(ctx, state.PortId)
 
-	for _, trace := range state.DenomTraces {
-		k.SetDenomTrace(ctx, trace)
-		k.setDenomMetadata(ctx, trace)
+	for _, denom := range state.Denoms {
+		k.SetDenom(ctx, denom)
+		k.setDenomMetadata(ctx, denom)
 	}
 
 	// Only try to bind to port if it is not already bound, since we may already own
@@ -41,7 +41,7 @@ func (k Keeper) InitGenesis(ctx sdk.Context, state types.GenesisState) {
 func (k Keeper) ExportGenesis(ctx sdk.Context) *types.GenesisState {
 	return &types.GenesisState{
 		PortId:        k.GetPort(ctx),
-		DenomTraces:   k.GetAllDenomTraces(ctx),
+		Denoms:        k.GetAllDenoms(ctx),
 		Params:        k.GetParams(ctx),
 		TotalEscrowed: k.GetAllTotalEscrowed(ctx),
 	}

modules/apps/transfer/keeper/genesis_test.go

@@ -16,47 +16,47 @@ func (suite *KeeperTestSuite) TestGenesis() {
 	}
 
 	var (
-		denomTraces           types.Traces
+		denoms                types.Denoms
 		escrows               sdk.Coins
-		pathsAndEscrowAmounts = []struct {
-			path   string
+		traceAndEscrowAmounts = []struct {
+			trace  []string
 			escrow string
 		}{
-			{getTrace(0), "10"},
-			{fmt.Sprintf("%s/%s", getTrace(1), getTrace(0)), "100000"},
-			{fmt.Sprintf("%s/%s/%s", getTrace(2), getTrace(1), getTrace(0)), "10000000000"},
-			{fmt.Sprintf("%s/%s/%s/%s", getTrace(3), getTrace(2), getTrace(1), getTrace(0)), "1000000000000000"},
-			{fmt.Sprintf("%s/%s/%s/%s/%s", getTrace(4), getTrace(3), getTrace(2), getTrace(1), getTrace(0)), "100000000000000000000"},
+			{[]string{getTrace(0)}, "10"},
+			{[]string{getTrace(1), getTrace(0)}, "100000"},
+			{[]string{getTrace(2), getTrace(1), getTrace(0)}, "10000000000"},
+			{[]string{getTrace(3), getTrace(2), getTrace(1), getTrace(0)}, "1000000000000000"},
+			{[]string{getTrace(4), getTrace(3), getTrace(2), getTrace(1), getTrace(0)}, "100000000000000000000"},
 		}
 	)
 
-	for _, pathAndEscrowAmount := range pathsAndEscrowAmounts {
-		denomTrace := types.DenomTrace{
-			BaseDenom: "uatom",
-			Path:      pathAndEscrowAmount.path,
+	for _, traceAndEscrowAmount := range traceAndEscrowAmounts {
+		denom := types.Denom{
+			Base:  "uatom",
+			Trace: traceAndEscrowAmount.trace,
 		}
-		denomTraces = append(types.Traces{denomTrace}, denomTraces...)
-		suite.chainA.GetSimApp().TransferKeeper.SetDenomTrace(suite.chainA.GetContext(), denomTrace)
+		denoms = append(denoms, denom)
+		suite.chainA.GetSimApp().TransferKeeper.SetDenom(suite.chainA.GetContext(), denom)
 
-		denom := denomTrace.IBCDenom()
-		amount, ok := sdkmath.NewIntFromString(pathAndEscrowAmount.escrow)
+		amount, ok := sdkmath.NewIntFromString(traceAndEscrowAmount.escrow)
 		suite.Require().True(ok)
-		escrows = append(sdk.NewCoins(sdk.NewCoin(denom, amount)), escrows...)
-		suite.chainA.GetSimApp().TransferKeeper.SetTotalEscrowForDenom(suite.chainA.GetContext(), sdk.NewCoin(denom, amount))
+		escrow := sdk.NewCoin(denom.IBCDenom(), amount)
+		escrows = append(escrows, escrow)
+		suite.chainA.GetSimApp().TransferKeeper.SetTotalEscrowForDenom(suite.chainA.GetContext(), escrow)
 	}
 
 	genesis := suite.chainA.GetSimApp().TransferKeeper.ExportGenesis(suite.chainA.GetContext())
 
 	suite.Require().Equal(types.PortID, genesis.PortId)
-	suite.Require().Equal(denomTraces.Sort(), genesis.DenomTraces)
+	suite.Require().Equal(denoms.Sort(), genesis.Denoms)
 	suite.Require().Equal(escrows.Sort(), genesis.TotalEscrowed)
 
 	suite.Require().NotPanics(func() {
 		suite.chainA.GetSimApp().TransferKeeper.InitGenesis(suite.chainA.GetContext(), *genesis)
 	})
 
-	for _, denomTrace := range denomTraces {
-		_, found := suite.chainA.GetSimApp().BankKeeper.GetDenomMetaData(suite.chainA.GetContext(), denomTrace.IBCDenom())
+	for _, denom := range denoms {
+		_, found := suite.chainA.GetSimApp().BankKeeper.GetDenomMetaData(suite.chainA.GetContext(), denom.IBCDenom())
 		suite.Require().True(found)
 	}
 }

modules/apps/transfer/keeper/grpc_query.go

@@ -19,10 +19,13 @@ import (
 	channeltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
 )
 
-var _ types.QueryServer = (*Keeper)(nil)
+var (
+	_ types.QueryServer   = (*Keeper)(nil)
+	_ types.QueryV2Server = (*Keeper)(nil)
+)
 
-// DenomTrace implements the Query/DenomTrace gRPC method
-func (k Keeper) DenomTrace(c context.Context, req *types.QueryDenomTraceRequest) (*types.QueryDenomTraceResponse, error) {
+// Denom implements the Query/Denom gRPC method
+func (k Keeper) Denom(c context.Context, req *types.QueryDenomRequest) (*types.QueryDenomResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
@@ -33,46 +36,46 @@ func (k Keeper) DenomTrace(c context.Context, req *types.QueryDenomTraceRequest)
 	}
 
 	ctx := sdk.UnwrapSDKContext(c)
-	denomTrace, found := k.GetDenomTrace(ctx, hash)
+	denom, found := k.GetDenom(ctx, hash)
 	if !found {
 		return nil, status.Error(
 			codes.NotFound,
-			errorsmod.Wrap(types.ErrTraceNotFound, req.Hash).Error(),
+			errorsmod.Wrap(types.ErrDenomNotFound, req.Hash).Error(),
 		)
 	}
 
-	return &types.QueryDenomTraceResponse{
-		DenomTrace: &denomTrace,
+	return &types.QueryDenomResponse{
+		Denom: &denom,
 	}, nil
 }
 
-// DenomTraces implements the Query/DenomTraces gRPC method
-func (k Keeper) DenomTraces(c context.Context, req *types.QueryDenomTracesRequest) (*types.QueryDenomTracesResponse, error) {
+// Denoms implements the Query/Denoms gRPC method
+func (k Keeper) Denoms(c context.Context, req *types.QueryDenomsRequest) (*types.QueryDenomsResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
 
 	ctx := sdk.UnwrapSDKContext(c)
 
-	var traces types.Traces
-	store := prefix.NewStore(ctx.KVStore(k.storeKey), types.DenomTraceKey)
+	var denoms types.Denoms
+	store := prefix.NewStore(ctx.KVStore(k.storeKey), types.DenomKey)
 
 	pageRes, err := query.Paginate(store, req.Pagination, func(_, value []byte) error {
-		var denomTrace types.DenomTrace
-		if err := k.cdc.Unmarshal(value, &denomTrace); err != nil {
+		var denom types.Denom
+		if err := k.cdc.Unmarshal(value, &denom); err != nil {
 			return err
 		}
 
-		traces = append(traces, denomTrace)
+		denoms = append(denoms, denom)
 		return nil
 	})
 	if err != nil {
 		return nil, err
 	}
 
-	return &types.QueryDenomTracesResponse{
-		DenomTraces: traces.Sort(),
-		Pagination:  pageRes,
+	return &types.QueryDenomsResponse{
+		Denoms:     denoms.Sort(),
+		Pagination: pageRes,
 	}, nil
 }
 
@@ -92,19 +95,19 @@ func (k Keeper) DenomHash(c context.Context, req *types.QueryDenomHashRequest) (
 		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
 
-	// Convert given request trace path to DenomTrace struct to confirm the path in a valid denom trace format
+	// Convert given request trace path to Denom struct to confirm the path in a valid denom trace format
 	denomTrace := types.ParseDenomTrace(req.Trace)
 	if err := denomTrace.Validate(); err != nil {
 		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
 	ctx := sdk.UnwrapSDKContext(c)
 	denomHash := denomTrace.Hash()
-	found := k.HasDenomTrace(ctx, denomHash)
+	found := k.HasDenom(ctx, denomHash)
 	if !found {
 		return nil, status.Error(
 			codes.NotFound,
-			errorsmod.Wrap(types.ErrTraceNotFound, req.Trace).Error(),
+			errorsmod.Wrap(types.ErrDenomNotFound, req.Trace).Error(),
 		)
 	}
 
@@ -156,3 +159,15 @@ func (k Keeper) TotalEscrowForDenom(c context.Context, req *types.QueryTotalEscr
 		Amount: amount,
 	}, nil
 }
+
+// DenomTrace implements the Query/DenomTrace gRPC method
+// Deprecated: Please use Denom instead.
+func (Keeper) DenomTrace(c context.Context, req *types.QueryDenomTraceRequest) (*types.QueryDenomTraceResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "unsupported rpc")
+}
+
+// DenomTraces implements the Query/DenomTraces gRPC method
+// Deprecated: Please use Denoms instead.
+func (Keeper) DenomTraces(c context.Context, req *types.QueryDenomTracesRequest) (*types.QueryDenomTracesResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "unsupported rpc")
+}