Implement Channel Upgrade Try functionality for 04 channel

internal/collections/collections.go

@@ -0,0 +1,11 @@
+package collections
+
+// Contains is a generic function which returns true if elem T exists within the list of elements []T.
+func Contains[T comparable](elem T, elements []T) bool {
+	for _, e := range elements {
+		if elem == e {
+			return true
+		}
+	}
+	return false
+}

modules/core/03-connection/keeper/verify.go

@@ -364,6 +364,44 @@ func (k Keeper) VerifyNextSequenceRecv(
 	return nil
 }
 
+// VerifyChannelUpgradeSequence verifies a proof of the upgrade sequence number to be
+// used during channel upgrades.
+func (k Keeper) VerifyChannelUpgradeSequence(
+	ctx sdk.Context,
+	connection exported.ConnectionI,
+	height exported.Height,
+	proof []byte,
+	portID,
+	channelID string,
+	upgradeSequence uint64,
+) error {
+	clientID := connection.GetClientID()
+	clientState, clientStore, err := k.getClientStateAndVerificationStore(ctx, clientID)
+	if err != nil {
+		return err
+	}
+
+	if status := k.clientKeeper.GetClientStatus(ctx, clientState, clientID); status != exported.Active {
+		return errorsmod.Wrapf(clienttypes.ErrClientNotActive, "client (%s) status is %s", clientID, status)
+	}
+
+	merklePath := commitmenttypes.NewMerklePath(host.ChannelUpgradeSequencePath(portID, channelID))
+	merklePath, err = commitmenttypes.ApplyPrefix(connection.GetCounterparty().GetPrefix(), merklePath)
+	if err != nil {
+		return err
+	}
+
+	if err := clientState.VerifyMembership(
+		ctx, clientStore, k.cdc, height,
+		0, 0, // skip delay period checks for non-packet processing verification
+		proof, merklePath, sdk.Uint64ToBigEndian(upgradeSequence),
+	); err != nil {
+		return errorsmod.Wrapf(err, "failed upgrade sequence verification for client (%s)", clientID)
+	}
+
+	return nil
+}
+
 // getBlockDelay calculates the block delay period from the time delay of the connection
 // and the maximum expected time per block.
 func (k Keeper) getBlockDelay(ctx sdk.Context, connection exported.ConnectionI) uint64 {

modules/core/03-connection/keeper/verify_test.go

@@ -682,6 +682,89 @@ func (suite *KeeperTestSuite) TestVerifyNextSequenceRecv() {
 	}
 }
 
+func (suite *KeeperTestSuite) TestVerifyUpgradeSequence() {
+	var (
+		path                    *ibctesting.Path
+		expectedUpgradeSequence uint64
+	)
+
+	cases := []struct {
+		name     string
+		malleate func()
+		expPass  bool
+	}{
+		{
+			name:     "success",
+			malleate: func() {},
+			expPass:  true,
+		},
+		{
+			name: "fails with different upgrade sequence",
+			malleate: func() {
+				expectedUpgradeSequence = 10
+			},
+			expPass: false,
+		},
+		{
+			name: "fails when client state is frozen",
+			malleate: func() {
+				clientState := path.EndpointB.GetClientState().(*ibctm.ClientState)
+				clientState.FrozenHeight = clienttypes.NewHeight(0, 1)
+				path.EndpointB.SetClientState(clientState)
+			},
+			expPass: false,
+		},
+		{
+			name: "fails with bad client id",
+			malleate: func() {
+				connection := path.EndpointB.GetConnection()
+				connection.ClientId = ibctesting.InvalidID
+				path.EndpointB.SetConnection(connection)
+			},
+			expPass: false,
+		},
+		{
+			name: "verification fails when the key does not exist",
+			malleate: func() {
+				storeKey := path.EndpointA.Chain.GetSimApp().GetKey(exported.StoreKey)
+				kvStore := path.EndpointA.Chain.GetContext().KVStore(storeKey)
+				kvStore.Delete(host.ChannelUpgradeSequenceKey(path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID))
+				suite.coordinator.CommitBlock(suite.chainA)
+			},
+			expPass: false,
+		},
+	}
+
+	for _, tc := range cases {
+		tc := tc
+
+		suite.Run(tc.name, func() {
+			suite.SetupTest() // reset
+
+			expectedUpgradeSequence = 1
+
+			path = ibctesting.NewPath(suite.chainA, suite.chainB)
+			suite.coordinator.Setup(path)
+
+			err := path.EndpointA.ChanUpgradeInit(path.EndpointB.Chain.GetTimeoutHeight(), 0)
+			suite.Require().NoError(err)
+
+			tc.malleate()
+
+			upgradeSequenceKey := host.ChannelUpgradeSequenceKey(path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID)
+			proof, proofHeight := suite.chainA.QueryProof(upgradeSequenceKey)
+
+			err = suite.chainB.GetSimApp().IBCKeeper.ConnectionKeeper.VerifyChannelUpgradeSequence(suite.chainB.GetContext(), path.EndpointB.GetConnection(), malleateHeight(proofHeight, 0), proof, path.EndpointB.ChannelConfig.PortID, path.EndpointB.ChannelID, expectedUpgradeSequence)
+
+			if tc.expPass {
+				suite.Require().NoError(err)
+			} else {
+				suite.Require().Error(err)
+			}
+		})
+	}
+}
+
 func malleateHeight(height exported.Height, diff uint64) exported.Height {
 	return clienttypes.NewHeight(height.GetRevisionNumber(), height.GetRevisionHeight()+diff)
 }

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

