feat: adding ChannelUpgradeConfirm rpc and msgs

modules/core/04-channel/types/codec.go

@@ -42,6 +42,7 @@ func RegisterInterfaces(registry codectypes.InterfaceRegistry) {
 		&MsgChannelUpgradeInit{},
 		&MsgChannelUpgradeTry{},
 		&MsgChannelUpgradeAck{},
+		&MsgChannelUpgradeConfirm{},
 		&MsgChannelUpgradeOpen{},
 		&MsgChannelUpgradeTimeout{},
 		&MsgChannelUpgradeCancel{},

modules/core/04-channel/types/msgs.go

@@ -659,6 +659,71 @@ func (msg MsgChannelUpgradeAck) GetSigners() []sdk.AccAddress {
 	return []sdk.AccAddress{signer}
 }
 
+var _ sdk.Msg = &MsgChannelUpgradeConfirm{}
+
+// NewMsgChannelUpgradeConfirm constructs a new MsgChannelUpgradeConfirm
+func NewMsgChannelUpgradeConfirm(
+	portID,
+	channelID string,
+	counterpartyChannelState State,
+	counterpartyUpgrade Upgrade,
+	proofChannel,
+	proofUpgrade []byte,
+	proofHeight clienttypes.Height,
+	signer string,
+) *MsgChannelUpgradeConfirm {
+	return &MsgChannelUpgradeConfirm{
+		PortId:                   portID,
+		ChannelId:                channelID,
+		CounterpartyChannelState: counterpartyChannelState,
+		CounterpartyUpgrade:      counterpartyUpgrade,
+		ProofChannel:             proofChannel,
+		ProofUpgrade:             proofUpgrade,
+		ProofHeight:              proofHeight,
+		Signer:                   signer,
+	}
+}
+
+// ValidateBasic implements sdk.Msg
+func (msg MsgChannelUpgradeConfirm) ValidateBasic() error {
+	if err := host.PortIdentifierValidator(msg.PortId); err != nil {
+		return errorsmod.Wrap(err, "invalid port ID")
+	}
+
+	if !IsValidChannelID(msg.ChannelId) {
+		return ErrInvalidChannelIdentifier
+	}
+
+	if !collections.Contains(msg.CounterpartyChannelState, []State{STATE_FLUSHING, STATE_FLUSHCOMPLETE}) {
+		return errorsmod.Wrapf(ErrInvalidChannelState, "expected channel state to be one of: %s or %s, got: %s", STATE_FLUSHING, STATE_FLUSHCOMPLETE, msg.CounterpartyChannelState)
+	}
+
+	if len(msg.ProofChannel) == 0 {
+		return errorsmod.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty channel proof")
+	}
+
+	if len(msg.ProofUpgrade) == 0 {
+		return errorsmod.Wrap(commitmenttypes.ErrInvalidProof, "cannot submit an empty upgrade proof")
+	}
+
+	_, err := sdk.AccAddressFromBech32(msg.Signer)
+	if err != nil {
+		return errorsmod.Wrapf(ibcerrors.ErrInvalidAddress, "string could not be parsed as address: %v", err)
+	}
+
+	return msg.CounterpartyUpgrade.ValidateBasic()
+}
+
+// GetSigners implements sdk.Msg
+func (msg MsgChannelUpgradeConfirm) GetSigners() []sdk.AccAddress {
+	signer, err := sdk.AccAddressFromBech32(msg.Signer)
+	if err != nil {
+		panic(err)
+	}
+
+	return []sdk.AccAddress{signer}
+}
+
 var _ sdk.Msg = &MsgChannelUpgradeOpen{}
 
 // NewMsgChannelUpgradeOpen constructs a new MsgChannelUpgradeOpen

modules/core/04-channel/types/msgs_test.go

@@ -695,6 +695,105 @@ func (suite *TypesTestSuite) TestMsgChannelUpgradeAckValidateBasic() {
 	}
 }
 
+func (suite *TypesTestSuite) TestMsgChannelUpgradeConfirmValidateBasic() {
+	var msg *types.MsgChannelUpgradeConfirm
+
+	testCases := []struct {
+		name     string
+		malleate func()
+		expPass  bool
+	}{
+		{
+			"success",
+			func() {},
+			true,
+		},
+		{
+			"success: counterparty state set to FLUSHCOMPLETE",
+			func() {
+				msg.CounterpartyChannelState = types.STATE_FLUSHCOMPLETE
+			},
+			true,
+		},
+		{
+			"invalid port identifier",
+			func() {
+				msg.PortId = invalidPort
+			},
+			false,
+		},
+		{
+			"invalid channel identifier",
+			func() {
+				msg.ChannelId = invalidChannel
+			},
+			false,
+		},
+		{
+			"invalid counterparty channel state",
+			func() {
+				msg.CounterpartyChannelState = types.CLOSED
+			},
+			false,
+		},
+		{
+			"cannot submit an empty channel proof",
+			func() {
+				msg.ProofChannel = emptyProof
+			},
+			false,
+		},
+		{
+			"cannot submit an empty upgrade proof",
+			func() {
+				msg.ProofUpgrade = emptyProof
+			},
+			false,
+		},
+		{
+			"missing signer address",
+			func() {
+				msg.Signer = emptyAddr
+			},
+			false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		suite.Run(tc.name, func() {
+			counterpartyUpgrade := types.NewUpgrade(
+				types.NewUpgradeFields(types.UNORDERED, []string{ibctesting.FirstConnectionID}, mock.Version),
+				types.NewTimeout(clienttypes.NewHeight(0, 10000), timeoutTimestamp),
+				1,
+			)
+
+			msg = types.NewMsgChannelUpgradeConfirm(
+				ibctesting.MockPort, ibctesting.FirstChannelID,
+				types.STATE_FLUSHING, counterpartyUpgrade, suite.proof, suite.proof,
+				height, addr,
+			)
+
+			tc.malleate()
+			err := msg.ValidateBasic()
+
+			if tc.expPass {
+				suite.Require().NoError(err)
+			} else {
+				suite.Require().Error(err)
+			}
+		})
+	}
+}
+
+func (suite *TypesTestSuite) TestMsgChannelUpgradeConfirmGetSigners() {
+	expSigner, err := sdk.AccAddressFromBech32(addr)
+	suite.Require().NoError(err)
+
+	msg := &types.MsgChannelUpgradeConfirm{Signer: addr}
+	suite.Require().Equal([]sdk.AccAddress{expSigner}, msg.GetSigners())
+}
+
 func (suite *TypesTestSuite) TestMsgChannelUpgradeOpenValidateBasic() {
 	var msg *types.MsgChannelUpgradeOpen