diff --git a/proto/umee/uibc/v1/events.proto b/proto/umee/uibc/v1/events.proto
index f7035c0932..c5f54ad287 100644
--- a/proto/umee/uibc/v1/events.proto
+++ b/proto/umee/uibc/v1/events.proto
@@ -15,7 +15,7 @@ message EventBadRevert {
   string packet = 2;
 }
 
-// EventQuotaPause is emitted on quota tracking pause status change.
-message EventQuotaPause {
+// EventIBCTransferStatus is emitted on quota tracking pause status change.
+message EventIBCTransferStatus {
   IBCTransferStatus status = 1;
 }
diff --git a/proto/umee/uibc/v1/quota.proto b/proto/umee/uibc/v1/quota.proto
index 567f8e6054..31960afd5d 100644
--- a/proto/umee/uibc/v1/quota.proto
+++ b/proto/umee/uibc/v1/quota.proto
@@ -10,7 +10,7 @@ option go_package = "github.com/umee-network/umee/v4/x/uibc";
 // Params of x/uibc module
 message Params {
   // ibc_status defines the wethever ibc-transfer enabled, disbaled or paused
-  IBCTransferStatus ibc_pause = 1;
+  IBCTransferStatus ibc_status = 1;
   // total_quota defines the total outflow limit of ibc-transfer in USD
   string total_quota = 2 [
     (cosmos_proto.scalar)  = "cosmos.Dec",
@@ -36,10 +36,10 @@ message Params {
 enum IBCTransferStatus {
   // UNSPECIFIED  defines a no-op status.
   IBC_TRANSFER_STATUS_UNSPECIFIED = 0;
-  // DISABLED defines the quota checking diabled for ibc-transfer.
-  IBC_TRANSFER_STATUS_DISABLED = 1;
-  // ENABLED defines the enable quota checking for ibc-transfer.
-  IBC_TRANSFER_STATUS_ENABLED = 2;
-  // PAUSED defines pause the ibc-transfer from app.
-  IBC_TRANSFER_STATUS_PAUSED = 3;
+  // DISABLED: quota checks are disabled.
+  IBC_TRANSFER_STATUS_QUOTA_DISABLED = 1;
+  // ENABLED: quota checks are enabled.
+  IBC_TRANSFER_STATUS_QUOTA_ENABLED = 2;
+  // PAUSED: all IBC transfers are paused.
+  IBC_TRANSFER_STATUS_TRANSFERS_PAUSED = 3;
 }
diff --git a/proto/umee/uibc/v1/tx.proto b/proto/umee/uibc/v1/tx.proto
index 861f5daa64..de21d20df2 100644
--- a/proto/umee/uibc/v1/tx.proto
+++ b/proto/umee/uibc/v1/tx.proto
@@ -18,8 +18,8 @@ service Msg {
   // updates the quota for existed ibc denoms.
   rpc GovUpdateQuota(MsgGovUpdateQuota) returns (MsgGovUpdateQuotaResponse);
 
-  // GovSetIBCPause update the status of ibc-transfer
-  rpc GovSetIBCPause(MsgGovSetIBCPause) returns (MsgGovSetIBCPauseResponse);
+  // GovSetIBCStatus update the status of ibc-transfer
+  rpc GovSetIBCStatus(MsgGovSetIBCStatus) returns (MsgGovSetIBCStatusResponse);
 }
 
 // MsgGovUpdateQuota defines the Msg/GovUpdateQuota request type.
@@ -56,8 +56,8 @@ message MsgGovUpdateQuota {
 // MsgGovUpdateQuotaResponse defines response type for the Msg/GovUpdateQuota for with x/gov proposals.
 message MsgGovUpdateQuotaResponse {};
 
-// MsgGovSetIBCPause defines request type for UpdateIBCTransferStatus
-message MsgGovSetIBCPause {
+// MsgGovSetIbcstatus defines request type for UpdateIBCTransferStatus
+message MsgGovSetIBCStatus {
   option (gogoproto.goproto_getters)  = false;
   option (gogoproto.goproto_stringer) = false;
   option (cosmos.msg.v1.signer)       = "authority";
@@ -65,9 +65,9 @@ message MsgGovSetIBCPause {
   string authority   = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"];
   string title       = 2;
   string description = 3;
-  // ibc_pause_status defines ibc transfer pause status
-  IBCTransferStatus ibc_pause_status = 4;
+  // ibc_status defines ibc transfer pause status
+  IBCTransferStatus ibc_status = 4;
 }
 
-// MsgGovSetIBCPauseResponse definesresponse type for Msg/MsgGovSetIBCPause for with x/gov proposals.
-message MsgGovSetIBCPauseResponse {}
+// MsgGovSetIbcstatusResponse definesresponse type for Msg/MsgGovSetIbcstatus for with x/gov proposals.
+message MsgGovSetIBCStatusResponse {}
diff --git a/x/uibc/codec.go b/x/uibc/codec.go
index a790b3bcc6..e805c8b818 100644
--- a/x/uibc/codec.go
+++ b/x/uibc/codec.go
@@ -28,14 +28,14 @@ func init() {
 // Amino JSON serialization.
 func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
 	cdc.RegisterConcrete(&MsgGovUpdateQuota{}, "umee/uibc/MsgGovUpdateQuota", nil)
-	cdc.RegisterConcrete(&MsgGovSetIBCPause{}, "umee/uibc/MsgGovSetIBCPause", nil)
+	cdc.RegisterConcrete(&MsgGovSetIBCStatus{}, "umee/uibc/MsgGovSetIBCStatus", nil)
 }
 
 func RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
 	registry.RegisterImplementations(
 		(*sdk.Msg)(nil),
 		&MsgGovUpdateQuota{},
-		&MsgGovSetIBCPause{},
+		&MsgGovSetIBCStatus{},
 	)
 
 	msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)
diff --git a/x/uibc/events.pb.go b/x/uibc/events.pb.go
index 2ab5a5a219..4971a16b2c 100644
--- a/x/uibc/events.pb.go
+++ b/x/uibc/events.pb.go
@@ -64,23 +64,23 @@ func (m *EventBadRevert) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_EventBadRevert proto.InternalMessageInfo
 
-// EventQuotaPause is emitted on quota tracking pause status change.
-type EventQuotaPause struct {
+// EventIBCTransferStatus is emitted on quota tracking pause status change.
+type EventIBCTransferStatus struct {
 	Status IBCTransferStatus `protobuf:"varint,1,opt,name=status,proto3,enum=umee.uibc.v1.IBCTransferStatus" json:"status,omitempty"`
 }
 
-func (m *EventQuotaPause) Reset()         { *m = EventQuotaPause{} }
-func (m *EventQuotaPause) String() string { return proto.CompactTextString(m) }
-func (*EventQuotaPause) ProtoMessage()    {}
-func (*EventQuotaPause) Descriptor() ([]byte, []int) {
+func (m *EventIBCTransferStatus) Reset()         { *m = EventIBCTransferStatus{} }
+func (m *EventIBCTransferStatus) String() string { return proto.CompactTextString(m) }
+func (*EventIBCTransferStatus) ProtoMessage()    {}
+func (*EventIBCTransferStatus) Descriptor() ([]byte, []int) {
 	return fileDescriptor_c64e60b79cebf048, []int{1}
 }
-func (m *EventQuotaPause) XXX_Unmarshal(b []byte) error {
+func (m *EventIBCTransferStatus) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *EventQuotaPause) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *EventIBCTransferStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_EventQuotaPause.Marshal(b, m, deterministic)
+		return xxx_messageInfo_EventIBCTransferStatus.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -90,27 +90,27 @@ func (m *EventQuotaPause) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
 		return b[:n], nil
 	}
 }
-func (m *EventQuotaPause) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EventQuotaPause.Merge(m, src)
+func (m *EventIBCTransferStatus) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EventIBCTransferStatus.Merge(m, src)
 }
-func (m *EventQuotaPause) XXX_Size() int {
+func (m *EventIBCTransferStatus) XXX_Size() int {
 	return m.Size()
 }
-func (m *EventQuotaPause) XXX_DiscardUnknown() {
-	xxx_messageInfo_EventQuotaPause.DiscardUnknown(m)
+func (m *EventIBCTransferStatus) XXX_DiscardUnknown() {
+	xxx_messageInfo_EventIBCTransferStatus.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_EventQuotaPause proto.InternalMessageInfo
+var xxx_messageInfo_EventIBCTransferStatus proto.InternalMessageInfo
 
 func init() {
 	proto.RegisterType((*EventBadRevert)(nil), "umee.uibc.v1.EventBadRevert")
-	proto.RegisterType((*EventQuotaPause)(nil), "umee.uibc.v1.EventQuotaPause")
+	proto.RegisterType((*EventIBCTransferStatus)(nil), "umee.uibc.v1.EventIBCTransferStatus")
 }
 
 func init() { proto.RegisterFile("umee/uibc/v1/events.proto", fileDescriptor_c64e60b79cebf048) }
 
 var fileDescriptor_c64e60b79cebf048 = []byte{
-	// 266 bytes of a gzipped FileDescriptorProto
+	// 260 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2c, 0xcd, 0x4d, 0x4d,
 	0xd5, 0x2f, 0xcd, 0x4c, 0x4a, 0xd6, 0x2f, 0x33, 0xd4, 0x4f, 0x2d, 0x4b, 0xcd, 0x2b, 0x29, 0xd6,
 	0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x01, 0x49, 0xe9, 0x81, 0xa4, 0xf4, 0xca, 0x0c, 0xa5,
@@ -119,15 +119,15 @@ var fileDescriptor_c64e60b79cebf048 = []byte{
 	0x94, 0xa0, 0xd4, 0xb2, 0xd4, 0xa2, 0x12, 0x21, 0x45, 0x2e, 0x9e, 0xb4, 0xc4, 0xcc, 0x9c, 0xd2,
 	0xa2, 0xd4, 0xf8, 0x92, 0xca, 0x82, 0x54, 0x09, 0x46, 0x05, 0x46, 0x0d, 0xce, 0x20, 0x6e, 0xa8,
 	0x58, 0x48, 0x65, 0x41, 0xaa, 0x90, 0x18, 0x17, 0x5b, 0x41, 0x62, 0x72, 0x76, 0x6a, 0x89, 0x04,
-	0x13, 0x58, 0x12, 0xca, 0x53, 0xf2, 0xe2, 0xe2, 0x07, 0x1b, 0x16, 0x08, 0xb2, 0x20, 0x20, 0xb1,
-	0xb4, 0x38, 0x55, 0xc8, 0x9c, 0x8b, 0xad, 0xb8, 0x24, 0xb1, 0xa4, 0xb4, 0x18, 0x6c, 0x0e, 0x9f,
-	0x91, 0xbc, 0x1e, 0xb2, 0x73, 0xf5, 0x3c, 0x9d, 0x9c, 0x43, 0x8a, 0x12, 0xf3, 0x8a, 0xd3, 0x52,
-	0x8b, 0x82, 0xc1, 0xca, 0x82, 0xa0, 0xca, 0x9d, 0x5c, 0x4e, 0x3c, 0x94, 0x63, 0x38, 0xf1, 0x48,
-	0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96, 0x63, 0xb8, 0xf0,
-	0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0xb5, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd,
-	0xe4, 0xfc, 0x5c, 0x7d, 0x90, 0x81, 0xba, 0x79, 0xa9, 0x25, 0xe5, 0xf9, 0x45, 0xd9, 0x60, 0x8e,
-	0x7e, 0x99, 0x89, 0x7e, 0x05, 0xd8, 0xb7, 0x49, 0x6c, 0x60, 0x5f, 0x1a, 0x03, 0x02, 0x00, 0x00,
-	0xff, 0xff, 0x3f, 0x48, 0xe0, 0x6d, 0x40, 0x01, 0x00, 0x00,
+	0x13, 0x58, 0x12, 0xca, 0x53, 0x0a, 0xe4, 0x12, 0x03, 0x1b, 0xe6, 0xe9, 0xe4, 0x1c, 0x52, 0x94,
+	0x98, 0x57, 0x9c, 0x96, 0x5a, 0x14, 0x5c, 0x92, 0x58, 0x52, 0x5a, 0x2c, 0x64, 0xce, 0xc5, 0x56,
+	0x0c, 0x66, 0x81, 0x8d, 0xe3, 0x33, 0x92, 0xd7, 0x43, 0x76, 0xb5, 0x1e, 0x86, 0x86, 0x20, 0xa8,
+	0x72, 0x27, 0x97, 0x13, 0x0f, 0xe5, 0x18, 0x4e, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1,
+	0xc1, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, 0xb8, 0xf1, 0x58, 0x8e,
+	0x21, 0x4a, 0x2d, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0x64, 0xa0,
+	0x6e, 0x5e, 0x6a, 0x49, 0x79, 0x7e, 0x51, 0x36, 0x98, 0xa3, 0x5f, 0x66, 0xa2, 0x5f, 0x01, 0xf6,
+	0x74, 0x12, 0x1b, 0xd8, 0xb3, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2f, 0xc0, 0x80, 0xb6,
+	0x47, 0x01, 0x00, 0x00,
 }
 
 func (m *EventBadRevert) Marshal() (dAtA []byte, err error) {
@@ -167,7 +167,7 @@ func (m *EventBadRevert) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *EventQuotaPause) Marshal() (dAtA []byte, err error) {
+func (m *EventIBCTransferStatus) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -177,12 +177,12 @@ func (m *EventQuotaPause) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *EventQuotaPause) MarshalTo(dAtA []byte) (int, error) {
+func (m *EventIBCTransferStatus) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *EventQuotaPause) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *EventIBCTransferStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -223,7 +223,7 @@ func (m *EventBadRevert) Size() (n int) {
 	return n
 }
 
-func (m *EventQuotaPause) Size() (n int) {
+func (m *EventIBCTransferStatus) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -355,7 +355,7 @@ func (m *EventBadRevert) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *EventQuotaPause) Unmarshal(dAtA []byte) error {
+func (m *EventIBCTransferStatus) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -378,10 +378,10 @@ func (m *EventQuotaPause) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: EventQuotaPause: wiretype end group for non-group")
+			return fmt.Errorf("proto: EventIBCTransferStatus: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: EventQuotaPause: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: EventIBCTransferStatus: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
diff --git a/x/uibc/msg.go b/x/uibc/msg.go
index e94c126ac8..4f79ec5b4e 100644
--- a/x/uibc/msg.go
+++ b/x/uibc/msg.go
@@ -11,7 +11,7 @@ import (
 
 var (
 	_ sdk.Msg = &MsgGovUpdateQuota{}
-	_ sdk.Msg = &MsgGovSetIBCPause{}
+	_ sdk.Msg = &MsgGovSetIBCStatus{}
 )
 
 // GetTitle returns the title of the proposal.
@@ -64,30 +64,30 @@ func (msg *MsgGovUpdateQuota) GetSigners() []sdk.AccAddress {
 }
 
 // GetTitle implements govv1b1.Content interface.
-func (msg *MsgGovSetIBCPause) GetTitle() string { return msg.Title }
+func (msg *MsgGovSetIBCStatus) GetTitle() string { return msg.Title }
 
 // GetDescription implements govv1b1.Content interface.
-func (msg *MsgGovSetIBCPause) GetDescription() string { return msg.Description }
+func (msg *MsgGovSetIBCStatus) GetDescription() string { return msg.Description }
 
 // Route implements Msg
-func (msg MsgGovSetIBCPause) Route() string { return RouterKey }
+func (msg MsgGovSetIBCStatus) Route() string { return RouterKey }
 
 // Type implements Msg
-func (msg MsgGovSetIBCPause) Type() string { return sdk.MsgTypeURL(&msg) }
+func (msg MsgGovSetIBCStatus) Type() string { return sdk.MsgTypeURL(&msg) }
 
 // String implements the Stringer interface.
-func (msg *MsgGovSetIBCPause) String() string {
+func (msg *MsgGovSetIBCStatus) String() string {
 	out, _ := json.Marshal(msg)
 	return string(out)
 }
 
 // ValidateBasic implements Msg
-func (msg *MsgGovSetIBCPause) ValidateBasic() error {
+func (msg *MsgGovSetIBCStatus) ValidateBasic() error {
 	if err := checkers.ValidateAddr(msg.Authority, "authority"); err != nil {
 		return err
 	}
 
-	if err := validateIBCTransferStatus(msg.IbcPauseStatus); err != nil {
+	if err := validateIBCTransferStatus(msg.IbcStatus); err != nil {
 		return err
 	}
 
@@ -95,12 +95,12 @@ func (msg *MsgGovSetIBCPause) ValidateBasic() error {
 }
 
 // GetSignBytes implements Msg
-func (msg *MsgGovSetIBCPause) GetSignBytes() []byte {
+func (msg *MsgGovSetIBCStatus) GetSignBytes() []byte {
 	bz := ModuleCdc.MustMarshalJSON(msg)
 	return sdk.MustSortJSON(bz)
 }
 
 // GetSigners implements Msg
-func (msg *MsgGovSetIBCPause) GetSigners() []sdk.AccAddress {
+func (msg *MsgGovSetIBCStatus) GetSigners() []sdk.AccAddress {
 	return checkers.Signers(msg.Authority)
 }
diff --git a/x/uibc/msg_test.go b/x/uibc/msg_test.go
index e10c2c2032..68ba565417 100644
--- a/x/uibc/msg_test.go
+++ b/x/uibc/msg_test.go
@@ -62,27 +62,27 @@ func TestMsgGovUpdateQuota(t *testing.T) {
 	}
 }
 
-func validMsgGovSetIBCPause() MsgGovSetIBCPause {
-	return MsgGovSetIBCPause{
-		Title:          "title",
-		Authority:      authtypes.NewModuleAddress("gov").String(),
-		Description:    "desc",
-		IbcPauseStatus: 1,
+func validMsgGovSetIBCStatus() MsgGovSetIBCStatus {
+	return MsgGovSetIBCStatus{
+		Title:       "title",
+		Authority:   authtypes.NewModuleAddress("gov").String(),
+		Description: "desc",
+		IbcStatus:   1,
 	}
 }
 
-func TestMsgGovSetIBCPause(t *testing.T) {
+func TestMsgGovSetIBCStatus(t *testing.T) {
 	t.Parallel()
-	validMsg := validMsgGovSetIBCPause()
+	validMsg := validMsgGovSetIBCStatus()
 
 	invalidAuthority := validMsg
 	invalidAuthority.Authority = authtypes.NewModuleAddress("govv").String()
 
-	invalidIBCPauseStatus := validMsg
-	invalidIBCPauseStatus.IbcPauseStatus = 10
+	invalidIBCStatus := validMsg
+	invalidIBCStatus.IbcStatus = 10
 
 	tests := []struct {
-		msg    MsgGovSetIBCPause
+		msg    MsgGovSetIBCStatus
 		name   string
 		errMsg string
 	}{
@@ -96,7 +96,7 @@ func TestMsgGovSetIBCPause(t *testing.T) {
 			errMsg: "invalid authority",
 		}, {
 			name:   "invalid ibc pause status in msg",
-			msg:    invalidIBCPauseStatus,
+			msg:    invalidIBCStatus,
 			errMsg: "invalid ibc-transfer status",
 		},
 	}
diff --git a/x/uibc/params.go b/x/uibc/params.go
index 0468c37a18..027859969b 100644
--- a/x/uibc/params.go
+++ b/x/uibc/params.go
@@ -10,7 +10,7 @@ import (
 // DefaultParams returns default genesis params
 func DefaultParams() Params {
 	return Params{
-		IbcPause:      IBCTransferStatus_IBC_TRANSFER_STATUS_DISABLED,
+		IbcStatus:     IBCTransferStatus_IBC_TRANSFER_STATUS_QUOTA_ENABLED,
 		TotalQuota:    sdk.NewDec(1_000_000),
 		TokenQuota:    sdk.NewDec(600_000),
 		QuotaDuration: time.Second * 60 * 60 * 24, // 24h
@@ -18,22 +18,18 @@ func DefaultParams() Params {
 }
 
 func (p Params) Validate() error {
-	if err := validateIBCTransferStatus(p.IbcPause); err != nil {
+	if err := validateIBCTransferStatus(p.IbcStatus); err != nil {
 		return err
 	}
-
 	if err := validateQuotaDuration(p.QuotaDuration); err != nil {
 		return err
 	}
-
 	if err := validateQuota(p.TotalQuota, "total quota"); err != nil {
 		return err
 	}
-
 	if err := validateQuota(p.TokenQuota, "quota per token"); err != nil {
 		return err
 	}
-
 	if p.TotalQuota.LT(p.TokenQuota) {
 		return fmt.Errorf("token quota shouldn't be less than quota per denom")
 	}
@@ -42,9 +38,9 @@ func (p Params) Validate() error {
 }
 
 func validateIBCTransferStatus(status IBCTransferStatus) error {
-	if status == IBCTransferStatus_IBC_TRANSFER_STATUS_DISABLED ||
-		status == IBCTransferStatus_IBC_TRANSFER_STATUS_ENABLED ||
-		status == IBCTransferStatus_IBC_TRANSFER_STATUS_PAUSED {
+	if status == IBCTransferStatus_IBC_TRANSFER_STATUS_QUOTA_DISABLED ||
+		status == IBCTransferStatus_IBC_TRANSFER_STATUS_QUOTA_ENABLED ||
+		status == IBCTransferStatus_IBC_TRANSFER_STATUS_TRANSFERS_PAUSED {
 		return nil
 	}
 
diff --git a/x/uibc/quota.pb.go b/x/uibc/quota.pb.go
index fadc1d6eaf..b0bc83a27e 100644
--- a/x/uibc/quota.pb.go
+++ b/x/uibc/quota.pb.go
@@ -35,26 +35,26 @@ type IBCTransferStatus int32
 const (
 	// UNSPECIFIED  defines a no-op status.
 	IBCTransferStatus_IBC_TRANSFER_STATUS_UNSPECIFIED IBCTransferStatus = 0
-	// DISABLED defines the quota checking diabled for ibc-transfer.
-	IBCTransferStatus_IBC_TRANSFER_STATUS_DISABLED IBCTransferStatus = 1
-	// ENABLED defines the enable quota checking for ibc-transfer.
-	IBCTransferStatus_IBC_TRANSFER_STATUS_ENABLED IBCTransferStatus = 2
-	// PAUSED defines pause the ibc-transfer from app.
-	IBCTransferStatus_IBC_TRANSFER_STATUS_PAUSED IBCTransferStatus = 3
+	// DISABLED: quota checks are disabled.
+	IBCTransferStatus_IBC_TRANSFER_STATUS_QUOTA_DISABLED IBCTransferStatus = 1
+	// ENABLED: quota checks are enabled.
+	IBCTransferStatus_IBC_TRANSFER_STATUS_QUOTA_ENABLED IBCTransferStatus = 2
+	// PAUSED: all IBC transfers are paused.
+	IBCTransferStatus_IBC_TRANSFER_STATUS_TRANSFERS_PAUSED IBCTransferStatus = 3
 )
 
 var IBCTransferStatus_name = map[int32]string{
 	0: "IBC_TRANSFER_STATUS_UNSPECIFIED",
-	1: "IBC_TRANSFER_STATUS_DISABLED",
-	2: "IBC_TRANSFER_STATUS_ENABLED",
-	3: "IBC_TRANSFER_STATUS_PAUSED",
+	1: "IBC_TRANSFER_STATUS_QUOTA_DISABLED",
+	2: "IBC_TRANSFER_STATUS_QUOTA_ENABLED",
+	3: "IBC_TRANSFER_STATUS_TRANSFERS_PAUSED",
 }
 
 var IBCTransferStatus_value = map[string]int32{
-	"IBC_TRANSFER_STATUS_UNSPECIFIED": 0,
-	"IBC_TRANSFER_STATUS_DISABLED":    1,
-	"IBC_TRANSFER_STATUS_ENABLED":     2,
-	"IBC_TRANSFER_STATUS_PAUSED":      3,
+	"IBC_TRANSFER_STATUS_UNSPECIFIED":      0,
+	"IBC_TRANSFER_STATUS_QUOTA_DISABLED":   1,
+	"IBC_TRANSFER_STATUS_QUOTA_ENABLED":    2,
+	"IBC_TRANSFER_STATUS_TRANSFERS_PAUSED": 3,
 }
 
 func (x IBCTransferStatus) String() string {
@@ -68,7 +68,7 @@ func (IBCTransferStatus) EnumDescriptor() ([]byte, []int) {
 // Params of x/uibc module
 type Params struct {
 	// ibc_status defines the wethever ibc-transfer enabled, disbaled or paused
-	IbcPause IBCTransferStatus `protobuf:"varint,1,opt,name=ibc_pause,json=ibcPause,proto3,enum=umee.uibc.v1.IBCTransferStatus" json:"ibc_pause,omitempty"`
+	IbcStatus IBCTransferStatus `protobuf:"varint,1,opt,name=ibc_status,json=ibcStatus,proto3,enum=umee.uibc.v1.IBCTransferStatus" json:"ibc_status,omitempty"`
 	// total_quota defines the total outflow limit of ibc-transfer in USD
 	TotalQuota github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=total_quota,json=totalQuota,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"total_quota"`
 	// token_quota defines the outflow limit per token in USD
@@ -110,9 +110,9 @@ func (m *Params) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_Params proto.InternalMessageInfo
 
-func (m *Params) GetIbcPause() IBCTransferStatus {
+func (m *Params) GetIbcStatus() IBCTransferStatus {
 	if m != nil {
-		return m.IbcPause
+		return m.IbcStatus
 	}
 	return IBCTransferStatus_IBC_TRANSFER_STATUS_UNSPECIFIED
 }
@@ -132,37 +132,37 @@ func init() {
 func init() { proto.RegisterFile("umee/uibc/v1/quota.proto", fileDescriptor_651be1a0280abcb6) }
 
 var fileDescriptor_651be1a0280abcb6 = []byte{
-	// 470 bytes of a gzipped FileDescriptorProto
+	// 478 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x92, 0x41, 0x8b, 0xd3, 0x40,
-	0x14, 0xc7, 0x33, 0x5b, 0x59, 0xdc, 0x59, 0x5d, 0x6a, 0x50, 0xc8, 0x56, 0x49, 0x4a, 0x05, 0x29,
-	0x62, 0x67, 0xd8, 0xd5, 0x93, 0xac, 0x60, 0xd3, 0x64, 0x21, 0x20, 0xa5, 0x26, 0xed, 0x45, 0x90,
-	0x30, 0xc9, 0xce, 0xc6, 0xd0, 0x26, 0x53, 0x93, 0x49, 0xb5, 0x27, 0x4f, 0xde, 0x3d, 0x0a, 0x7e,
-	0x0d, 0x3f, 0xc4, 0x1e, 0x17, 0x4f, 0xe2, 0xa1, 0x4a, 0x7b, 0xf3, 0xe8, 0x27, 0x90, 0xcc, 0xa4,
-	0xb0, 0xc5, 0x1e, 0x3d, 0x25, 0x6f, 0xfe, 0xff, 0xf7, 0x7b, 0x8f, 0x3f, 0x0f, 0x6a, 0x45, 0x42,
-	0x29, 0x2e, 0xe2, 0x20, 0xc4, 0xb3, 0x23, 0xfc, 0xb6, 0x60, 0x9c, 0xa0, 0x69, 0xc6, 0x38, 0x53,
-	0x6f, 0x94, 0x0a, 0x2a, 0x15, 0x34, 0x3b, 0x6a, 0xdc, 0x8e, 0x58, 0xc4, 0x84, 0x80, 0xcb, 0x3f,
-	0xe9, 0x69, 0xe8, 0x11, 0x63, 0xd1, 0x84, 0x62, 0x51, 0x05, 0xc5, 0x39, 0x3e, 0x2b, 0x32, 0xc2,
-	0x63, 0x96, 0x56, 0xfa, 0x61, 0xc8, 0xf2, 0x84, 0xe5, 0xbe, 0x6c, 0x94, 0x85, 0x94, 0x5a, 0x1f,
-	0x6b, 0x70, 0x77, 0x40, 0x32, 0x92, 0xe4, 0xea, 0x09, 0xdc, 0x8b, 0x83, 0xd0, 0x9f, 0x92, 0x22,
-	0xa7, 0x1a, 0x68, 0x82, 0xf6, 0xc1, 0xb1, 0x81, 0xae, 0x4e, 0x47, 0x8e, 0xd9, 0x1b, 0x66, 0x24,
-	0xcd, 0xcf, 0x69, 0xe6, 0x71, 0xc2, 0x8b, 0xdc, 0xbd, 0x1e, 0x07, 0xe1, 0xa0, 0x6c, 0x50, 0x5f,
-	0xc3, 0x7d, 0xce, 0x38, 0x99, 0xf8, 0x62, 0x79, 0x6d, 0xa7, 0x09, 0xda, 0x7b, 0xe6, 0xc9, 0xc5,
-	0xc2, 0x50, 0x7e, 0x2c, 0x8c, 0x07, 0x51, 0xcc, 0xdf, 0x14, 0x01, 0x0a, 0x59, 0x52, 0x8d, 0xaf,
-	0x3e, 0x9d, 0xfc, 0x6c, 0x8c, 0xf9, 0x7c, 0x4a, 0x73, 0x64, 0xd1, 0xf0, 0xdb, 0xd7, 0x0e, 0xac,
-	0xb6, 0xb3, 0x68, 0xe8, 0x42, 0x01, 0x7c, 0x59, 0xf2, 0x24, 0x7e, 0x4c, 0xd3, 0x0a, 0x5f, 0xfb,
-	0x3f, 0xf8, 0x31, 0x4d, 0x25, 0xfe, 0x03, 0x3c, 0x10, 0x60, 0x7f, 0x9d, 0x9c, 0x76, 0xad, 0x09,
-	0xda, 0xfb, 0xc7, 0x87, 0x48, 0x46, 0x8b, 0xd6, 0xd1, 0x22, 0xab, 0x32, 0x98, 0xcf, 0xca, 0xe1,
-	0xbf, 0x17, 0x86, 0xb6, 0xd9, 0xf8, 0x88, 0x25, 0x31, 0xa7, 0xc9, 0x94, 0xcf, 0xff, 0x2c, 0x8c,
-	0x3b, 0x73, 0x92, 0x4c, 0x9e, 0xb6, 0x36, 0x1d, 0xad, 0xcf, 0x3f, 0x0d, 0xe0, 0xde, 0x14, 0x8f,
-	0x6b, 0xda, 0xc3, 0x2f, 0x00, 0xde, 0xfa, 0x27, 0x5e, 0xf5, 0x3e, 0x34, 0x1c, 0xb3, 0xe7, 0x0f,
-	0xdd, 0x6e, 0xdf, 0x3b, 0xb5, 0x5d, 0xdf, 0x1b, 0x76, 0x87, 0x23, 0xcf, 0x1f, 0xf5, 0xbd, 0x81,
-	0xdd, 0x73, 0x4e, 0x1d, 0xdb, 0xaa, 0x2b, 0x6a, 0x13, 0xde, 0xdb, 0x66, 0xb2, 0x1c, 0xaf, 0x6b,
-	0xbe, 0xb0, 0xad, 0x3a, 0x50, 0x0d, 0x78, 0x77, 0x9b, 0xc3, 0xee, 0x4b, 0xc3, 0x8e, 0xaa, 0xc3,
-	0xc6, 0x36, 0xc3, 0xa0, 0x3b, 0xf2, 0x6c, 0xab, 0x5e, 0x33, 0x9f, 0x5f, 0x2c, 0x75, 0x70, 0xb9,
-	0xd4, 0xc1, 0xaf, 0xa5, 0x0e, 0x3e, 0xad, 0x74, 0xe5, 0x72, 0xa5, 0x2b, 0xdf, 0x57, 0xba, 0xf2,
-	0xea, 0x6a, 0xf4, 0xe5, 0xad, 0x74, 0x52, 0xca, 0xdf, 0xb1, 0x6c, 0x2c, 0x0a, 0x3c, 0x7b, 0x82,
-	0xdf, 0x8b, 0xab, 0x0e, 0x76, 0x45, 0x80, 0x8f, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0xe7, 0x96,
-	0xf8, 0x4c, 0xe9, 0x02, 0x00, 0x00,
+	0x1c, 0xc5, 0x33, 0x5b, 0x59, 0xd8, 0x59, 0x5d, 0x6a, 0x50, 0xc8, 0xee, 0x21, 0xa9, 0x55, 0x97,
+	0x22, 0x76, 0xc2, 0xae, 0x9e, 0x44, 0xc5, 0xa4, 0xc9, 0x42, 0x40, 0x6a, 0x37, 0x49, 0x2f, 0x82,
+	0x0c, 0x49, 0x76, 0x36, 0x86, 0x36, 0x99, 0x9a, 0x4c, 0xaa, 0x3d, 0x79, 0xf4, 0xea, 0xd1, 0xaf,
+	0x21, 0xf8, 0x21, 0xf6, 0xb8, 0x78, 0x12, 0x0f, 0x55, 0xda, 0x9b, 0x47, 0x3f, 0x81, 0x64, 0x26,
+	0x85, 0x5d, 0xac, 0x37, 0x4f, 0x99, 0x97, 0xf7, 0xe6, 0x37, 0x7f, 0xde, 0x0c, 0x54, 0xca, 0x94,
+	0x10, 0xbd, 0x4c, 0xc2, 0x48, 0x9f, 0x1e, 0xe8, 0x6f, 0x4a, 0xca, 0x02, 0x34, 0xc9, 0x29, 0xa3,
+	0xf2, 0xd5, 0xca, 0x41, 0x95, 0x83, 0xa6, 0x07, 0x7b, 0x37, 0x62, 0x1a, 0x53, 0x6e, 0xe8, 0xd5,
+	0x4a, 0x64, 0xf6, 0xd4, 0x98, 0xd2, 0x78, 0x4c, 0x74, 0xae, 0xc2, 0xf2, 0x54, 0x3f, 0x29, 0xf3,
+	0x80, 0x25, 0x34, 0xab, 0xfd, 0xdd, 0x88, 0x16, 0x29, 0x2d, 0xb0, 0xd8, 0x28, 0x84, 0xb0, 0xda,
+	0x1f, 0x1a, 0x70, 0x73, 0x10, 0xe4, 0x41, 0x5a, 0xc8, 0x4f, 0x21, 0x4c, 0xc2, 0x08, 0x17, 0x2c,
+	0x60, 0x65, 0xa1, 0x80, 0x16, 0xe8, 0xec, 0x1c, 0x6a, 0xe8, 0xe2, 0xf1, 0xc8, 0x31, 0x7b, 0x7e,
+	0x1e, 0x64, 0xc5, 0x29, 0xc9, 0x3d, 0x1e, 0x73, 0xb7, 0x92, 0x30, 0x12, 0x4b, 0xf9, 0x15, 0xdc,
+	0x66, 0x94, 0x05, 0x63, 0xcc, 0xc7, 0x57, 0x36, 0x5a, 0xa0, 0xb3, 0x65, 0x3e, 0x3e, 0x9b, 0x6b,
+	0xd2, 0xf7, 0xb9, 0xb6, 0x1f, 0x27, 0xec, 0x75, 0x19, 0xa2, 0x88, 0xa6, 0xf5, 0x00, 0xf5, 0xa7,
+	0x5b, 0x9c, 0x8c, 0x74, 0x36, 0x9b, 0x90, 0x02, 0x59, 0x24, 0xfa, 0xfa, 0xa5, 0x0b, 0xeb, 0xf9,
+	0x2c, 0x12, 0xb9, 0x90, 0x03, 0x8f, 0x2b, 0x9e, 0xc0, 0x8f, 0x48, 0x56, 0xe3, 0x1b, 0xff, 0x07,
+	0x3f, 0x22, 0x99, 0xc0, 0xbf, 0x87, 0x3b, 0x1c, 0x8c, 0x57, 0xdd, 0x29, 0x57, 0x5a, 0xa0, 0xb3,
+	0x7d, 0xb8, 0x8b, 0x44, 0xb9, 0x68, 0x55, 0x2e, 0xb2, 0xea, 0x80, 0xf9, 0xa4, 0x3a, 0xfc, 0xd7,
+	0x5c, 0x53, 0x2e, 0x6f, 0xbc, 0x4f, 0xd3, 0x84, 0x91, 0x74, 0xc2, 0x66, 0xbf, 0xe7, 0xda, 0xcd,
+	0x59, 0x90, 0x8e, 0x1f, 0xb5, 0x2f, 0x27, 0xda, 0x9f, 0x7e, 0x68, 0xc0, 0xbd, 0xc6, 0x7f, 0xae,
+	0x68, 0xf7, 0x3e, 0x03, 0x78, 0xfd, 0xaf, 0x7e, 0xe5, 0xdb, 0x50, 0x73, 0xcc, 0x1e, 0xf6, 0x5d,
+	0xa3, 0xef, 0x1d, 0xd9, 0x2e, 0xf6, 0x7c, 0xc3, 0x1f, 0x7a, 0x78, 0xd8, 0xf7, 0x06, 0x76, 0xcf,
+	0x39, 0x72, 0x6c, 0xab, 0x29, 0xc9, 0xfb, 0xb0, 0xbd, 0x2e, 0x74, 0x3c, 0x7c, 0xe1, 0x1b, 0xd8,
+	0x72, 0x3c, 0xc3, 0x7c, 0x6e, 0x5b, 0x4d, 0x20, 0xdf, 0x85, 0xb7, 0xfe, 0x9d, 0xb3, 0xfb, 0x22,
+	0xb6, 0x21, 0x77, 0xe0, 0x9d, 0x75, 0xb1, 0x95, 0xf6, 0xf0, 0xc0, 0x18, 0x7a, 0xb6, 0xd5, 0x6c,
+	0x98, 0xcf, 0xce, 0x16, 0x2a, 0x38, 0x5f, 0xa8, 0xe0, 0xe7, 0x42, 0x05, 0x1f, 0x97, 0xaa, 0x74,
+	0xbe, 0x54, 0xa5, 0x6f, 0x4b, 0x55, 0x7a, 0x79, 0xf1, 0x42, 0xaa, 0x27, 0xd4, 0xcd, 0x08, 0x7b,
+	0x4b, 0xf3, 0x11, 0x17, 0xfa, 0xf4, 0xa1, 0xfe, 0x8e, 0xbf, 0xf6, 0x70, 0x93, 0xd7, 0xfa, 0xe0,
+	0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x26, 0x38, 0x22, 0xb8, 0x01, 0x03, 0x00, 0x00,
 }
 
 func (m *Params) Marshal() (dAtA []byte, err error) {
@@ -213,8 +213,8 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	}
 	i--
 	dAtA[i] = 0x12
-	if m.IbcPause != 0 {
-		i = encodeVarintQuota(dAtA, i, uint64(m.IbcPause))
+	if m.IbcStatus != 0 {
+		i = encodeVarintQuota(dAtA, i, uint64(m.IbcStatus))
 		i--
 		dAtA[i] = 0x8
 	}
@@ -238,8 +238,8 @@ func (m *Params) Size() (n int) {
 	}
 	var l int
 	_ = l
-	if m.IbcPause != 0 {
-		n += 1 + sovQuota(uint64(m.IbcPause))
+	if m.IbcStatus != 0 {
+		n += 1 + sovQuota(uint64(m.IbcStatus))
 	}
 	l = m.TotalQuota.Size()
 	n += 1 + l + sovQuota(uint64(l))
@@ -287,9 +287,9 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IbcPause", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IbcStatus", wireType)
 			}
-			m.IbcPause = 0
+			m.IbcStatus = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuota
@@ -299,7 +299,7 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.IbcPause |= IBCTransferStatus(b&0x7F) << shift
+				m.IbcStatus |= IBCTransferStatus(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
diff --git a/x/uibc/quota/keeper/genesis_test.go b/x/uibc/quota/keeper/genesis_test.go
index ec64f5c954..e1c22bab68 100644
--- a/x/uibc/quota/keeper/genesis_test.go
+++ b/x/uibc/quota/keeper/genesis_test.go
@@ -12,9 +12,10 @@ func TestInitGenesis(t *testing.T) {
 	app, ctx := s.app, s.ctx
 
 	defaultGs := uibc.DefaultGenesisState()
+	assert.Equal(t, uibc.IBCTransferStatus_IBC_TRANSFER_STATUS_QUOTA_ENABLED, defaultGs.Params.IbcStatus)
 	app.UIbcQuotaKeeper.InitGenesis(ctx, *defaultGs)
 	params := app.UIbcQuotaKeeper.GetParams(ctx)
-	assert.Equal(t, params.IbcPause, defaultGs.Params.IbcPause)
+	assert.Equal(t, params.IbcStatus, defaultGs.Params.IbcStatus)
 }
 
 func TestExportGenesis(t *testing.T) {
@@ -25,8 +26,8 @@ func TestExportGenesis(t *testing.T) {
 	eGs := app.UIbcQuotaKeeper.ExportGenesis(ctx)
 	assert.DeepEqual(t, eGs, defaultGs)
 	// update params in genesis state
-	defaultGs.Params.IbcPause = uibc.IBCTransferStatus_IBC_TRANSFER_STATUS_ENABLED
+	defaultGs.Params.IbcStatus = uibc.IBCTransferStatus_IBC_TRANSFER_STATUS_QUOTA_DISABLED
 	app.UIbcQuotaKeeper.InitGenesis(ctx, *defaultGs)
 	eGs = app.UIbcQuotaKeeper.ExportGenesis(ctx)
-	assert.Equal(t, eGs.Params.IbcPause, uibc.IBCTransferStatus_IBC_TRANSFER_STATUS_ENABLED)
+	assert.Equal(t, eGs.Params.IbcStatus, uibc.IBCTransferStatus_IBC_TRANSFER_STATUS_QUOTA_DISABLED)
 }
diff --git a/x/uibc/quota/keeper/msg_server.go b/x/uibc/quota/keeper/msg_server.go
index 81772d7b69..34e4e8e15b 100644
--- a/x/uibc/quota/keeper/msg_server.go
+++ b/x/uibc/quota/keeper/msg_server.go
@@ -37,22 +37,22 @@ func (m msgServer) GovUpdateQuota(goCtx context.Context, msg *uibc.MsgGovUpdateQ
 	return &uibc.MsgGovUpdateQuotaResponse{}, nil
 }
 
-// GovSetIBCPause implements types.MsgServer
-func (m msgServer) GovSetIBCPause(
-	goCtx context.Context, msg *uibc.MsgGovSetIBCPause,
-) (*uibc.MsgGovSetIBCPauseResponse, error) {
+// GovSetIBCStatus implements types.MsgServer
+func (m msgServer) GovSetIBCStatus(
+	goCtx context.Context, msg *uibc.MsgGovSetIBCStatus,
+) (*uibc.MsgGovSetIBCStatusResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
 	if err := msg.ValidateBasic(); err != nil {
 		return nil, err
 	}
 
-	if err := m.keeper.SetIBCPause(ctx, msg.IbcPauseStatus); err != nil {
-		return &uibc.MsgGovSetIBCPauseResponse{}, err
+	if err := m.keeper.SetIBCStatus(ctx, msg.IbcStatus); err != nil {
+		return &uibc.MsgGovSetIBCStatusResponse{}, err
 	}
-	sdkutil.Emit(&ctx, &uibc.EventQuotaPause{
-		Status: msg.IbcPauseStatus,
+	sdkutil.Emit(&ctx, &uibc.EventIBCTransferStatus{
+		Status: msg.IbcStatus,
 	})
 
-	return &uibc.MsgGovSetIBCPauseResponse{}, nil
+	return &uibc.MsgGovSetIBCStatusResponse{}, nil
 }
diff --git a/x/uibc/quota/keeper/msg_server_test.go b/x/uibc/quota/keeper/msg_server_test.go
index 5b1bcd0686..9a493dbbba 100644
--- a/x/uibc/quota/keeper/msg_server_test.go
+++ b/x/uibc/quota/keeper/msg_server_test.go
@@ -88,41 +88,41 @@ func TestMsgServer_GovUpdateQuota(t *testing.T) {
 	}
 }
 
-func TestMsgServer_GovSetIBCPause(t *testing.T) {
+func TestMsgServer_GovSetIBCStatus(t *testing.T) {
 	t.Parallel()
 	s := initKeeperTestSuite(t)
 	ctx := s.ctx
 
 	tests := []struct {
 		name   string
-		msg    uibc.MsgGovSetIBCPause
+		msg    uibc.MsgGovSetIBCStatus
 		errMsg string
 	}{
 		{
 			name: "invalid authority address in msg",
-			msg: uibc.MsgGovSetIBCPause{
-				Title:          "title",
-				Description:    "desc",
-				Authority:      authtypes.NewModuleAddress("govv").String(),
-				IbcPauseStatus: 1,
+			msg: uibc.MsgGovSetIBCStatus{
+				Title:       "title",
+				Description: "desc",
+				Authority:   authtypes.NewModuleAddress("govv").String(),
+				IbcStatus:   1,
 			},
 			errMsg: "expected gov account as only signer for proposal message",
 		}, {
 			name: "invalid ibc-transfer status in msg",
-			msg: uibc.MsgGovSetIBCPause{
-				Title:          "title",
-				Description:    "desc",
-				Authority:      authtypes.NewModuleAddress("gov").String(),
-				IbcPauseStatus: 5,
+			msg: uibc.MsgGovSetIBCStatus{
+				Title:       "title",
+				Description: "desc",
+				Authority:   authtypes.NewModuleAddress("gov").String(),
+				IbcStatus:   5,
 			},
 			errMsg: "invalid ibc-transfer status",
 		}, {
 			name: "valid in msg <enable the ibc-transfer pause",
-			msg: uibc.MsgGovSetIBCPause{
-				Title:          "title",
-				Description:    "desc",
-				Authority:      authtypes.NewModuleAddress("gov").String(),
-				IbcPauseStatus: 2,
+			msg: uibc.MsgGovSetIBCStatus{
+				Title:       "title",
+				Description: "desc",
+				Authority:   authtypes.NewModuleAddress("gov").String(),
+				IbcStatus:   2,
 			},
 			errMsg: "",
 		},
@@ -130,13 +130,13 @@ func TestMsgServer_GovSetIBCPause(t *testing.T) {
 
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			_, err := s.msgServer.GovSetIBCPause(ctx, &tc.msg)
+			_, err := s.msgServer.GovSetIBCStatus(ctx, &tc.msg)
 			if tc.errMsg == "" {
 				assert.NilError(t, err)
 				// check the update ibc-transfer pause status
 				params, err := s.queryClient.Params(ctx, &uibc.QueryParams{})
 				assert.NilError(t, err)
-				assert.Equal(t, params.Params.IbcPause, tc.msg.IbcPauseStatus)
+				assert.Equal(t, params.Params.IbcStatus, tc.msg.IbcStatus)
 			} else {
 				assert.ErrorContains(t, err, tc.errMsg)
 			}
diff --git a/x/uibc/quota/keeper/params.go b/x/uibc/quota/keeper/params.go
index 05316dc9d5..4319b95282 100644
--- a/x/uibc/quota/keeper/params.go
+++ b/x/uibc/quota/keeper/params.go
@@ -42,10 +42,10 @@ func (k Keeper) UpdateQuotaParams(ctx sdk.Context, totalQuota, quotaPerDenom sdk
 	return k.SetParams(ctx, params)
 }
 
-// SetIBCPause update the ibc pause status in module params.
-func (k Keeper) SetIBCPause(ctx sdk.Context, ibcStatus uibc.IBCTransferStatus) error {
+// SetIBCStatus update the ibc pause status in module params.
+func (k Keeper) SetIBCStatus(ctx sdk.Context, ibcStatus uibc.IBCTransferStatus) error {
 	params := k.GetParams(ctx)
-	params.IbcPause = ibcStatus
+	params.IbcStatus = ibcStatus
 
 	return k.SetParams(ctx, params)
 }
diff --git a/x/uibc/quota/keeper/params_test.go b/x/uibc/quota/keeper/params_test.go
index 9b9d549795..bfa223940f 100644
--- a/x/uibc/quota/keeper/params_test.go
+++ b/x/uibc/quota/keeper/params_test.go
@@ -14,10 +14,10 @@ func TestParams(t *testing.T) {
 	defaultParams := uibc.DefaultParams()
 	assert.DeepEqual(t, params, defaultParams)
 	// update params
-	params.IbcPause = uibc.IBCTransferStatus_IBC_TRANSFER_STATUS_ENABLED
+	params.IbcStatus = uibc.IBCTransferStatus_IBC_TRANSFER_STATUS_TRANSFERS_PAUSED
 	err := app.UIbcQuotaKeeper.SetParams(ctx, params)
 	assert.NilError(t, err)
 	// check the update param
 	params = app.UIbcQuotaKeeper.GetParams(ctx)
-	assert.Equal(t, params.IbcPause, uibc.IBCTransferStatus_IBC_TRANSFER_STATUS_ENABLED)
+	assert.Equal(t, params.IbcStatus, uibc.IBCTransferStatus_IBC_TRANSFER_STATUS_TRANSFERS_PAUSED)
 }
diff --git a/x/uibc/tx.pb.go b/x/uibc/tx.pb.go
index 1dd9fd71f9..863be522ae 100644
--- a/x/uibc/tx.pb.go
+++ b/x/uibc/tx.pb.go
@@ -126,27 +126,27 @@ func (*MsgGovUpdateQuotaResponse) XXX_MessageName() string {
 	return "umee.uibc.v1.MsgGovUpdateQuotaResponse"
 }
 
-// MsgGovSetIBCPause defines request type for UpdateIBCTransferStatus
-type MsgGovSetIBCPause struct {
+// MsgGovSetIbcstatus defines request type for UpdateIBCTransferStatus
+type MsgGovSetIBCStatus struct {
 	// authority is the address of the governance account.
 	Authority   string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
 	Title       string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
 	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
-	// ibc_pause_status defines ibc transfer pause status
-	IbcPauseStatus IBCTransferStatus `protobuf:"varint,4,opt,name=ibc_pause_status,json=ibcPauseStatus,proto3,enum=umee.uibc.v1.IBCTransferStatus" json:"ibc_pause_status,omitempty"`
+	// ibc_status defines ibc transfer pause status
+	IbcStatus IBCTransferStatus `protobuf:"varint,4,opt,name=ibc_status,json=ibcStatus,proto3,enum=umee.uibc.v1.IBCTransferStatus" json:"ibc_status,omitempty"`
 }
 
-func (m *MsgGovSetIBCPause) Reset()      { *m = MsgGovSetIBCPause{} }
-func (*MsgGovSetIBCPause) ProtoMessage() {}
-func (*MsgGovSetIBCPause) Descriptor() ([]byte, []int) {
+func (m *MsgGovSetIBCStatus) Reset()      { *m = MsgGovSetIBCStatus{} }
+func (*MsgGovSetIBCStatus) ProtoMessage() {}
+func (*MsgGovSetIBCStatus) Descriptor() ([]byte, []int) {
 	return fileDescriptor_1982abc7d531f4dc, []int{2}
 }
-func (m *MsgGovSetIBCPause) XXX_Unmarshal(b []byte) error {
+func (m *MsgGovSetIBCStatus) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *MsgGovSetIBCPause) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *MsgGovSetIBCStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_MsgGovSetIBCPause.Marshal(b, m, deterministic)
+		return xxx_messageInfo_MsgGovSetIBCStatus.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -156,38 +156,38 @@ func (m *MsgGovSetIBCPause) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
-func (m *MsgGovSetIBCPause) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgGovSetIBCPause.Merge(m, src)
+func (m *MsgGovSetIBCStatus) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgGovSetIBCStatus.Merge(m, src)
 }
-func (m *MsgGovSetIBCPause) XXX_Size() int {
+func (m *MsgGovSetIBCStatus) XXX_Size() int {
 	return m.Size()
 }
-func (m *MsgGovSetIBCPause) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgGovSetIBCPause.DiscardUnknown(m)
+func (m *MsgGovSetIBCStatus) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgGovSetIBCStatus.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_MsgGovSetIBCPause proto.InternalMessageInfo
+var xxx_messageInfo_MsgGovSetIBCStatus proto.InternalMessageInfo
 
-func (*MsgGovSetIBCPause) XXX_MessageName() string {
-	return "umee.uibc.v1.MsgGovSetIBCPause"
+func (*MsgGovSetIBCStatus) XXX_MessageName() string {
+	return "umee.uibc.v1.MsgGovSetIBCStatus"
 }
 
-// MsgGovSetIBCPauseResponse definesresponse type for Msg/MsgGovSetIBCPause for with x/gov proposals.
-type MsgGovSetIBCPauseResponse struct {
+// MsgGovSetIbcstatusResponse definesresponse type for Msg/MsgGovSetIbcstatus for with x/gov proposals.
+type MsgGovSetIBCStatusResponse struct {
 }
 
-func (m *MsgGovSetIBCPauseResponse) Reset()         { *m = MsgGovSetIBCPauseResponse{} }
-func (m *MsgGovSetIBCPauseResponse) String() string { return proto.CompactTextString(m) }
-func (*MsgGovSetIBCPauseResponse) ProtoMessage()    {}
-func (*MsgGovSetIBCPauseResponse) Descriptor() ([]byte, []int) {
+func (m *MsgGovSetIBCStatusResponse) Reset()         { *m = MsgGovSetIBCStatusResponse{} }
+func (m *MsgGovSetIBCStatusResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgGovSetIBCStatusResponse) ProtoMessage()    {}
+func (*MsgGovSetIBCStatusResponse) Descriptor() ([]byte, []int) {
 	return fileDescriptor_1982abc7d531f4dc, []int{3}
 }
-func (m *MsgGovSetIBCPauseResponse) XXX_Unmarshal(b []byte) error {
+func (m *MsgGovSetIBCStatusResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *MsgGovSetIBCPauseResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *MsgGovSetIBCStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_MsgGovSetIBCPauseResponse.Marshal(b, m, deterministic)
+		return xxx_messageInfo_MsgGovSetIBCStatusResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -197,69 +197,69 @@ func (m *MsgGovSetIBCPauseResponse) XXX_Marshal(b []byte, deterministic bool) ([
 		return b[:n], nil
 	}
 }
-func (m *MsgGovSetIBCPauseResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgGovSetIBCPauseResponse.Merge(m, src)
+func (m *MsgGovSetIBCStatusResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgGovSetIBCStatusResponse.Merge(m, src)
 }
-func (m *MsgGovSetIBCPauseResponse) XXX_Size() int {
+func (m *MsgGovSetIBCStatusResponse) XXX_Size() int {
 	return m.Size()
 }
-func (m *MsgGovSetIBCPauseResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgGovSetIBCPauseResponse.DiscardUnknown(m)
+func (m *MsgGovSetIBCStatusResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgGovSetIBCStatusResponse.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_MsgGovSetIBCPauseResponse proto.InternalMessageInfo
+var xxx_messageInfo_MsgGovSetIBCStatusResponse proto.InternalMessageInfo
 
-func (*MsgGovSetIBCPauseResponse) XXX_MessageName() string {
-	return "umee.uibc.v1.MsgGovSetIBCPauseResponse"
+func (*MsgGovSetIBCStatusResponse) XXX_MessageName() string {
+	return "umee.uibc.v1.MsgGovSetIBCStatusResponse"
 }
 func init() {
 	proto.RegisterType((*MsgGovUpdateQuota)(nil), "umee.uibc.v1.MsgGovUpdateQuota")
 	proto.RegisterType((*MsgGovUpdateQuotaResponse)(nil), "umee.uibc.v1.MsgGovUpdateQuotaResponse")
-	proto.RegisterType((*MsgGovSetIBCPause)(nil), "umee.uibc.v1.MsgGovSetIBCPause")
-	proto.RegisterType((*MsgGovSetIBCPauseResponse)(nil), "umee.uibc.v1.MsgGovSetIBCPauseResponse")
+	proto.RegisterType((*MsgGovSetIBCStatus)(nil), "umee.uibc.v1.MsgGovSetIBCStatus")
+	proto.RegisterType((*MsgGovSetIBCStatusResponse)(nil), "umee.uibc.v1.MsgGovSetIBCStatusResponse")
 }
 
 func init() { proto.RegisterFile("umee/uibc/v1/tx.proto", fileDescriptor_1982abc7d531f4dc) }
 
 var fileDescriptor_1982abc7d531f4dc = []byte{
-	// 586 bytes of a gzipped FileDescriptorProto
+	// 588 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x54, 0xbf, 0x6f, 0xd3, 0x40,
-	0x14, 0xb6, 0x09, 0xa9, 0xc8, 0x15, 0x22, 0xb0, 0x52, 0x70, 0x82, 0x64, 0x47, 0x19, 0xa0, 0x42,
-	0xc4, 0x56, 0x03, 0x62, 0xa8, 0x60, 0x20, 0x8d, 0x04, 0x19, 0x2a, 0x81, 0x03, 0x03, 0x5d, 0x22,
-	0xff, 0xb8, 0xba, 0xa7, 0xc6, 0x3e, 0x73, 0x77, 0x0e, 0xcd, 0x84, 0xc4, 0xc4, 0xc8, 0xd8, 0xb1,
-	0x7f, 0x02, 0x43, 0x57, 0xf6, 0x48, 0x2c, 0x55, 0x27, 0xc4, 0x10, 0x20, 0x91, 0x40, 0x62, 0xe4,
-	0x2f, 0x40, 0x77, 0xb6, 0x55, 0xa7, 0x8d, 0xd4, 0x05, 0x31, 0xd9, 0xef, 0x7d, 0xdf, 0x7d, 0xef,
-	0xdd, 0xfb, 0x9e, 0x0d, 0x56, 0xe2, 0x00, 0x42, 0x33, 0x46, 0x8e, 0x6b, 0x0e, 0xd7, 0x4c, 0xb6,
-	0x67, 0x44, 0x04, 0x33, 0xac, 0x5c, 0xe6, 0x69, 0x83, 0xa7, 0x8d, 0xe1, 0x5a, 0xad, 0xe2, 0x63,
-	0x1f, 0x0b, 0xc0, 0xe4, 0x6f, 0x09, 0xa7, 0xa6, 0xf9, 0x18, 0xfb, 0x03, 0x68, 0x8a, 0xc8, 0x89,
-	0xb7, 0x4d, 0x2f, 0x26, 0x36, 0x43, 0x38, 0x4c, 0xf1, 0x1b, 0x2e, 0xa6, 0x01, 0xa6, 0x66, 0x40,
-	0x7d, 0xae, 0x1d, 0x50, 0x3f, 0x05, 0xaa, 0x09, 0xd0, 0x4f, 0x14, 0x93, 0x20, 0x85, 0xd4, 0xb9,
-	0x76, 0x5e, 0xc7, 0x98, 0xd9, 0x09, 0xd2, 0xf8, 0x5c, 0x00, 0xd7, 0x36, 0xa9, 0xff, 0x04, 0x0f,
-	0x5f, 0x46, 0x9e, 0xcd, 0xe0, 0x73, 0x8e, 0x29, 0x0f, 0x40, 0xc9, 0x8e, 0xd9, 0x0e, 0x26, 0x88,
-	0x8d, 0x54, 0xb9, 0x2e, 0xaf, 0x96, 0xda, 0xea, 0xf1, 0x61, 0xb3, 0x92, 0x8a, 0x3e, 0xf6, 0x3c,
-	0x02, 0x29, 0xed, 0x31, 0x82, 0x42, 0xdf, 0x3a, 0xa1, 0x2a, 0x15, 0x50, 0x64, 0x88, 0x0d, 0xa0,
-	0x7a, 0x81, 0x9f, 0xb1, 0x92, 0x40, 0xa9, 0x83, 0x65, 0x0f, 0x52, 0x97, 0xa0, 0x88, 0x5f, 0x43,
-	0x2d, 0x08, 0x2c, 0x9f, 0x52, 0x2c, 0x50, 0x64, 0x98, 0xd9, 0x03, 0xf5, 0xa2, 0xa8, 0xf5, 0x70,
-	0x3c, 0xd1, 0xa5, 0xaf, 0x13, 0xfd, 0x96, 0x8f, 0xd8, 0x4e, 0xec, 0x18, 0x2e, 0x0e, 0xd2, 0xfb,
-	0xa4, 0x8f, 0x26, 0xf5, 0x76, 0x4d, 0x36, 0x8a, 0x20, 0x35, 0x3a, 0xd0, 0x3d, 0x3e, 0x6c, 0x82,
-	0xb4, 0xb3, 0x0e, 0x74, 0xad, 0x44, 0x4a, 0x79, 0x05, 0x4a, 0x11, 0x24, 0x7d, 0x0f, 0x86, 0x38,
-	0x50, 0x8b, 0xff, 0x40, 0xf7, 0x52, 0x04, 0x49, 0x87, 0xab, 0x29, 0x6f, 0x41, 0x59, 0xcc, 0xb0,
-	0x9f, 0x59, 0xa3, 0x2e, 0xd5, 0xe5, 0xd5, 0xe5, 0x56, 0xd5, 0x48, 0xbc, 0x33, 0x32, 0xef, 0x8c,
-	0x4e, 0x4a, 0x68, 0x3f, 0xe2, 0xa5, 0x7f, 0x4f, 0x74, 0x75, 0xfe, 0xe0, 0x5d, 0x1c, 0x20, 0x06,
-	0x83, 0x88, 0x8d, 0xfe, 0x4c, 0xf4, 0x95, 0x91, 0x1d, 0x0c, 0xd6, 0x1b, 0xf3, 0x8c, 0xc6, 0xfe,
-	0x37, 0x5d, 0xb6, 0xae, 0x88, 0x64, 0xa6, 0xb6, 0x7e, 0xfd, 0xfd, 0x81, 0x2e, 0xed, 0x1f, 0xe8,
-	0xd2, 0xbb, 0x5f, 0x1f, 0xef, 0x9c, 0xcc, 0xbf, 0x71, 0x13, 0x54, 0xcf, 0x98, 0x69, 0x41, 0x1a,
-	0xe1, 0x90, 0xc2, 0xc6, 0x4f, 0x39, 0xb3, 0xba, 0x07, 0x59, 0xb7, 0xbd, 0xf1, 0xcc, 0x8e, 0x29,
-	0xfc, 0xef, 0x56, 0x77, 0xc1, 0x55, 0xe4, 0xb8, 0xfd, 0x88, 0x17, 0xef, 0x53, 0x66, 0xb3, 0x98,
-	0x0a, 0xd7, 0xcb, 0x2d, 0xdd, 0xc8, 0x7f, 0x1d, 0x46, 0xb7, 0xbd, 0xf1, 0x82, 0xd8, 0x21, 0xdd,
-	0x86, 0xa4, 0x27, 0x68, 0x56, 0x19, 0x39, 0xae, 0x68, 0x3a, 0x89, 0xcf, 0x9f, 0x42, 0xee, 0x9e,
-	0xd9, 0x14, 0x5a, 0x9f, 0x64, 0x50, 0xd8, 0xa4, 0xbe, 0xb2, 0x05, 0xca, 0xa7, 0x96, 0xfe, 0x54,
-	0xfd, 0x33, 0x83, 0xac, 0xdd, 0x3e, 0x87, 0x90, 0xd5, 0x48, 0xb5, 0xf3, 0x53, 0x5e, 0xa8, 0x9d,
-	0x23, 0x2c, 0xd6, 0x5e, 0xd0, 0x7f, 0xfb, 0xe9, 0xf8, 0x87, 0x26, 0x8d, 0xa7, 0x9a, 0x7c, 0x34,
-	0xd5, 0xe4, 0xef, 0x53, 0x4d, 0xfe, 0x30, 0xd3, 0xa4, 0xf1, 0x4c, 0x93, 0x8f, 0x66, 0x9a, 0xf4,
-	0x65, 0xa6, 0x49, 0x5b, 0xf9, 0xed, 0xe6, 0xa2, 0xcd, 0x10, 0xb2, 0x37, 0x98, 0xec, 0x8a, 0xc0,
-	0x1c, 0xde, 0x37, 0xf7, 0xc4, 0x9f, 0xc0, 0x59, 0x12, 0x5b, 0x7a, 0xef, 0x6f, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0x3b, 0x6f, 0x81, 0x19, 0xac, 0x04, 0x00, 0x00,
+	0x14, 0xb6, 0x09, 0xa9, 0xc8, 0x15, 0x82, 0xb0, 0x52, 0x70, 0x02, 0xb2, 0xa3, 0x0c, 0x10, 0x21,
+	0x62, 0xab, 0x01, 0x31, 0x54, 0x80, 0x44, 0x1a, 0x09, 0x3a, 0x74, 0xc0, 0x81, 0x81, 0x4a, 0x28,
+	0xf2, 0x8f, 0xab, 0x6b, 0x35, 0xf6, 0x99, 0xbb, 0x73, 0x68, 0x26, 0x24, 0x26, 0x46, 0xc6, 0x8e,
+	0xfd, 0x13, 0x18, 0xfa, 0x07, 0x30, 0x46, 0x62, 0xa9, 0x3a, 0x21, 0x84, 0x02, 0x24, 0x03, 0x12,
+	0x23, 0x7f, 0x01, 0xba, 0x3b, 0x5b, 0xcd, 0x0f, 0x50, 0x17, 0xc4, 0x94, 0x7b, 0xef, 0xfb, 0xee,
+	0x7b, 0xf7, 0xde, 0xf7, 0x62, 0xb0, 0x92, 0x84, 0x10, 0x9a, 0x49, 0xe0, 0xb8, 0x66, 0x7f, 0xd5,
+	0xa4, 0x7b, 0x46, 0x8c, 0x11, 0x45, 0xca, 0x79, 0x96, 0x36, 0x58, 0xda, 0xe8, 0xaf, 0x56, 0x4a,
+	0x3e, 0xf2, 0x11, 0x07, 0x4c, 0x76, 0x12, 0x9c, 0x8a, 0xe6, 0x23, 0xe4, 0xf7, 0xa0, 0xc9, 0x23,
+	0x27, 0xd9, 0x36, 0xbd, 0x04, 0xdb, 0x34, 0x40, 0x51, 0x8a, 0x5f, 0x71, 0x11, 0x09, 0x11, 0x31,
+	0x43, 0xe2, 0x33, 0xed, 0x90, 0xf8, 0x29, 0x50, 0x16, 0x40, 0x57, 0x28, 0x8a, 0x20, 0x85, 0xd4,
+	0x99, 0xe7, 0xbc, 0x4c, 0x10, 0xb5, 0x05, 0x52, 0xfb, 0x98, 0x03, 0x97, 0x36, 0x89, 0xff, 0x08,
+	0xf5, 0x9f, 0xc5, 0x9e, 0x4d, 0xe1, 0x13, 0x86, 0x29, 0x77, 0x41, 0xc1, 0x4e, 0xe8, 0x0e, 0xc2,
+	0x01, 0x1d, 0xa8, 0x72, 0x55, 0xae, 0x17, 0x5a, 0xea, 0xf1, 0x61, 0xa3, 0x94, 0x8a, 0x3e, 0xf4,
+	0x3c, 0x0c, 0x09, 0xe9, 0x50, 0x1c, 0x44, 0xbe, 0x75, 0x42, 0x55, 0x4a, 0x20, 0x4f, 0x03, 0xda,
+	0x83, 0xea, 0x19, 0x76, 0xc7, 0x12, 0x81, 0x52, 0x05, 0xcb, 0x1e, 0x24, 0x2e, 0x0e, 0x62, 0xd6,
+	0x86, 0x9a, 0xe3, 0xd8, 0x74, 0x4a, 0xb1, 0x40, 0x9e, 0x22, 0x6a, 0xf7, 0xd4, 0xb3, 0xbc, 0xd6,
+	0xbd, 0xe1, 0x48, 0x97, 0x3e, 0x8f, 0xf4, 0xeb, 0x7e, 0x40, 0x77, 0x12, 0xc7, 0x70, 0x51, 0x98,
+	0xf6, 0x93, 0xfe, 0x34, 0x88, 0xb7, 0x6b, 0xd2, 0x41, 0x0c, 0x89, 0xd1, 0x86, 0xee, 0xf1, 0x61,
+	0x03, 0xa4, 0x2f, 0x6b, 0x43, 0xd7, 0x12, 0x52, 0xca, 0x73, 0x50, 0x88, 0x21, 0xee, 0x7a, 0x30,
+	0x42, 0xa1, 0x9a, 0xff, 0x07, 0xba, 0xe7, 0x62, 0x88, 0xdb, 0x4c, 0x4d, 0x79, 0x0d, 0x8a, 0x7c,
+	0x86, 0xdd, 0xcc, 0x1a, 0x75, 0xa9, 0x2a, 0xd7, 0x97, 0x9b, 0x65, 0x43, 0x78, 0x67, 0x64, 0xde,
+	0x19, 0xed, 0x94, 0xd0, 0xba, 0xcf, 0x4a, 0xff, 0x1c, 0xe9, 0xea, 0xec, 0xc5, 0x5b, 0x28, 0x0c,
+	0x28, 0x0c, 0x63, 0x3a, 0xf8, 0x35, 0xd2, 0x57, 0x06, 0x76, 0xd8, 0x5b, 0xab, 0xcd, 0x32, 0x6a,
+	0xfb, 0x5f, 0x75, 0xd9, 0xba, 0xc0, 0x93, 0x99, 0xda, 0xda, 0xe5, 0xb7, 0x07, 0xba, 0xb4, 0x7f,
+	0xa0, 0x4b, 0x6f, 0x7e, 0xbc, 0xbf, 0x79, 0x32, 0xff, 0xda, 0x55, 0x50, 0x5e, 0x30, 0xd3, 0x82,
+	0x24, 0x46, 0x11, 0x81, 0xb5, 0x2f, 0x32, 0x50, 0x04, 0xda, 0x81, 0x74, 0xa3, 0xb5, 0xde, 0xa1,
+	0x36, 0x4d, 0xc8, 0x7f, 0xf7, 0xfa, 0x01, 0x00, 0x81, 0xe3, 0x76, 0x09, 0xaf, 0xce, 0x0d, 0x2f,
+	0x36, 0x75, 0x63, 0xfa, 0x8f, 0x61, 0x6c, 0xb4, 0xd6, 0x9f, 0x62, 0x3b, 0x22, 0xdb, 0x10, 0x8b,
+	0x47, 0x5a, 0x85, 0xc0, 0x71, 0xc5, 0xf1, 0xaf, 0xbd, 0x5f, 0x03, 0x95, 0xc5, 0xee, 0xb2, 0xe6,
+	0x9b, 0x1f, 0x64, 0x90, 0xdb, 0x24, 0xbe, 0xb2, 0x05, 0x8a, 0x73, 0xbb, 0x3e, 0x57, 0x7b, 0x61,
+	0x7e, 0x95, 0x1b, 0xa7, 0x10, 0xb2, 0x1a, 0xca, 0x0b, 0x70, 0x71, 0x7e, 0xb8, 0xd5, 0x3f, 0xdd,
+	0x9d, 0x66, 0x54, 0xea, 0xa7, 0x31, 0x32, 0xf9, 0xd6, 0xe3, 0xe1, 0x77, 0x4d, 0x1a, 0x8e, 0x35,
+	0xf9, 0x68, 0xac, 0xc9, 0xdf, 0xc6, 0x9a, 0xfc, 0x6e, 0xa2, 0x49, 0xc3, 0x89, 0x26, 0x1f, 0x4d,
+	0x34, 0xe9, 0xd3, 0x44, 0x93, 0xb6, 0xa6, 0xf7, 0x9a, 0xa9, 0x36, 0x22, 0x48, 0x5f, 0x21, 0xbc,
+	0xcb, 0x03, 0xb3, 0x7f, 0xc7, 0xdc, 0xe3, 0xdf, 0x00, 0x67, 0x89, 0xef, 0xe7, 0xed, 0xdf, 0x01,
+	0x00, 0x00, 0xff, 0xff, 0xa9, 0xc6, 0xdd, 0x61, 0xa6, 0x04, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -277,8 +277,8 @@ type MsgClient interface {
 	// GovUpdateQuota adds new quota for ibc denoms or
 	// updates the quota for existed ibc denoms.
 	GovUpdateQuota(ctx context.Context, in *MsgGovUpdateQuota, opts ...grpc.CallOption) (*MsgGovUpdateQuotaResponse, error)
-	// GovSetIBCPause update the status of ibc-transfer
-	GovSetIBCPause(ctx context.Context, in *MsgGovSetIBCPause, opts ...grpc.CallOption) (*MsgGovSetIBCPauseResponse, error)
+	// GovSetIBCStatus update the status of ibc-transfer
+	GovSetIBCStatus(ctx context.Context, in *MsgGovSetIBCStatus, opts ...grpc.CallOption) (*MsgGovSetIBCStatusResponse, error)
 }
 
 type msgClient struct {
@@ -298,9 +298,9 @@ func (c *msgClient) GovUpdateQuota(ctx context.Context, in *MsgGovUpdateQuota, o
 	return out, nil
 }
 
-func (c *msgClient) GovSetIBCPause(ctx context.Context, in *MsgGovSetIBCPause, opts ...grpc.CallOption) (*MsgGovSetIBCPauseResponse, error) {
-	out := new(MsgGovSetIBCPauseResponse)
-	err := c.cc.Invoke(ctx, "/umee.uibc.v1.Msg/GovSetIBCPause", in, out, opts...)
+func (c *msgClient) GovSetIBCStatus(ctx context.Context, in *MsgGovSetIBCStatus, opts ...grpc.CallOption) (*MsgGovSetIBCStatusResponse, error) {
+	out := new(MsgGovSetIBCStatusResponse)
+	err := c.cc.Invoke(ctx, "/umee.uibc.v1.Msg/GovSetIBCStatus", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -312,8 +312,8 @@ type MsgServer interface {
 	// GovUpdateQuota adds new quota for ibc denoms or
 	// updates the quota for existed ibc denoms.
 	GovUpdateQuota(context.Context, *MsgGovUpdateQuota) (*MsgGovUpdateQuotaResponse, error)
-	// GovSetIBCPause update the status of ibc-transfer
-	GovSetIBCPause(context.Context, *MsgGovSetIBCPause) (*MsgGovSetIBCPauseResponse, error)
+	// GovSetIBCStatus update the status of ibc-transfer
+	GovSetIBCStatus(context.Context, *MsgGovSetIBCStatus) (*MsgGovSetIBCStatusResponse, error)
 }
 
 // UnimplementedMsgServer can be embedded to have forward compatible implementations.
@@ -323,8 +323,8 @@ type UnimplementedMsgServer struct {
 func (*UnimplementedMsgServer) GovUpdateQuota(ctx context.Context, req *MsgGovUpdateQuota) (*MsgGovUpdateQuotaResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GovUpdateQuota not implemented")
 }
-func (*UnimplementedMsgServer) GovSetIBCPause(ctx context.Context, req *MsgGovSetIBCPause) (*MsgGovSetIBCPauseResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GovSetIBCPause not implemented")
+func (*UnimplementedMsgServer) GovSetIBCStatus(ctx context.Context, req *MsgGovSetIBCStatus) (*MsgGovSetIBCStatusResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GovSetIBCStatus not implemented")
 }
 
 func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
@@ -349,20 +349,20 @@ func _Msg_GovUpdateQuota_Handler(srv interface{}, ctx context.Context, dec func(
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Msg_GovSetIBCPause_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(MsgGovSetIBCPause)
+func _Msg_GovSetIBCStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgGovSetIBCStatus)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(MsgServer).GovSetIBCPause(ctx, in)
+		return srv.(MsgServer).GovSetIBCStatus(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/umee.uibc.v1.Msg/GovSetIBCPause",
+		FullMethod: "/umee.uibc.v1.Msg/GovSetIBCStatus",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MsgServer).GovSetIBCPause(ctx, req.(*MsgGovSetIBCPause))
+		return srv.(MsgServer).GovSetIBCStatus(ctx, req.(*MsgGovSetIBCStatus))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -376,8 +376,8 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 			Handler:    _Msg_GovUpdateQuota_Handler,
 		},
 		{
-			MethodName: "GovSetIBCPause",
-			Handler:    _Msg_GovSetIBCPause_Handler,
+			MethodName: "GovSetIBCStatus",
+			Handler:    _Msg_GovSetIBCStatus_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
@@ -479,7 +479,7 @@ func (m *MsgGovUpdateQuotaResponse) MarshalToSizedBuffer(dAtA []byte) (int, erro
 	return len(dAtA) - i, nil
 }
 
-func (m *MsgGovSetIBCPause) Marshal() (dAtA []byte, err error) {
+func (m *MsgGovSetIBCStatus) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -489,18 +489,18 @@ func (m *MsgGovSetIBCPause) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *MsgGovSetIBCPause) MarshalTo(dAtA []byte) (int, error) {
+func (m *MsgGovSetIBCStatus) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *MsgGovSetIBCPause) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MsgGovSetIBCStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.IbcPauseStatus != 0 {
-		i = encodeVarintTx(dAtA, i, uint64(m.IbcPauseStatus))
+	if m.IbcStatus != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.IbcStatus))
 		i--
 		dAtA[i] = 0x20
 	}
@@ -528,7 +528,7 @@ func (m *MsgGovSetIBCPause) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *MsgGovSetIBCPauseResponse) Marshal() (dAtA []byte, err error) {
+func (m *MsgGovSetIBCStatusResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -538,12 +538,12 @@ func (m *MsgGovSetIBCPauseResponse) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *MsgGovSetIBCPauseResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *MsgGovSetIBCStatusResponse) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *MsgGovSetIBCPauseResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MsgGovSetIBCStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -598,7 +598,7 @@ func (m *MsgGovUpdateQuotaResponse) Size() (n int) {
 	return n
 }
 
-func (m *MsgGovSetIBCPause) Size() (n int) {
+func (m *MsgGovSetIBCStatus) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -616,13 +616,13 @@ func (m *MsgGovSetIBCPause) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTx(uint64(l))
 	}
-	if m.IbcPauseStatus != 0 {
-		n += 1 + sovTx(uint64(m.IbcPauseStatus))
+	if m.IbcStatus != 0 {
+		n += 1 + sovTx(uint64(m.IbcStatus))
 	}
 	return n
 }
 
-func (m *MsgGovSetIBCPauseResponse) Size() (n int) {
+func (m *MsgGovSetIBCStatusResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -934,7 +934,7 @@ func (m *MsgGovUpdateQuotaResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *MsgGovSetIBCPause) Unmarshal(dAtA []byte) error {
+func (m *MsgGovSetIBCStatus) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -957,10 +957,10 @@ func (m *MsgGovSetIBCPause) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: MsgGovSetIBCPause: wiretype end group for non-group")
+			return fmt.Errorf("proto: MsgGovSetIBCStatus: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgGovSetIBCPause: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: MsgGovSetIBCStatus: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -1061,9 +1061,9 @@ func (m *MsgGovSetIBCPause) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 4:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IbcPauseStatus", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IbcStatus", wireType)
 			}
-			m.IbcPauseStatus = 0
+			m.IbcStatus = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowTx
@@ -1073,7 +1073,7 @@ func (m *MsgGovSetIBCPause) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.IbcPauseStatus |= IBCTransferStatus(b&0x7F) << shift
+				m.IbcStatus |= IBCTransferStatus(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -1099,7 +1099,7 @@ func (m *MsgGovSetIBCPause) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *MsgGovSetIBCPauseResponse) Unmarshal(dAtA []byte) error {
+func (m *MsgGovSetIBCStatusResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1122,10 +1122,10 @@ func (m *MsgGovSetIBCPauseResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: MsgGovSetIBCPauseResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: MsgGovSetIBCStatusResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgGovSetIBCPauseResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: MsgGovSetIBCStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		default: