diff --git a/proto/interchain_security/ccv/provider/v1/provider.proto b/proto/interchain_security/ccv/provider/v1/provider.proto
index 779f4cd9b5..8c7fa8fe5f 100644
--- a/proto/interchain_security/ccv/provider/v1/provider.proto
+++ b/proto/interchain_security/ccv/provider/v1/provider.proto
@@ -94,7 +94,9 @@ message ConsumerAdditionProposal {
 // remove (and stop) a consumer chain. If it passes, all the consumer chain's
 // state is removed from the provider chain. The outstanding unbonding operation
 // funds are released.
+// Deprecated: Use MsgConsumerRemoval instead
 message ConsumerRemovalProposal {
+  option deprecated = true;
   option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
 
   // the title of the proposal
@@ -111,6 +113,7 @@ message ConsumerRemovalProposal {
 
 // ChangeRewardDenomsProposal is a governance proposal on the provider chain to
 // mutate the set of denoms accepted by the provider as rewards.
+
 message ChangeRewardDenomsProposal {
   option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
 
diff --git a/proto/interchain_security/ccv/provider/v1/tx.proto b/proto/interchain_security/ccv/provider/v1/tx.proto
index c08684dc6c..eb009144d6 100644
--- a/proto/interchain_security/ccv/provider/v1/tx.proto
+++ b/proto/interchain_security/ccv/provider/v1/tx.proto
@@ -21,6 +21,9 @@ service Msg {
 
   rpc ConsumerAddition(MsgConsumerAddition)
       returns (MsgConsumerAdditionResponse);
+
+   rpc ConsumerRemoval(MsgConsumerRemoval)
+      returns (MsgConsumerRemovalResponse);
 }
 
 message MsgAssignConsumerKey {
@@ -101,8 +104,24 @@ message MsgConsumerAddition {
   string distribution_transmission_channel = 12;
 
   // signer address
-  string signer = 13 [(cosmos_proto.scalar) = "cosmos.AddressString"];;
+  string signer = 13 [(cosmos_proto.scalar) = "cosmos.AddressString"];
 }
 
 // MsgConsumerAdditionResponse defines the Msg/MsgIBCSoftwareUpgrade response type
-message MsgConsumerAdditionResponse {}
\ No newline at end of file
+message MsgConsumerAdditionResponse {}
+
+message MsgConsumerRemoval {
+  option (cosmos.msg.v1.signer) = "signer";
+
+  // the chain-id of the consumer chain to be stopped
+  string chain_id = 3;
+  // the time on the provider chain at which all validators are responsible to
+  // stop their consumer chain validator node
+  google.protobuf.Timestamp stop_time = 4
+      [ (gogoproto.stdtime) = true, (gogoproto.nullable) = false ];
+
+  // signer address
+  string signer = 13 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+}
+
+message MsgConsumerRemovalResponse {}
\ No newline at end of file
diff --git a/x/ccv/provider/keeper/msg_server.go b/x/ccv/provider/keeper/msg_server.go
index c265b536aa..87447ae243 100644
--- a/x/ccv/provider/keeper/msg_server.go
+++ b/x/ccv/provider/keeper/msg_server.go
@@ -121,3 +121,16 @@ func (k msgServer) ConsumerAddition(goCtx context.Context, msg *types.MsgConsume
 
 	return &types.MsgConsumerAdditionResponse{}, nil
 }
+
+// ConsumerRemoval defines a rpc handler method for MsgConsumerRemoval
+func (k msgServer) ConsumerRemoval(
+	goCtx context.Context,
+	msg *types.MsgConsumerRemoval) (*types.MsgConsumerRemovalResponse, error) {
+	if k.GetAuthority() != msg.Signer {
+		return nil, errorsmod.Wrapf(types.ErrUnauthorized, "expected %s, got %s", k.GetAuthority(), msg.Signer)
+	}
+
+	// TODO: Call keeper implementation !
+
+	return &types.MsgConsumerRemovalResponse{}, nil
+}
diff --git a/x/ccv/provider/types/codec.go b/x/ccv/provider/types/codec.go
index 2127ae1a56..21892abad4 100644
--- a/x/ccv/provider/types/codec.go
+++ b/x/ccv/provider/types/codec.go
@@ -27,6 +27,7 @@ func RegisterInterfaces(registry codectypes.InterfaceRegistry) {
 		(*sdk.Msg)(nil),
 		&MsgAssignConsumerKey{},
 		&MsgConsumerAddition{},
+		&MsgConsumerRemoval{},
 	)
 	registry.RegisterImplementations(
 		(*govv1beta1.Content)(nil),
diff --git a/x/ccv/provider/types/legacy_proposal.go b/x/ccv/provider/types/legacy_proposal.go
index 5e0356e9e8..a7b96273b4 100644
--- a/x/ccv/provider/types/legacy_proposal.go
+++ b/x/ccv/provider/types/legacy_proposal.go
@@ -194,7 +194,7 @@ func (sccp *ConsumerRemovalProposal) ValidateBasic() error {
 	}
 
 	if sccp.StopTime.IsZero() {
-		return errorsmod.Wrap(ErrInvalidConsumerRemovalProp, "spawn time cannot be zero")
+		return errorsmod.Wrap(ErrInvalidConsumerRemovalProp, "stop time cannot be zero")
 	}
 	return nil
 }
diff --git a/x/ccv/provider/types/msg.go b/x/ccv/provider/types/msg.go
index 56f6a1d7dd..2d2993eaad 100644
--- a/x/ccv/provider/types/msg.go
+++ b/x/ccv/provider/types/msg.go
@@ -5,8 +5,10 @@ import (
 	"strings"
 	"time"
 
+	errorsmod "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types"
+	ccvtypes "github.com/cosmos/interchain-security/v3/x/ccv/types"
 )
 
 // provider message types
@@ -15,11 +17,13 @@ const (
 )
 
 var (
-	_ sdk.Msg = &MsgAssignConsumerKey{}
-	_ sdk.Msg = &MsgConsumerAddition{}
+	_ sdk.Msg = (*MsgAssignConsumerKey)(nil)
+	_ sdk.Msg = (*MsgConsumerAddition)(nil)
+	_ sdk.Msg = (*MsgConsumerRemoval)(nil)
 
-	_ sdk.HasValidateBasic = &MsgAssignConsumerKey{}
-	_ sdk.HasValidateBasic = &MsgConsumerAddition{}
+	_ sdk.HasValidateBasic = (*MsgAssignConsumerKey)(nil)
+	_ sdk.HasValidateBasic = (*MsgConsumerAddition)(nil)
+	_ sdk.HasValidateBasic = (*MsgConsumerRemoval)(nil)
 )
 
 // NewMsgAssignConsumerKey creates a new MsgAssignConsumerKey instance.
@@ -103,7 +107,6 @@ func ParseConsumerKeyFromJson(jsonStr string) (pkType, key string, err error) {
 }
 
 // NewMsgConsumerAddition creates a new MsgConsumerAddition instance.
-// Delegator address and validator address are the same.
 func NewMsgConsumerAddition(signer, chainID string,
 	initialHeight clienttypes.Height, genesisHash, binaryHash []byte,
 	spawnTime time.Time,
@@ -127,19 +130,10 @@ func NewMsgConsumerAddition(signer, chainID string,
 		CcvTimeoutPeriod:                  ccvTimeoutPeriod,
 		TransferTimeoutPeriod:             transferTimeoutPeriod,
 		UnbondingPeriod:                   unbondingPeriod,
+		Signer:                            signer,
 	}
 }
 
-// TODO: remove if not needed
-/* // Route implements the sdk.Msg interface.
-func (msg MsgConsumerAddition) Route() string { return RouterKey }
-
-// Type implements the sdk.Msg interface.
-func (msg MsgConsumerAddition) Type() string {
-	return TypeMsgConsumerAdditionKey
-}
-*/
-
 // GetSigners implements the sdk.Msg interface. It returns the address(es) that
 // must sign over msg.GetSignBytes().
 // If the validator address is not same as delegator's, then the validator must
@@ -153,24 +147,76 @@ func (msg *MsgConsumerAddition) GetSigners() []sdk.AccAddress {
 	return []sdk.AccAddress{valAddr.Bytes()}
 }
 
-// GetSignBytes returns the message bytes to sign over.
-func (msg *MsgConsumerAddition) GetSignBytes() []byte {
-	bz := ModuleCdc.MustMarshalJSON(msg)
-	return sdk.MustSortJSON(bz)
-}
-
 // ValidateBasic implements the sdk.Msg interface.
 func (msg *MsgConsumerAddition) ValidateBasic() error {
 	if strings.TrimSpace(msg.ChainId) == "" {
 		return ErrBlankConsumerChainID
 	}
-	//TODO
+
+	if strings.TrimSpace(msg.ChainId) == "" {
+		return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "consumer chain id must not be blank")
+	}
+
+	if msg.InitialHeight.IsZero() {
+		return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "initial height cannot be zero")
+	}
+
+	if len(msg.GenesisHash) == 0 {
+		return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "genesis hash cannot be empty")
+	}
+	if len(msg.BinaryHash) == 0 {
+		return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "binary hash cannot be empty")
+	}
+
+	if msg.SpawnTime.IsZero() {
+		return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "spawn time cannot be zero")
+	}
+
+	if err := ccvtypes.ValidateStringFraction(msg.ConsumerRedistributionFraction); err != nil {
+		return errorsmod.Wrapf(ErrInvalidConsumerAdditionProposal, "consumer redistribution fraction is invalid: %s", err)
+	}
+
+	if err := ccvtypes.ValidatePositiveInt64(msg.BlocksPerDistributionTransmission); err != nil {
+		return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "blocks per distribution transmission cannot be < 1")
+	}
+
+	if err := ccvtypes.ValidateDistributionTransmissionChannel(msg.DistributionTransmissionChannel); err != nil {
+		return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "distribution transmission channel")
+	}
+
+	if err := ccvtypes.ValidatePositiveInt64(msg.HistoricalEntries); err != nil {
+		return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "historical entries cannot be < 1")
+	}
+
+	if err := ccvtypes.ValidateDuration(msg.CcvTimeoutPeriod); err != nil {
+		return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "ccv timeout period cannot be zero")
+	}
+
+	if err := ccvtypes.ValidateDuration(msg.TransferTimeoutPeriod); err != nil {
+		return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "transfer timeout period cannot be zero")
+	}
+
+	if err := ccvtypes.ValidateDuration(msg.UnbondingPeriod); err != nil {
+		return errorsmod.Wrap(ErrInvalidConsumerAdditionProposal, "unbonding period cannot be zero")
+	}
+
 	return nil
 }
 