@@ -271,3 +271,23 @@ func emitChannelClosedEvent(ctx sdk.Context, packet exported.PacketI, channel ty
 		),
 	})
 }
+
+// emitChannelUpgradeInitEvent emits a channel upgrade init event
+func emitChannelUpgradeInitEvent(ctx sdk.Context, portID string, channelID string, upgradeSequence uint64, channel types.Channel) {
+	ctx.EventManager().EmitEvents(sdk.Events{
+		sdk.NewEvent(
+			types.EventTypeChannelUpgradeInit,
+			sdk.NewAttribute(types.AttributeKeyPortID, portID),
+			sdk.NewAttribute(types.AttributeKeyChannelID, channelID),
+			sdk.NewAttribute(types.AttributeCounterpartyPortID, channel.Counterparty.PortId),
+			sdk.NewAttribute(types.AttributeCounterpartyChannelID, channel.Counterparty.ChannelId),
+			sdk.NewAttribute(types.AttributeKeyConnectionID, channel.ConnectionHops[0]),
+			sdk.NewAttribute(types.AttributeVersion, channel.Version),
+			sdk.NewAttribute(types.AttributeKeyUpgradeSequence, fmt.Sprintf("%d", upgradeSequence)),
+		),
+		sdk.NewEvent(
+			sdk.EventTypeMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory),
+		),
+	})
+}

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

@@ -478,6 +478,66 @@ func (k Keeper) LookupModuleByChannel(ctx sdk.Context, portID, channelID string)
 	return porttypes.GetModuleOwner(modules), capability, nil
 }
 
