feat: adding base implementation with unit and integration tests

Author: n2p5

proto/interchain_security/ccv/consumer/v1/genesis.proto

@@ -54,6 +54,8 @@ message GenesisState {
   bool preCCV = 13;
   interchain_security.ccv.v1.ProviderInfo provider = 14
       [ (gogoproto.nullable) = false ];
+  // The ID of the connection end on the consumer chain on top of which the CCV channel will be established
+  string connection_id = 15;
 }
 
 // HeightValsetUpdateID represents a mapping internal to the consumer CCV module

proto/interchain_security/ccv/provider/v1/provider.proto

@@ -114,6 +114,15 @@ message ConsumerAdditionProposal {
   // Corresponds to a list of provider consensus addresses of validators that
   // CANNOT validate the consumer chain.
   repeated string denylist = 19;
+  // ICS1_DEVIATION: v6.4.0 structure adaptation
+  // Upstream v6.4.0 moved connection_id to ConsumerInitializationParameters message.
+  // Since we're based on v5.2.0 which uses ConsumerAdditionProposal for all init params,
+  // we add connection_id here to maintain the same functionality.
+  //
+  // The ID of the connection end on the provider chain on top of which the CCV channel will be established.
+  // If connection_id is empty, a new client will be created and a new connection on top of this client will be
+  // established for the consumer chain.
+  string connection_id = 20;
 }
 
 // ConsumerRemovalProposal is a governance proposal on the provider chain to

proto/interchain_security/ccv/provider/v1/tx.proto

@@ -191,6 +191,15 @@ message MsgConsumerAddition {
   repeated string denylist = 17;
   // signer address
   string authority = 18 [ (cosmos_proto.scalar) = "cosmos.AddressString" ];
+  // ICS1_DEVIATION: v6.4.0 structure adaptation
+  // Upstream v6.4.0 moved connection_id to ConsumerInitializationParameters message.
+  // Since we're based on v5.2.0 which uses MsgConsumerAddition for all init params,
+  // we add connection_id here to maintain the same functionality.
+  //
+  // The ID of the connection end on the provider chain on top of which the CCV channel will be established.
+  // If connection_id is empty, a new client will be created and a new connection on top of this client will be
+  // established for the consumer chain.
+  string connection_id = 19;
 }
 
 // MsgConsumerAdditionResponse defines response type for MsgConsumerAddition

proto/interchain_security/ccv/v1/shared_consumer.proto

@@ -85,6 +85,10 @@ message ConsumerGenesisState {
   ProviderInfo provider = 2 [ (gogoproto.nullable) = false ];
   // true for new chain, false for chain restart.
   bool new_chain = 3; // TODO:Check if this is really needed
+  // Flag indicating whether the consumer CCV module starts in pre-CCV state
+  bool preCCV = 4;
+  // The ID of the connection end on the consumer chain on top of which the CCV channel will be established
+  string connection_id = 5;
 }
 
 // ProviderInfo defines all information a consumer needs from a provider

tests/integration/changeover.go