-// UnpackInterfaces implements UnpackInterfacesMessage.UnpackInterfaces
-/* func (msg *MsgConsumerAddition) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error {
-	//return unpacker.UnpackAny(msg., new(exported.ClientState))
+// NewMsgConsumerRemoval creates a new MsgConsumerRemoval instance
+func NewMsgConsumerRemoval(signer string) *MsgConsumerRemoval {
+	//@bermuell: TODO finsh implementation!
+	return &MsgConsumerRemoval{}
+}
+
+func (msg *MsgConsumerRemoval) ValidateBasic() error {
+
+	if strings.TrimSpace(msg.ChainId) == "" {
+		return errorsmod.Wrap(ErrInvalidConsumerRemovalProp, "consumer chain id must not be blank")
+	}
+
+	if msg.StopTime.IsZero() {
+		return errorsmod.Wrap(ErrInvalidConsumerRemovalProp, "spawn time cannot be zero")
+	}
 	return nil
 }
-*/
diff --git a/x/ccv/provider/types/provider.pb.go b/x/ccv/provider/types/provider.pb.go
index e4392171a1..95d02de611 100644
--- a/x/ccv/provider/types/provider.pb.go
+++ b/x/ccv/provider/types/provider.pb.go
@@ -132,6 +132,9 @@ var xxx_messageInfo_ConsumerAdditionProposal proto.InternalMessageInfo
 // remove (and stop) a consumer chain. If it passes, all the consumer chain's
 // state is removed from the provider chain. The outstanding unbonding operation
 // funds are released.