+// GetUpgradeRestoreChannel returns the upgrade restore channel for the provided port and channel identifiers.
+func (k Keeper) GetUpgradeRestoreChannel(ctx sdk.Context, portID, channelID string) (types.Channel, bool) {
+	store := ctx.KVStore(k.storeKey)
+	bz := store.Get(host.ChannelRestoreKey(portID, channelID))
+	if bz == nil {
+		return types.Channel{}, false
+	}
+
+	var channel types.Channel
+	k.cdc.MustUnmarshal(bz, &channel)
+
+	return channel, true
+}
+
+// SetUpgradeRestoreChannel sets the provided channel in store using the port and channel identifiers.
+func (k Keeper) SetUpgradeRestoreChannel(ctx sdk.Context, portID, channelID string, channel types.Channel) {
+	store := ctx.KVStore(k.storeKey)
+	bz := k.cdc.MustMarshal(&channel)
+	store.Set(host.ChannelRestoreKey(portID, channelID), bz)
+}
+
+// GetUpgradeSequence returns the upgrade sequence for the provided port and channel identifers.
+func (k Keeper) GetUpgradeSequence(ctx sdk.Context, portID, channelID string) (uint64, bool) {
+	store := ctx.KVStore(k.storeKey)
+	bz := store.Get(host.ChannelUpgradeSequenceKey(portID, channelID))
+	if bz == nil {
+		return 0, false
+	}
+
+	return sdk.BigEndianToUint64(bz), true
+}
+
+// SetUpgradeSequence sets the upgrade sequence using the provided port and channel identifiers.
+func (k Keeper) SetUpgradeSequence(ctx sdk.Context, portID, channelID string, sequence uint64) {
+	store := ctx.KVStore(k.storeKey)
+	bz := sdk.Uint64ToBigEndian(sequence)
+	store.Set(host.ChannelUpgradeSequenceKey(portID, channelID), bz)
+}
+
+// GetUpgradeTimeout returns the upgrade timeout stored in state for the provided port and channel identifiers.
+func (k Keeper) GetUpgradeTimeout(ctx sdk.Context, portID, channelID string) (types.UpgradeTimeout, bool) {
+	store := ctx.KVStore(k.storeKey)
+	bz := store.Get(host.ChannelUpgradeTimeoutKey(portID, channelID))
+	if bz == nil {
+		return types.UpgradeTimeout{}, false
+	}
+
+	var upgradeTimeout types.UpgradeTimeout
+	k.cdc.MustUnmarshal(bz, &upgradeTimeout)
+
+	return upgradeTimeout, true
+}
+
+// SetUpgradeTimeout sets the upgrade timeout in store using the provided port and channel identifiers.
+func (k Keeper) SetUpgradeTimeout(ctx sdk.Context, portID, channelID string, upgradeTimeout types.UpgradeTimeout) {
+	store := ctx.KVStore(k.storeKey)
+	bz := k.cdc.MustMarshal(&upgradeTimeout)
+	store.Set(host.ChannelUpgradeTimeoutKey(portID, channelID), bz)
+}
+
 // common functionality for IteratePacketCommitment and IteratePacketAcknowledgement
 func (k Keeper) iterateHashes(ctx sdk.Context, iterator db.Iterator, cb func(portID, channelID string, sequence uint64, hash []byte) bool) {
 	defer sdk.LogDeferred(ctx.Logger(), func() error { return iterator.Close() })

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

@@ -7,6 +7,7 @@ import (
 	"github.com/stretchr/testify/suite"
 
 	transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types"
+	clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types"
 	"github.com/cosmos/ibc-go/v7/modules/core/04-channel/types"
 	ibctesting "github.com/cosmos/ibc-go/v7/testing"
 	ibcmock "github.com/cosmos/ibc-go/v7/testing/mock"
@@ -465,3 +466,54 @@ func (suite *KeeperTestSuite) TestSetPacketAcknowledgement() {
 	suite.Require().Equal(ackHash, storedAckHash)
 	suite.Require().True(suite.chainA.App.GetIBCKeeper().ChannelKeeper.HasPacketAcknowledgement(ctxA, path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID, seq))
 }
+
+func (suite *KeeperTestSuite) TestSetRestoreChannel() {
+	path := ibctesting.NewPath(suite.chainA, suite.chainB)
+	suite.coordinator.SetupConnections(path)
+	suite.coordinator.CreateChannels(path)
+
+	restoreChannel, found := suite.chainA.App.GetIBCKeeper().ChannelKeeper.GetUpgradeRestoreChannel(suite.chainA.GetContext(), path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID)
+	suite.Require().False(found)
+	suite.Require().Empty(restoreChannel)
+
+	expChannel := types.NewChannel(types.OPEN, types.UNORDERED, types.NewCounterparty(ibcmock.PortID, ibctesting.FirstChannelID), []string{ibctesting.FirstConnectionID}, ibcmock.Version)
+	suite.chainA.App.GetIBCKeeper().ChannelKeeper.SetUpgradeRestoreChannel(suite.chainA.GetContext(), path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID, expChannel)
+
+	restoreChannel, found = suite.chainA.App.GetIBCKeeper().ChannelKeeper.GetUpgradeRestoreChannel(suite.chainA.GetContext(), path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID)
+	suite.Require().True(found)
+	suite.Require().Equal(expChannel, restoreChannel)
+}
+
+func (suite *KeeperTestSuite) TestSetUpgradeSequence() {
+	path := ibctesting.NewPath(suite.chainA, suite.chainB)
+	suite.coordinator.SetupConnections(path)
+	suite.coordinator.CreateChannels(path)
+
+	sequence, found := suite.chainA.App.GetIBCKeeper().ChannelKeeper.GetUpgradeSequence(suite.chainA.GetContext(), path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID)
+	suite.Require().False(found)
+	suite.Require().Zero(sequence)
+
+	expSequence := uint64(1)
+	suite.chainA.App.GetIBCKeeper().ChannelKeeper.SetUpgradeSequence(suite.chainA.GetContext(), path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID, expSequence)
+
+	sequence, found = suite.chainA.App.GetIBCKeeper().ChannelKeeper.GetUpgradeSequence(suite.chainA.GetContext(), path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID)
+	suite.Require().True(found)
+	suite.Require().Equal(expSequence, sequence)
+}
+
+func (suite *KeeperTestSuite) TestSetUpgradeTimeout() {
+	path := ibctesting.NewPath(suite.chainA, suite.chainB)
+	suite.coordinator.SetupConnections(path)
+	suite.coordinator.CreateChannels(path)
+
+	upgradeTimeout, found := suite.chainA.App.GetIBCKeeper().ChannelKeeper.GetUpgradeTimeout(suite.chainA.GetContext(), path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID)
+	suite.Require().False(found)
+	suite.Require().Empty(upgradeTimeout)
+
+	expUpgradeTimeout := types.UpgradeTimeout{TimeoutHeight: clienttypes.NewHeight(1, 10), TimeoutTimestamp: uint64(suite.coordinator.CurrentTime.UnixNano())}
+	suite.chainA.App.GetIBCKeeper().ChannelKeeper.SetUpgradeTimeout(suite.chainA.GetContext(), path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID, expUpgradeTimeout)
+
+	upgradeTimeout, found = suite.chainA.App.GetIBCKeeper().ChannelKeeper.GetUpgradeTimeout(suite.chainA.GetContext(), path.EndpointA.ChannelConfig.PortID, path.EndpointA.ChannelID)
+	suite.Require().True(found)
+	suite.Require().Equal(expUpgradeTimeout, upgradeTimeout)
+}