@@ -3,6 +3,10 @@ package integration
 import (
 	transfertypes "github.com/cosmos/ibc-go/v10/modules/apps/transfer/types"
 	channeltypes "github.com/cosmos/ibc-go/v10/modules/core/04-channel/types"
+
+	consumertypes "github.com/cosmos/interchain-security/v5/x/ccv/consumer/types"
+	providertypes "github.com/cosmos/interchain-security/v5/x/ccv/provider/types"
+	ccv "github.com/cosmos/interchain-security/v5/x/ccv/types"
 )
 
 func (suite *CCVTestSuite) TestRecycleTransferChannel() {
@@ -53,3 +57,129 @@ func (suite *CCVTestSuite) TestRecycleTransferChannel() {
 	channels := suite.consumerApp.GetIBCKeeper().ChannelKeeper.GetAllChannels(suite.consumerCtx())
 	suite.Require().Len(channels, 2)
 }
+
+// TestChangeoverWithConnectionReuse tests the standalone-to-consumer changeover
+// when reusing an existing IBC connection (ICS1 feature).
+// This validates that a consumer chain can reuse an existing connection during changeover.
+func (suite *CCVTestSuite) TestChangeoverWithConnectionReuse() {
+	// Step 1: Create connection between consumer and provider (simulating existing connection)
+	suite.coordinator.CreateConnections(suite.path)
+
+	consumerKeeper := suite.consumerApp.GetConsumerKeeper()
+	providerKeeper := suite.providerApp.GetProviderKeeper()
+
+	// Get the connection IDs from the created connection
+	providerConnectionID := suite.path.EndpointA.ConnectionID
+	consumerConnectionID := suite.path.EndpointB.ConnectionID
+
+	suite.Require().NotEmpty(providerConnectionID, "provider connection ID should be set")
+	suite.Require().NotEmpty(consumerConnectionID, "consumer connection ID should be set")
+
+	// Commit blocks on provider chain to ensure historical info is saved
+	// MakeConsumerGenesis needs historical info at the current height
+	suite.coordinator.CommitBlock(suite.providerChain)
+
+	// Step 2: Create a consumer addition proposal with connection_id set
+	prop := providertypes.ConsumerAdditionProposal{
+		ChainId:                           suite.consumerChain.ChainID,
+		UnbondingPeriod:                   ccv.DefaultConsumerUnbondingPeriod,
+		CcvTimeoutPeriod:                  ccv.DefaultCCVTimeoutPeriod,
+		TransferTimeoutPeriod:             ccv.DefaultTransferTimeoutPeriod,
+		ConsumerRedistributionFraction:    "0.75",
+		BlocksPerDistributionTransmission: 1000,
+		HistoricalEntries:                 10000,
+		ConnectionId:                      providerConnectionID, // ICS1: Reuse existing connection
+	}
+
+	// Step 3: Generate consumer genesis with connection reuse
+	consumerGenesis, _, err := providerKeeper.MakeConsumerGenesis(suite.providerCtx(), &prop)
+	suite.Require().NoError(err, "MakeConsumerGenesis should succeed")
+
+	// Step 4: Verify the generated genesis has connection reuse fields set correctly
+	suite.Require().Equal(consumerConnectionID, consumerGenesis.ConnectionId,
+		"consumer genesis should have connection_id set to consumer-side connection")
+	suite.Require().True(consumerGenesis.PreCCV,
+		"consumer genesis should have preCCV=true for connection reuse")
+	suite.Require().Nil(consumerGenesis.Provider.ClientState,
+		"client_state should be nil when reusing connection")
+	suite.Require().Nil(consumerGenesis.Provider.ConsensusState,
+		"consensus_state should be nil when reusing connection")
+
+	// For integration testing purposes, override preCCV to false since our test consumer
+	// is not a real standalone chain with a standalone staking keeper.
+	// In a real changeover scenario, preCCV would be true and the consumer would have
+	// a standalone staking keeper. This test focuses on verifying the connection reuse
+	// mechanism (provider genesis generation and consumer initialization with existing client).
+	consumerGenesis.PreCCV = false
+
+	// Step 5: Get the existing client ID from the connection (before InitGenesis)
+	consumerConn, found := suite.consumerApp.GetIBCKeeper().ConnectionKeeper.GetConnection(
+		suite.consumerCtx(), consumerConnectionID,
+	)
+	suite.Require().True(found, "consumer connection should exist")
+	existingClientID := consumerConn.ClientId
+
+	// Step 6: Initialize consumer with the generated genesis (with connection reuse)
+	// Construct consumer GenesisState from the shared ConsumerGenesisState
+	consumerGenesisState := &consumertypes.GenesisState{
+		Params:       consumerGenesis.Params,
+		NewChain:     consumerGenesis.NewChain,
+		Provider:     consumerGenesis.Provider,
+		PreCCV:       consumerGenesis.PreCCV,
+		ConnectionId: consumerGenesis.ConnectionId,
+	}
+	consumerKeeper.InitGenesis(suite.consumerCtx(), consumerGenesisState)
+
+	// Step 7: Verify consumer initialized correctly using existing connection's client
+	providerClientID, found := consumerKeeper.GetProviderClientID(suite.consumerCtx())
+	suite.Require().True(found, "provider client ID should be set")
+	suite.Require().Equal(existingClientID, providerClientID,
+		"consumer should use existing client from connection")
+
+	// Step 8: Complete CCV channel handshake on top of existing connection
+	suite.ExecuteCCVChannelHandshake(suite.path)
+
+	// Step 9: Verify CCV channel was established on the existing connection
+	// Note: In a real scenario, the provider channel ID would be set when the first VSC packet
+	// is received. For this test, we verify the channel exists and manually set it since
+	// we're testing connection reuse, not the full packet relay flow.
+	channels := suite.consumerApp.GetIBCKeeper().ChannelKeeper.GetAllChannels(suite.consumerCtx())
+	var ccvChannelID string
+	for _, ch := range channels {
+		if ch.PortId == ccv.ConsumerPortID && ch.State == channeltypes.OPEN {
+			ccvChannelID = ch.ChannelId
+			break
+		}
+	}
+	suite.Require().NotEmpty(ccvChannelID, "CCV channel should exist")
+
+	// Set the provider channel manually for testing purposes
+	consumerKeeper.SetProviderChannel(suite.consumerCtx(), ccvChannelID)
+
+	// Verify we can now get the provider channel
+	retrievedChannelID, found := consumerKeeper.GetProviderChannel(suite.consumerCtx())
+	suite.Require().True(found, "provider channel should be set")
+	suite.Require().Equal(ccvChannelID, retrievedChannelID, "provider channel ID should match")
+
+	ccvChannel, found := suite.consumerApp.GetIBCKeeper().ChannelKeeper.GetChannel(
+		suite.consumerCtx(), ccv.ConsumerPortID, ccvChannelID,
+	)
+	suite.Require().True(found, "CCV channel should exist")
+	suite.Require().Equal(consumerConnectionID, ccvChannel.ConnectionHops[0],
+		"CCV channel should be on the existing connection")
+
+	// Step 10: Verify the connection is shared between CCV and any other channels
+	allChannels := suite.consumerApp.GetIBCKeeper().ChannelKeeper.GetAllChannels(suite.consumerCtx())
+
+	// Count how many channels use the existing connection
+	channelsOnConnection := 0
+	for _, ch := range allChannels {
+		if len(ch.ConnectionHops) > 0 && ch.ConnectionHops[0] == consumerConnectionID {
+			channelsOnConnection++
+		}
+	}
+
+	// At minimum, the CCV channel should be on the existing connection
+	suite.Require().GreaterOrEqual(channelsOnConnection, 1,
+		"at least CCV channel should use the existing connection")
+}

x/ccv/consumer/keeper/genesis.go

@@ -45,14 +45,29 @@ func (k Keeper) InitGenesis(ctx sdk.Context, state *types.GenesisState) []abci.V
 	// initialValSet is checked in NewChain case by ValidateGenesis
 	// start a new chain
 	if state.NewChain {
-		// create the provider client in InitGenesis for new consumer chain. CCV Handshake must be established with this client id.
-		// IBC v10: CreateClient now requires clientType string and marshaled states
-		clientStateBz := k.cdc.MustMarshal(state.Provider.ClientState)
-		consensusStateBz := k.cdc.MustMarshal(state.Provider.ConsensusState)
-		clientID, err := k.clientKeeper.CreateClient(ctx, ibcexported.Tendermint, clientStateBz, consensusStateBz)
-		if err != nil {
-			// If the client creation fails, the chain MUST NOT start
-			panic(err)
+		// ICS1_DEVIATION: Connection reuse logic
+		// Upstream v6.4.0 has this logic but in a different code structure.
+		// When connection_id is set, we reuse the existing client instead of creating a new one.
+
+		var clientID string
+		if state.ConnectionId != "" {
+			// Reuse existing client from the connection
+			connection, found := k.connectionKeeper.GetConnection(ctx, state.ConnectionId)
+			if !found {
+				panic("connection " + state.ConnectionId + " not found during consumer genesis initialization")
+			}
+			clientID = connection.ClientId
+		} else {
+			// create the provider client in InitGenesis for new consumer chain. CCV Handshake must be established with this client id.
+			// IBC v10: CreateClient now requires clientType string and marshaled states
+			clientStateBz := k.cdc.MustMarshal(state.Provider.ClientState)
+			consensusStateBz := k.cdc.MustMarshal(state.Provider.ConsensusState)
+			var err error
+			clientID, err = k.clientKeeper.CreateClient(ctx, ibcexported.Tendermint, clientStateBz, consensusStateBz)
+			if err != nil {
+				// If the client creation fails, the chain MUST NOT start
+				panic(err)
+			}
 		}
 
 		// set provider client id.

x/ccv/consumer/keeper/genesis_test.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	clienttypes "github.com/cosmos/ibc-go/v10/modules/core/02-client/types"
+	conntypes "github.com/cosmos/ibc-go/v10/modules/core/03-connection/types"
 	commitmenttypes "github.com/cosmos/ibc-go/v10/modules/core/23-commitment/types"
 	ibctmtypes "github.com/cosmos/ibc-go/v10/modules/light-clients/07-tendermint"
 	"github.com/golang/mock/gomock"
@@ -205,6 +206,47 @@ func TestInitGenesis(t *testing.T) {
 				require.Equal(t, gs.Params, ck.GetConsumerParams(ctx))
 			},
 		},
+		{
+			"start a new chain with connection reuse",
+			func(ctx sdk.Context, mocks testkeeper.MockedKeepers) {
+				// ICS1_DEVIATION: Test connection reuse path
+				// Mock the connection keeper to return an existing connection
+				connectionID := "connection-0"
+				clientID := "07-tendermint-existing"
+				gomock.InOrder(
+					mocks.MockConnectionKeeper.EXPECT().GetConnection(ctx, connectionID).Return(
+						conntypes.ConnectionEnd{
+							ClientId: clientID,
+						},
+						true, // connection found
+					).Times(1),
+				)
+			},
+			func() *consumertypes.GenesisState {
+				// Create genesis with connection_id set for reuse
+				gs := consumertypes.NewInitialGenesisState(
+					provClientState,
+					provConsState,
+					valset,
+					params,
+				)
+				gs.ConnectionId = "connection-0" // Set connection_id for reuse
+				return gs
+			}(),
+			func(ctx sdk.Context, ck consumerkeeper.Keeper, gs *consumertypes.GenesisState) {
+				assertConsumerPortIsBound(t, ctx, &ck)
+
+				// Verify the provider client ID was set from the existing connection
+				providerClientID, ok := ck.GetProviderClientID(ctx)
+				require.True(t, ok, "provider client ID should be set")
+				require.Equal(t, "07-tendermint-existing", providerClientID, "should use existing client from connection")
+
+				assertHeightValsetUpdateIDs(t, ctx, &ck, defaultHeightValsetUpdateIDs)
+
+				require.Equal(t, validator.Address.Bytes(), ck.GetAllCCValidator(ctx)[0].Address)
+				require.Equal(t, gs.Params, ck.GetConsumerParams(ctx))
+			},
+		},
 	}
 
 	for _, tc := range testCases {