WIP: add cll tx,query cmds

1. add cli queries for rate_limits and params
2. add updateProposal for rate_limits and ibcPause status

app/app.go

@@ -503,7 +503,7 @@ func New(
 
 	app.ibcRateLimitKeeper = ibcratelimitkeeper.NewKeeper(
 		appCodec,
-		keys[ibchost.StoreKey], app.GetSubspace(ibcratelimittypes.ModuleName),
+		keys[ibcratelimittypes.StoreKey], app.GetSubspace(ibcratelimittypes.ModuleName),
 		app.IBCKeeper.ChannelKeeper,
 		authtypes.NewModuleAddress(govtypes.ModuleName).String(),
 	)
@@ -643,6 +643,7 @@ func New(
 		leverage.NewAppModule(appCodec, app.LeverageKeeper, app.AccountKeeper, app.BankKeeper),
 		oracle.NewAppModule(appCodec, app.OracleKeeper, app.AccountKeeper, app.BankKeeper),
 		bech32ibc.NewAppModule(appCodec, app.bech32IbcKeeper),
+		ibcratelimit.NewAppModule(appCodec, app.ibcRateLimitKeeper),
 	}
 	if Experimental {
 		appModules = append(appModules,
@@ -669,6 +670,7 @@ func New(
 		oracletypes.ModuleName,
 		gravitytypes.ModuleName,
 		bech32ibctypes.ModuleName,
+		ibcratelimittypes.ModuleName,
 	}
 	endBlockers := []string{
 		crisistypes.ModuleName,
@@ -684,6 +686,7 @@ func New(
 		leveragetypes.ModuleName,
 		gravitytypes.ModuleName,
 		bech32ibctypes.ModuleName,
+		ibcratelimittypes.ModuleName,
 	}
 
 	// NOTE: The genutils module must occur after staking so that pools are
@@ -704,6 +707,7 @@ func New(
 		leveragetypes.ModuleName,
 		gravitytypes.ModuleName,
 		bech32ibctypes.ModuleName,
+		ibcratelimittypes.ModuleName,
 	}
 	orderMigrations := []string{
 		capabilitytypes.ModuleName, authtypes.ModuleName, banktypes.ModuleName, distrtypes.ModuleName,
@@ -717,7 +721,7 @@ func New(
 		leveragetypes.ModuleName,
 		gravitytypes.ModuleName,
 		bech32ibctypes.ModuleName,
-	}
+		ibcratelimittypes.ModuleName}
 
 	if Experimental {
 		beginBlockers = append(beginBlockers, wasm.ModuleName)
@@ -1018,6 +1022,7 @@ func initParamsKeeper(
 	paramsKeeper.Subspace(ibchost.ModuleName)
 	// paramsKeeper.Subspace(icacontrollertypes.SubModuleName)
 	// paramsKeeper.Subspace(icahosttypes.SubModuleName)
+	paramsKeeper.Subspace(ibcratelimittypes.ModuleName)
 	paramsKeeper.Subspace(gravitytypes.ModuleName)
 	paramsKeeper.Subspace(leveragetypes.ModuleName)
 	paramsKeeper.Subspace(oracletypes.ModuleName)

proto/umee/ibc_rate_limit/v1beta1/query.proto

@@ -12,15 +12,20 @@ option (gogoproto.goproto_getters_all) = false;
 
 // Query defines the gRPC querier service.
 service Query {
-  // Params queries the parameters of the x/leverage module.
+  // Params queries the parameters of the x/ibc-rate-limit module.
   rpc Params(QueryParams) returns (QueryParamsResponse) {
     option (google.api.http).get = "/umee/ibc_rate_limit/v1/params";
   }
 
-  // RateLimits 
-  rpc RateLimits(QueryRateLimits) returns (QueryRateLimitsResponse) {
+  // RateLimitsOfIBCDenoms queries the rate limits of ibc denoms.
+  rpc RateLimitsOfIBCDenoms(QueryRateLimitsOfIBCDenoms) returns (QueryRateLimitsOfIBCDenomsResponse) {
     option (google.api.http).get = "/umee/ibc_rate_limit/v1/rate_limits";
   }
+
+  // RateLimitsOfIBCDenom queries the rate limits of ibc denom.
+  rpc RateLimitsOfIBCDenom(QueryRateLimitsOfIBCDenom) returns (QueryRateLimitsOfIBCDenomResponse) {
+    option (google.api.http).get = "/umee/ibc_rate_limit/v1/rate_limits/{ibc_denom}";
+  }
 }
 
 // QueryParams defines the request structure for the Params gRPC service
@@ -33,11 +38,20 @@ message QueryParamsResponse {
   Params params = 1 [(gogoproto.nullable) = false];
 }
 
-// QueryRateLimits
-message QueryRateLimits{}
+// QueryRateLimitsOfIBCDenoms defines request type
+message QueryRateLimitsOfIBCDenoms{}
 
-// QueryRateLimitsResponse defines 
-message QueryRateLimitsResponse{
-    repeated RateLimit rate_limits = 1 [(gogoproto.nullable) = false];
+// QueryRateLimitsOfIBCDenomsResponse defines response type 
+message QueryRateLimitsOfIBCDenomsResponse{
+  repeated RateLimit rate_limits = 1 [(gogoproto.nullable) = false];
 }
 
+// QueryRateLimitsOfIBCDenom defines request type 
+message QueryRateLimitsOfIBCDenom{
+  string ibc_denom = 1;
+}
+
+// QueryRateLimitsOfIBCDenomResponse defines response type of QueryRateLimitsOfIBCDenom
+message QueryRateLimitsOfIBCDenomResponse{
+  RateLimit rate_limit = 1 [(gogoproto.nullable) = false];
+}

proto/umee/ibc_rate_limit/v1beta1/tx.proto

@@ -17,11 +17,13 @@ service Msg {
     // UpdateIBCDenomsRateLimit adds new rate limits for ibc denoms or 
     // updates the rate limits for existed ibc denoms.
     rpc UpdateIBCDenomsRateLimit(MsgUpdateIBCDenomsRateLimit) returns (MsgUpdateIBCDenomsRateLimitResponse);
+
+    // UpdateIBCTransferPauseStatus
+    rpc UpdateIBCTransferPauseStatus(MsgUpdateIBCTransferPauseStatus) returns (MsgUpdateIBCTransferPauseStatusResponse);
 }
 
 // MsgUpdateIBCDenomsRateLimit defines the Msg/UpdateIBCDenomsRateLimit request type.
 message MsgUpdateIBCDenomsRateLimit {
-    // option (gogoproto.equal)            = true;
     option (gogoproto.goproto_getters)  = false;
     option (gogoproto.goproto_stringer) = false;
     option (cosmos.msg.v1.signer) = "authority";
@@ -36,5 +38,21 @@ message MsgUpdateIBCDenomsRateLimit {
     repeated RateLimit update_ibc_denoms_rate_limits = 5 [(gogoproto.nullable) = false];
 }
 
-// MsgUpdateIBCDenomsRateLimitResponse defines the Msg/UpdateIBCDenomsRateLimit response type.
+// MsgUpdateIBCDenomsRateLimitResponse defines response type for the Msg/UpdateIBCDenomsRateLimit
 message MsgUpdateIBCDenomsRateLimitResponse {};
+
+// MsgUpdateIBCTransferPauseStatus defines request type for UpdateIBCTransferStatus
+message MsgUpdateIBCTransferPauseStatus {
+    option (gogoproto.goproto_getters)  = false;
+    option (gogoproto.goproto_stringer) = false;
+    option (cosmos.msg.v1.signer) = "authority";
+    // authority is the address of the governance account.
+    string         authority   = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+    string         title       = 2;
+    string         description = 3;
+    // ibc_pause_status defines ibc transfer pause status
+    bool ibc_pause_status = 4;
+}
+
+// MsgUpdateIBCTransferPauseStatusResponse definesresponse type for Msg/MsgUpdateIBCTransferPauseStatus
+message MsgUpdateIBCTransferPauseStatusResponse {}

x/ibc-rate-limit/client/cli/query.go

@@ -4,12 +4,14 @@ import (
 	"fmt"
 
 	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
 	"github.com/spf13/cobra"
+	"github.com/umee-network/umee/v3/util/cli"
 	"github.com/umee-network/umee/v3/x/ibc-rate-limit/types"
 )
 
 // GetQueryCmd returns the CLI query commands for the x/ibc-rate-limit module.
-func GetQueryCmd() *cobra.Command {
+func GetQueryCmd(queryRoute string) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:                        types.ModuleName,
 		Short:                      fmt.Sprintf("Querying commands for the %s module", types.ModuleName),
@@ -18,7 +20,61 @@ func GetQueryCmd() *cobra.Command {
 		RunE:                       client.ValidateCmd,
 	}
 
-	cmd.AddCommand()
+	cmd.AddCommand(
+		GetCmdQueryParams(),
+		GetRateLimitsForIBCDenoms(),
+	)
 
 	return cmd
 }
+
+// GetCmdQueryParams creates a Cobra command to query for the x/ibc-rate-limit
+// module parameters.
+func GetCmdQueryParams() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "params",
+		Args:  cobra.NoArgs,
+		Short: "Query the x/ibc-rate-limit module parameters",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			queryClient := types.NewQueryClient(clientCtx)
+			resp, err := queryClient.Params(cmd.Context(), &types.QueryParams{})
+			return cli.PrintOrErr(resp, err, clientCtx)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}
+
+// GetRateLimitsForIBCDenoms
+func GetRateLimitsForIBCDenoms() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "rate-limits [ibc-denom]",
+		Args:  cobra.MaximumNArgs(1),
+		Short: "Get the rate limits for ibc denoms",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			queryClient := types.NewQueryClient(clientCtx)
+			if len(args) > 0 {
+				resp, err := queryClient.RateLimitsOfIBCDenom(cmd.Context(), &types.QueryRateLimitsOfIBCDenom{IbcDenom: args[0]})
+				return cli.PrintOrErr(resp, err, clientCtx)
+			}
+
+			resp, err := queryClient.RateLimitsOfIBCDenoms(cmd.Context(), &types.QueryRateLimitsOfIBCDenoms{})
+			return cli.PrintOrErr(resp, err, clientCtx)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	return cmd
+}

x/ibc-rate-limit/client/cli/tx.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 
 	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/client/tx"
 	"github.com/spf13/cobra"
 	"github.com/umee-network/umee/v3/x/ibc-rate-limit/types"
 )
@@ -18,7 +20,43 @@ func GetTxCmd() *cobra.Command {
 		RunE:                       client.ValidateCmd,
 	}
 
-	cmd.AddCommand()
+	cmd.AddCommand(
+		SampleTOkenRegistration(),
+	)
+
+	return cmd
+}
+
+func SampleTOkenRegistration() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "register",
+		Args:  cobra.NoArgs,
+		Short: "Supply a specified amount of a supported asset",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+			addRateLimits := []types.RateLimit{
+				{
+					IbcDenom:     "sai",
+					OutflowLimit: 1234,
+					Window:       1000,
+				},
+				{
+					IbcDenom:     "raj",
+					OutflowLimit: 1234,
+					Window:       1000,
+				},
+			}
+
+			msg := types.NewIbcDenomsRateLimits(clientCtx.FromAddress.String(), "title", "desc", addRateLimits, nil)
+
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
 
 	return cmd
 }

x/ibc-rate-limit/genesis.go

@@ -10,11 +10,20 @@ import (
 // state.
 func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState) {
 	k.SetParams(ctx, genState.Params)
+	if err := k.SetRateLimitsOfIBCDenoms(ctx, genState.RateLimits); err != nil {
+		panic(err)
+	}
 }
 
 // ExportGenesis returns the x/leverage module's exported genesis state.
 func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState {
+	rateLimits, err := k.GetRateLimitsOfIBCDenoms(ctx)
+	if err != nil {
+		panic(err)
+	}
+
 	return &types.GenesisState{
-		Params: k.GetParams(ctx),
+		Params:     k.GetParams(ctx),
+		RateLimits: rateLimits,
 	}
 }

x/ibc-rate-limit/keeper/grpc_query.go

@@ -11,7 +11,7 @@ import (
 
 var _ types.QueryServer = Querier{}
 
-// Querier implements a QueryServer for the x/leverage module.
+// Querier implements a QueryServer for the x/ibc-rate-limit module.
 type Querier struct {
 	Keeper
 }
@@ -32,7 +32,32 @@ func (q Querier) Params(goCtx context.Context, req *types.QueryParams) (*types.Q
 	return &types.QueryParamsResponse{Params: params}, nil
 }
 
-// RateLimits implements types.QueryServer
-func (Querier) RateLimits(context.Context, *types.QueryRateLimits) (*types.QueryRateLimitsResponse, error) {
-	return &types.QueryRateLimitsResponse{}, nil
+// RateLimitsOfIBCDenom implements types.QueryServer
+func (q Querier) RateLimitsOfIBCDenom(goCtx context.Context, req *types.QueryRateLimitsOfIBCDenom) (*types.QueryRateLimitsOfIBCDenomResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "empty request")
+	}
+
+	ctx := sdk.UnwrapSDKContext(goCtx)
+	rateLimit, err := q.Keeper.GetRateLimitsOfIBCDenom(ctx, req.IbcDenom)
+	if err != nil {
+		return &types.QueryRateLimitsOfIBCDenomResponse{}, nil
+	}
+
+	return &types.QueryRateLimitsOfIBCDenomResponse{RateLimit: rateLimit}, nil
+}
+
+// RateLimitsOfIBCDenoms implements types.QueryServer
+func (q Querier) RateLimitsOfIBCDenoms(goCtx context.Context, req *types.QueryRateLimitsOfIBCDenoms) (*types.QueryRateLimitsOfIBCDenomsResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "empty request")
+	}
+
+	ctx := sdk.UnwrapSDKContext(goCtx)
+	rateLimits, err := q.Keeper.GetRateLimitsOfIBCDenoms(ctx)
+	if err != nil {
+		return &types.QueryRateLimitsOfIBCDenomsResponse{}, err
+	}
+
+	return &types.QueryRateLimitsOfIBCDenomsResponse{RateLimits: rateLimits}, nil
 }

x/ibc-rate-limit/keeper/keeper.go

@@ -3,6 +3,7 @@ package keeper
 import (
 	"github.com/cosmos/cosmos-sdk/codec"
 	storetypes "github.com/cosmos/cosmos-sdk/store/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
 	"github.com/umee-network/umee/v3/x/ibc-rate-limit/types"
 )
@@ -19,6 +20,11 @@ func NewKeeper(
 	cdc codec.BinaryCodec, key storetypes.StoreKey, paramSpace paramtypes.Subspace, ics4Wrapper types.ICS4Wrapper,
 	authority string,
 ) Keeper {
+	// set KeyTable if it has not already been set
+	if !paramSpace.HasKeyTable() {
+		paramSpace = paramSpace.WithKeyTable(types.ParamKeyTable())
+	}
+
 	return Keeper{
 		cdc:         cdc,
 		storeKey:    key,
@@ -27,3 +33,18 @@ func NewKeeper(
 		authority:   authority,
 	}
 }
+
+// UpdateIBCTansferStatus update the ibc pause status in module params.
+func (k Keeper) UpdateIBCTansferStatus(ctx sdk.Context, ibcStatus bool) error {
+	var ibcPause bool
+	k.paramSpace.Get(ctx, types.KeyIBCPause, &ibcPause)
+
+	if ibcPause == ibcPause {
+		return types.ErrIBCPauseStatus
+	}
+
+	// update the ibc status
+	k.paramSpace.Set(ctx, types.KeyIBCPause, ibcStatus)
+
+	return nil
+}