diff --git a/modules/apps/27-interchain-accounts/controller/ibc_middleware.go b/modules/apps/27-interchain-accounts/controller/ibc_middleware.go
index 31863d685f9..0fc16aed46f 100644
--- a/modules/apps/27-interchain-accounts/controller/ibc_middleware.go
+++ b/modules/apps/27-interchain-accounts/controller/ibc_middleware.go
@@ -246,19 +246,6 @@ func (im IBCMiddleware) OnChanUpgradeOpen(ctx sdk.Context, portID, channelID str
 // OnChanUpgradeRestore implements the IBCModule interface
 func (im IBCMiddleware) OnChanUpgradeRestore(ctx sdk.Context, portID, channelID string) {}
 
-// OnChanUpgradeTimeout implements the IBCModule interface
-func (im IBCMiddleware) OnChanUpgradeTimeout(
-	ctx sdk.Context,
-	portID, channelID string,
-	counterpartyChannel channeltypes.Channel,
-	prevErrorReceipt channeltypes.ErrorReceipt,
-	proofCounterpartyChannel,
-	proofErrorReceipt []byte,
-	proofHeight ibcexported.Height,
-) error {
-	return im.app.OnChanUpgradeTimeout(ctx, portID, channelID, counterpartyChannel, prevErrorReceipt, proofCounterpartyChannel, proofErrorReceipt, proofHeight)
-}
-
 // SendPacket implements the ICS4 Wrapper interface
 func (im IBCMiddleware) SendPacket(
 	ctx sdk.Context,
diff --git a/modules/apps/27-interchain-accounts/host/ibc_module.go b/modules/apps/27-interchain-accounts/host/ibc_module.go
index 1eb39ef081a..b9c54af43aa 100644
--- a/modules/apps/27-interchain-accounts/host/ibc_module.go
+++ b/modules/apps/27-interchain-accounts/host/ibc_module.go
@@ -169,16 +169,3 @@ func (im IBCModule) OnChanUpgradeOpen(ctx sdk.Context, portID, channelID string)
 
 // OnChanUpgradeRestore implements the IBCModule interface
 func (im IBCModule) OnChanUpgradeRestore(ctx sdk.Context, portID, channelID string) {}
-
-// OnChanUpgradeTimeout implements the IBCModule interface
-func (im IBCModule) OnChanUpgradeTimeout(
-	ctx sdk.Context,
-	portID, channelID string,
-	counterpartyChannel channeltypes.Channel,
-	prevErrorReceipt channeltypes.ErrorReceipt,
-	proofCounterpartyChannel,
-	proofErrorReceipt []byte,
-	proofHeight ibcexported.Height,
-) error {
-	return nil
-}
diff --git a/modules/apps/29-fee/ibc_middleware.go b/modules/apps/29-fee/ibc_middleware.go
index 4a80b53a56c..778870b7776 100644
--- a/modules/apps/29-fee/ibc_middleware.go
+++ b/modules/apps/29-fee/ibc_middleware.go
@@ -345,19 +345,6 @@ func (im IBCMiddleware) OnChanUpgradeRestore(ctx sdk.Context, portID, channelID
 	im.app.OnChanUpgradeRestore(ctx, portID, channelID)
 }
 
-// OnChanUpgradeTimeout implements the IBCModule interface
-func (im IBCMiddleware) OnChanUpgradeTimeout(
-	ctx sdk.Context,
-	portID, channelID string,
-	counterpartyChannel channeltypes.Channel,
-	prevErrorReceipt channeltypes.ErrorReceipt,
-	proofCounterpartyChannel,
-	proofErrorReceipt []byte,
-	proofHeight exported.Height,
-) error {
-	return im.app.OnChanUpgradeTimeout(ctx, portID, channelID, counterpartyChannel, prevErrorReceipt, proofCounterpartyChannel, proofErrorReceipt, proofHeight)
-}
-
 // SendPacket implements the ICS4 Wrapper interface
 func (im IBCMiddleware) SendPacket(
 	ctx sdk.Context,
diff --git a/modules/apps/transfer/ibc_module.go b/modules/apps/transfer/ibc_module.go
index 86ac928ebd4..722f2ea6bf4 100644
--- a/modules/apps/transfer/ibc_module.go
+++ b/modules/apps/transfer/ibc_module.go
@@ -321,16 +321,3 @@ func (im IBCModule) OnChanUpgradeOpen(ctx sdk.Context, portID, channelID string)
 
 // OnChanUpgradeRestore implements the IBCModule interface
 func (im IBCModule) OnChanUpgradeRestore(ctx sdk.Context, portID, channelID string) {}
-
-// OnChanUpgradeTimeout implements the IBCModule interface
-func (im IBCModule) OnChanUpgradeTimeout(
-	ctx sdk.Context,
-	portID, channelID string,
-	counterpartyChannel channeltypes.Channel,
-	prevErrorReceipt channeltypes.ErrorReceipt,
-	proofCounterpartyChannel,
-	proofErrorReceipt []byte,
-	proofHeight ibcexported.Height,
-) error {
-	return nil
-}
diff --git a/modules/core/04-channel/keeper/export_test.go b/modules/core/04-channel/keeper/export_test.go
index 4ee7f0f11fc..d97fd5e5a67 100644
--- a/modules/core/04-channel/keeper/export_test.go
+++ b/modules/core/04-channel/keeper/export_test.go
@@ -35,8 +35,3 @@ func (k Keeper) ValidateUpgradeFields(ctx sdk.Context, proposedUpgrade types.Upg
 func (k Keeper) WriteUpgradeOpenChannel(ctx sdk.Context, portID, channelID string) {
 	k.writeUpgradeOpenChannel(ctx, portID, channelID)
 }
-
-// WriteUpgradeTimeoutChannel is a wrapper around writeUpgradeTimeoutChannel to allow the function to be directly called in tests.
-func (k Keeper) WriteUpgradeTimeoutChannel(ctx sdk.Context, portID, channelID string) error {
-	return k.writeUpgradeTimeoutChannel(ctx, portID, channelID)
-}
diff --git a/modules/core/04-channel/keeper/upgrade.go b/modules/core/04-channel/keeper/upgrade.go
index ee1e9380c68..a6df01e71a0 100644
--- a/modules/core/04-channel/keeper/upgrade.go
+++ b/modules/core/04-channel/keeper/upgrade.go
@@ -463,13 +463,13 @@ func (k Keeper) ChanUpgradeTimeout(
 	return nil
 }
 
-// writeUpgradeTimeoutChannel restores the channel state of an initialising chain in the event that the counterparty chain has passed the timeout set in ChanUpgradeInit to the state before the upgrade was proposed.
+// WriteUpgradeTimeoutChannel restores the channel state of an initialising chain in the event that the counterparty chain has passed the timeout set in ChanUpgradeInit to the state before the upgrade was proposed.
 // Auxiliary upgrade state is also deleted.
 // An event is emitted for the handshake step.
-func (k Keeper) writeUpgradeTimeoutChannel(
+func (k Keeper) WriteUpgradeTimeoutChannel(
 	ctx sdk.Context,
 	portID, channelID string,
-) error {
+) {
 	defer telemetry.IncrCounter(1, "ibc", "channel", "upgrade-timeout")
 
 	channel, found := k.GetChannel(ctx, portID, channelID)
@@ -482,14 +482,10 @@ func (k Keeper) writeUpgradeTimeoutChannel(
 		panic(fmt.Sprintf("could not find existing upgrade when cancelling channel upgrade, channelID: %s, portID: %s", channelID, portID))
 	}
 
-	if err := k.AbortUpgrade(ctx, portID, channelID, types.NewUpgradeError(channel.UpgradeSequence, types.ErrUpgradeTimeout)); err != nil {
-		return errorsmod.Wrapf(types.ErrUpgradeRestoreFailed, "err: %v", err)
-	}
+	k.restoreChannel(ctx, portID, channelID, channel.UpgradeSequence, channel)
 
 	k.Logger(ctx).Info("channel state restored", "port-id", portID, "channel-id", channelID)
 	emitChannelUpgradeTimeoutEvent(ctx, portID, channelID, channel, upgrade)
-
-	return nil
 }
 
 // startFlushUpgradeHandshake will verify the counterparty proposed upgrade and the current channel state.
diff --git a/modules/core/04-channel/types/msgs.go b/modules/core/04-channel/types/msgs.go
index 39b01567693..3b87babcf33 100644
--- a/modules/core/04-channel/types/msgs.go
+++ b/modules/core/04-channel/types/msgs.go
@@ -723,7 +723,7 @@ var _ sdk.Msg = &MsgChannelUpgradeTimeout{}
 func NewMsgChannelUpgradeTimeout(
 	portID, channelID string,
 	counterpartyChannel Channel,
-	errorReceipt ErrorReceipt,
+	errorReceipt *ErrorReceipt,
 	proofChannel, proofErrorReceipt []byte,
 	proofHeight clienttypes.Height,
 	signer string,
diff --git a/modules/core/04-channel/types/msgs_test.go b/modules/core/04-channel/types/msgs_test.go
index 9b685238b19..eef9d330283 100644
--- a/modules/core/04-channel/types/msgs_test.go
+++ b/modules/core/04-channel/types/msgs_test.go
@@ -793,6 +793,16 @@ func (suite *TypesTestSuite) TestMsgChannelUpgradeTimeoutValidateBasic() {
 			func() {},
 			true,
 		},
+		{
+			"success with non-nil error receipt",
+			func() {
+				msg.PreviousErrorReceipt = &types.ErrorReceipt{
+					Sequence: 1,
+					Message:  "error message",
+				}
+			},
+			true,
+		},
 		{
 			"invalid port identifier",
 			func() {
@@ -835,7 +845,7 @@ func (suite *TypesTestSuite) TestMsgChannelUpgradeTimeoutValidateBasic() {
 		suite.Run(tc.name, func() {
 			msg = types.NewMsgChannelUpgradeTimeout(
 				ibctesting.MockPort, ibctesting.FirstChannelID,
-				types.Channel{State: types.OPEN}, types.ErrorReceipt{},
+				types.Channel{State: types.OPEN}, nil,
 				suite.proof, suite.proof,
 				height, addr,
 			)
@@ -858,7 +868,7 @@ func (suite *TypesTestSuite) TestMsgChannelUpgradeTimeoutGetSigners() {
 
 	msg := types.NewMsgChannelUpgradeTimeout(
 		ibctesting.MockPort, ibctesting.FirstChannelID,
-		types.Channel{}, types.ErrorReceipt{},
+		types.Channel{}, nil,
 		suite.proof, suite.proof,
 		height, addr,
 	)
diff --git a/modules/core/04-channel/types/tx.pb.go b/modules/core/04-channel/types/tx.pb.go
index 0d9d0f49dbd..9566620a148 100644
--- a/modules/core/04-channel/types/tx.pb.go
+++ b/modules/core/04-channel/types/tx.pb.go
@@ -1238,14 +1238,14 @@ var xxx_messageInfo_MsgChannelUpgradeOpenResponse proto.InternalMessageInfo
 
 // MsgChannelUpgradeTimeout defines the request type for the ChannelUpgradeTimeout rpc
 type MsgChannelUpgradeTimeout struct {
-	PortId               string       `protobuf:"bytes,1,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty"`
-	ChannelId            string       `protobuf:"bytes,2,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
-	CounterpartyChannel  Channel      `protobuf:"bytes,3,opt,name=counterparty_channel,json=counterpartyChannel,proto3" json:"counterparty_channel"`
-	PreviousErrorReceipt ErrorReceipt `protobuf:"bytes,4,opt,name=previous_error_receipt,json=previousErrorReceipt,proto3" json:"previous_error_receipt"`
-	ProofChannel         []byte       `protobuf:"bytes,5,opt,name=proof_channel,json=proofChannel,proto3" json:"proof_channel,omitempty"`
-	ProofErrorReceipt    []byte       `protobuf:"bytes,6,opt,name=proof_error_receipt,json=proofErrorReceipt,proto3" json:"proof_error_receipt,omitempty"`
-	ProofHeight          types.Height `protobuf:"bytes,7,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
-	Signer               string       `protobuf:"bytes,8,opt,name=signer,proto3" json:"signer,omitempty"`
+	PortId               string        `protobuf:"bytes,1,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty"`
+	ChannelId            string        `protobuf:"bytes,2,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
+	CounterpartyChannel  Channel       `protobuf:"bytes,3,opt,name=counterparty_channel,json=counterpartyChannel,proto3" json:"counterparty_channel"`
+	PreviousErrorReceipt *ErrorReceipt `protobuf:"bytes,4,opt,name=previous_error_receipt,json=previousErrorReceipt,proto3" json:"previous_error_receipt,omitempty"`
+	ProofChannel         []byte        `protobuf:"bytes,5,opt,name=proof_channel,json=proofChannel,proto3" json:"proof_channel,omitempty"`
+	ProofErrorReceipt    []byte        `protobuf:"bytes,6,opt,name=proof_error_receipt,json=proofErrorReceipt,proto3" json:"proof_error_receipt,omitempty"`
+	ProofHeight          types.Height  `protobuf:"bytes,7,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height"`
+	Signer               string        `protobuf:"bytes,8,opt,name=signer,proto3" json:"signer,omitempty"`
 }
 
 func (m *MsgChannelUpgradeTimeout) Reset()         { *m = MsgChannelUpgradeTimeout{} }
@@ -1438,121 +1438,121 @@ func init() {
 func init() { proto.RegisterFile("ibc/core/channel/v1/tx.proto", fileDescriptor_bc4637e0ac3fc7b7) }
 
 var fileDescriptor_bc4637e0ac3fc7b7 = []byte{
-	// 1818 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcd, 0x6f, 0xdb, 0x46,
-	0x16, 0x17, 0x25, 0x59, 0xb2, 0x9f, 0xbf, 0x29, 0x27, 0x56, 0x68, 0x5b, 0x52, 0xb4, 0x40, 0xe2,
-	0x78, 0x63, 0x29, 0x76, 0x92, 0x5d, 0x24, 0x08, 0xb0, 0x6b, 0x6b, 0xe5, 0x8d, 0xb1, 0x71, 0x6c,
-	0x50, 0xd6, 0x62, 0x3f, 0xb2, 0x2b, 0xc8, 0xd4, 0x58, 0x26, 0x24, 0x91, 0x0c, 0x49, 0x29, 0xf1,
-	0x02, 0x7b, 0xd8, 0xbd, 0x34, 0x08, 0x50, 0xa0, 0xff, 0x40, 0x80, 0x00, 0xfd, 0x03, 0xda, 0x5e,
-	0x7b, 0x69, 0x7b, 0xcb, 0xa1, 0x40, 0x03, 0x14, 0x68, 0x73, 0x28, 0x8a, 0x22, 0x39, 0xb4, 0xd7,
-	0xde, 0x73, 0x28, 0x38, 0x1c, 0x52, 0x24, 0x35, 0xb4, 0x68, 0xcb, 0x31, 0x7a, 0x93, 0x66, 0x7e,
-	0xf3, 0xbe, 0x7e, 0xef, 0xbd, 0xf9, 0x90, 0x60, 0x5e, 0xdc, 0x13, 0xf2, 0x82, 0xac, 0xa2, 0xbc,
-	0x70, 0x50, 0x95, 0x24, 0xd4, 0xcc, 0x77, 0x56, 0xf2, 0xfa, 0xe3, 0x9c, 0xa2, 0xca, 0xba, 0xcc,
-	0x26, 0xc4, 0x3d, 0x21, 0x67, 0xcc, 0xe6, 0xc8, 0x6c, 0xae, 0xb3, 0xc2, 0xcd, 0xd4, 0xe5, 0xba,
-	0x8c, 0xe7, 0xf3, 0xc6, 0x27, 0x13, 0xca, 0xcd, 0x0a, 0xb2, 0xd6, 0x92, 0xb5, 0x7c, 0x4b, 0xab,
-	0x1b, 0x22, 0x5a, 0x5a, 0x9d, 0x4c, 0xa4, 0xbb, 0x1a, 0x9a, 0x22, 0x92, 0x74, 0x63, 0xd6, 0xfc,
-	0x44, 0x00, 0x17, 0x69, 0x26, 0x58, 0xfa, 0x8e, 0x80, 0xb4, 0x95, 0xba, 0x5a, 0xad, 0x21, 0x13,
-	0x92, 0x7d, 0x9f, 0x01, 0x76, 0x4b, 0xab, 0x17, 0xcc, 0xf9, 0x6d, 0x05, 0x49, 0x9b, 0x92, 0xa8,
-	0xb3, 0xb3, 0x10, 0x57, 0x64, 0x55, 0xaf, 0x88, 0xb5, 0x24, 0x93, 0x61, 0x16, 0x47, 0xf8, 0x98,
-	0xf1, 0x75, 0xb3, 0xc6, 0xde, 0x81, 0x38, 0x91, 0x95, 0x0c, 0x67, 0x98, 0xc5, 0xd1, 0xd5, 0xf9,
-	0x1c, 0xc5, 0xd9, 0x1c, 0x91, 0xb7, 0x1e, 0x7d, 0xf1, 0x7d, 0x3a, 0xc4, 0x5b, 0x4b, 0xd8, 0xf3,
-	0x10, 0xd3, 0xc4, 0xba, 0x84, 0xd4, 0x64, 0xc4, 0x94, 0x6a, 0x7e, 0xbb, 0x3d, 0xfc, 0xe4, 0x79,
-	0x3a, 0xf4, 0xd3, 0xf3, 0x74, 0x28, 0x5b, 0x06, 0xae, 0xd7, 0x1c, 0x1e, 0x69, 0x8a, 0x2c, 0x69,
-	0x88, 0x5d, 0x00, 0x20, 0xa2, 0xba, 0x96, 0x8d, 0x90, 0x91, 0xcd, 0x1a, 0x9b, 0x84, 0x78, 0x07,
-	0xa9, 0x9a, 0x28, 0x4b, 0xd8, 0xb8, 0x11, 0xde, 0xfa, 0x9a, 0xfd, 0x36, 0x0c, 0xd3, 0x6e, 0xb9,
-	0xbb, 0xea, 0xa1, 0xbf, 0x97, 0xab, 0x90, 0x50, 0x54, 0xd4, 0x11, 0xe5, 0xb6, 0x56, 0x71, 0x28,
-	0xc4, 0x42, 0xd7, 0xc3, 0x49, 0x86, 0x9f, 0xb6, 0xa6, 0x0b, 0xb6, 0x72, 0x47, 0x64, 0x22, 0xc7,
-	0x8f, 0xcc, 0x0a, 0xcc, 0x08, 0x72, 0x5b, 0xd2, 0x91, 0xaa, 0x54, 0x55, 0xfd, 0xb0, 0x62, 0xf9,
-	0x11, 0xc5, 0x76, 0x25, 0x9c, 0x73, 0x7f, 0x35, 0xa7, 0x8c, 0x60, 0x28, 0xaa, 0x2c, 0xef, 0x57,
-	0x44, 0x49, 0xd4, 0x93, 0x43, 0x19, 0x66, 0x71, 0x8c, 0x1f, 0xc1, 0x23, 0x98, 0xc2, 0x02, 0x8c,
-	0x99, 0xd3, 0x07, 0x48, 0xac, 0x1f, 0xe8, 0xc9, 0x18, 0x36, 0x8a, 0x73, 0x18, 0x65, 0x66, 0x53,
-	0x67, 0x25, 0x77, 0x17, 0x23, 0x88, 0x49, 0xa3, 0x78, 0x95, 0x39, 0xe4, 0x20, 0x2c, 0xee, 0x43,
-	0xd8, 0x2e, 0x5c, 0xe8, 0x09, 0xac, 0xcd, 0x97, 0x83, 0x10, 0xc6, 0x45, 0x88, 0x87, 0xc9, 0xb0,
-	0x87, 0xc9, 0xec, 0xa7, 0x3d, 0x7c, 0xad, 0x09, 0x0d, 0x7f, 0xbe, 0x8e, 0x96, 0xc6, 0xfe, 0x0e,
-	0x66, 0x5d, 0xc1, 0x75, 0x60, 0xcd, 0x3c, 0x3c, 0xe7, 0x9c, 0xee, 0x52, 0x7a, 0x02, 0x52, 0xe6,
-	0xc0, 0xa4, 0xa0, 0xa2, 0xab, 0x87, 0x84, 0x93, 0x61, 0x3c, 0x60, 0xe4, 0xdb, 0x19, 0x51, 0x32,
-	0xe7, 0xa5, 0x64, 0x4d, 0x68, 0x58, 0x94, 0x64, 0xbf, 0x66, 0xe0, 0x9c, 0x7b, 0xb6, 0x20, 0x4b,
-	0xfb, 0xa2, 0xda, 0x3a, 0x71, 0x74, 0x6d, 0x97, 0xab, 0x42, 0x03, 0xc7, 0xd3, 0x72, 0xd9, 0xa0,
-	0xcc, 0xeb, 0x72, 0x74, 0x30, 0x97, 0x87, 0x7c, 0x5c, 0x4e, 0xc3, 0x02, 0xd5, 0x29, 0xdb, 0x6d,
-	0x19, 0x12, 0x5d, 0x40, 0xa1, 0x29, 0x6b, 0xe8, 0xe8, 0x3e, 0xd7, 0xc7, 0xe7, 0xfe, 0x8d, 0x6c,
-	0x01, 0xe6, 0x28, 0x0a, 0x6d, 0x7b, 0xbe, 0x61, 0xe0, 0xbc, 0x67, 0x7e, 0x50, 0x1e, 0xdc, 0xfd,
-	0x20, 0xd2, 0xaf, 0x1f, 0xbc, 0x23, 0x26, 0x32, 0x90, 0xa2, 0xfb, 0x65, 0xbb, 0xfe, 0x1d, 0x03,
-	0xe3, 0x5b, 0x5a, 0x9d, 0x47, 0x42, 0x67, 0xa7, 0x2a, 0x34, 0x90, 0xce, 0xde, 0x82, 0x98, 0x82,
-	0x3f, 0x61, 0x87, 0x47, 0x57, 0xe7, 0xa8, 0x9d, 0xd3, 0x04, 0x13, 0xab, 0xc8, 0x02, 0xf6, 0x0a,
-	0x4c, 0x99, 0x5e, 0x09, 0x72, 0xab, 0x25, 0xea, 0x2d, 0x24, 0xe9, 0x38, 0x32, 0x63, 0xfc, 0x24,
-	0x1e, 0x2f, 0xd8, 0xc3, 0x3d, 0x01, 0x88, 0x0c, 0x16, 0x80, 0xa8, 0x4f, 0x00, 0xfe, 0x8d, 0xeb,
-	0xab, 0xeb, 0x9d, 0xdd, 0x0c, 0xff, 0x00, 0x31, 0x15, 0x69, 0xed, 0xa6, 0xe9, 0xe5, 0xc4, 0xea,
-	0x65, 0xaa, 0x97, 0x16, 0x9c, 0xc7, 0xd0, 0xdd, 0x43, 0x05, 0xf1, 0x64, 0xd9, 0xed, 0xa8, 0xa1,
-	0x23, 0xfb, 0x5e, 0x18, 0x60, 0x4b, 0xab, 0xef, 0x8a, 0x2d, 0x24, 0xb7, 0x4f, 0x27, 0x76, 0x6d,
-	0x49, 0x45, 0x02, 0x12, 0x3b, 0xa8, 0xe6, 0x8a, 0x5d, 0xd9, 0x1e, 0x3e, 0x9d, 0xd8, 0x5d, 0x05,
-	0x56, 0x42, 0x8f, 0xf5, 0x8a, 0x86, 0x1e, 0xb6, 0x91, 0x24, 0xa0, 0x8a, 0x8a, 0x84, 0x0e, 0x8e,
-	0x63, 0x94, 0x9f, 0x32, 0x66, 0x4a, 0x64, 0xc2, 0x08, 0x5e, 0x80, 0x54, 0xfb, 0x27, 0x3e, 0xba,
-	0x90, 0x40, 0x9c, 0x76, 0x98, 0x3f, 0x32, 0x77, 0x20, 0x22, 0x7d, 0x5b, 0xc2, 0xa9, 0x7c, 0x46,
-	0xd1, 0x4e, 0xc3, 0x28, 0x49, 0x6a, 0x43, 0x29, 0x29, 0x65, 0xb3, 0xb8, 0x4d, 0x33, 0x4e, 0xa5,
-	0x96, 0xe9, 0x74, 0x0c, 0xf5, 0xa5, 0x23, 0xe6, 0x43, 0xc7, 0x1e, 0xde, 0x76, 0xdc, 0x01, 0x3b,
-	0x6d, 0x56, 0xfe, 0x17, 0xc6, 0x9c, 0xaf, 0x09, 0x0d, 0x49, 0x7e, 0xd4, 0x44, 0xb5, 0x3a, 0xc2,
-	0xa5, 0x3d, 0x00, 0x2d, 0x8b, 0x30, 0x59, 0x75, 0x4b, 0xb3, 0x58, 0xf1, 0x0c, 0x77, 0x59, 0x31,
-	0x16, 0xd6, 0x5c, 0xac, 0xac, 0x19, 0x23, 0x67, 0xd5, 0x61, 0x05, 0x7c, 0x44, 0xf6, 0x84, 0xe0,
-	0xb4, 0x03, 0xfd, 0xd6, 0x75, 0x4c, 0x28, 0x9b, 0x77, 0x86, 0x81, 0xb6, 0xcc, 0x3f, 0x42, 0x6c,
-	0x5f, 0x44, 0xcd, 0x9a, 0x46, 0x9a, 0x47, 0x96, 0x6a, 0x18, 0xd1, 0xb4, 0x81, 0x91, 0x16, 0x55,
-	0xe6, 0x3a, 0xe3, 0x84, 0xad, 0x9b, 0xd9, 0x45, 0x42, 0x4b, 0x3f, 0x61, 0x93, 0x0c, 0xb4, 0x4e,
-	0xd8, 0x64, 0x89, 0x6f, 0x60, 0x13, 0x56, 0x60, 0xff, 0xff, 0xe3, 0xc7, 0x4b, 0x64, 0x30, 0xfb,
-	0x09, 0xe3, 0x3c, 0x50, 0x38, 0xdc, 0x0f, 0x7a, 0x15, 0xb9, 0x03, 0x71, 0x72, 0xd1, 0x3a, 0xf2,
-	0x9e, 0x44, 0x24, 0x5b, 0xb6, 0x92, 0x25, 0x46, 0xaf, 0x20, 0x1f, 0xed, 0xea, 0xc4, 0x51, 0x8b,
-	0xf2, 0x93, 0x64, 0xdc, 0xaa, 0x4d, 0x47, 0x5e, 0x7c, 0x19, 0x85, 0x99, 0x1e, 0x9b, 0x8f, 0xbc,
-	0xe6, 0xf4, 0x61, 0xec, 0xcf, 0x90, 0x51, 0x54, 0x59, 0x91, 0x35, 0x54, 0xab, 0x58, 0xe6, 0x08,
-	0xb2, 0x24, 0x21, 0x41, 0x17, 0x65, 0xa9, 0x72, 0x20, 0x2b, 0x06, 0x97, 0x91, 0xc5, 0x11, 0x7e,
-	0xc1, 0xc2, 0x11, 0xad, 0x05, 0x1b, 0x75, 0x57, 0x56, 0x34, 0xf6, 0x2f, 0x60, 0x99, 0x5d, 0x39,
-	0x3e, 0x81, 0x13, 0x64, 0xa9, 0xb5, 0xe1, 0xed, 0xc3, 0x82, 0xeb, 0x50, 0xee, 0x35, 0x11, 0xd3,
-	0x1b, 0x2c, 0xde, 0x73, 0x4e, 0x41, 0x3b, 0x6e, 0x17, 0xd8, 0x75, 0x8f, 0x9e, 0x1e, 0x42, 0x62,
-	0x98, 0x10, 0x97, 0x8c, 0xb2, 0x9b, 0x1c, 0xf6, 0x37, 0x30, 0x4e, 0x1a, 0x39, 0xb9, 0x19, 0xc6,
-	0x71, 0xd3, 0x30, 0xdb, 0x04, 0x21, 0xaa, 0x0b, 0xb2, 0x1c, 0x18, 0x76, 0x80, 0x2c, 0x6b, 0xbc,
-	0xbd, 0x65, 0x64, 0xb0, 0xde, 0x02, 0xfd, 0x4b, 0xe0, 0x67, 0x06, 0xe6, 0x69, 0xe9, 0xf4, 0x6b,
-	0xab, 0x00, 0x47, 0xc7, 0x8b, 0x9e, 0xac, 0xe3, 0x75, 0x4b, 0xe8, 0xb3, 0x08, 0xa5, 0x84, 0x06,
-	0xb9, 0x79, 0x3e, 0x80, 0x0b, 0xae, 0x24, 0xda, 0x6f, 0xb6, 0xb5, 0x83, 0x8a, 0xa6, 0x57, 0xf5,
-	0xb6, 0xd9, 0x07, 0x27, 0x56, 0x33, 0x54, 0x73, 0x37, 0x0c, 0x60, 0x09, 0xe3, 0x78, 0xd7, 0xe5,
-	0xd5, 0x31, 0xc1, 0x96, 0x3d, 0xf7, 0x53, 0x2b, 0xde, 0xd1, 0xc0, 0xf1, 0x4e, 0x50, 0xb2, 0xb7,
-	0x37, 0x6b, 0x87, 0x82, 0x64, 0x6d, 0x2c, 0x40, 0xd6, 0xc6, 0x07, 0xcb, 0xda, 0xe1, 0xfe, 0x59,
-	0x2b, 0x52, 0x92, 0xd6, 0x71, 0xfd, 0x1d, 0x7c, 0x7b, 0xec, 0x26, 0xcb, 0xe7, 0x61, 0xca, 0x16,
-	0x69, 0xdc, 0x3d, 0x4f, 0x9c, 0x2d, 0x7f, 0x03, 0x8e, 0xfa, 0x4e, 0x61, 0xe4, 0x0b, 0x22, 0xe9,
-	0xc2, 0x51, 0x0d, 0x36, 0x12, 0x02, 0xf1, 0x49, 0xca, 0x33, 0x06, 0x9e, 0xe9, 0xa5, 0x34, 0x4a,
-	0xa1, 0xd4, 0xcb, 0xd6, 0xd0, 0x60, 0x6c, 0xc5, 0xfa, 0xb3, 0x95, 0xa6, 0xec, 0xb2, 0x46, 0x04,
-	0xed, 0xbb, 0xe2, 0x57, 0x11, 0x48, 0xf6, 0x36, 0x21, 0xb2, 0x13, 0x9c, 0x34, 0xcc, 0xde, 0xb2,
-	0x39, 0xfe, 0xb3, 0x5d, 0x82, 0x12, 0x68, 0xf6, 0x5f, 0x70, 0xde, 0x7e, 0x34, 0x44, 0xaa, 0x2a,
-	0xab, 0x15, 0x7c, 0xa0, 0x57, 0xac, 0xcd, 0xee, 0x22, 0x55, 0x70, 0xd1, 0x40, 0xf2, 0x26, 0x90,
-	0x48, 0x9f, 0xb1, 0xc4, 0x38, 0xe7, 0x82, 0x55, 0x65, 0x0e, 0x12, 0x26, 0xc8, 0x6d, 0x80, 0x59,
-	0x9b, 0xd3, 0x78, 0xca, 0x25, 0xf4, 0xec, 0x0b, 0xb4, 0x05, 0x19, 0x3f, 0x42, 0xdf, 0x45, 0x91,
-	0x7e, 0x11, 0x86, 0xd9, 0x1e, 0x7d, 0x85, 0xaa, 0x24, 0xa0, 0xe6, 0x89, 0xf3, 0xe7, 0x1e, 0x8c,
-	0xbb, 0xc3, 0x1b, 0x39, 0x1e, 0xbf, 0x63, 0xc8, 0x49, 0x81, 0x0f, 0x65, 0xd1, 0xa0, 0x94, 0xbd,
-	0xfb, 0x2a, 0xbd, 0x08, 0x69, 0x9f, 0x10, 0x5a, 0x14, 0x2c, 0xbd, 0x62, 0x80, 0xed, 0xe5, 0x83,
-	0xbd, 0x09, 0x19, 0xbe, 0x58, 0xda, 0xd9, 0xbe, 0x5f, 0x2a, 0x56, 0xf8, 0x62, 0xa9, 0x7c, 0x6f,
-	0xb7, 0xb2, 0xfb, 0xf7, 0x9d, 0x62, 0xa5, 0x7c, 0xbf, 0xb4, 0x53, 0x2c, 0x6c, 0x6e, 0x6c, 0x16,
-	0xff, 0x34, 0x15, 0xe2, 0x26, 0x9f, 0x3e, 0xcb, 0x8c, 0x3a, 0x86, 0xd8, 0xcb, 0x70, 0x81, 0xba,
-	0xec, 0xfe, 0xf6, 0xf6, 0xce, 0x14, 0xc3, 0x0d, 0x3f, 0x7d, 0x96, 0x89, 0x1a, 0x9f, 0xd9, 0x65,
-	0x98, 0xa7, 0x02, 0x4b, 0xe5, 0x42, 0xa1, 0x58, 0x2a, 0x4d, 0x85, 0xb9, 0xd1, 0xa7, 0xcf, 0x32,
-	0x71, 0xf2, 0xd5, 0x17, 0xbe, 0xb1, 0xb6, 0x79, 0xaf, 0xcc, 0x17, 0xa7, 0x22, 0x26, 0x9c, 0x7c,
-	0xe5, 0xa2, 0x4f, 0x3e, 0x4c, 0x85, 0x56, 0xdf, 0x8e, 0x43, 0x64, 0x4b, 0xab, 0xb3, 0x0d, 0x98,
-	0xf4, 0xfe, 0x4a, 0x42, 0xcf, 0xcb, 0xde, 0xdf, 0x2f, 0xb8, 0x7c, 0x40, 0xa0, 0x5d, 0x01, 0x07,
-	0x30, 0xe1, 0xf9, 0xad, 0xe2, 0x52, 0x00, 0x11, 0xbb, 0xea, 0x21, 0x97, 0x0b, 0x86, 0xf3, 0xd1,
-	0x64, 0x9c, 0x75, 0x82, 0x68, 0x5a, 0x13, 0x1a, 0x81, 0x34, 0x39, 0xb7, 0x5e, 0x1d, 0x58, 0xca,
-	0xab, 0xf3, 0x52, 0x00, 0x29, 0x04, 0xcb, 0xad, 0x06, 0xc7, 0xda, 0x5a, 0x25, 0x98, 0xea, 0x79,
-	0xf5, 0x5d, 0xec, 0x23, 0xc7, 0x46, 0x72, 0xd7, 0x82, 0x22, 0x6d, 0x7d, 0x8f, 0x20, 0x41, 0x7b,
-	0xd4, 0xfd, 0x6d, 0x10, 0x41, 0x96, 0x9f, 0xd7, 0x8f, 0x01, 0xb6, 0x15, 0x3f, 0x00, 0x70, 0x3c,
-	0xa9, 0x66, 0xfd, 0x44, 0x74, 0x31, 0xdc, 0x52, 0x7f, 0x8c, 0x2d, 0xbd, 0x04, 0x71, 0x6b, 0xdb,
-	0x4d, 0xfb, 0x2d, 0x23, 0x00, 0xee, 0x72, 0x1f, 0x80, 0x33, 0xf7, 0x3c, 0xef, 0x6b, 0x97, 0xfa,
-	0x2c, 0x25, 0x38, 0xff, 0xdc, 0xf3, 0x79, 0x7e, 0x6a, 0xc0, 0xa4, 0xf7, 0xcd, 0xc8, 0xd7, 0x4a,
-	0x0f, 0xd0, 0xbf, 0x78, 0xfd, 0x9e, 0x60, 0xba, 0x89, 0xee, 0x7c, 0x37, 0xe9, 0x97, 0xe8, 0x0e,
-	0x6c, 0xdf, 0x44, 0xa7, 0x3d, 0x48, 0x3c, 0x84, 0xe9, 0xde, 0xab, 0xff, 0x95, 0x60, 0x82, 0x8c,
-	0xc6, 0xb1, 0x12, 0x18, 0xea, 0xaf, 0xd2, 0x68, 0x1f, 0x01, 0x55, 0x1a, 0x1d, 0x64, 0x25, 0x30,
-	0xd4, 0x3f, 0xb6, 0xf8, 0xc0, 0x1d, 0x30, 0xb6, 0x06, 0x36, 0x68, 0x6c, 0x9d, 0xc7, 0x50, 0xf6,
-	0xbf, 0x70, 0x8e, 0x7e, 0x04, 0x5d, 0x0e, 0x18, 0x34, 0x52, 0x19, 0x37, 0x8f, 0x05, 0xb7, 0xd5,
-	0xff, 0x07, 0x66, 0xa8, 0x07, 0x98, 0xab, 0xc1, 0xc4, 0x99, 0x68, 0xee, 0xc6, 0x71, 0xd0, 0x96,
-	0xee, 0xf5, 0xd2, 0x8b, 0xd7, 0x29, 0xe6, 0xe5, 0xeb, 0x14, 0xf3, 0xc3, 0xeb, 0x14, 0xf3, 0xc1,
-	0x9b, 0x54, 0xe8, 0xe5, 0x9b, 0x54, 0xe8, 0xd5, 0x9b, 0x54, 0xe8, 0x1f, 0xb7, 0xea, 0xa2, 0x7e,
-	0xd0, 0xde, 0xcb, 0x09, 0x72, 0x2b, 0x4f, 0xfe, 0xc5, 0x20, 0xee, 0x09, 0xcb, 0x75, 0x39, 0xdf,
-	0xf9, 0x7d, 0xbe, 0x25, 0xd7, 0xda, 0x4d, 0xa4, 0x99, 0xff, 0x3e, 0xb8, 0x76, 0x63, 0xd9, 0xfa,
-	0x03, 0x82, 0x7e, 0xa8, 0x20, 0x6d, 0x2f, 0x86, 0xff, 0x7c, 0x70, 0xfd, 0x97, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0x22, 0x95, 0x38, 0x75, 0x47, 0x21, 0x00, 0x00,
+	// 1817 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcf, 0x6f, 0xdb, 0x46,
+	0x16, 0x16, 0x25, 0x59, 0xb2, 0x9f, 0x7f, 0x53, 0x4e, 0xac, 0xd0, 0xb6, 0xa4, 0x68, 0x81, 0xc4,
+	0xf1, 0xc6, 0x52, 0xec, 0x24, 0xbb, 0x48, 0x10, 0x60, 0xd7, 0xd6, 0xca, 0x1b, 0x63, 0xe3, 0xd8,
+	0xa0, 0xac, 0xfd, 0x19, 0xac, 0x20, 0x53, 0x63, 0x99, 0x90, 0x44, 0x32, 0x24, 0xa5, 0xc4, 0x05,
+	0x7a, 0x68, 0x2f, 0x0d, 0x02, 0x14, 0xe8, 0x3f, 0x10, 0x20, 0x40, 0xff, 0x80, 0xb6, 0xd7, 0x5e,
+	0xda, 0x1e, 0x0a, 0xe4, 0xd0, 0x43, 0x80, 0x02, 0x6d, 0x0e, 0x45, 0x51, 0x24, 0x87, 0xf6, 0xda,
+	0x7b, 0x0e, 0x05, 0x87, 0x43, 0x8a, 0xa4, 0x86, 0x16, 0x6d, 0x39, 0x41, 0x6f, 0xe4, 0xcc, 0x37,
+	0xef, 0xcd, 0xfb, 0xbe, 0x37, 0x8f, 0x33, 0x23, 0xc1, 0xbc, 0xb8, 0x27, 0xe4, 0x05, 0x59, 0x45,
+	0x79, 0xe1, 0xa0, 0x2a, 0x49, 0xa8, 0x99, 0xef, 0xac, 0xe4, 0xf5, 0x87, 0x39, 0x45, 0x95, 0x75,
+	0x99, 0x4d, 0x88, 0x7b, 0x42, 0xce, 0xe8, 0xcd, 0x91, 0xde, 0x5c, 0x67, 0x85, 0x9b, 0xa9, 0xcb,
+	0x75, 0x19, 0xf7, 0xe7, 0x8d, 0x27, 0x13, 0xca, 0xcd, 0x0a, 0xb2, 0xd6, 0x92, 0xb5, 0x7c, 0x4b,
+	0xab, 0x1b, 0x26, 0x5a, 0x5a, 0x9d, 0x74, 0xa4, 0xbb, 0x1e, 0x9a, 0x22, 0x92, 0x74, 0xa3, 0xd7,
+	0x7c, 0x22, 0x80, 0xf3, 0xb4, 0x29, 0x58, 0xfe, 0x8e, 0x80, 0xb4, 0x95, 0xba, 0x5a, 0xad, 0x21,
+	0x13, 0x92, 0xfd, 0x90, 0x01, 0x76, 0x4b, 0xab, 0x17, 0xcc, 0xfe, 0x6d, 0x05, 0x49, 0x9b, 0x92,
+	0xa8, 0xb3, 0xb3, 0x10, 0x57, 0x64, 0x55, 0xaf, 0x88, 0xb5, 0x24, 0x93, 0x61, 0x16, 0x47, 0xf8,
+	0x98, 0xf1, 0xba, 0x59, 0x63, 0x6f, 0x41, 0x9c, 0xd8, 0x4a, 0x86, 0x33, 0xcc, 0xe2, 0xe8, 0xea,
+	0x7c, 0x8e, 0x12, 0x6c, 0x8e, 0xd8, 0x5b, 0x8f, 0x3e, 0xfb, 0x31, 0x1d, 0xe2, 0xad, 0x21, 0xec,
+	0x59, 0x88, 0x69, 0x62, 0x5d, 0x42, 0x6a, 0x32, 0x62, 0x5a, 0x35, 0xdf, 0x6e, 0x0e, 0x3f, 0x7a,
+	0x9a, 0x0e, 0xfd, 0xf2, 0x34, 0x1d, 0xca, 0x96, 0x81, 0xeb, 0x9d, 0x0e, 0x8f, 0x34, 0x45, 0x96,
+	0x34, 0xc4, 0x2e, 0x00, 0x10, 0x53, 0xdd, 0x99, 0x8d, 0x90, 0x96, 0xcd, 0x1a, 0x9b, 0x84, 0x78,
+	0x07, 0xa9, 0x9a, 0x28, 0x4b, 0x78, 0x72, 0x23, 0xbc, 0xf5, 0x9a, 0xfd, 0x3e, 0x0c, 0xd3, 0x6e,
+	0xbb, 0xbb, 0xea, 0xa1, 0x7f, 0x94, 0xab, 0x90, 0x50, 0x54, 0xd4, 0x11, 0xe5, 0xb6, 0x56, 0x71,
+	0x38, 0xc4, 0x46, 0xd7, 0xc3, 0x49, 0x86, 0x9f, 0xb6, 0xba, 0x0b, 0xb6, 0x73, 0x07, 0x33, 0x91,
+	0xe3, 0x33, 0xb3, 0x02, 0x33, 0x82, 0xdc, 0x96, 0x74, 0xa4, 0x2a, 0x55, 0x55, 0x3f, 0xac, 0x58,
+	0x71, 0x44, 0xf1, 0xbc, 0x12, 0xce, 0xbe, 0x7f, 0x9a, 0x5d, 0x06, 0x19, 0x8a, 0x2a, 0xcb, 0xfb,
+	0x15, 0x51, 0x12, 0xf5, 0xe4, 0x50, 0x86, 0x59, 0x1c, 0xe3, 0x47, 0x70, 0x0b, 0x96, 0xb0, 0x00,
+	0x63, 0x66, 0xf7, 0x01, 0x12, 0xeb, 0x07, 0x7a, 0x32, 0x86, 0x27, 0xc5, 0x39, 0x26, 0x65, 0x66,
+	0x53, 0x67, 0x25, 0x77, 0x1b, 0x23, 0xc8, 0x94, 0x46, 0xf1, 0x28, 0xb3, 0xc9, 0x21, 0x58, 0xdc,
+	0x47, 0xb0, 0x5d, 0x38, 0xd7, 0x43, 0xac, 0xad, 0x97, 0x43, 0x10, 0xc6, 0x25, 0x88, 0x47, 0xc9,
+	0xb0, 0x47, 0xc9, 0xec, 0xe7, 0x3d, 0x7a, 0xad, 0x09, 0x0d, 0x7f, 0xbd, 0x8e, 0xb6, 0xc6, 0xfe,
+	0x09, 0x66, 0x5d, 0xe4, 0x3a, 0xb0, 0x66, 0x1e, 0x9e, 0x71, 0x76, 0x77, 0x25, 0x3d, 0x81, 0x28,
+	0x73, 0x60, 0x4a, 0x50, 0xd1, 0xd5, 0x43, 0xa2, 0xc9, 0x30, 0x6e, 0x30, 0xf2, 0xed, 0x2d, 0x49,
+	0x32, 0xe7, 0x95, 0x64, 0x4d, 0x68, 0x58, 0x92, 0x64, 0xbf, 0x65, 0xe0, 0x8c, 0xbb, 0xb7, 0x20,
+	0x4b, 0xfb, 0xa2, 0xda, 0x3a, 0x31, 0xbb, 0x76, 0xc8, 0x55, 0xa1, 0x81, 0xf9, 0xb4, 0x42, 0x36,
+	0x24, 0xf3, 0x86, 0x1c, 0x1d, 0x2c, 0xe4, 0x21, 0x9f, 0x90, 0xd3, 0xb0, 0x40, 0x0d, 0xca, 0x0e,
+	0x5b, 0x86, 0x44, 0x17, 0x50, 0x68, 0xca, 0x1a, 0x3a, 0xba, 0xce, 0xf5, 0x89, 0xb9, 0x7f, 0x21,
+	0x5b, 0x80, 0x39, 0x8a, 0x43, 0x7b, 0x3e, 0xdf, 0x31, 0x70, 0xd6, 0xd3, 0x3f, 0xa8, 0x0e, 0xee,
+	0x7a, 0x10, 0xe9, 0x57, 0x0f, 0xde, 0x90, 0x12, 0x19, 0x48, 0xd1, 0xe3, 0xb2, 0x43, 0xff, 0x81,
+	0x81, 0xf1, 0x2d, 0xad, 0xce, 0x23, 0xa1, 0xb3, 0x53, 0x15, 0x1a, 0x48, 0x67, 0x6f, 0x40, 0x4c,
+	0xc1, 0x4f, 0x38, 0xe0, 0xd1, 0xd5, 0x39, 0x6a, 0xe5, 0x34, 0xc1, 0x64, 0x56, 0x64, 0x00, 0x7b,
+	0x09, 0xa6, 0xcc, 0xa8, 0x04, 0xb9, 0xd5, 0x12, 0xf5, 0x16, 0x92, 0x74, 0xcc, 0xcc, 0x18, 0x3f,
+	0x89, 0xdb, 0x0b, 0x76, 0x73, 0x0f, 0x01, 0x91, 0xc1, 0x08, 0x88, 0xfa, 0x10, 0xf0, 0x7f, 0xbc,
+	0xbe, 0xba, 0xd1, 0xd9, 0xc5, 0xf0, 0x2f, 0x10, 0x53, 0x91, 0xd6, 0x6e, 0x9a, 0x51, 0x4e, 0xac,
+	0x5e, 0xa4, 0x46, 0x69, 0xc1, 0x79, 0x0c, 0xdd, 0x3d, 0x54, 0x10, 0x4f, 0x86, 0xdd, 0x8c, 0x1a,
+	0x3e, 0xb2, 0x1f, 0x84, 0x01, 0xb6, 0xb4, 0xfa, 0xae, 0xd8, 0x42, 0x72, 0xfb, 0x74, 0xb8, 0x6b,
+	0x4b, 0x2a, 0x12, 0x90, 0xd8, 0x41, 0x35, 0x17, 0x77, 0x65, 0xbb, 0xf9, 0x74, 0xb8, 0xbb, 0x0c,
+	0xac, 0x84, 0x1e, 0xea, 0x15, 0x0d, 0xdd, 0x6f, 0x23, 0x49, 0x40, 0x15, 0x15, 0x09, 0x1d, 0xcc,
+	0x63, 0x94, 0x9f, 0x32, 0x7a, 0x4a, 0xa4, 0xc3, 0x20, 0x2f, 0x40, 0xaa, 0xfd, 0x0f, 0x6f, 0x5d,
+	0x08, 0x11, 0xa7, 0x4d, 0xf3, 0x27, 0xe6, 0x17, 0x88, 0x58, 0xdf, 0x96, 0x70, 0x2a, 0xbf, 0x25,
+	0xb6, 0xd3, 0x30, 0x4a, 0x92, 0xda, 0x70, 0x4a, 0x96, 0xb2, 0xb9, 0xb8, 0xcd, 0x69, 0x9c, 0xca,
+	0x5a, 0xa6, 0xcb, 0x31, 0xd4, 0x57, 0x8e, 0x98, 0x8f, 0x1c, 0x7b, 0xf8, 0xb3, 0xe3, 0x26, 0xec,
+	0xb4, 0x55, 0x79, 0x2f, 0x8c, 0x35, 0x5f, 0x13, 0x1a, 0x92, 0xfc, 0xa0, 0x89, 0x6a, 0x75, 0x84,
+	0x97, 0xf6, 0x00, 0xb2, 0x2c, 0xc2, 0x64, 0xd5, 0x6d, 0xcd, 0x52, 0xc5, 0xd3, 0xdc, 0x55, 0xc5,
+	0x18, 0x58, 0x73, 0xa9, 0xb2, 0x66, 0xb4, 0xbc, 0xad, 0x0a, 0x2b, 0xe0, 0x2d, 0xb2, 0x87, 0x82,
+	0xd3, 0x26, 0xfa, 0xb5, 0x6b, 0x9b, 0x50, 0x36, 0xcf, 0x0c, 0x03, 0x7d, 0x32, 0xff, 0x0a, 0xb1,
+	0x7d, 0x11, 0x35, 0x6b, 0x1a, 0x29, 0x1e, 0x59, 0xea, 0xc4, 0x88, 0xa7, 0x0d, 0x8c, 0xb4, 0xa4,
+	0x32, 0xc7, 0x19, 0x3b, 0x6c, 0xdd, 0xcc, 0x2e, 0x42, 0x2d, 0x7d, 0x87, 0x4d, 0x32, 0xd0, 0xda,
+	0x61, 0x93, 0x21, 0xbe, 0xc4, 0x26, 0x2c, 0x62, 0xdf, 0xff, 0xf9, 0xd3, 0x25, 0xd2, 0x98, 0xfd,
+	0x8c, 0x71, 0x6e, 0x28, 0x1c, 0xe1, 0x07, 0x3d, 0x8a, 0xdc, 0x82, 0x38, 0x39, 0x68, 0x1d, 0x79,
+	0x4e, 0x22, 0x96, 0xad, 0xb9, 0x92, 0x21, 0x46, 0xad, 0x20, 0x8f, 0xf6, 0xea, 0xc4, 0xac, 0x45,
+	0xf9, 0x49, 0xd2, 0x6e, 0xad, 0x4d, 0x47, 0x5e, 0x7c, 0x13, 0x85, 0x99, 0x9e, 0x39, 0x1f, 0x79,
+	0xcc, 0xe9, 0xa3, 0xd8, 0xdf, 0x21, 0xa3, 0xa8, 0xb2, 0x22, 0x6b, 0xa8, 0x56, 0xb1, 0xa6, 0x23,
+	0xc8, 0x92, 0x84, 0x04, 0x5d, 0x94, 0xa5, 0xca, 0x81, 0xac, 0x18, 0x5a, 0x46, 0x16, 0x47, 0xf8,
+	0x05, 0x0b, 0x47, 0xbc, 0x16, 0x6c, 0xd4, 0x6d, 0x59, 0xd1, 0xd8, 0x7f, 0x80, 0x35, 0xed, 0xca,
+	0xf1, 0x05, 0x9c, 0x20, 0x43, 0xad, 0x0f, 0xde, 0x3e, 0x2c, 0xb8, 0x36, 0xe5, 0xde, 0x29, 0x62,
+	0x79, 0x83, 0xf1, 0x3d, 0xe7, 0x34, 0xb4, 0xe3, 0x0e, 0x81, 0x5d, 0xf7, 0xf8, 0xe9, 0x11, 0x24,
+	0x86, 0x05, 0x71, 0xd9, 0x28, 0xbb, 0xc5, 0x61, 0xff, 0x00, 0xe3, 0xa4, 0x90, 0x93, 0x93, 0x61,
+	0x1c, 0x17, 0x0d, 0xb3, 0x4c, 0x10, 0xa1, 0xba, 0x20, 0x2b, 0x80, 0x61, 0x07, 0xc8, 0x9a, 0x8d,
+	0xb7, 0xb6, 0x8c, 0x0c, 0x56, 0x5b, 0xa0, 0xff, 0x12, 0xf8, 0x95, 0x81, 0x79, 0x5a, 0x3a, 0xfd,
+	0xde, 0x56, 0x80, 0xa3, 0xe2, 0x45, 0x4f, 0x56, 0xf1, 0xba, 0x4b, 0xe8, 0x8b, 0x08, 0x65, 0x09,
+	0x0d, 0x72, 0xf2, 0xbc, 0x07, 0xe7, 0x5c, 0x49, 0xb4, 0xdf, 0x6c, 0x6b, 0x07, 0x15, 0x4d, 0xaf,
+	0xea, 0x6d, 0xb3, 0x0e, 0x4e, 0xac, 0x66, 0xa8, 0xd3, 0xdd, 0x30, 0x80, 0x25, 0x8c, 0xe3, 0x5d,
+	0x87, 0x57, 0x47, 0x07, 0x5b, 0xf6, 0x9c, 0x4f, 0x2d, 0xbe, 0xa3, 0x81, 0xf9, 0x4e, 0x50, 0xb2,
+	0xb7, 0x37, 0x6b, 0x87, 0x82, 0x64, 0x6d, 0x2c, 0x40, 0xd6, 0xc6, 0x07, 0xcb, 0xda, 0xe1, 0xfe,
+	0x59, 0x9b, 0xa2, 0x24, 0xad, 0xf3, 0xf8, 0xfb, 0x65, 0x98, 0xf2, 0x5d, 0x33, 0x0e, 0x8c, 0x27,
+	0x96, 0xf8, 0xdf, 0xc0, 0x51, 0x2f, 0x17, 0x0c, 0x91, 0x11, 0xd1, 0x98, 0xa3, 0x4a, 0x61, 0xa8,
+	0x88, 0xf8, 0x24, 0xe5, 0xee, 0x01, 0xf7, 0xf4, 0xea, 0x10, 0xa5, 0xe8, 0xe0, 0xa5, 0x78, 0x68,
+	0x30, 0x8a, 0x63, 0xfd, 0x29, 0x4e, 0x53, 0x3e, 0x8d, 0x06, 0x83, 0x36, 0xc7, 0x5f, 0x47, 0x20,
+	0xd9, 0x5b, 0x39, 0x48, 0xf9, 0x3e, 0x29, 0xcd, 0xde, 0x5c, 0x3f, 0xfe, 0x5d, 0x5b, 0x82, 0x42,
+	0x34, 0xfb, 0x2f, 0x38, 0x6b, 0xdf, 0xf4, 0x21, 0x55, 0x95, 0xd5, 0x0a, 0xde, 0x85, 0x2b, 0xd6,
+	0x17, 0xea, 0x3c, 0xd5, 0x70, 0xd1, 0x40, 0xf2, 0x26, 0x90, 0x9f, 0xb1, 0x0c, 0x38, 0x5b, 0x83,
+	0x2d, 0xa2, 0x1c, 0x24, 0x4c, 0x90, 0xdb, 0xb5, 0xb9, 0x94, 0xa6, 0x71, 0x97, 0xcb, 0xe8, 0x1b,
+	0x5d, 0x4f, 0x93, 0x8f, 0x3c, 0x42, 0x8b, 0x90, 0xf1, 0x93, 0xf1, 0xb4, 0xb7, 0x9b, 0x5f, 0x85,
+	0x61, 0xb6, 0xc7, 0x57, 0xa1, 0x2a, 0x09, 0xa8, 0x79, 0xe2, 0x8c, 0xb9, 0x03, 0xe3, 0x6e, 0x5a,
+	0x23, 0x01, 0x15, 0x25, 0xa4, 0x8d, 0x21, 0x27, 0xf5, 0x3e, 0x52, 0x45, 0x83, 0x4a, 0xf5, 0xe6,
+	0xd7, 0xe5, 0x79, 0x48, 0xfb, 0x50, 0x68, 0xd1, 0xbf, 0xf4, 0x82, 0x01, 0xb6, 0x57, 0x0b, 0xf6,
+	0x3a, 0x64, 0xf8, 0x62, 0x69, 0x67, 0xfb, 0x6e, 0xa9, 0x58, 0xe1, 0x8b, 0xa5, 0xf2, 0x9d, 0xdd,
+	0xca, 0xee, 0x7f, 0x76, 0x8a, 0x95, 0xf2, 0xdd, 0xd2, 0x4e, 0xb1, 0xb0, 0xb9, 0xb1, 0x59, 0xfc,
+	0xdb, 0x54, 0x88, 0x9b, 0x7c, 0xfc, 0x24, 0x33, 0xea, 0x68, 0x62, 0x2f, 0xc2, 0x39, 0xea, 0xb0,
+	0xbb, 0xdb, 0xdb, 0x3b, 0x53, 0x0c, 0x37, 0xfc, 0xf8, 0x49, 0x26, 0x6a, 0x3c, 0xb3, 0xcb, 0x30,
+	0x4f, 0x05, 0x96, 0xca, 0x85, 0x42, 0xb1, 0x54, 0x9a, 0x0a, 0x73, 0xa3, 0x8f, 0x9f, 0x64, 0xe2,
+	0xe4, 0xd5, 0x17, 0xbe, 0xb1, 0xb6, 0x79, 0xa7, 0xcc, 0x17, 0xa7, 0x22, 0x26, 0x9c, 0xbc, 0x72,
+	0xd1, 0x47, 0x1f, 0xa7, 0x42, 0xab, 0xaf, 0xc7, 0x21, 0xb2, 0xa5, 0xd5, 0xd9, 0x06, 0x4c, 0x7a,
+	0x7f, 0xcc, 0xa0, 0xe7, 0x64, 0xef, 0xcf, 0x0c, 0x5c, 0x3e, 0x20, 0xd0, 0xce, 0xfe, 0x03, 0x98,
+	0xf0, 0xfc, 0xa4, 0x70, 0x21, 0x80, 0x89, 0x5d, 0xf5, 0x90, 0xcb, 0x05, 0xc3, 0xf9, 0x78, 0x32,
+	0xb6, 0x24, 0x41, 0x3c, 0xad, 0x09, 0x8d, 0x40, 0x9e, 0x1c, 0x5f, 0x48, 0x56, 0x07, 0x96, 0x72,
+	0x39, 0xbc, 0x14, 0xc0, 0x0a, 0xc1, 0x72, 0xab, 0xc1, 0xb1, 0xb6, 0x57, 0x09, 0xa6, 0x7a, 0x2e,
+	0x67, 0x17, 0xfb, 0xd8, 0xb1, 0x91, 0xdc, 0x95, 0xa0, 0x48, 0xdb, 0xdf, 0x03, 0x48, 0xd0, 0xee,
+	0x5e, 0xff, 0x18, 0xc4, 0x90, 0x15, 0xe7, 0xd5, 0x63, 0x80, 0x6d, 0xc7, 0xf7, 0x00, 0x1c, 0x37,
+	0x9f, 0x59, 0x3f, 0x13, 0x5d, 0x0c, 0xb7, 0xd4, 0x1f, 0x63, 0x5b, 0x2f, 0x41, 0xdc, 0xfa, 0xd0,
+	0xa6, 0xfd, 0x86, 0x11, 0x00, 0x77, 0xb1, 0x0f, 0xc0, 0x99, 0x7b, 0x9e, 0x6b, 0xb0, 0x0b, 0x7d,
+	0x86, 0x12, 0x9c, 0x7f, 0xee, 0xf9, 0xdc, 0x12, 0x35, 0x60, 0xd2, 0x7b, 0xb5, 0xe3, 0x3b, 0x4b,
+	0x0f, 0xd0, 0x7f, 0xf1, 0xfa, 0xdd, 0x94, 0x74, 0x13, 0xdd, 0x79, 0xbd, 0xd1, 0x2f, 0xd1, 0x1d,
+	0xd8, 0xbe, 0x89, 0x4e, 0xbb, 0x37, 0xb8, 0x0f, 0xd3, 0xbd, 0x27, 0xf4, 0x4b, 0xc1, 0x0c, 0x19,
+	0x85, 0x63, 0x25, 0x30, 0xd4, 0xdf, 0xa5, 0x51, 0x3e, 0x02, 0xba, 0x34, 0x2a, 0xc8, 0x4a, 0x60,
+	0xa8, 0x3f, 0xb7, 0x78, 0x8b, 0x1d, 0x90, 0x5b, 0x03, 0x1b, 0x94, 0x5b, 0xe7, 0xc6, 0x93, 0x7d,
+	0x17, 0xce, 0xd0, 0x37, 0x9d, 0xcb, 0x01, 0x49, 0x23, 0x2b, 0xe3, 0xfa, 0xb1, 0xe0, 0xb6, 0xfb,
+	0x77, 0x60, 0x86, 0xba, 0x81, 0xb9, 0x1c, 0xcc, 0x9c, 0x89, 0xe6, 0xae, 0x1d, 0x07, 0x6d, 0xf9,
+	0x5e, 0x2f, 0x3d, 0x7b, 0x99, 0x62, 0x9e, 0xbf, 0x4c, 0x31, 0x3f, 0xbd, 0x4c, 0x31, 0x1f, 0xbd,
+	0x4a, 0x85, 0x9e, 0xbf, 0x4a, 0x85, 0x5e, 0xbc, 0x4a, 0x85, 0xfe, 0x7b, 0xa3, 0x2e, 0xea, 0x07,
+	0xed, 0xbd, 0x9c, 0x20, 0xb7, 0xf2, 0xe4, 0xcf, 0x06, 0xe2, 0x9e, 0xb0, 0x5c, 0x97, 0xf3, 0x9d,
+	0x3f, 0xe7, 0x5b, 0x72, 0xad, 0xdd, 0x44, 0x9a, 0xf9, 0x27, 0x81, 0x2b, 0xd7, 0x96, 0xad, 0xff,
+	0x09, 0xe8, 0x87, 0x0a, 0xd2, 0xf6, 0x62, 0xf8, 0x3f, 0x02, 0x57, 0x7f, 0x0b, 0x00, 0x00, 0xff,
+	0xff, 0x87, 0xc0, 0x64, 0xc4, 0xee, 0x20, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3617,16 +3617,18 @@ func (m *MsgChannelUpgradeTimeout) MarshalToSizedBuffer(dAtA []byte) (int, error
 		i--
 		dAtA[i] = 0x2a
 	}
-	{
-		size, err := m.PreviousErrorReceipt.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+	if m.PreviousErrorReceipt != nil {
+		{
+			size, err := m.PreviousErrorReceipt.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTx(dAtA, i, uint64(size))
 		}
-		i -= size
-		i = encodeVarintTx(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x22
 	}
-	i--
-	dAtA[i] = 0x22
 	{
 		size, err := m.CounterpartyChannel.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
@@ -4376,8 +4378,10 @@ func (m *MsgChannelUpgradeTimeout) Size() (n int) {
 	}
 	l = m.CounterpartyChannel.Size()
 	n += 1 + l + sovTx(uint64(l))
-	l = m.PreviousErrorReceipt.Size()
-	n += 1 + l + sovTx(uint64(l))
+	if m.PreviousErrorReceipt != nil {
+		l = m.PreviousErrorReceipt.Size()
+		n += 1 + l + sovTx(uint64(l))
+	}
 	l = len(m.ProofChannel)
 	if l > 0 {
 		n += 1 + l + sovTx(uint64(l))
@@ -8931,6 +8935,9 @@ func (m *MsgChannelUpgradeTimeout) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			if m.PreviousErrorReceipt == nil {
+				m.PreviousErrorReceipt = &ErrorReceipt{}
+			}
 			if err := m.PreviousErrorReceipt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
diff --git a/modules/core/05-port/types/module.go b/modules/core/05-port/types/module.go
index 66c19eed931..37f772a9b5d 100644
--- a/modules/core/05-port/types/module.go
+++ b/modules/core/05-port/types/module.go
@@ -149,17 +149,6 @@ type UpgradableModule interface {
 		portID,
 		channelID string,
 	)
-
-	// OnChanUpgradeTimeout times out an outstanding upgrade when the counterparty chain has not responded.
-	OnChanUpgradeTimeout(
-		ctx sdk.Context,
-		portID, channelID string,
-		counterpartyChannel channeltypes.Channel,
-		prevErrorReceipt channeltypes.ErrorReceipt,
-		proofCounterpartyChannel,
-		proofErrorReceipt []byte,
-		proofHeight exported.Height,
-	) error
 }
 
 // ICS4Wrapper implements the ICS4 interfaces that IBC applications use to send packets and acknowledgements.
diff --git a/modules/core/keeper/msg_server.go b/modules/core/keeper/msg_server.go
index b8d78997e0b..27aacf6ec60 100644
--- a/modules/core/keeper/msg_server.go
+++ b/modules/core/keeper/msg_server.go
@@ -815,7 +815,33 @@ func (k Keeper) ChannelUpgradeOpen(goCtx context.Context, msg *channeltypes.MsgC
 
 // ChannelUpgradeTimeout defines a rpc handler method for MsgChannelUpgradeTimeout.
 func (k Keeper) ChannelUpgradeTimeout(goCtx context.Context, msg *channeltypes.MsgChannelUpgradeTimeout) (*channeltypes.MsgChannelUpgradeTimeoutResponse, error) {
-	return nil, nil
+	ctx := sdk.UnwrapSDKContext(goCtx)
+	module, _, err := k.ChannelKeeper.LookupModuleByChannel(ctx, msg.PortId, msg.ChannelId)
+	if err != nil {
+		ctx.Logger().Error("channel upgrade timeout failed", "port-id", msg.PortId, "error", errorsmod.Wrap(err, "could not retrieve module from port-id"))
+		return nil, errorsmod.Wrap(err, "could not retrieve module from port-id")
+	}
+
+	cbs, ok := k.Router.GetRoute(module)
+	if !ok {
+		ctx.Logger().Error("channel upgrade timeout failed", "port-id", msg.PortId, "error", errorsmod.Wrapf(porttypes.ErrInvalidRoute, "route not found to module: %s", module))
+		return nil, errorsmod.Wrapf(porttypes.ErrInvalidRoute, "route not found to module: %s", module)
+	}
+
+	err = k.ChannelKeeper.ChanUpgradeTimeout(ctx, msg.PortId, msg.ChannelId, msg.CounterpartyChannel, msg.PreviousErrorReceipt, msg.ProofChannel, msg.ProofErrorReceipt, msg.ProofHeight)
+	if err != nil {
+		return nil, errorsmod.Wrapf(err, "could not timeout upgrade for channel: %s", msg.ChannelId)
+	}
+
+	cbs.OnChanUpgradeRestore(ctx, msg.PortId, msg.ChannelId)
+
+	k.ChannelKeeper.WriteUpgradeTimeoutChannel(ctx, msg.PortId, msg.ChannelId)
+
+	ctx.Logger().Info("channel upgrade timeout callback succeeded: portID %s, channelID %s", msg.PortId, msg.ChannelId)
+
+	return &channeltypes.MsgChannelUpgradeTimeoutResponse{
+		Result: channeltypes.SUCCESS,
+	}, nil
 }
 
 // ChannelUpgradeCancel defines a rpc handler method for MsgChannelUpgradeCancel.
diff --git a/modules/core/keeper/msg_server_test.go b/modules/core/keeper/msg_server_test.go
index 7cdc0a36c10..21ecf575ab2 100644
--- a/modules/core/keeper/msg_server_test.go
+++ b/modules/core/keeper/msg_server_test.go
@@ -1053,3 +1053,147 @@ func (suite *KeeperTestSuite) TestChannelUpgradeCancel() {
 		})
 	}
 }
+
+func (suite *KeeperTestSuite) TestChannelUpgradeTimeout() {
+	var (
+		path *ibctesting.Path
+		msg  *channeltypes.MsgChannelUpgradeTimeout
+	)
+
+	cases := []struct {
+		name     string
+		malleate func()
+		expErr   error
+	}{
+		{
+			name:     "success",
+			malleate: func() {},
+			expErr:   nil,
+		},
+		{
+			name: "success with error receipt",
+			malleate: func() {
+				// this error receipt is for a past upgrade so is stale
+				errReceipt := channeltypes.ErrorReceipt{
+					Sequence: 0,
+					Message:  "error",
+				}
+				path.EndpointB.Chain.App.GetIBCKeeper().ChannelKeeper.SetUpgradeErrorReceipt(path.EndpointB.Chain.GetContext(), path.EndpointB.ChannelConfig.PortID, path.EndpointB.ChannelID, errReceipt)
+
+				suite.Require().NoError(path.EndpointB.UpdateClient())
+				suite.Require().NoError(path.EndpointA.UpdateClient())
+
+				upgradeErrorReceiptKey := host.ChannelUpgradeErrorKey(path.EndpointB.ChannelConfig.PortID, path.EndpointB.ChannelID)
+				errorReceiptProof, proofHeight := path.EndpointB.QueryProof(upgradeErrorReceiptKey)
+				counterpartyChannel := path.EndpointB.GetChannel()
+				// the channel proof is being regenerated as the proof height will change
+				channelProof, _, _ := path.EndpointA.QueryChannelUpgradeProof()
+
+				msg.PreviousErrorReceipt = &errReceipt
+				msg.ProofErrorReceipt = errorReceiptProof
+				msg.CounterpartyChannel = counterpartyChannel
+				msg.ProofChannel = channelProof
+				msg.ProofHeight = proofHeight
+			},
+			expErr: nil,
+		},
+		{
+			name: "invalid proof",
+			malleate: func() {
+				msg.ProofErrorReceipt = []byte("invalid proof")
+			},
+			expErr: commitmenttypes.ErrInvalidProof,
+		},
+		{
+			name: "invalid error receipt sequence, this error receipt is for this same upgrade so UpgradeCancel should be used instead",
+			malleate: func() {
+				errReceipt := channeltypes.ErrorReceipt{
+					Sequence: 1,
+					Message:  "error",
+				}
+				path.EndpointB.Chain.App.GetIBCKeeper().ChannelKeeper.SetUpgradeErrorReceipt(path.EndpointB.Chain.GetContext(), path.EndpointB.ChannelConfig.PortID, path.EndpointB.ChannelID, errReceipt)
+				suite.Require().NoError(path.EndpointB.UpdateClient())
+				suite.Require().NoError(path.EndpointA.UpdateClient())
+
+				upgradeErrorReceiptKey := host.ChannelUpgradeErrorKey(path.EndpointB.ChannelConfig.PortID, path.EndpointB.ChannelID)
+				errorReceiptProof, proofHeight := path.EndpointB.QueryProof(upgradeErrorReceiptKey)
+				counterpartyChannel := path.EndpointB.GetChannel()
+				channelProof, _, _ := path.EndpointA.QueryChannelUpgradeProof()
+
+				msg.PreviousErrorReceipt = &errReceipt
+				msg.ProofErrorReceipt = errorReceiptProof
+				msg.CounterpartyChannel = counterpartyChannel
+				msg.ProofChannel = channelProof
+				msg.ProofHeight = proofHeight
+			},
+			expErr: channeltypes.ErrInvalidUpgradeSequence,
+		},
+	}
+
+	for _, tc := range cases {
+		tc := tc
+		suite.Run(tc.name, func() {
+			suite.SetupTest()
+
+			path = ibctesting.NewPath(suite.chainA, suite.chainB)
+			suite.coordinator.Setup(path)
+
+			// configure the channel upgrade version on testing endpoints
+			path.EndpointA.ChannelConfig.ProposedUpgrade.Fields.Version = ibcmock.UpgradeVersion
+			path.EndpointA.ChannelConfig.ProposedUpgrade.Timeout.Height = clienttypes.NewHeight(1, 1)
+
+			suite.Require().NoError(path.EndpointA.ChanUpgradeInit())
+
+			// fetch the previous channel when it is in the INITUPGRADE state.
+			prevChannel := path.EndpointA.GetChannel()
+
+			suite.Require().NoError(path.EndpointB.UpdateClient())
+
+			upgradeErrorReceiptKey := host.ChannelUpgradeErrorKey(path.EndpointB.ChannelConfig.PortID, path.EndpointB.ChannelID)
+			errorReceiptProof, proofHeight := path.EndpointB.QueryProof(upgradeErrorReceiptKey)
+
+			channelProof, _, _ := path.EndpointA.QueryChannelUpgradeProof()
+
+			msg = &channeltypes.MsgChannelUpgradeTimeout{
+				PortId:               path.EndpointA.ChannelConfig.PortID,
+				ChannelId:            path.EndpointA.ChannelID,
+				CounterpartyChannel:  path.EndpointB.GetChannel(),
+				PreviousErrorReceipt: nil,
+				ProofChannel:         channelProof,
+				ProofErrorReceipt:    errorReceiptProof,
+				ProofHeight:          proofHeight,
+				Signer:               suite.chainA.SenderAccount.GetAddress().String(),
+			}
+
+			tc.malleate()
+
+			res, err := suite.chainA.GetSimApp().GetIBCKeeper().ChannelUpgradeTimeout(suite.chainA.GetContext(), msg)
+
+			expPass := tc.expErr == nil
+			if expPass {
+				suite.Require().NoError(err)
+
+				channel := path.EndpointA.GetChannel()
+				suite.Require().Equalf(channeltypes.OPEN, channel.State, "channel state should be %s", channeltypes.OPEN.String())
+				suite.Require().Equalf(channeltypes.NOTINFLUSH, channel.FlushStatus, "channel flush status should be %s", channeltypes.NOTINFLUSH.String())
+
+				_, found := path.EndpointA.Chain.GetSimApp().IBCKeeper.ChannelKeeper.GetUpgrade(suite.chainA.GetContext(), path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID)
+				suite.Require().False(found, "channel upgrade should be nil")
+
+				suite.Require().NotNil(res)
+				suite.Require().Equal(channeltypes.SUCCESS, res.Result)
+			} else {
+				suite.Require().Nil(res)
+				suite.Require().ErrorIs(err, tc.expErr)
+
+				channel := path.EndpointA.GetChannel()
+				suite.Require().Equalf(prevChannel.State, channel.State, "channel state should be %s", prevChannel.State.String())
+				suite.Require().Equalf(prevChannel.FlushStatus, channel.FlushStatus, "channel flush status should be %s", prevChannel.FlushStatus.String())
+				suite.Require().Equal(prevChannel.UpgradeSequence, channel.UpgradeSequence, "channel upgrade sequence should not incremented")
+
+				_, found := path.EndpointA.Chain.GetSimApp().IBCKeeper.ChannelKeeper.GetUpgrade(suite.chainA.GetContext(), path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID)
+				suite.Require().True(found, "channel upgrade should not be nil")
+			}
+		})
+	}
+}
diff --git a/proto/ibc/core/channel/v1/tx.proto b/proto/ibc/core/channel/v1/tx.proto
index 4ddd6d9a626..b8f0b75ecf5 100644
--- a/proto/ibc/core/channel/v1/tx.proto
+++ b/proto/ibc/core/channel/v1/tx.proto
@@ -358,13 +358,12 @@ message MsgChannelUpgradeOpenResponse {}
 message MsgChannelUpgradeTimeout {
   option (cosmos.msg.v1.signer) = "signer";
 
-  option (gogoproto.equal)           = false;
   option (gogoproto.goproto_getters) = false;
 
   string                    port_id                = 1;
   string                    channel_id             = 2;
   Channel                   counterparty_channel   = 3 [(gogoproto.nullable) = false];
-  ErrorReceipt              previous_error_receipt = 4 [(gogoproto.nullable) = false];
+  ErrorReceipt              previous_error_receipt = 4;
   bytes                     proof_channel          = 5;
   bytes                     proof_error_receipt    = 6;
   ibc.core.client.v1.Height proof_height           = 7 [(gogoproto.nullable) = false];
@@ -373,7 +372,6 @@ message MsgChannelUpgradeTimeout {
 
 // MsgChannelUpgradeTimeoutRepsonse defines the MsgChannelUpgradeTimeout response type
 message MsgChannelUpgradeTimeoutResponse {
-  option (gogoproto.equal)           = false;
   option (gogoproto.goproto_getters) = false;
 
   ResponseResultType result = 1;
diff --git a/testing/endpoint.go b/testing/endpoint.go
index bee6c9421fe..bc112435eec 100644
--- a/testing/endpoint.go
+++ b/testing/endpoint.go
@@ -692,7 +692,7 @@ func (endpoint *Endpoint) ChanUpgradeTimeout() error {
 		endpoint.ChannelConfig.PortID,
 		endpoint.ChannelID,
 		endpoint.Counterparty.GetChannel(),
-		errorReceipt,
+		&errorReceipt,
 		proofChannel,
 		proofErrorReceipt,
 		height,
diff --git a/testing/mock/ibc_app.go b/testing/mock/ibc_app.go
index 15b0081b403..44f8f0f5b68 100644
--- a/testing/mock/ibc_app.go
+++ b/testing/mock/ibc_app.go
@@ -121,16 +121,6 @@ type IBCApp struct {
 		portID,
 		channelID string,
 	)
-
-	OnChanUpgradeTimeout func(
-		ctx sdk.Context,
-		portID, channelID string,
-		counterpartyChannel channeltypes.Channel,
-		prevErrorReceipt channeltypes.ErrorReceipt,
-		proofCounterpartyChannel,
-		proofErrorReceipt []byte,
-		proofHeight exported.Height,
-	) error
 }
 
 // NewIBCApp returns a IBCApp. An empty PortID indicates the mock app doesn't bind/claim ports.
diff --git a/testing/mock/ibc_module.go b/testing/mock/ibc_module.go
index 3a02aee3670..b6520c73335 100644
--- a/testing/mock/ibc_module.go
+++ b/testing/mock/ibc_module.go
@@ -210,23 +210,6 @@ func (im IBCModule) OnChanUpgradeRestore(ctx sdk.Context, portID, channelID stri
 	}
 }
 
-// OnChanUpgradeTimeout implements the IBCModule interface
-func (im IBCModule) OnChanUpgradeTimeout(
-	ctx sdk.Context,
-	portID, channelID string,
-	counterpartyChannel channeltypes.Channel,
-	prevErrorReceipt channeltypes.ErrorReceipt,
-	proofCounterpartyChannel,
-	proofErrorReceipt []byte,
-	proofHeight exported.Height,
-) error {
-	if im.IBCApp.OnChanUpgradeTimeout != nil {
-		return im.IBCApp.OnChanUpgradeTimeout(ctx, portID, channelID, counterpartyChannel, prevErrorReceipt, proofCounterpartyChannel, proofErrorReceipt, proofHeight)
-	}
-
-	return nil
-}
-
 // GetMockRecvCanaryCapabilityName generates a capability name for testing OnRecvPacket functionality.
 func GetMockRecvCanaryCapabilityName(packet channeltypes.Packet) string {
 	return fmt.Sprintf("%s%s%s%s", MockRecvCanaryCapabilityName, packet.GetDestPort(), packet.GetDestChannel(), strconv.Itoa(int(packet.GetSequence())))