+// Deprecated: Use MsgConsumerRemoval instead
+//
+// Deprecated: Do not use.
 type ConsumerRemovalProposal struct {
 	// the title of the proposal
 	Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
@@ -205,8 +208,6 @@ func (m *ConsumerRemovalProposal) GetStopTime() time.Time {
 	return time.Time{}
 }
 
-// ChangeRewardDenomsProposal is a governance proposal on the provider chain to
-// mutate the set of denoms accepted by the provider as rewards.
 type ChangeRewardDenomsProposal struct {
 	// the title of the proposal
 	Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
@@ -1356,115 +1357,115 @@ func init() {
 }
 
 var fileDescriptor_f22ec409a72b7b72 = []byte{
-	// 1717 bytes of a gzipped FileDescriptorProto
+	// 1719 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xcd, 0x6f, 0x1b, 0xc7,
 	0x15, 0xd7, 0x8a, 0x94, 0x2c, 0x3e, 0xea, 0xcb, 0x2b, 0x3b, 0xa6, 0x54, 0x95, 0x92, 0x37, 0x6d,
-	0xaa, 0x22, 0xf0, 0x32, 0x92, 0x51, 0x20, 0x30, 0x1a, 0x04, 0x12, 0x95, 0xc4, 0x8a, 0x9b, 0x58,
+	0xaa, 0x22, 0xf0, 0x32, 0x92, 0x51, 0x20, 0x10, 0x1a, 0x04, 0x12, 0x95, 0xc4, 0x8a, 0x9b, 0x58,
 	0x59, 0xa9, 0x32, 0xda, 0x1e, 0x16, 0xc3, 0xd9, 0x31, 0x39, 0xd0, 0xee, 0xce, 0x66, 0x66, 0xb8,
 	0x36, 0x2f, 0x3d, 0xf7, 0x98, 0xde, 0x82, 0x9e, 0xd2, 0xfe, 0x0d, 0xfd, 0x0b, 0x7a, 0x0a, 0x7a,
-	0x69, 0x8e, 0x3d, 0xa5, 0x85, 0x7c, 0xe8, 0xa1, 0x7f, 0x44, 0x8b, 0x99, 0xd9, 0x2f, 0x52, 0x1f,
+	0x4a, 0x6f, 0x3d, 0xa5, 0x85, 0x7d, 0xe8, 0xa1, 0x7f, 0x44, 0x8b, 0x99, 0xd9, 0x2f, 0x52, 0x1f,
 	0xa1, 0x11, 0xe4, 0xb6, 0xf3, 0xe6, 0xbd, 0xdf, 0xfb, 0x7e, 0x6f, 0x48, 0xd8, 0xa3, 0xb1, 0x24,
 	0x1c, 0x0f, 0x10, 0x8d, 0x7d, 0x41, 0xf0, 0x90, 0x53, 0x39, 0xea, 0x60, 0x9c, 0x76, 0x12, 0xce,
 	0x52, 0x1a, 0x10, 0xde, 0x49, 0x77, 0x8b, 0x6f, 0x37, 0xe1, 0x4c, 0x32, 0xfb, 0xcd, 0x2b, 0x64,
 	0x5c, 0x8c, 0x53, 0xb7, 0xe0, 0x4b, 0x77, 0x37, 0xde, 0xb9, 0x0e, 0x38, 0xdd, 0xed, 0x88, 0x01,
-	0xe2, 0x24, 0xf0, 0x31, 0x8b, 0xc5, 0x30, 0xca, 0x61, 0x37, 0x7e, 0x7a, 0x83, 0xc4, 0x0b, 0xca,
+	0xe2, 0x24, 0xf0, 0x31, 0x8b, 0xc5, 0x30, 0xca, 0x61, 0x37, 0x7e, 0x7a, 0x83, 0xc4, 0x73, 0xca,
 	0x49, 0xc6, 0x76, 0xa7, 0xcf, 0xfa, 0x4c, 0x7f, 0x76, 0xd4, 0x57, 0x46, 0xdd, 0xea, 0x33, 0xd6,
-	0x0f, 0x49, 0x47, 0x9f, 0x7a, 0xc3, 0xe7, 0x1d, 0x49, 0x23, 0x22, 0x24, 0x8a, 0x92, 0x8c, 0xa1,
+	0x0f, 0x49, 0x47, 0x9f, 0x7a, 0xc3, 0x67, 0x1d, 0x49, 0x23, 0x22, 0x24, 0x8a, 0x92, 0x8c, 0xa1,
 	0x3d, 0xc9, 0x10, 0x0c, 0x39, 0x92, 0x94, 0xc5, 0x39, 0x00, 0xed, 0xe1, 0x0e, 0x66, 0x9c, 0x74,
 	0x70, 0x48, 0x49, 0x2c, 0x95, 0x56, 0xf3, 0x95, 0x31, 0x74, 0x14, 0x43, 0x48, 0xfb, 0x03, 0x69,
 	0xc8, 0xa2, 0x23, 0x49, 0x1c, 0x10, 0x1e, 0x51, 0xc3, 0x5c, 0x9e, 0x32, 0x81, 0xcd, 0xca, 0x3d,
-	0xe6, 0xa3, 0x44, 0xb2, 0xce, 0x39, 0x19, 0x89, 0xec, 0xf6, 0x2d, 0xcc, 0x44, 0xc4, 0x44, 0x87,
+	0xe6, 0xa3, 0x44, 0xb2, 0xce, 0x05, 0x19, 0x89, 0xec, 0xf6, 0x2d, 0xcc, 0x44, 0xc4, 0x44, 0x87,
 	0xa8, 0x88, 0xc5, 0x98, 0x74, 0xd2, 0xdd, 0x1e, 0x91, 0x68, 0xb7, 0x20, 0xe4, 0x76, 0x67, 0x7c,
 	0x3d, 0x24, 0x4a, 0x1e, 0xcc, 0x68, 0x6e, 0xf7, 0xba, 0xb9, 0xf7, 0x4d, 0x44, 0xcc, 0xc1, 0x5c,
-	0x39, 0xff, 0x9b, 0x87, 0x56, 0x37, 0x8b, 0xf1, 0x7e, 0x10, 0x50, 0xe5, 0xed, 0x31, 0x67, 0x09,
+	0x39, 0xff, 0x9b, 0x87, 0x56, 0x37, 0x8b, 0xf1, 0x41, 0x10, 0x50, 0xe5, 0xed, 0x09, 0x67, 0x09,
 	0x13, 0x28, 0xb4, 0xef, 0xc0, 0x9c, 0xa4, 0x32, 0x24, 0x2d, 0x6b, 0xdb, 0xda, 0x69, 0x78, 0xe6,
 	0x60, 0x6f, 0x43, 0x33, 0x20, 0x02, 0x73, 0x9a, 0x28, 0xe6, 0xd6, 0xac, 0xbe, 0xab, 0x92, 0xec,
-	0x75, 0x58, 0x30, 0x29, 0xa2, 0x41, 0xab, 0xa6, 0xaf, 0x6f, 0xe9, 0xf3, 0x51, 0x60, 0x7f, 0x04,
+	0x75, 0x58, 0x30, 0x29, 0xa2, 0x41, 0xab, 0xa6, 0xaf, 0x6f, 0xe9, 0xf3, 0x71, 0x60, 0x7f, 0x04,
 	0xcb, 0x34, 0xa6, 0x92, 0xa2, 0xd0, 0x1f, 0x10, 0x15, 0xa8, 0x56, 0x7d, 0xdb, 0xda, 0x69, 0xee,
-	0x6d, 0xb8, 0xb4, 0x87, 0x5d, 0x15, 0x5b, 0x37, 0x8b, 0x68, 0xba, 0xeb, 0x3e, 0xd6, 0x1c, 0x07,
+	0x6d, 0xb8, 0xb4, 0x87, 0x5d, 0x15, 0x5b, 0x37, 0x8b, 0x68, 0xba, 0xeb, 0x3e, 0xd2, 0x1c, 0x87,
 	0xf5, 0xaf, 0xbf, 0xdd, 0x9a, 0xf1, 0x96, 0x32, 0x39, 0x43, 0xb4, 0xef, 0xc3, 0x62, 0x9f, 0xc4,
 	0x44, 0x50, 0xe1, 0x0f, 0x90, 0x18, 0xb4, 0xe6, 0xb6, 0xad, 0x9d, 0x45, 0xaf, 0x99, 0xd1, 0x1e,
-	0x23, 0x31, 0xb0, 0xb7, 0xa0, 0xd9, 0xa3, 0x31, 0xe2, 0x23, 0xc3, 0x31, 0xaf, 0x39, 0xc0, 0x90,
-	0x34, 0x43, 0x17, 0x40, 0x24, 0xe8, 0x45, 0xec, 0xab, 0x42, 0x68, 0xdd, 0xca, 0x0c, 0x31, 0x45,
-	0xe0, 0xe6, 0x45, 0xe0, 0x9e, 0xe6, 0x55, 0x72, 0xb0, 0xa0, 0x0c, 0xf9, 0xe2, 0x5f, 0x5b, 0x96,
+	0x21, 0x31, 0xb0, 0xb7, 0xa0, 0xd9, 0xa3, 0x31, 0xe2, 0x23, 0xc3, 0x31, 0xaf, 0x39, 0xc0, 0x90,
+	0x34, 0x43, 0x17, 0x40, 0x24, 0xe8, 0x79, 0xec, 0xab, 0x42, 0x68, 0xdd, 0xca, 0x0c, 0x31, 0x45,
+	0xe0, 0xe6, 0x45, 0xe0, 0x9e, 0xe5, 0x55, 0x72, 0xb8, 0xa0, 0x0c, 0xf9, 0xe2, 0x5f, 0x5b, 0x96,
 	0xd7, 0xd0, 0x72, 0xea, 0xc6, 0xfe, 0x14, 0x56, 0x87, 0x71, 0x8f, 0xc5, 0x01, 0x8d, 0xfb, 0x7e,
-	0x42, 0x38, 0x65, 0x41, 0x6b, 0x41, 0x43, 0xad, 0x5f, 0x82, 0x3a, 0xcc, 0xea, 0xc9, 0x20, 0x7d,
-	0xa9, 0x90, 0x56, 0x0a, 0xe1, 0x63, 0x2d, 0x6b, 0x7f, 0x06, 0x36, 0xc6, 0xa9, 0x36, 0x89, 0x0d,
-	0x65, 0x8e, 0xd8, 0x98, 0x1e, 0x71, 0x15, 0xe3, 0xf4, 0xd4, 0x48, 0x67, 0x90, 0xbf, 0x83, 0x7b,
-	0x92, 0xa3, 0x58, 0x3c, 0x27, 0x7c, 0x12, 0x17, 0xa6, 0xc7, 0xbd, 0x9b, 0x63, 0x8c, 0x83, 0x3f,
-	0x86, 0xed, 0xbc, 0x49, 0x7d, 0x4e, 0x02, 0x2a, 0x24, 0xa7, 0xbd, 0xa1, 0x92, 0xf5, 0x9f, 0x73,
+	0x42, 0x38, 0x65, 0x41, 0x6b, 0x41, 0x43, 0xad, 0x5f, 0x82, 0x3a, 0xca, 0xea, 0xc9, 0x20, 0x7d,
+	0xa9, 0x90, 0x56, 0x0a, 0xe1, 0x13, 0x2d, 0x6b, 0x7f, 0x06, 0x36, 0xc6, 0xa9, 0x36, 0x89, 0x0d,
+	0x65, 0x8e, 0xd8, 0x98, 0x1e, 0x71, 0x15, 0xe3, 0xf4, 0xcc, 0x48, 0x67, 0x90, 0xbf, 0x83, 0x7b,
+	0x92, 0xa3, 0x58, 0x3c, 0x23, 0x7c, 0x12, 0x17, 0xa6, 0xc7, 0xbd, 0x9b, 0x63, 0x8c, 0x83, 0x3f,
+	0x82, 0xed, 0xbc, 0x49, 0x7d, 0x4e, 0x02, 0x2a, 0x24, 0xa7, 0xbd, 0xa1, 0x92, 0xf5, 0x9f, 0x71,
 	0x84, 0x75, 0x8d, 0x34, 0x75, 0x11, 0xb4, 0x73, 0x3e, 0x6f, 0x8c, 0xed, 0xc3, 0x8c, 0xcb, 0x7e,
-	0x0a, 0x3f, 0xe9, 0x85, 0x0c, 0x9f, 0x0b, 0x65, 0x9c, 0x3f, 0x86, 0xa4, 0x55, 0x47, 0x54, 0x08,
-	0x85, 0xb6, 0xb8, 0x6d, 0xed, 0xd4, 0xbc, 0xfb, 0x86, 0xf7, 0x98, 0xf0, 0xc3, 0x0a, 0xe7, 0x69,
+	0x02, 0x3f, 0xe9, 0x85, 0x0c, 0x5f, 0x08, 0x65, 0x9c, 0x3f, 0x86, 0xa4, 0x55, 0x47, 0x54, 0x08,
+	0x85, 0xb6, 0xb8, 0x6d, 0xed, 0xd4, 0xbc, 0xfb, 0x86, 0xf7, 0x84, 0xf0, 0xa3, 0x0a, 0xe7, 0x59,
 	0x85, 0xd1, 0x7e, 0x00, 0xf6, 0x80, 0x0a, 0xc9, 0x38, 0xc5, 0x28, 0xf4, 0x49, 0x2c, 0x39, 0x25,
 	0xa2, 0xb5, 0xa4, 0xc5, 0x6f, 0x97, 0x37, 0x1f, 0x98, 0x0b, 0xfb, 0x63, 0xb8, 0x7f, 0xad, 0x52,
 	0x1f, 0x0f, 0x50, 0x1c, 0x93, 0xb0, 0xb5, 0xac, 0x5d, 0xd9, 0x0a, 0xae, 0xd1, 0xd9, 0x35, 0x6c,
-	0x8f, 0x76, 0xfe, 0xf0, 0xd5, 0xd6, 0xcc, 0x97, 0x5f, 0x6d, 0xcd, 0xfc, 0xfd, 0xaf, 0x0f, 0x36,
-	0xb2, 0x8e, 0xeb, 0xb3, 0xd4, 0xcd, 0xba, 0xd3, 0xed, 0xb2, 0x58, 0x92, 0x58, 0xb6, 0x2c, 0xe7,
-	0x1f, 0x16, 0xdc, 0xeb, 0x16, 0x81, 0x89, 0x58, 0x8a, 0xc2, 0x1f, 0xb2, 0x01, 0xf7, 0xa1, 0x21,
-	0x24, 0x4b, 0x4c, 0xc9, 0xd7, 0x5f, 0xa3, 0xe4, 0x17, 0x94, 0x98, 0xba, 0x78, 0xd4, 0xbe, 0xd9,
-	0x27, 0xe7, 0x6f, 0x16, 0x6c, 0xa8, 0x38, 0xf4, 0x89, 0x47, 0x5e, 0x20, 0x1e, 0x1c, 0x92, 0x98,
-	0x45, 0xe2, 0x7b, 0x3b, 0xe5, 0xc0, 0x52, 0xa0, 0x91, 0x7c, 0xc9, 0x7c, 0x14, 0x28, 0xcf, 0x6a,
-	0x86, 0x47, 0x11, 0x4f, 0xd9, 0x7e, 0x10, 0xd8, 0x3b, 0xb0, 0x5a, 0xf2, 0x70, 0x15, 0x4d, 0xe5,
-	0xa4, 0x62, 0x5b, 0xce, 0xd9, 0x74, 0x8c, 0xbf, 0xdb, 0x89, 0xff, 0x5a, 0xb0, 0xfa, 0x51, 0xc8,
-	0x7a, 0x28, 0x3c, 0x09, 0x91, 0x18, 0xa8, 0x1a, 0x19, 0xa9, 0xe0, 0x71, 0x92, 0x35, 0xa7, 0x36,
-	0x7f, 0xea, 0xe0, 0x29, 0x31, 0x3d, 0x2e, 0xde, 0x87, 0xdb, 0x45, 0xbb, 0x14, 0x39, 0xd2, 0xde,
-	0x1e, 0xac, 0x5d, 0x7c, 0xbb, 0xb5, 0x92, 0x97, 0x42, 0x57, 0xe7, 0xeb, 0xd0, 0x5b, 0xc1, 0x63,
-	0x84, 0xc0, 0x6e, 0x43, 0x93, 0xf6, 0xb0, 0x2f, 0xc8, 0xe7, 0x7e, 0x3c, 0x8c, 0x74, 0x7a, 0xeb,
-	0x5e, 0x83, 0xf6, 0xf0, 0x09, 0xf9, 0xfc, 0xd3, 0x61, 0x64, 0x3f, 0x84, 0x37, 0xf2, 0x1d, 0xeb,
-	0xa7, 0x28, 0xd4, 0x1b, 0x54, 0x85, 0x8b, 0xeb, 0x6c, 0x2f, 0x7a, 0x6b, 0xf9, 0xed, 0x19, 0x0a,
-	0x95, 0xb2, 0xfd, 0x20, 0xe0, 0xce, 0x7f, 0xe6, 0x60, 0xfe, 0x18, 0x71, 0x14, 0x09, 0xfb, 0x14,
-	0x56, 0x24, 0x89, 0x92, 0x10, 0x49, 0xe2, 0x9b, 0x51, 0x9c, 0x79, 0xfa, 0xb6, 0x1e, 0xd1, 0xd5,
-	0xed, 0xe6, 0x56, 0xf6, 0x59, 0xba, 0xeb, 0x76, 0x35, 0xf5, 0x44, 0x22, 0x49, 0xbc, 0xe5, 0x1c,
-	0xc3, 0x10, 0xed, 0x77, 0xa1, 0x25, 0xf9, 0x50, 0xc8, 0x72, 0x48, 0x96, 0xd3, 0xc1, 0xe4, 0xfa,
-	0x8d, 0xfc, 0xde, 0xcc, 0x95, 0x62, 0x2a, 0x5c, 0x3d, 0x0f, 0x6b, 0xdf, 0x67, 0x1e, 0x9e, 0xc0,
-	0x9a, 0x5a, 0x26, 0x93, 0x98, 0xf5, 0xe9, 0x31, 0x6f, 0x2b, 0xf9, 0x71, 0xd0, 0xcf, 0xc0, 0x4e,
-	0x05, 0x9e, 0xc4, 0x9c, 0x7b, 0x0d, 0x3b, 0x53, 0x81, 0xc7, 0x21, 0x03, 0xd8, 0x14, 0xaa, 0xf8,
-	0xfc, 0x88, 0x48, 0x3d, 0x5d, 0x93, 0x90, 0xc4, 0x54, 0x0c, 0x72, 0xf0, 0xf9, 0xe9, 0xc1, 0xd7,
-	0x35, 0xd0, 0x27, 0x0a, 0xc7, 0xcb, 0x61, 0x32, 0x2d, 0x5d, 0x68, 0x5f, 0xad, 0xa5, 0x48, 0xd0,
-	0x2d, 0x9d, 0xa0, 0x1f, 0x5d, 0x01, 0x51, 0x64, 0x69, 0x0f, 0xee, 0x46, 0xe8, 0xa5, 0x2f, 0x07,
-	0x9c, 0x49, 0x19, 0x92, 0xc0, 0x4f, 0x10, 0x3e, 0x27, 0x52, 0xe8, 0x55, 0x58, 0xf3, 0xd6, 0x22,
-	0xf4, 0xf2, 0x34, 0xbf, 0x3b, 0x36, 0x57, 0xb6, 0x80, 0xb7, 0x2a, 0x9b, 0x43, 0x4d, 0x0a, 0x5f,
-	0x37, 0xa9, 0xcf, 0x49, 0x5f, 0x8d, 0x57, 0x64, 0x96, 0x08, 0x21, 0xc5, 0xf6, 0xcb, 0xfa, 0x55,
-	0xbd, 0x73, 0x2a, 0x0d, 0x4b, 0xe3, 0xec, 0x89, 0xe0, 0x94, 0x0b, 0xa6, 0x98, 0x3b, 0x5e, 0x05,
-	0xeb, 0x43, 0x42, 0x9c, 0x9f, 0x43, 0x43, 0x37, 0xf4, 0x3e, 0x3e, 0x17, 0xf6, 0x26, 0x34, 0x54,
-	0x67, 0x10, 0x21, 0x88, 0x68, 0x59, 0x7a, 0x4e, 0x94, 0x04, 0x47, 0xc2, 0xfa, 0x75, 0x4f, 0x23,
-	0x61, 0x3f, 0x83, 0x5b, 0x09, 0xd1, 0x7b, 0x5b, 0x0b, 0x36, 0xf7, 0xde, 0x73, 0xa7, 0x78, 0xf2,
-	0xba, 0xd7, 0x01, 0x7a, 0x39, 0x9a, 0xc3, 0xcb, 0x07, 0xd9, 0xc4, 0x3a, 0x10, 0xf6, 0xd9, 0xa4,
-	0xd2, 0x5f, 0xbe, 0x96, 0xd2, 0x09, 0xbc, 0x52, 0xe7, 0xdb, 0xd0, 0xdc, 0x37, 0x6e, 0xff, 0x8a,
-	0x0a, 0x79, 0x39, 0x2c, 0x8b, 0xd5, 0xb0, 0x7c, 0x0c, 0xcb, 0xd9, 0x96, 0x3b, 0x65, 0x7a, 0x28,
-	0xd9, 0x3f, 0x06, 0xc8, 0xd6, 0xa3, 0x1a, 0x66, 0x66, 0xac, 0x37, 0x32, 0xca, 0x51, 0x30, 0xb6,
-	0x8d, 0x66, 0xc7, 0xb6, 0x91, 0xe3, 0xc1, 0xca, 0x99, 0xc0, 0xbf, 0xce, 0x9f, 0x40, 0x4f, 0x13,
-	0x61, 0xdf, 0x85, 0x79, 0xd5, 0x47, 0x19, 0x50, 0xdd, 0x9b, 0x4b, 0x05, 0x3e, 0xd2, 0x93, 0xbd,
-	0x7c, 0x66, 0xb1, 0xc4, 0xa7, 0x81, 0x68, 0xcd, 0x6e, 0xd7, 0x76, 0xea, 0xde, 0xf2, 0xb0, 0x14,
-	0x3f, 0x0a, 0x84, 0xf3, 0x1b, 0x68, 0x56, 0x00, 0xed, 0x65, 0x98, 0x2d, 0xb0, 0x66, 0x69, 0x60,
-	0x3f, 0x82, 0xf5, 0x12, 0x68, 0x7c, 0x14, 0x1b, 0xc4, 0x86, 0x77, 0xaf, 0x60, 0x18, 0x9b, 0xc6,
-	0xc2, 0x79, 0x0a, 0x77, 0x8e, 0xca, 0xc6, 0x2f, 0x06, 0xfd, 0x98, 0x87, 0xd6, 0xf8, 0xbe, 0xdd,
-	0x84, 0x46, 0xf1, 0x33, 0x43, 0x7b, 0x5f, 0xf7, 0x4a, 0x82, 0x13, 0xc1, 0xea, 0x99, 0xc0, 0x27,
-	0x24, 0x0e, 0x4a, 0xb0, 0x6b, 0x02, 0x70, 0x30, 0x09, 0x34, 0xf5, 0x5b, 0xb5, 0x54, 0xc7, 0x60,
-	0xfd, 0x0c, 0x85, 0x34, 0x40, 0x92, 0xf1, 0x13, 0x22, 0xcd, 0x92, 0xce, 0xdb, 0xd1, 0x83, 0x7a,
-	0x48, 0x85, 0xcc, 0x2a, 0xeb, 0xdd, 0x6b, 0x2b, 0x2b, 0xdd, 0x75, 0xaf, 0x03, 0x39, 0x44, 0x12,
-	0x65, 0xbd, 0xa8, 0xb1, 0x9c, 0x9f, 0xc1, 0xda, 0x27, 0x48, 0x0e, 0x39, 0x09, 0xc6, 0x72, 0xbc,
-	0x0a, 0x35, 0x95, 0x3f, 0x4b, 0xe7, 0x4f, 0x7d, 0x3a, 0x7f, 0xb1, 0xa0, 0xf5, 0xc1, 0xcb, 0x84,
-	0x71, 0x49, 0x82, 0x4b, 0x11, 0xb9, 0x21, 0xbc, 0xe7, 0xb0, 0xa6, 0x82, 0x25, 0x48, 0x1c, 0xf8,
-	0x85, 0x9f, 0x26, 0x8f, 0xcd, 0xbd, 0x5f, 0x4c, 0xd5, 0x1d, 0x93, 0xea, 0x32, 0x07, 0x6e, 0xa7,
-	0x13, 0x74, 0xe1, 0xfc, 0xd1, 0x82, 0xd6, 0x13, 0x32, 0xda, 0x17, 0x82, 0xf6, 0xe3, 0x88, 0xc4,
-	0x52, 0xcd, 0x41, 0x84, 0x89, 0xfa, 0xb4, 0xdf, 0x84, 0xa5, 0x62, 0xef, 0xea, 0x75, 0x6b, 0xe9,
-	0x75, 0xbb, 0x98, 0x13, 0x55, 0x83, 0xd9, 0x8f, 0x00, 0x12, 0x4e, 0x52, 0x1f, 0xfb, 0xe7, 0x64,
-	0x94, 0x65, 0x71, 0xb3, 0xba, 0x46, 0xcd, 0x8f, 0x40, 0xf7, 0x78, 0xd8, 0x0b, 0x29, 0x7e, 0x42,
-	0x46, 0xde, 0x82, 0xe2, 0xef, 0x3e, 0x21, 0x23, 0xf5, 0x6e, 0x4a, 0xd8, 0x0b, 0xc2, 0xf5, 0xee,
-	0xab, 0x79, 0xe6, 0xe0, 0xfc, 0xc9, 0x82, 0x7b, 0x45, 0x3a, 0xf2, 0x72, 0x3d, 0x1e, 0xf6, 0x94,
-	0xc4, 0x0d, 0x71, 0xbb, 0x64, 0xed, 0xec, 0x15, 0xd6, 0xbe, 0x0f, 0x8b, 0x45, 0x83, 0x28, 0x7b,
-	0x6b, 0x53, 0xd8, 0xdb, 0xcc, 0x25, 0x9e, 0x90, 0x91, 0xf3, 0xfb, 0x8a, 0x6d, 0x07, 0xa3, 0xca,
-	0xec, 0xe3, 0xdf, 0x61, 0x5b, 0xa1, 0xb6, 0x6a, 0x1b, 0xae, 0xca, 0x5f, 0x72, 0xa0, 0x76, 0xd9,
-	0x01, 0xe7, 0xcf, 0x16, 0xdc, 0xa9, 0x6a, 0x15, 0xa7, 0xec, 0x98, 0x0f, 0x63, 0x72, 0x93, 0xf6,
-	0xb2, 0xfd, 0x66, 0xab, 0xed, 0xf7, 0x0c, 0x96, 0xc7, 0x8c, 0x12, 0x59, 0x34, 0xde, 0x99, 0xaa,
-	0xc6, 0x2a, 0xd3, 0xd5, 0x5b, 0xaa, 0xfa, 0x21, 0x0e, 0x9e, 0x7d, 0x7d, 0xd1, 0xb6, 0xbe, 0xb9,
-	0x68, 0x5b, 0xff, 0xbe, 0x68, 0x5b, 0x5f, 0xbc, 0x6a, 0xcf, 0x7c, 0xf3, 0xaa, 0x3d, 0xf3, 0xcf,
-	0x57, 0xed, 0x99, 0xdf, 0xbe, 0xd7, 0xa7, 0x72, 0x30, 0xec, 0xb9, 0x98, 0x45, 0xd9, 0x8f, 0xf6,
-	0x4e, 0xa9, 0xeb, 0x41, 0xf1, 0xf7, 0x47, 0xfa, 0xb0, 0xf3, 0x72, 0xfc, 0xef, 0x18, 0x39, 0x4a,
-	0x88, 0xe8, 0xcd, 0xeb, 0xa9, 0xf0, 0xf0, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0xe6, 0xb7, 0xf2,
-	0xf2, 0xbf, 0x11, 0x00, 0x00,
+	0xfb, 0x3b, 0x7f, 0xf8, 0x6a, 0x6b, 0xe6, 0xcb, 0xaf, 0xb6, 0x66, 0xfe, 0xfe, 0xd7, 0x07, 0x1b,
+	0x59, 0xc7, 0xf5, 0x59, 0xea, 0x66, 0xdd, 0xe9, 0x76, 0x59, 0x2c, 0x49, 0x2c, 0x5b, 0x96, 0xf3,
+	0x0f, 0x0b, 0xee, 0x75, 0x8b, 0xc0, 0x44, 0x2c, 0x45, 0xe1, 0x0f, 0xd9, 0x80, 0x07, 0xd0, 0x10,
+	0x92, 0x25, 0xa6, 0xe4, 0xeb, 0xaf, 0x51, 0xf2, 0x0b, 0x4a, 0x4c, 0x5d, 0xec, 0x6f, 0x7f, 0xa7,
+	0x4f, 0x7f, 0xb3, 0x60, 0x43, 0x45, 0xa2, 0x4f, 0x3c, 0xf2, 0x1c, 0xf1, 0xe0, 0x88, 0xc4, 0x2c,
+	0x12, 0xdf, 0xdb, 0x2d, 0x07, 0x96, 0x02, 0x8d, 0xe4, 0x4b, 0xe6, 0xa3, 0x40, 0xf9, 0x56, 0x33,
+	0x3c, 0x8a, 0x78, 0xc6, 0x0e, 0x82, 0xc0, 0xde, 0x81, 0xd5, 0x92, 0x87, 0xab, 0x78, 0x2a, 0x37,
+	0x15, 0xdb, 0x72, 0xce, 0xa6, 0xa3, 0x4c, 0xf6, 0xdb, 0x37, 0xbb, 0xe1, 0xfc, 0xd7, 0x82, 0xd5,
+	0x8f, 0x42, 0xd6, 0x43, 0xe1, 0x69, 0x88, 0xc4, 0x40, 0x55, 0xc9, 0x48, 0x85, 0x8f, 0x93, 0xac,
+	0x3d, 0xb5, 0xf9, 0x53, 0x87, 0x4f, 0x89, 0xe9, 0x81, 0xf1, 0x3e, 0xdc, 0x2e, 0x1a, 0xa6, 0xc8,
+	0x92, 0xf6, 0xf6, 0x70, 0xed, 0xe5, 0xb7, 0x5b, 0x2b, 0x79, 0x31, 0x74, 0x75, 0xc6, 0x8e, 0xbc,
+	0x15, 0x3c, 0x46, 0x08, 0xec, 0x36, 0x34, 0x69, 0x0f, 0xfb, 0x82, 0x7c, 0xee, 0xc7, 0xc3, 0x48,
+	0x27, 0xb8, 0xee, 0x35, 0x68, 0x0f, 0x9f, 0x92, 0xcf, 0x3f, 0x1d, 0x46, 0xf6, 0x43, 0x78, 0x23,
+	0xdf, 0xb2, 0x7e, 0x8a, 0x42, 0xbd, 0x43, 0x55, 0xb8, 0xb8, 0xce, 0xf7, 0xa2, 0xb7, 0x96, 0xdf,
+	0x9e, 0xa3, 0x50, 0x29, 0x3b, 0x08, 0x02, 0xee, 0xfc, 0x67, 0x0e, 0xe6, 0x4f, 0x10, 0x47, 0x91,
+	0xb0, 0xcf, 0x60, 0x45, 0x92, 0x28, 0x09, 0x91, 0x24, 0xbe, 0x19, 0xc6, 0x99, 0xa7, 0x6f, 0xeb,
+	0x21, 0x5d, 0xdd, 0x6f, 0x6e, 0x65, 0xa3, 0xa5, 0xbb, 0x6e, 0x57, 0x53, 0x4f, 0x25, 0x92, 0xc4,
+	0x5b, 0xce, 0x31, 0x0c, 0xd1, 0x7e, 0x17, 0x5a, 0x92, 0x0f, 0x85, 0x2c, 0xc7, 0x64, 0x39, 0x1f,
+	0x4c, 0xae, 0xdf, 0xc8, 0xef, 0xcd, 0x64, 0x29, 0xe6, 0xc2, 0xd5, 0x13, 0xb1, 0xf6, 0x7d, 0x26,
+	0xe2, 0x29, 0xac, 0xa9, 0x75, 0x32, 0x89, 0x59, 0x9f, 0x1e, 0xf3, 0xb6, 0x92, 0x1f, 0x07, 0xfd,
+	0x0c, 0xec, 0x54, 0xe0, 0x49, 0xcc, 0xb9, 0xd7, 0xb0, 0x33, 0x15, 0x78, 0x1c, 0x32, 0x80, 0x4d,
+	0xa1, 0x8a, 0xcf, 0x8f, 0x88, 0xd4, 0xf3, 0x35, 0x09, 0x49, 0x4c, 0xc5, 0x20, 0x07, 0x9f, 0x9f,
+	0x1e, 0x7c, 0x5d, 0x03, 0x7d, 0xa2, 0x70, 0xbc, 0x1c, 0x26, 0xd3, 0xd2, 0x85, 0xf6, 0xd5, 0x5a,
+	0x8a, 0x04, 0xdd, 0xd2, 0x09, 0xfa, 0xd1, 0x15, 0x10, 0x45, 0x96, 0xf6, 0xe0, 0x6e, 0x84, 0x5e,
+	0xf8, 0x72, 0xc0, 0x99, 0x94, 0x21, 0x09, 0xfc, 0x04, 0xe1, 0x0b, 0x22, 0x85, 0x5e, 0x86, 0x35,
+	0x6f, 0x2d, 0x42, 0x2f, 0xce, 0xf2, 0xbb, 0x13, 0x73, 0x65, 0x0b, 0x78, 0xab, 0xb2, 0x3b, 0xd4,
+	0xa4, 0xf0, 0x75, 0x93, 0xfa, 0x9c, 0xf4, 0xd5, 0x80, 0x45, 0x66, 0x8d, 0x10, 0x52, 0xec, 0xbf,
+	0xac, 0x5f, 0xd5, 0x4b, 0xa7, 0xd2, 0xb0, 0x34, 0xce, 0x1e, 0x09, 0x4e, 0xb9, 0x62, 0x8a, 0xb9,
+	0xe3, 0x55, 0xb0, 0x3e, 0x24, 0xc4, 0xf9, 0x39, 0x34, 0x74, 0x43, 0x1f, 0xe0, 0x0b, 0x61, 0x6f,
+	0x42, 0x43, 0x75, 0x06, 0x11, 0x82, 0x88, 0x96, 0xa5, 0xe7, 0x44, 0x49, 0x70, 0x24, 0xac, 0x5f,
+	0xf7, 0x38, 0x12, 0xf6, 0x53, 0xb8, 0x95, 0x10, 0xbd, 0xb9, 0xb5, 0x60, 0x73, 0xef, 0x3d, 0x77,
+	0x8a, 0x47, 0xaf, 0x7b, 0x1d, 0xa0, 0x97, 0xa3, 0x39, 0xbc, 0x7c, 0x92, 0x4d, 0x2c, 0x04, 0x61,
+	0x9f, 0x4f, 0x2a, 0xfd, 0xe5, 0x6b, 0x29, 0x9d, 0xc0, 0x2b, 0x75, 0xbe, 0x0d, 0xcd, 0x03, 0xe3,
+	0xf6, 0xaf, 0xa8, 0x90, 0x97, 0xc3, 0xb2, 0x58, 0x0d, 0xcb, 0xc7, 0xb0, 0x9c, 0xed, 0xb9, 0x33,
+	0xa6, 0x87, 0x92, 0xfd, 0x63, 0x80, 0x6c, 0x41, 0xaa, 0x61, 0x66, 0xc6, 0x7a, 0x23, 0xa3, 0x1c,
+	0x07, 0x63, 0xfb, 0x68, 0x76, 0x6c, 0x1f, 0x39, 0x1e, 0xac, 0x9c, 0x0b, 0xfc, 0xeb, 0xfc, 0x11,
+	0xf4, 0x24, 0x11, 0xf6, 0x5d, 0x98, 0x57, 0x7d, 0x94, 0x01, 0xd5, 0xbd, 0xb9, 0x54, 0xe0, 0x63,
+	0x3d, 0xd9, 0xcb, 0x87, 0x16, 0x4b, 0x7c, 0x1a, 0x88, 0xd6, 0xec, 0x76, 0x6d, 0xa7, 0xee, 0x2d,
+	0x0f, 0x4b, 0xf1, 0xe3, 0x40, 0x38, 0xbf, 0x81, 0x66, 0x05, 0xd0, 0x5e, 0x86, 0xd9, 0x02, 0x6b,
+	0x96, 0x06, 0xf6, 0x3e, 0xac, 0x97, 0x40, 0xe3, 0xa3, 0xd8, 0x20, 0x36, 0xbc, 0x7b, 0x05, 0xc3,
+	0xd8, 0x34, 0x16, 0xce, 0x13, 0xb8, 0x73, 0x5c, 0x36, 0x7e, 0x31, 0xe8, 0xc7, 0x3c, 0xb4, 0xc6,
+	0x37, 0xee, 0x26, 0x34, 0x8a, 0x1f, 0x1a, 0xda, 0xfb, 0xba, 0x57, 0x12, 0x9c, 0x08, 0x56, 0xcf,
+	0x05, 0x3e, 0x25, 0x71, 0x50, 0x82, 0x5d, 0x13, 0x80, 0xc3, 0x49, 0xa0, 0xa9, 0x5f, 0xab, 0xa5,
+	0x3a, 0x06, 0xeb, 0xe7, 0x28, 0xa4, 0x01, 0x92, 0x8c, 0x9f, 0x12, 0x69, 0x96, 0x74, 0xde, 0x8e,
+	0x1e, 0xd4, 0x43, 0x2a, 0x64, 0x56, 0x59, 0xef, 0x5e, 0x5b, 0x59, 0xe9, 0xae, 0x7b, 0x1d, 0xc8,
+	0x11, 0x92, 0x28, 0xeb, 0x45, 0x8d, 0xe5, 0xfc, 0x0c, 0xd6, 0x3e, 0x41, 0x72, 0xc8, 0x49, 0x30,
+	0x96, 0xe3, 0x55, 0xa8, 0xa9, 0xfc, 0x59, 0x3a, 0x7f, 0xea, 0xd3, 0xf9, 0x8b, 0x05, 0xad, 0x0f,
+	0x5e, 0x24, 0x8c, 0x4b, 0x12, 0x5c, 0x8a, 0xc8, 0x0d, 0xe1, 0xbd, 0x80, 0x35, 0x15, 0x2c, 0x41,
+	0xe2, 0xc0, 0x2f, 0xfc, 0x34, 0x79, 0x6c, 0xee, 0xfd, 0x62, 0xaa, 0xee, 0x98, 0x54, 0x97, 0x39,
+	0x70, 0x3b, 0x9d, 0xa0, 0x0b, 0xe7, 0x8f, 0x16, 0xb4, 0x1e, 0x93, 0xd1, 0x81, 0x10, 0xb4, 0x1f,
+	0x47, 0x24, 0x96, 0x6a, 0x0e, 0x22, 0x4c, 0xd4, 0xa7, 0xfd, 0x26, 0x2c, 0x15, 0x7b, 0x57, 0xaf,
+	0x5b, 0x4b, 0xaf, 0xdb, 0xc5, 0x9c, 0xa8, 0x1a, 0xcc, 0xde, 0x07, 0x48, 0x38, 0x49, 0x7d, 0xec,
+	0x5f, 0x90, 0x51, 0x96, 0xc5, 0xcd, 0xea, 0x1a, 0x35, 0x3f, 0x03, 0xdd, 0x93, 0x61, 0x2f, 0xa4,
+	0xf8, 0x31, 0x19, 0x79, 0x0b, 0x8a, 0xbf, 0xfb, 0x98, 0x8c, 0xd4, 0xbb, 0x29, 0x61, 0xcf, 0x09,
+	0xd7, 0xbb, 0xaf, 0xe6, 0x99, 0x83, 0xf3, 0x27, 0x0b, 0xee, 0x15, 0xe9, 0xc8, 0xcb, 0xf5, 0x64,
+	0xd8, 0x53, 0x12, 0x37, 0xc4, 0xed, 0x92, 0xb5, 0xb3, 0x57, 0x58, 0xfb, 0x3e, 0x2c, 0x16, 0x0d,
+	0xa2, 0xec, 0xad, 0x4d, 0x61, 0x6f, 0x33, 0x97, 0x78, 0x4c, 0x46, 0xce, 0xef, 0x2b, 0xb6, 0x1d,
+	0x8e, 0x2a, 0xb3, 0x8f, 0x7f, 0x87, 0x6d, 0x85, 0xda, 0xaa, 0x6d, 0xb8, 0x2a, 0x7f, 0xc9, 0x81,
+	0xda, 0x65, 0x07, 0x9c, 0x3f, 0x5b, 0x70, 0xa7, 0xaa, 0x55, 0x9c, 0xb1, 0x13, 0x3e, 0x8c, 0xc9,
+	0x4d, 0xda, 0xcb, 0xf6, 0x9b, 0xad, 0xb6, 0xdf, 0x53, 0x58, 0x1e, 0x33, 0x4a, 0x64, 0xd1, 0x78,
+	0x67, 0xaa, 0x1a, 0xab, 0x4c, 0x57, 0x6f, 0xa9, 0xea, 0x87, 0x38, 0x7c, 0xfa, 0xf5, 0xcb, 0xb6,
+	0xf5, 0xcd, 0xcb, 0xb6, 0xf5, 0xef, 0x97, 0x6d, 0xeb, 0x8b, 0x57, 0xed, 0x99, 0x6f, 0x5e, 0xb5,
+	0x67, 0xfe, 0xf9, 0xaa, 0x3d, 0xf3, 0xdb, 0xf7, 0xfa, 0x54, 0x0e, 0x86, 0x3d, 0x17, 0xb3, 0x28,
+	0xfb, 0xd9, 0xde, 0x29, 0x75, 0x3d, 0x28, 0xfe, 0x00, 0x49, 0x1f, 0x76, 0x5e, 0x8c, 0xff, 0x21,
+	0x23, 0x47, 0x09, 0x11, 0xbd, 0x79, 0x3d, 0x15, 0x1e, 0xfe, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xf0,
+	0x0c, 0x1a, 0x41, 0xc1, 0x11, 0x00, 0x00,
 }
 
 func (m *ConsumerAdditionProposal) Marshal() (dAtA []byte, err error) {
diff --git a/x/ccv/provider/types/tx.pb.go b/x/ccv/provider/types/tx.pb.go
index 8b3c91a5f0..ccb97f9f0e 100644
--- a/x/ccv/provider/types/tx.pb.go
+++ b/x/ccv/provider/types/tx.pb.go
@@ -336,11 +336,113 @@ func (m *MsgConsumerAdditionResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MsgConsumerAdditionResponse proto.InternalMessageInfo
 
+type MsgConsumerRemoval struct {
+	// the chain-id of the consumer chain to be stopped
+	ChainId string `protobuf:"bytes,3,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
+	// the time on the provider chain at which all validators are responsible to
+	// stop their consumer chain validator node
+	StopTime time.Time `protobuf:"bytes,4,opt,name=stop_time,json=stopTime,proto3,stdtime" json:"stop_time"`
+	// signer address
+	Signer string `protobuf:"bytes,13,opt,name=signer,proto3" json:"signer,omitempty"`
+}
+
+func (m *MsgConsumerRemoval) Reset()         { *m = MsgConsumerRemoval{} }
+func (m *MsgConsumerRemoval) String() string { return proto.CompactTextString(m) }
+func (*MsgConsumerRemoval) ProtoMessage()    {}
+func (*MsgConsumerRemoval) Descriptor() ([]byte, []int) {
+	return fileDescriptor_43221a4391e9fbf4, []int{4}
+}
+func (m *MsgConsumerRemoval) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgConsumerRemoval) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgConsumerRemoval.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgConsumerRemoval) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgConsumerRemoval.Merge(m, src)
+}
+func (m *MsgConsumerRemoval) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgConsumerRemoval) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgConsumerRemoval.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgConsumerRemoval proto.InternalMessageInfo
+
+func (m *MsgConsumerRemoval) GetChainId() string {
+	if m != nil {
+		return m.ChainId
+	}
+	return ""
+}
+
+func (m *MsgConsumerRemoval) GetStopTime() time.Time {
+	if m != nil {
+		return m.StopTime
+	}
+	return time.Time{}
+}
+
+func (m *MsgConsumerRemoval) GetSigner() string {
+	if m != nil {
+		return m.Signer
+	}
+	return ""
+}
+
+type MsgConsumerRemovalResponse struct {
+}
+
+func (m *MsgConsumerRemovalResponse) Reset()         { *m = MsgConsumerRemovalResponse{} }
+func (m *MsgConsumerRemovalResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgConsumerRemovalResponse) ProtoMessage()    {}
+func (*MsgConsumerRemovalResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_43221a4391e9fbf4, []int{5}
+}
+func (m *MsgConsumerRemovalResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgConsumerRemovalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgConsumerRemovalResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgConsumerRemovalResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgConsumerRemovalResponse.Merge(m, src)
+}
+func (m *MsgConsumerRemovalResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgConsumerRemovalResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgConsumerRemovalResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgConsumerRemovalResponse proto.InternalMessageInfo
+
 func init() {
 	proto.RegisterType((*MsgAssignConsumerKey)(nil), "interchain_security.ccv.provider.v1.MsgAssignConsumerKey")
 	proto.RegisterType((*MsgAssignConsumerKeyResponse)(nil), "interchain_security.ccv.provider.v1.MsgAssignConsumerKeyResponse")
 	proto.RegisterType((*MsgConsumerAddition)(nil), "interchain_security.ccv.provider.v1.MsgConsumerAddition")
 	proto.RegisterType((*MsgConsumerAdditionResponse)(nil), "interchain_security.ccv.provider.v1.MsgConsumerAdditionResponse")
+	proto.RegisterType((*MsgConsumerRemoval)(nil), "interchain_security.ccv.provider.v1.MsgConsumerRemoval")
+	proto.RegisterType((*MsgConsumerRemovalResponse)(nil), "interchain_security.ccv.provider.v1.MsgConsumerRemovalResponse")
 }
 
 func init() {
@@ -348,59 +450,63 @@ func init() {
 }
 
 var fileDescriptor_43221a4391e9fbf4 = []byte{
-	// 830 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x55, 0x4f, 0x6f, 0x1c, 0x35,
-	0x14, 0xdf, 0x69, 0xda, 0x34, 0xf1, 0x26, 0x25, 0x35, 0x41, 0x9d, 0x2c, 0x65, 0x26, 0x59, 0x38,
-	0x54, 0x15, 0x99, 0x21, 0xed, 0x01, 0x88, 0x84, 0xc4, 0x26, 0x05, 0x02, 0x28, 0x50, 0x86, 0x48,
-	0x48, 0x70, 0x18, 0x79, 0x3c, 0xce, 0x8c, 0xd5, 0x1d, 0x7b, 0x64, 0x7b, 0x86, 0xee, 0x0d, 0x71,
-	0xe2, 0x84, 0xca, 0x09, 0x8e, 0xfd, 0x08, 0x45, 0xe2, 0x43, 0xf4, 0x58, 0x71, 0x81, 0x53, 0x41,
-	0xc9, 0xa1, 0x9c, 0xf9, 0x04, 0xc8, 0x7f, 0x26, 0x69, 0xfe, 0x14, 0x45, 0xb9, 0xd9, 0xfe, 0xfd,
-	0x79, 0xcf, 0xd6, 0x7b, 0xcf, 0xe0, 0x4d, 0xca, 0x14, 0x11, 0xb8, 0x44, 0x94, 0xa5, 0x92, 0xe0,
-	0x46, 0x50, 0x35, 0x89, 0x31, 0x6e, 0xe3, 0x5a, 0xf0, 0x96, 0xe6, 0x44, 0xc4, 0xed, 0x5a, 0xac,
-	0xee, 0x47, 0xb5, 0xe0, 0x8a, 0xc3, 0xd7, 0x4f, 0x61, 0x47, 0x18, 0xb7, 0x51, 0xc7, 0x8e, 0xda,
-	0xb5, 0xc1, 0xf5, 0x82, 0xf3, 0x62, 0x4c, 0x62, 0x54, 0xd3, 0x18, 0x31, 0xc6, 0x15, 0x52, 0x94,
-	0x33, 0x69, 0x2d, 0x06, 0xa1, 0x43, 0xcd, 0x2e, 0x6b, 0x76, 0x63, 0x45, 0x2b, 0x22, 0x15, 0xaa,
-	0x6a, 0x47, 0x08, 0x8e, 0x13, 0xf2, 0x46, 0x18, 0x07, 0x87, 0x2f, 0x1d, 0xc7, 0x11, 0x9b, 0x38,
-	0x68, 0xb1, 0xe0, 0x05, 0x37, 0xcb, 0x58, 0xaf, 0x3a, 0x01, 0xe6, 0xb2, 0xe2, 0x32, 0xb5, 0x80,
-	0xdd, 0x38, 0xe8, 0x9a, 0xdd, 0xc5, 0x95, 0x2c, 0xf4, 0x3d, 0x2b, 0x59, 0x74, 0x59, 0xd2, 0x0c,
-	0xc7, 0x98, 0x0b, 0x12, 0xe3, 0x31, 0x25, 0x4c, 0x69, 0xd4, 0xae, 0x2c, 0x61, 0xf8, 0xb3, 0x07,
-	0x16, 0xb7, 0x65, 0x31, 0x92, 0x92, 0x16, 0x6c, 0x93, 0x33, 0xd9, 0x54, 0x44, 0x7c, 0x4a, 0x26,
-	0x70, 0x09, 0xcc, 0xd8, 0xf7, 0xa1, 0xb9, 0xef, 0x2d, 0x7b, 0x37, 0x66, 0x93, 0xcb, 0x66, 0xff,
-	0x71, 0x0e, 0xdf, 0x06, 0xf3, 0xdd, 0x3b, 0xa5, 0x28, 0xcf, 0x85, 0x7f, 0x41, 0xe3, 0x1b, 0xf0,
-	0xdf, 0xa7, 0xe1, 0x95, 0x09, 0xaa, 0xc6, 0xeb, 0x43, 0x7d, 0x4a, 0xa4, 0x1c, 0x26, 0x73, 0x1d,
-	0x71, 0x94, 0xe7, 0x02, 0xae, 0x80, 0x39, 0xec, 0x42, 0xa4, 0xf7, 0xc8, 0xc4, 0x9f, 0x32, 0xbe,
-	0x7d, 0x7c, 0x18, 0x76, 0x7d, 0xe6, 0x87, 0x87, 0x61, 0xef, 0x9f, 0x87, 0x61, 0x6f, 0x18, 0x80,
-	0xeb, 0xa7, 0x25, 0x96, 0x10, 0x59, 0x73, 0x26, 0xc9, 0xf0, 0x8f, 0x69, 0xf0, 0xf2, 0xb6, 0x2c,
-	0x3a, 0x68, 0x94, 0xe7, 0x54, 0xbf, 0xee, 0xff, 0x25, 0xfe, 0x11, 0xb8, 0x42, 0x19, 0x55, 0x14,
-	0x8d, 0xd3, 0x92, 0xd0, 0xa2, 0x54, 0x26, 0xf3, 0xfe, 0xad, 0x41, 0x44, 0x33, 0x1c, 0xe9, 0x67,
-	0x8a, 0xdc, 0xe3, 0xb4, 0x6b, 0xd1, 0x96, 0x61, 0x6c, 0x5c, 0x7c, 0xfc, 0x34, 0xec, 0x25, 0xf3,
-	0x4e, 0x67, 0x0f, 0xf5, 0x45, 0x0a, 0xc2, 0x88, 0xa4, 0x32, 0x2d, 0x91, 0x2c, 0xcd, 0x45, 0xe6,
-	0x92, 0xbe, 0x3b, 0xdb, 0x42, 0xb2, 0x84, 0x21, 0xe8, 0x67, 0x94, 0x21, 0x31, 0xb1, 0x8c, 0x8b,
-	0x86, 0x01, 0xec, 0x91, 0x21, 0x6c, 0x02, 0x20, 0x6b, 0xf4, 0x2d, 0x4b, 0x75, 0xe1, 0xf8, 0x97,
-	0x5c, 0x22, 0xb6, 0x28, 0xa2, 0xae, 0x28, 0xa2, 0x9d, 0xae, 0xaa, 0x36, 0x66, 0x74, 0x22, 0x0f,
-	0xfe, 0x0a, 0xbd, 0x64, 0xd6, 0xe8, 0x34, 0x02, 0x3f, 0x03, 0x0b, 0x0d, 0xcb, 0x38, 0xcb, 0x29,
-	0x2b, 0xd2, 0x9a, 0x08, 0xca, 0x73, 0x7f, 0xda, 0x58, 0x2d, 0x9d, 0xb0, 0xba, 0xe3, 0xea, 0xcf,
-	0x3a, 0xfd, 0xa2, 0x9d, 0x5e, 0x3a, 0x10, 0xdf, 0x35, 0x5a, 0xf8, 0x05, 0x80, 0x18, 0xb7, 0x26,
-	0x25, 0xde, 0xa8, 0xce, 0xf1, 0xf2, 0xd9, 0x1d, 0x17, 0x30, 0x6e, 0x77, 0xac, 0xda, 0x59, 0x7e,
-	0x03, 0xae, 0x29, 0x81, 0x98, 0xdc, 0x25, 0xe2, 0xb8, 0xef, 0xcc, 0xd9, 0x7d, 0x5f, 0xe9, 0x3c,
-	0x8e, 0x9a, 0x6f, 0x81, 0xe5, 0x83, 0x8a, 0x12, 0x24, 0xa7, 0x52, 0x09, 0x9a, 0x35, 0x5a, 0x9b,
-	0xee, 0x0a, 0x84, 0xf5, 0xc2, 0x9f, 0x35, 0x45, 0x10, 0x74, 0xbc, 0xe4, 0x08, 0xed, 0x43, 0xc7,
-	0x82, 0x9f, 0x83, 0x37, 0xb2, 0x31, 0xc7, 0xf7, 0xa4, 0x4e, 0x2e, 0x3d, 0xe2, 0x64, 0x42, 0x57,
-	0x54, 0x4a, 0xed, 0x06, 0x96, 0xbd, 0x1b, 0x53, 0xc9, 0x8a, 0xe5, 0xde, 0x25, 0xe2, 0xce, 0x73,
-	0xcc, 0x9d, 0xe7, 0x88, 0x70, 0x15, 0xc0, 0x92, 0x4a, 0xc5, 0x05, 0xc5, 0x68, 0x9c, 0x12, 0xa6,
-	0x04, 0x25, 0xd2, 0xef, 0x1b, 0xf9, 0xd5, 0x43, 0xe4, 0x03, 0x0b, 0xc0, 0x4f, 0xc0, 0xca, 0x0b,
-	0x83, 0xa6, 0xb8, 0x44, 0x8c, 0x91, 0xb1, 0x3f, 0x67, 0xae, 0x12, 0xe6, 0x2f, 0x88, 0xb9, 0x69,
-	0x69, 0xf0, 0x2d, 0x30, 0xad, 0xbb, 0x86, 0x08, 0x7f, 0xde, 0x74, 0xa6, 0xff, 0xfb, 0x6f, 0xab,
-	0x8b, 0x6e, 0x60, 0x8c, 0x6c, 0x6b, 0x7e, 0xa9, 0x04, 0x65, 0x45, 0xe2, 0x78, 0xeb, 0xfd, 0xef,
-	0x9f, 0x3d, 0xba, 0xe9, 0x36, 0xc3, 0xd7, 0xc0, 0xab, 0xa7, 0x34, 0x56, 0xd7, 0x78, 0xb7, 0x7e,
-	0xbd, 0x00, 0xa6, 0xb6, 0x65, 0x01, 0x7f, 0xf2, 0xc0, 0xd5, 0x93, 0x73, 0xe3, 0xdd, 0xe8, 0x0c,
-	0xb3, 0x35, 0x3a, 0xad, 0xb3, 0x07, 0xa3, 0x73, 0x4b, 0xbb, 0xdc, 0xe0, 0x8f, 0x1e, 0x58, 0x38,
-	0x31, 0x11, 0xde, 0x39, 0xab, 0xef, 0x71, 0xe5, 0xe0, 0xfd, 0xf3, 0x2a, 0xbb, 0x84, 0x06, 0x97,
-	0xbe, 0x7b, 0xf6, 0xe8, 0xa6, 0xb7, 0xf1, 0xd5, 0xe3, 0xbd, 0xc0, 0x7b, 0xb2, 0x17, 0x78, 0x7f,
-	0xef, 0x05, 0xde, 0x83, 0xfd, 0xa0, 0xf7, 0x64, 0x3f, 0xe8, 0xfd, 0xb9, 0x1f, 0xf4, 0xbe, 0x7e,
-	0xaf, 0xa0, 0xaa, 0x6c, 0xb2, 0x08, 0xf3, 0xca, 0xcd, 0xf4, 0xf8, 0x30, 0xe6, 0xea, 0xc1, 0x57,
-	0xd6, 0xde, 0x8e, 0xef, 0x1f, 0xfd, 0xcf, 0xd4, 0xa4, 0x26, 0x32, 0x9b, 0x36, 0x4d, 0x73, 0xfb,
-	0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xca, 0x60, 0xb2, 0x45, 0x00, 0x07, 0x00, 0x00,
+	// 896 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x4d, 0x6f, 0x1c, 0x35,
+	0x1f, 0xdf, 0x79, 0x36, 0x4d, 0x37, 0xde, 0xa4, 0x4d, 0xe7, 0x09, 0xea, 0x64, 0x09, 0xb3, 0xc9,
+	0xc2, 0xa1, 0xaa, 0xc8, 0x0c, 0x69, 0x0f, 0x85, 0x48, 0x08, 0x36, 0x29, 0x10, 0x40, 0x81, 0x32,
+	0x44, 0x42, 0x82, 0xc3, 0xc8, 0xe3, 0x71, 0x66, 0xac, 0xee, 0xd8, 0x23, 0xdb, 0x3b, 0x74, 0x6f,
+	0x88, 0x13, 0x12, 0x12, 0x2a, 0x27, 0x38, 0xf6, 0x23, 0x14, 0x89, 0x3b, 0xd7, 0x1e, 0x2b, 0x2e,
+	0x70, 0x2a, 0x28, 0x39, 0x94, 0x33, 0x9f, 0x00, 0xf9, 0x65, 0x36, 0xd9, 0x4d, 0x8a, 0xd2, 0x70,
+	0xb3, 0xfd, 0x7b, 0xf1, 0xcf, 0xde, 0xff, 0xdf, 0x3b, 0xe0, 0x55, 0x42, 0x25, 0xe6, 0x28, 0x87,
+	0x84, 0xc6, 0x02, 0xa3, 0x21, 0x27, 0x72, 0x14, 0x22, 0x54, 0x85, 0x25, 0x67, 0x15, 0x49, 0x31,
+	0x0f, 0xab, 0x8d, 0x50, 0xde, 0x0b, 0x4a, 0xce, 0x24, 0x73, 0x5f, 0x3e, 0x85, 0x1d, 0x20, 0x54,
+	0x05, 0x35, 0x3b, 0xa8, 0x36, 0x3a, 0x2b, 0x19, 0x63, 0xd9, 0x00, 0x87, 0xb0, 0x24, 0x21, 0xa4,
+	0x94, 0x49, 0x28, 0x09, 0xa3, 0xc2, 0x58, 0x74, 0xba, 0x16, 0xd5, 0xb3, 0x64, 0xb8, 0x1f, 0x4a,
+	0x52, 0x60, 0x21, 0x61, 0x51, 0x5a, 0x82, 0x3f, 0x4d, 0x48, 0x87, 0x5c, 0x3b, 0x58, 0x7c, 0x79,
+	0x1a, 0x87, 0x74, 0x64, 0xa1, 0xa5, 0x8c, 0x65, 0x4c, 0x0f, 0x43, 0x35, 0xaa, 0x05, 0x88, 0x89,
+	0x82, 0x89, 0xd8, 0x00, 0x66, 0x62, 0xa1, 0xab, 0x66, 0x16, 0x16, 0x22, 0x53, 0xe7, 0x2c, 0x44,
+	0x56, 0xa7, 0x24, 0x09, 0x0a, 0x11, 0xe3, 0x38, 0x44, 0x03, 0x82, 0xa9, 0x54, 0xa8, 0x19, 0x19,
+	0x42, 0xef, 0x07, 0x07, 0x2c, 0xed, 0x8a, 0xac, 0x2f, 0x04, 0xc9, 0xe8, 0x36, 0xa3, 0x62, 0x58,
+	0x60, 0xfe, 0x21, 0x1e, 0xb9, 0xcb, 0xa0, 0x65, 0xee, 0x87, 0xa4, 0x9e, 0xb3, 0xea, 0x5c, 0x9b,
+	0x8b, 0x2e, 0xea, 0xf9, 0xfb, 0xa9, 0x7b, 0x0b, 0x2c, 0xd4, 0xf7, 0x14, 0xc3, 0x34, 0xe5, 0xde,
+	0xff, 0x14, 0xbe, 0xe5, 0xfe, 0xfd, 0xa4, 0x7b, 0x69, 0x04, 0x8b, 0xc1, 0x66, 0x4f, 0xad, 0x62,
+	0x21, 0x7a, 0xd1, 0x7c, 0x4d, 0xec, 0xa7, 0x29, 0x77, 0xd7, 0xc0, 0x3c, 0xb2, 0x5b, 0xc4, 0x77,
+	0xf1, 0xc8, 0x6b, 0x6a, 0xdf, 0x36, 0x3a, 0xda, 0x76, 0xb3, 0xf5, 0xcd, 0x83, 0x6e, 0xe3, 0xaf,
+	0x07, 0xdd, 0x46, 0xcf, 0x07, 0x2b, 0xa7, 0x05, 0x8b, 0xb0, 0x28, 0x19, 0x15, 0xb8, 0xf7, 0xdb,
+	0x2c, 0xf8, 0xff, 0xae, 0xc8, 0x6a, 0xa8, 0x9f, 0xa6, 0x44, 0xdd, 0xee, 0xbf, 0x05, 0x7f, 0x0f,
+	0x5c, 0x22, 0x94, 0x48, 0x02, 0x07, 0x71, 0x8e, 0x49, 0x96, 0x4b, 0x9d, 0xbc, 0x7d, 0xa3, 0x13,
+	0x90, 0x04, 0x05, 0xea, 0x9a, 0x02, 0x7b, 0x39, 0xd5, 0x46, 0xb0, 0xa3, 0x19, 0x5b, 0x33, 0x8f,
+	0x9e, 0x74, 0x1b, 0xd1, 0x82, 0xd5, 0x99, 0x45, 0x75, 0x90, 0x0c, 0x53, 0x2c, 0x88, 0x88, 0x73,
+	0x28, 0x72, 0x7d, 0x90, 0xf9, 0xa8, 0x6d, 0xd7, 0x76, 0xa0, 0xc8, 0xdd, 0x2e, 0x68, 0x27, 0x84,
+	0x42, 0x3e, 0x32, 0x8c, 0x19, 0xcd, 0x00, 0x66, 0x49, 0x13, 0xb6, 0x01, 0x10, 0x25, 0xfc, 0x92,
+	0xc6, 0xaa, 0x70, 0xbc, 0x0b, 0x36, 0x88, 0x29, 0x8a, 0xa0, 0x2e, 0x8a, 0x60, 0xaf, 0xae, 0xaa,
+	0xad, 0x96, 0x0a, 0x72, 0xff, 0x8f, 0xae, 0x13, 0xcd, 0x69, 0x9d, 0x42, 0xdc, 0x8f, 0xc0, 0xe2,
+	0x90, 0x26, 0x8c, 0xa6, 0x84, 0x66, 0x71, 0x89, 0x39, 0x61, 0xa9, 0x37, 0xab, 0xad, 0x96, 0x4f,
+	0x58, 0xdd, 0xb6, 0xf5, 0x67, 0x9c, 0x7e, 0x54, 0x4e, 0x97, 0xc7, 0xe2, 0x3b, 0x5a, 0xeb, 0x7e,
+	0x02, 0x5c, 0x84, 0x2a, 0x1d, 0x89, 0x0d, 0x65, 0xed, 0x78, 0xf1, 0xec, 0x8e, 0x8b, 0x08, 0x55,
+	0x7b, 0x46, 0x6d, 0x2d, 0xbf, 0x00, 0x57, 0x25, 0x87, 0x54, 0xec, 0x63, 0x3e, 0xed, 0xdb, 0x3a,
+	0xbb, 0xef, 0x0b, 0xb5, 0xc7, 0xa4, 0xf9, 0x0e, 0x58, 0x1d, 0x57, 0x14, 0xc7, 0x29, 0x11, 0x92,
+	0x93, 0x64, 0xa8, 0xb4, 0xf1, 0x3e, 0x87, 0x48, 0x0d, 0xbc, 0x39, 0x5d, 0x04, 0x7e, 0xcd, 0x8b,
+	0x26, 0x68, 0xef, 0x5a, 0x96, 0xfb, 0x31, 0x78, 0x25, 0x19, 0x30, 0x74, 0x57, 0xa8, 0x70, 0xf1,
+	0x84, 0x93, 0xde, 0xba, 0x20, 0x42, 0x28, 0x37, 0xb0, 0xea, 0x5c, 0x6b, 0x46, 0x6b, 0x86, 0x7b,
+	0x07, 0xf3, 0xdb, 0xc7, 0x98, 0x7b, 0xc7, 0x88, 0xee, 0x3a, 0x70, 0x73, 0x22, 0x24, 0xe3, 0x04,
+	0xc1, 0x41, 0x8c, 0xa9, 0xe4, 0x04, 0x0b, 0xaf, 0xad, 0xe5, 0x57, 0x8e, 0x90, 0x77, 0x0c, 0xe0,
+	0x7e, 0x00, 0xd6, 0x9e, 0xb9, 0x69, 0x8c, 0x72, 0x48, 0x29, 0x1e, 0x78, 0xf3, 0xfa, 0x28, 0xdd,
+	0xf4, 0x19, 0x7b, 0x6e, 0x1b, 0x9a, 0xfb, 0x1a, 0x98, 0x55, 0x5d, 0x83, 0xb9, 0xb7, 0xa0, 0x3b,
+	0xd3, 0xfb, 0xf5, 0xe7, 0xf5, 0x25, 0xfb, 0x60, 0xf4, 0x4d, 0x6b, 0x7e, 0x2a, 0x39, 0xa1, 0x59,
+	0x64, 0x79, 0x9b, 0xed, 0xaf, 0x9f, 0x3e, 0xbc, 0x6e, 0x27, 0xbd, 0x97, 0xc0, 0x8b, 0xa7, 0x34,
+	0xd6, 0xb8, 0xf1, 0x7e, 0x72, 0x80, 0x7b, 0x0c, 0x8f, 0x70, 0xc1, 0x2a, 0x38, 0x98, 0xe8, 0xbb,
+	0xe6, 0x64, 0xdf, 0xf5, 0xc1, 0x9c, 0x90, 0xac, 0x34, 0x95, 0x3e, 0xf3, 0x1c, 0x95, 0xde, 0x52,
+	0x32, 0x5d, 0xe8, 0xff, 0xf1, 0x48, 0x2b, 0xa0, 0x73, 0x32, 0x72, 0x7d, 0xa2, 0x1b, 0xbf, 0x34,
+	0x41, 0x73, 0x57, 0x64, 0xee, 0xf7, 0x0e, 0xb8, 0x72, 0xf2, 0x25, 0x7c, 0x23, 0x38, 0xc3, 0xbf,
+	0x45, 0x70, 0xda, 0x5b, 0xd5, 0xe9, 0x9f, 0x5b, 0x5a, 0x67, 0x73, 0xbf, 0x73, 0xc0, 0xe2, 0x89,
+	0x37, 0xee, 0xf5, 0xb3, 0xfa, 0x4e, 0x2b, 0x3b, 0x6f, 0x9f, 0x57, 0x39, 0x0e, 0xf4, 0xad, 0x03,
+	0x2e, 0x4f, 0xff, 0xf6, 0xb7, 0x9e, 0xd7, 0xd5, 0x0a, 0x3b, 0x6f, 0x9d, 0x53, 0x58, 0xa7, 0xe9,
+	0x5c, 0xf8, 0xea, 0xe9, 0xc3, 0xeb, 0xce, 0xd6, 0x67, 0x8f, 0x0e, 0x7c, 0xe7, 0xf1, 0x81, 0xef,
+	0xfc, 0x79, 0xe0, 0x3b, 0xf7, 0x0f, 0xfd, 0xc6, 0xe3, 0x43, 0xbf, 0xf1, 0xfb, 0xa1, 0xdf, 0xf8,
+	0xfc, 0xcd, 0x8c, 0xc8, 0x7c, 0x98, 0x04, 0x88, 0x15, 0xf6, 0x3f, 0x33, 0x3c, 0xda, 0x72, 0x7d,
+	0xfc, 0xa9, 0x50, 0xdd, 0x0c, 0xef, 0x4d, 0x7e, 0x2f, 0xc8, 0x51, 0x89, 0x45, 0x32, 0xab, 0xeb,
+	0xf3, 0xe6, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x2c, 0x0f, 0x85, 0x95, 0x60, 0x08, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -417,6 +523,7 @@ const _ = grpc.SupportPackageIsVersion4
 type MsgClient interface {
 	AssignConsumerKey(ctx context.Context, in *MsgAssignConsumerKey, opts ...grpc.CallOption) (*MsgAssignConsumerKeyResponse, error)
 	ConsumerAddition(ctx context.Context, in *MsgConsumerAddition, opts ...grpc.CallOption) (*MsgConsumerAdditionResponse, error)
+	ConsumerRemoval(ctx context.Context, in *MsgConsumerRemoval, opts ...grpc.CallOption) (*MsgConsumerRemovalResponse, error)
 }
 
 type msgClient struct {
@@ -445,10 +552,20 @@ func (c *msgClient) ConsumerAddition(ctx context.Context, in *MsgConsumerAdditio
 	return out, nil
 }
 
+func (c *msgClient) ConsumerRemoval(ctx context.Context, in *MsgConsumerRemoval, opts ...grpc.CallOption) (*MsgConsumerRemovalResponse, error) {
+	out := new(MsgConsumerRemovalResponse)
+	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Msg/ConsumerRemoval", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // MsgServer is the server API for Msg service.
 type MsgServer interface {
 	AssignConsumerKey(context.Context, *MsgAssignConsumerKey) (*MsgAssignConsumerKeyResponse, error)
 	ConsumerAddition(context.Context, *MsgConsumerAddition) (*MsgConsumerAdditionResponse, error)
+	ConsumerRemoval(context.Context, *MsgConsumerRemoval) (*MsgConsumerRemovalResponse, error)
 }
 
 // UnimplementedMsgServer can be embedded to have forward compatible implementations.
@@ -461,6 +578,9 @@ func (*UnimplementedMsgServer) AssignConsumerKey(ctx context.Context, req *MsgAs
 func (*UnimplementedMsgServer) ConsumerAddition(ctx context.Context, req *MsgConsumerAddition) (*MsgConsumerAdditionResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ConsumerAddition not implemented")
 }
+func (*UnimplementedMsgServer) ConsumerRemoval(ctx context.Context, req *MsgConsumerRemoval) (*MsgConsumerRemovalResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ConsumerRemoval not implemented")
+}
 
 func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
 	s.RegisterService(&_Msg_serviceDesc, srv)
@@ -502,6 +622,24 @@ func _Msg_ConsumerAddition_Handler(srv interface{}, ctx context.Context, dec fun
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Msg_ConsumerRemoval_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgConsumerRemoval)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).ConsumerRemoval(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/interchain_security.ccv.provider.v1.Msg/ConsumerRemoval",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).ConsumerRemoval(ctx, req.(*MsgConsumerRemoval))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Msg_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "interchain_security.ccv.provider.v1.Msg",
 	HandlerType: (*MsgServer)(nil),
@@ -514,6 +652,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 			MethodName: "ConsumerAddition",
 			Handler:    _Msg_ConsumerAddition_Handler,
 		},
+		{
+			MethodName: "ConsumerRemoval",
+			Handler:    _Msg_ConsumerRemoval_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "interchain_security/ccv/provider/v1/tx.proto",
@@ -726,6 +868,74 @@ func (m *MsgConsumerAdditionResponse) MarshalToSizedBuffer(dAtA []byte) (int, er
 	return len(dAtA) - i, nil
 }
 
+func (m *MsgConsumerRemoval) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgConsumerRemoval) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgConsumerRemoval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Signer) > 0 {
+		i -= len(m.Signer)
+		copy(dAtA[i:], m.Signer)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Signer)))
+		i--
+		dAtA[i] = 0x6a
+	}
+	n6, err6 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.StopTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.StopTime):])
+	if err6 != nil {
+		return 0, err6
+	}
+	i -= n6
+	i = encodeVarintTx(dAtA, i, uint64(n6))
+	i--
+	dAtA[i] = 0x22
+	if len(m.ChainId) > 0 {
+		i -= len(m.ChainId)
+		copy(dAtA[i:], m.ChainId)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.ChainId)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgConsumerRemovalResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgConsumerRemovalResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgConsumerRemovalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
 	offset -= sovTx(v)
 	base := offset
@@ -825,6 +1035,34 @@ func (m *MsgConsumerAdditionResponse) Size() (n int) {
 	return n
 }
 
+func (m *MsgConsumerRemoval) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.ChainId)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.StopTime)
+	n += 1 + l + sovTx(uint64(l))
+	l = len(m.Signer)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	return n
+}
+
+func (m *MsgConsumerRemovalResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
 func sovTx(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -1526,6 +1764,203 @@ func (m *MsgConsumerAdditionResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *MsgConsumerRemoval) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgConsumerRemoval: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgConsumerRemoval: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ChainId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StopTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.StopTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 13:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Signer", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Signer = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MsgConsumerRemovalResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgConsumerRemovalResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgConsumerRemovalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipTx(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0