Modify startFlushUpgradeHandshake to be used as a write function

modules/core/04-channel/keeper/export_test.go

@@ -7,23 +7,12 @@ package keeper
 import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
-	clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types"
 	"github.com/cosmos/ibc-go/v7/modules/core/04-channel/types"
 )
 
-// StartFlushUpgradeHandshake is a wrapper around startFlushUpgradeHandshake to allow the function to be directly called in tests.
-func (k Keeper) StartFlushUpgradeHandshake(
-	ctx sdk.Context,
-	portID,
-	channelID string,
-	proposedUpgradeFields types.UpgradeFields,
-	counterpartyChannel types.Channel,
-	counterpartyUpgrade types.Upgrade,
-	proofCounterpartyChannel,
-	proofCounterpartyUpgrade []byte,
-	proofHeight clienttypes.Height,
-) error {
-	return k.startFlushUpgradeHandshake(ctx, portID, channelID, proposedUpgradeFields, counterpartyChannel, counterpartyUpgrade, proofCounterpartyChannel, proofCounterpartyUpgrade, proofHeight)
+// StartFlushing is a wrapper around startFlushing to allow the function to be directly called in tests.
+func (k Keeper) StartFlushing(ctx sdk.Context, portID, channelID string) error {
+	return k.startFlushing(ctx, portID, channelID)
 }
 
 // ValidateSelfUpgradeFields is a wrapper around validateSelfUpgradeFields to allow the function to be directly called in tests.

modules/core/04-channel/keeper/upgrade.go

@@ -170,15 +170,7 @@ func (k Keeper) ChanUpgradeTry(
 		return types.Upgrade{}, errorsmod.Wrap(err, "failed to verify counterparty upgrade")
 	}
 
-	if err := k.startFlushUpgradeHandshake(
-		ctx,
-		portID, channelID,
-		proposedUpgradeFields,
-		counterpartyChannel,
-		types.NewUpgrade(counterpartyUpgradeFields, types.Timeout{}, 0),
-		proofCounterpartyChannel, proofCounterpartyUpgrade,
-		proofHeight,
-	); err != nil {
+	if err := k.startFlushing(ctx, portID, channelID); err != nil {
 		return types.Upgrade{}, err
 	}
 
@@ -300,8 +292,7 @@ func (k Keeper) ChanUpgradeAck(
 		return types.NewUpgradeError(channel.UpgradeSequence, errorsmod.Wrap(err, "counterparty upgrade timeout has passed"))
 	}
 
-	if err := k.startFlushUpgradeHandshake(ctx, portID, channelID, upgrade.Fields, counterpartyChannel, counterpartyUpgrade,
-		proofChannel, proofUpgrade, proofHeight); err != nil {
+	if err := k.startFlushing(ctx, portID, channelID); err != nil {
 		return err
 	}
 
@@ -718,21 +709,9 @@ func (k Keeper) WriteUpgradeTimeoutChannel(
 	emitChannelUpgradeTimeoutEvent(ctx, portID, channelID, channel, upgrade)
 }
 
-// startFlushUpgradeHandshake will verify the counterparty proposed upgrade and the current channel state.
-// Once the counterparty information has been verified, it will be validated against the self proposed upgrade.
-// If any of the proposed upgrade fields are incompatible, an upgrade error will be returned resulting in an
-// aborted upgrade.
-func (k Keeper) startFlushUpgradeHandshake(
-	ctx sdk.Context,
-	portID,
-	channelID string,
-	proposedUpgradeFields types.UpgradeFields,
-	counterpartyChannel types.Channel,
-	counterpartyUpgrade types.Upgrade,
-	proofCounterpartyChannel,
-	proofCounterpartyUpgrade []byte,
-	proofHeight clienttypes.Height,
-) error {
+// startFlushing will set the upgrade last packet send and continue blocking the upgrade from continuing until all
+// in-flight packets have been flushed.
+func (k Keeper) startFlushing(ctx sdk.Context, portID, channelID string) error {
 	channel, found := k.GetChannel(ctx, portID, channelID)
 	if !found {
 		return errorsmod.Wrapf(types.ErrChannelNotFound, "port ID (%s) channel ID (%s)", portID, channelID)
@@ -747,9 +726,31 @@ func (k Keeper) startFlushUpgradeHandshake(
 		return errorsmod.Wrapf(connectiontypes.ErrInvalidConnectionState, "connection state is not OPEN (got %s)", connectiontypes.State(connection.GetState()).String())
 	}
 
+	channel.State = types.STATE_FLUSHING
+	k.SetChannel(ctx, portID, channelID, channel)
+
+	upgrade, found := k.GetUpgrade(ctx, portID, channelID)
+	if !found {
+		return errorsmod.Wrapf(types.ErrUpgradeNotFound, "port ID (%s) channel ID (%s)", portID, channelID)
+	}
+
+	nextSequenceSend, found := k.GetNextSequenceSend(ctx, portID, channelID)
+	if !found {
+		return errorsmod.Wrapf(types.ErrSequenceSendNotFound, "port ID (%s) channel ID (%s)", portID, channelID)
+	}
+
+	upgrade.LatestSequenceSend = nextSequenceSend - 1
+	upgrade.Timeout = getUpgradeTimeout()
+	k.SetUpgrade(ctx, portID, channelID, upgrade)
+
 	return nil
 }
 
+// TODO: use a hard coded value for now. Will be resolved in https://github.com/cosmos/ibc-go/issues/4313
+func getUpgradeTimeout() types.Timeout {
+	return types.NewTimeout(clienttypes.NewHeight(1, 1000), 0)
+}
+
 // syncUpgradeSequence ensures current upgrade handshake only continues if both channels are using the same upgrade sequence,
 // otherwise an upgrade error is returned so that an error receipt will be written so that the upgrade handshake may be attempted again with synchronized sequences.
 func (k Keeper) syncUpgradeSequence(ctx sdk.Context, portID, channelID string, channel types.Channel, counterpartyUpgradeSequence uint64) error {

modules/core/04-channel/keeper/upgrade_test.go

@@ -522,7 +522,7 @@ func (suite *KeeperTestSuite) TestChanUpgradeAck() {
 			commitmenttypes.ErrInvalidProof,
 		},
 		{
-			"startFlushUpgradeHandshake fails due to mismatch in upgrade ordering",
+			"fails due to mismatch in upgrade ordering",
 			func() {
 				upgrade := path.EndpointA.GetChannelUpgrade()
 				upgrade.Fields.Ordering = types.NONE
@@ -1376,16 +1376,8 @@ func (suite *KeeperTestSuite) TestWriteUpgradeCancelChannel() {
 // 	}
 // }
 
-// TestStartFlushUpgradeHandshake tests the startFlushUpgradeHandshake.
-// UpgradeInit will be run on chainA and startFlushUpgradeHandshake
-// will be called on chainB
-func (suite *KeeperTestSuite) TestStartFlushUpgradeHandshake() {
-	var (
-		path                *ibctesting.Path
-		upgrade             types.Upgrade
-		counterpartyChannel types.Channel
-		counterpartyUpgrade types.Upgrade
-	)
+func (suite *KeeperTestSuite) TestStartFlush() {
+	var path *ibctesting.Path
 
 	testCases := []struct {
 		name     string
@@ -1434,38 +1426,36 @@ func (suite *KeeperTestSuite) TestStartFlushUpgradeHandshake() {
 			suite.coordinator.Setup(path)
 
 			path.EndpointA.ChannelConfig.ProposedUpgrade.Fields.Version = mock.UpgradeVersion
+			path.EndpointB.ChannelConfig.ProposedUpgrade.Fields.Version = mock.UpgradeVersion
+
 			err := path.EndpointA.ChanUpgradeInit()
 			suite.Require().NoError(err)
 
-			// ensure proof verification succeeds
-			err = path.EndpointB.UpdateClient()
+			// crossing hellos so that the upgrade is created on chain B.
+			// the ChanUpgradeInit sub protocol is also called when it is not a crossing hello situation.
+			err = path.EndpointB.ChanUpgradeInit()
 			suite.Require().NoError(err)
 
-			proofChannel, proofUpgrade, proofHeight := path.EndpointB.QueryChannelUpgradeProof()
-			counterpartyChannel = path.EndpointA.GetChannel()
-
-			var found bool
-			counterpartyUpgrade, found = path.EndpointA.Chain.App.GetIBCKeeper().ChannelKeeper.GetUpgrade(path.EndpointA.Chain.GetContext(), path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID)
-			suite.Require().True(found)
-
-			// ensure that the channel has a valid upgrade sequence
-			channel := path.EndpointB.GetChannel()
-			channel.UpgradeSequence = 1
-			path.EndpointB.SetChannel(channel)
-
-			path.EndpointB.ChannelConfig.ProposedUpgrade.Fields.Version = mock.UpgradeVersion
-			upgrade = path.EndpointB.GetProposedUpgrade()
-
 			tc.malleate()
 
-			err = suite.chainB.GetSimApp().IBCKeeper.ChannelKeeper.StartFlushUpgradeHandshake(
-				suite.chainB.GetContext(), path.EndpointB.ChannelConfig.PortID, path.EndpointB.ChannelID, upgrade.Fields,
-				counterpartyChannel, counterpartyUpgrade, proofChannel, proofUpgrade, proofHeight,
+			err = suite.chainB.GetSimApp().IBCKeeper.ChannelKeeper.StartFlushing(
+				suite.chainB.GetContext(), path.EndpointB.ChannelConfig.PortID, path.EndpointB.ChannelID,
 			)
 
 			if tc.expError != nil {
 				suite.assertUpgradeError(err, tc.expError)
 			} else {
+				channel := path.EndpointB.GetChannel()
+				upgrade := path.EndpointB.GetChannelUpgrade()
+
+				nextSequenceSend, ok := suite.chainB.GetSimApp().IBCKeeper.ChannelKeeper.GetNextSequenceSend(suite.chainB.GetContext(), path.EndpointB.ChannelConfig.PortID, path.EndpointB.ChannelID)
+				suite.Require().True(ok)
+
+				suite.Require().Equal(types.STATE_FLUSHING, channel.State)
+				suite.Require().Equal(nextSequenceSend-1, upgrade.LatestSequenceSend)
+
+				// TODO: fix in https://github.com/cosmos/ibc-go/issues/4313
+				suite.Require().Equal(types.NewTimeout(clienttypes.NewHeight(1, 1000), 0), upgrade.Timeout)
 				suite.Require().NoError(err)
 			}
 		})