diff --git a/app/consumer-democracy/app.go b/app/consumer-democracy/app.go
index 1a35a89a8a..09b13520ae 100644
--- a/app/consumer-democracy/app.go
+++ b/app/consumer-democracy/app.go
@@ -713,7 +713,7 @@ func New(
 				return fromVM, fmt.Errorf("failed to unmarshal genesis state: %w", err)
 			}
 
-			consumerGenesis := ccvtypes.GenesisState{}
+			consumerGenesis := ccvtypes.ConsumerGenesisState{}
 			appCodec.MustUnmarshalJSON(appState[consumertypes.ModuleName], &consumerGenesis)
 
 			consumerGenesis.PreCCV = true
diff --git a/proto/interchain_security/ccv/consumer/v1/query.proto b/proto/interchain_security/ccv/consumer/v1/query.proto
index ff2a5901fe..b21e07341a 100644
--- a/proto/interchain_security/ccv/consumer/v1/query.proto
+++ b/proto/interchain_security/ccv/consumer/v1/query.proto
@@ -55,7 +55,7 @@ message QueryParamsRequest {}
 // QueryParamsResponse is response type for the Query/Params RPC method.
 message QueryParamsResponse {
   // params holds all the parameters of this module.
-  interchain_security.ccv.v1.Params params = 1 [ (gogoproto.nullable) = false ];
+  interchain_security.ccv.v1.ConsumerParams params = 1 [ (gogoproto.nullable) = false ];
 }
 
 message QueryProviderInfoRequest {}
diff --git a/proto/interchain_security/ccv/provider/v1/genesis.proto b/proto/interchain_security/ccv/provider/v1/genesis.proto
index 22da5c4200..9cefe26ee0 100644
--- a/proto/interchain_security/ccv/provider/v1/genesis.proto
+++ b/proto/interchain_security/ccv/provider/v1/genesis.proto
@@ -64,7 +64,7 @@ message ConsumerState {
   // InitalHeight defines the initial block height for the consumer chain
   uint64 initial_height = 4;
   // ConsumerGenesis defines the initial consumer chain genesis states
-  interchain_security.ccv.v1.GenesisState consumer_genesis = 5
+  interchain_security.ccv.v1.ConsumerGenesisState consumer_genesis = 5
       [ (gogoproto.nullable) = false ];
   // PendingValsetChanges defines the pending validator set changes for the
   // consumer chain
diff --git a/proto/interchain_security/ccv/provider/v1/query.proto b/proto/interchain_security/ccv/provider/v1/query.proto
index b0c1dc2b47..6dfcdcb320 100644
--- a/proto/interchain_security/ccv/provider/v1/query.proto
+++ b/proto/interchain_security/ccv/provider/v1/query.proto
@@ -86,7 +86,7 @@ service Query {
 message QueryConsumerGenesisRequest { string chain_id = 1; }
 
 message QueryConsumerGenesisResponse {
-  interchain_security.ccv.v1.GenesisState genesis_state = 1
+  interchain_security.ccv.v1.ConsumerGenesisState genesis_state = 1
       [ (gogoproto.nullable) = false ];
 }
 
diff --git a/proto/interchain_security/ccv/v1/shared_consumer.proto b/proto/interchain_security/ccv/v1/shared_consumer.proto
index 825a84e346..4a44548ea3 100644
--- a/proto/interchain_security/ccv/v1/shared_consumer.proto
+++ b/proto/interchain_security/ccv/v1/shared_consumer.proto
@@ -17,13 +17,12 @@ import "google/protobuf/timestamp.proto";
 // but not sent over the wire. These schemas could change, only with careful consideration of effects!
 //
 
-// Params defines the parameters for CCV consumer module.
+// ConsumerParams defines the parameters for CCV consumer module.
 // 
 // Note this type is referenced in both the consumer and provider CCV modules,
 // and persisted on the provider, see MakeConsumerGenesis and SetConsumerGenesis. 
 //
-// TODO: Rename to ConsumerParams. See https://github.com/cosmos/interchain-security/issues/1206
-message Params {
+message ConsumerParams {
     // TODO: Remove enabled flag and find a better way to setup integration tests
     // See: https://github.com/cosmos/interchain-security/issues/339
     bool enabled = 1;
@@ -79,19 +78,17 @@ message Params {
     repeated string provider_reward_denoms = 12;
 }
 
-// GenesisState defines the CCV consumer chain genesis state.
+// ConsumerGenesisState defines the CCV consumer chain genesis state.
 // 
 // Note this type is referenced in both the consumer and provider CCV modules,
 // and persisted on the provider, see MakeConsumerGenesis and SetConsumerGenesis.
-// 
-// TODO: Rename to ConsumerGenesisState. See https://github.com/cosmos/interchain-security/issues/1206
-message GenesisState {
-    Params params = 1 [ (gogoproto.nullable) = false ];
+message ConsumerGenesisState {
+    ConsumerParams params = 1 [ (gogoproto.nullable) = false ];
     string provider_client_id = 2; // empty for a new chain, filled in on restart.
     string provider_channel_id =
         3; // empty for a new chain, filled in on restart.
     bool new_chain =
-        4; // true for new chain GenesisState, false for chain restart.
+        4; // true for new chain, false for chain restart.
     // ProviderClientState filled in on new chain, nil on restart.
     ibc.lightclients.tendermint.v1.ClientState provider_client_state = 5;
     // ProviderConsensusState filled in on new chain, nil on restart.
diff --git a/tests/difference/core/driver/setup.go b/tests/difference/core/driver/setup.go
index 2a4b17eddf..c1d1c272ff 100644
--- a/tests/difference/core/driver/setup.go
+++ b/tests/difference/core/driver/setup.go
@@ -207,7 +207,7 @@ func (b *Builder) getAppBytesAndSenders(
 
 	bondDenom := sdk.DefaultBondDenom
 	genesisStaking := stakingtypes.GenesisState{}
-	genesisConsumer := ccv.GenesisState{}
+	genesisConsumer := ccv.ConsumerGenesisState{}
 
 	if genesis[stakingtypes.ModuleName] != nil {
 		// If staking module genesis already exists
@@ -522,7 +522,7 @@ func (b *Builder) createConsumersLocalClientGenesis() *ibctmtypes.ClientState {
 	)
 }
 
-func (b *Builder) createConsumerGenesis(client *ibctmtypes.ClientState) *ccv.GenesisState {
+func (b *Builder) createConsumerGenesis(client *ibctmtypes.ClientState) *ccv.ConsumerGenesisState {
 	providerConsState := b.provider().LastHeader.ConsensusState()
 
 	valUpdates := tmtypes.TM2PB.ValidatorUpdates(b.provider().Vals)
@@ -540,7 +540,7 @@ func (b *Builder) createConsumerGenesis(client *ibctmtypes.ClientState) *ccv.Gen
 		[]string{},
 		[]string{},
 	)
-	return ccv.NewInitialGenesisState(client, providerConsState, valUpdates, params)
+	return ccv.NewInitialConsumerGenesisState(client, providerConsState, valUpdates, params)
 }
 
 // The state of the data returned is equivalent to the state of two chains
diff --git a/tests/integration/setup.go b/tests/integration/setup.go
index 76f6311dab..8db75519c0 100644
--- a/tests/integration/setup.go
+++ b/tests/integration/setup.go
@@ -182,7 +182,7 @@ func (s *CCVTestSuite) getSentPacket(chain *ibctesting.TestChain, sequence uint6
 func initConsumerChain(
 	s *CCVTestSuite,
 	chainID string,
-	genesisState *ccv.GenesisState,
+	genesisState *ccv.ConsumerGenesisState,
 ) {
 	providerKeeper := s.providerApp.GetProviderKeeper()
 	bundle := s.consumerBundles[chainID]
diff --git a/testutil/ibc_testing/specific_setup.go b/testutil/ibc_testing/specific_setup.go
index 8ac559d740..1c5529e22a 100644
--- a/testutil/ibc_testing/specific_setup.go
+++ b/testutil/ibc_testing/specific_setup.go
@@ -51,7 +51,7 @@ func ConsumerAppIniter(initValPowers []types.ValidatorUpdate) AppIniter {
 			},
 		)
 		// Feed consumer genesis with provider validators
-		var consumerGenesis ccvtypes.GenesisState
+		var consumerGenesis ccvtypes.ConsumerGenesisState
 		encoding.Codec.MustUnmarshalJSON(genesisState[consumertypes.ModuleName], &consumerGenesis)
 		consumerGenesis.InitialValSet = initValPowers
 		consumerGenesis.Params.Enabled = true
@@ -69,7 +69,7 @@ func DemocracyConsumerAppIniter(initValPowers []types.ValidatorUpdate) AppIniter
 		genesisState := appConsumerDemocracy.NewDefaultGenesisState(encoding.Codec)
 		// Feed consumer genesis with provider validators
 		// TODO See if useful for democracy
-		var consumerGenesis ccvtypes.GenesisState
+		var consumerGenesis ccvtypes.ConsumerGenesisState
 		encoding.Codec.MustUnmarshalJSON(genesisState[consumertypes.ModuleName], &consumerGenesis)
 		consumerGenesis.InitialValSet = initValPowers
 		consumerGenesis.Params.Enabled = true
diff --git a/x/ccv/consumer/keeper/genesis.go b/x/ccv/consumer/keeper/genesis.go
index 2ac38f650c..f20d8849dc 100644
--- a/x/ccv/consumer/keeper/genesis.go
+++ b/x/ccv/consumer/keeper/genesis.go
@@ -16,7 +16,7 @@ import (
 //  1. A client to the provider was never created, i.e. a new consumer chain is started for the first time.
 //  2. A consumer chain restarts after a client to the provider was created, but the CCV channel handshake is still in progress
 //  3. A consumer chain restarts after the CCV channel handshake was completed.
-func (k Keeper) InitGenesis(ctx sdk.Context, state *ccv.GenesisState) []abci.ValidatorUpdate {
+func (k Keeper) InitGenesis(ctx sdk.Context, state *ccv.ConsumerGenesisState) []abci.ValidatorUpdate {
 	// PreCCV is true during the process of a standalone to consumer changeover.
 	// At the PreCCV point in the process, the standalone chain has just been upgraded to include
 	// the consumer ccv module, but the standalone staking keeper is still managing the validator set.
@@ -115,10 +115,10 @@ func (k Keeper) InitGenesis(ctx sdk.Context, state *ccv.GenesisState) []abci.Val
 }
 
 // ExportGenesis returns the CCV consumer module's exported genesis
-func (k Keeper) ExportGenesis(ctx sdk.Context) (genesis *ccv.GenesisState) {
+func (k Keeper) ExportGenesis(ctx sdk.Context) (genesis *ccv.ConsumerGenesisState) {
 	params := k.GetConsumerParams(ctx)
 	if !params.Enabled {
-		return ccv.DefaultGenesisState()
+		return ccv.DefaultConsumerGenesisState()
 	}
 
 	// export the current validator set
@@ -137,7 +137,7 @@ func (k Keeper) ExportGenesis(ctx sdk.Context) (genesis *ccv.GenesisState) {
 			panic("provider client does not exist although provider channel does exist")
 		}
 
-		genesis = ccv.NewRestartGenesisState(
+		genesis = ccv.NewRestartConsumerGenesisState(
 			clientID,
 			channelID,
 			k.GetAllPacketMaturityTimes(ctx),
@@ -153,11 +153,11 @@ func (k Keeper) ExportGenesis(ctx sdk.Context) (genesis *ccv.GenesisState) {
 		// if provider clientID and channelID don't exist on the consumer chain,
 		// then CCV protocol is disabled for this chain return a default genesis state
 		if !ok {
-			return ccv.DefaultGenesisState()
+			return ccv.DefaultConsumerGenesisState()
 		}
 
 		// export client states and pending slashing requests into a new chain genesis
-		genesis = ccv.NewRestartGenesisState(
+		genesis = ccv.NewRestartConsumerGenesisState(
 			clientID,
 			"",
 			nil,
diff --git a/x/ccv/consumer/keeper/genesis_test.go b/x/ccv/consumer/keeper/genesis_test.go
index 9cb489b3c0..a07388a6cb 100644
--- a/x/ccv/consumer/keeper/genesis_test.go
+++ b/x/ccv/consumer/keeper/genesis_test.go
@@ -100,8 +100,8 @@ func TestInitGenesis(t *testing.T) {
 	testCases := []struct {
 		name         string
 		malleate     func(sdk.Context, testkeeper.MockedKeepers)
-		genesis      *ccv.GenesisState
-		assertStates func(sdk.Context, consumerkeeper.Keeper, *ccv.GenesisState)
+		genesis      *ccv.ConsumerGenesisState
+		assertStates func(sdk.Context, consumerkeeper.Keeper, *ccv.ConsumerGenesisState)
 	}{
 		{
 			"start a new chain",
@@ -112,13 +112,13 @@ func TestInitGenesis(t *testing.T) {
 					testkeeper.ExpectGetCapabilityMock(ctx, mocks, 1),
 				)
 			},
-			ccv.NewInitialGenesisState(
+			ccv.NewInitialConsumerGenesisState(
 				provClientState,
 				provConsState,
 				valset,
 				params,
 			),
-			func(ctx sdk.Context, ck consumerkeeper.Keeper, gs *ccv.GenesisState) {
+			func(ctx sdk.Context, ck consumerkeeper.Keeper, gs *ccv.ConsumerGenesisState) {
 				assertConsumerPortIsBound(t, ctx, &ck)
 
 				assertProviderClientID(t, ctx, &ck, provClientID)
@@ -134,7 +134,7 @@ func TestInitGenesis(t *testing.T) {
 					testkeeper.ExpectGetCapabilityMock(ctx, mocks, 2),
 				)
 			},
-			ccv.NewRestartGenesisState(
+			ccv.NewRestartConsumerGenesisState(
 				provClientID,
 				"",
 				matPackets,
@@ -145,7 +145,7 @@ func TestInitGenesis(t *testing.T) {
 				ccv.LastTransmissionBlockHeight{},
 				params,
 			),
-			func(ctx sdk.Context, ck consumerkeeper.Keeper, gs *ccv.GenesisState) {
+			func(ctx sdk.Context, ck consumerkeeper.Keeper, gs *ccv.ConsumerGenesisState) {
 				assertConsumerPortIsBound(t, ctx, &ck)
 
 				obtainedPendingPackets := ck.GetPendingPackets(ctx)
@@ -170,7 +170,7 @@ func TestInitGenesis(t *testing.T) {
 				)
 			},
 			// create a genesis for a restarted chain
-			ccv.NewRestartGenesisState(
+			ccv.NewRestartConsumerGenesisState(
 				provClientID,
 				provChannelID,
 				matPackets,
@@ -183,7 +183,7 @@ func TestInitGenesis(t *testing.T) {
 				ccv.LastTransmissionBlockHeight{Height: int64(100)},
 				params,
 			),
-			func(ctx sdk.Context, ck consumerkeeper.Keeper, gs *ccv.GenesisState) {
+			func(ctx sdk.Context, ck consumerkeeper.Keeper, gs *ccv.ConsumerGenesisState) {
 				assertConsumerPortIsBound(t, ctx, &ck)
 
 				gotChannelID, ok := ck.GetProviderChannel(ctx)
@@ -289,7 +289,7 @@ func TestExportGenesis(t *testing.T) {
 	testCases := []struct {
 		name       string
 		malleate   func(sdk.Context, consumerkeeper.Keeper, testkeeper.MockedKeepers)
-		expGenesis *ccv.GenesisState
+		expGenesis *ccv.ConsumerGenesisState
 	}{
 		{
 			"export a chain without an established CCV channel",
@@ -307,7 +307,7 @@ func TestExportGenesis(t *testing.T) {
 
 				ck.SetHeightValsetUpdateID(ctx, defaultHeightValsetUpdateIDs[0].Height, defaultHeightValsetUpdateIDs[0].ValsetUpdateId)
 			},
-			ccv.NewRestartGenesisState(
+			ccv.NewRestartConsumerGenesisState(
 				provClientID,
 				"",
 				nil,
@@ -343,7 +343,7 @@ func TestExportGenesis(t *testing.T) {
 				ck.SetOutstandingDowntime(ctx, sdk.ConsAddress(validator.Address.Bytes()))
 				ck.SetLastTransmissionBlockHeight(ctx, ltbh)
 			},
-			ccv.NewRestartGenesisState(
+			ccv.NewRestartConsumerGenesisState(
 				provClientID,
 				provChannelID,
 				matPackets,
diff --git a/x/ccv/consumer/keeper/keeper.go b/x/ccv/consumer/keeper/keeper.go
index 2d3e78e0f8..b84f3d1864 100644
--- a/x/ccv/consumer/keeper/keeper.go
+++ b/x/ccv/consumer/keeper/keeper.go
@@ -309,7 +309,7 @@ func (k Keeper) DeletePreCCV(ctx sdk.Context) {
 
 func (k Keeper) SetInitialValSet(ctx sdk.Context, initialValSet []tmtypes.ValidatorUpdate) {
 	store := ctx.KVStore(k.storeKey)
-	initialValSetState := ccv.GenesisState{
+	initialValSetState := ccv.ConsumerGenesisState{
 		InitialValSet: initialValSet,
 	}
 	bz := k.cdc.MustMarshal(&initialValSetState)
@@ -318,7 +318,7 @@ func (k Keeper) SetInitialValSet(ctx sdk.Context, initialValSet []tmtypes.Valida
 
 func (k Keeper) GetInitialValSet(ctx sdk.Context) []tmtypes.ValidatorUpdate {
 	store := ctx.KVStore(k.storeKey)
-	initialValSet := ccv.GenesisState{}
+	initialValSet := ccv.ConsumerGenesisState{}
 	bz := store.Get(types.InitialValSetKey())
 	if bz != nil {
 		k.cdc.MustUnmarshal(bz, &initialValSet)
diff --git a/x/ccv/consumer/keeper/params.go b/x/ccv/consumer/keeper/params.go
index 770edf229e..12524fe3d2 100644
--- a/x/ccv/consumer/keeper/params.go
+++ b/x/ccv/consumer/keeper/params.go
@@ -11,7 +11,7 @@ import (
 
 // GetParams returns the params for the consumer ccv module
 // NOTE: it is different from the GetParams method which is required to implement StakingKeeper interface
-func (k Keeper) GetConsumerParams(ctx sdk.Context) ccvtypes.Params {
+func (k Keeper) GetConsumerParams(ctx sdk.Context) ccvtypes.ConsumerParams {
 	return ccvtypes.NewParams(
 		k.GetEnabled(ctx),
 		k.GetBlocksPerDistributionTransmission(ctx),
@@ -29,7 +29,7 @@ func (k Keeper) GetConsumerParams(ctx sdk.Context) ccvtypes.Params {
 }
 
 // SetParams sets the paramset for the consumer module
-func (k Keeper) SetParams(ctx sdk.Context, params ccvtypes.Params) {
+func (k Keeper) SetParams(ctx sdk.Context, params ccvtypes.ConsumerParams) {
 	k.paramStore.SetParamSet(ctx, &params)
 }
 
diff --git a/x/ccv/consumer/module.go b/x/ccv/consumer/module.go
index a9f4a4fc7e..e175205530 100644
--- a/x/ccv/consumer/module.go
+++ b/x/ccv/consumer/module.go
@@ -52,12 +52,12 @@ func (AppModuleBasic) RegisterInterfaces(registry codectypes.InterfaceRegistry)
 // DefaultGenesis returns default genesis state as raw bytes for the ibc
 // consumer module.
 func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage {
-	return cdc.MustMarshalJSON(ccvtypes.DefaultGenesisState())
+	return cdc.MustMarshalJSON(ccvtypes.DefaultConsumerGenesisState())
 }
 
 // ValidateGenesis performs genesis state validation for the ibc consumer module.
 func (AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config client.TxEncodingConfig, bz json.RawMessage) error {
-	var data ccvtypes.GenesisState
+	var data ccvtypes.ConsumerGenesisState
 	if err := cdc.UnmarshalJSON(bz, &data); err != nil {
 		return fmt.Errorf("failed to unmarshal %s genesis state: %w", consumertypes.ModuleName, err)
 	}
@@ -112,7 +112,7 @@ func (am AppModule) RegisterServices(cfg module.Configurator) {
 // InitGenesis performs genesis initialization for the consumer module. It returns
 // no validator updates.
 func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) []abci.ValidatorUpdate {
-	var genesisState ccvtypes.GenesisState
+	var genesisState ccvtypes.ConsumerGenesisState
 	cdc.MustUnmarshalJSON(data, &genesisState)
 	return am.keeper.InitGenesis(ctx, &genesisState)
 }
diff --git a/x/ccv/consumer/types/genesis_test.go b/x/ccv/consumer/types/genesis_test.go
index 453a3aab20..d543c4df21 100644
--- a/x/ccv/consumer/types/genesis_test.go
+++ b/x/ccv/consumer/types/genesis_test.go
@@ -52,39 +52,39 @@ func TestValidateInitialGenesisState(t *testing.T) {
 
 	cases := []struct {
 		name     string
-		gs       *types.GenesisState
+		gs       *types.ConsumerGenesisState
 		expError bool
 	}{
 		{
 			"valid new consumer genesis state",
-			types.NewInitialGenesisState(cs, consensusState, valUpdates, params),
+			types.NewInitialConsumerGenesisState(cs, consensusState, valUpdates, params),
 			false,
 		},
 		{
 			"invalid new consumer genesis state: nil client state",
-			types.NewInitialGenesisState(nil, consensusState, valUpdates, params),
+			types.NewInitialConsumerGenesisState(nil, consensusState, valUpdates, params),
 			true,
 		},
 		{
 			"invalid new consumer genesis state: invalid client state",
-			types.NewInitialGenesisState(&ibctmtypes.ClientState{ChainId: "badClientState"},
+			types.NewInitialConsumerGenesisState(&ibctmtypes.ClientState{ChainId: "badClientState"},
 				consensusState, valUpdates, params),
 			true,
 		},
 		{
 			"invalid new consumer genesis state: nil consensus state",
-			types.NewInitialGenesisState(cs, nil, valUpdates, params),
+			types.NewInitialConsumerGenesisState(cs, nil, valUpdates, params),
 			true,
 		},
 		{
 			"invalid new consumer genesis state: invalid consensus state",
-			types.NewInitialGenesisState(cs, &ibctmtypes.ConsensusState{Timestamp: time.Now()},
+			types.NewInitialConsumerGenesisState(cs, &ibctmtypes.ConsensusState{Timestamp: time.Now()},
 				valUpdates, params),
 			true,
 		},
 		{
 			"invalid new consumer genesis state: client id not empty",
-			&types.GenesisState{
+			&types.ConsumerGenesisState{
 				Params:                      params,
 				ProviderClientId:            "ccvclient",
 				ProviderChannelId:           "",
@@ -103,7 +103,7 @@ func TestValidateInitialGenesisState(t *testing.T) {
 		},
 		{
 			"invalid new consumer genesis state: channel id not empty",
-			&types.GenesisState{
+			&types.ConsumerGenesisState{
 				Params:                      params,
 				ProviderClientId:            "",
 				ProviderChannelId:           "ccvchannel",
@@ -122,7 +122,7 @@ func TestValidateInitialGenesisState(t *testing.T) {
 		},
 		{
 			"invalid new consumer genesis state: non-empty unbonding sequences",
-			&types.GenesisState{
+			&types.ConsumerGenesisState{
 				Params:                      params,
 				ProviderClientId:            "",
 				ProviderChannelId:           "",
@@ -141,7 +141,7 @@ func TestValidateInitialGenesisState(t *testing.T) {
 		},
 		{
 			"invalid new consumer genesis state: non-empty last transmission packet",
-			&types.GenesisState{
+			&types.ConsumerGenesisState{
 				Params:                      params,
 				ProviderClientId:            "",
 				ProviderChannelId:           "",
@@ -160,7 +160,7 @@ func TestValidateInitialGenesisState(t *testing.T) {
 		},
 		{
 			"invalid new consumer genesis state: non-empty pending consumer packets",
-			&types.GenesisState{
+			&types.ConsumerGenesisState{
 				Params:                      params,
 				ProviderClientId:            "",
 				ProviderChannelId:           "",
@@ -179,12 +179,12 @@ func TestValidateInitialGenesisState(t *testing.T) {
 		},
 		{
 			"invalid new consumer genesis state: nil initial validator set",
-			types.NewInitialGenesisState(cs, consensusState, nil, params),
+			types.NewInitialConsumerGenesisState(cs, consensusState, nil, params),
 			true,
 		},
 		{
 			"invalid new consumer genesis state: invalid consensus state validator set hash",
-			types.NewInitialGenesisState(
+			types.NewInitialConsumerGenesisState(
 				cs, ibctmtypes.NewConsensusState(
 					time.Now(), commitmenttypes.NewMerkleRoot([]byte("apphash")), []byte("wrong_length_hash")),
 				valUpdates, params),
@@ -192,7 +192,7 @@ func TestValidateInitialGenesisState(t *testing.T) {
 		},
 		{
 			"invalid new consumer genesis state: initial validator set does not match validator set hash",
-			types.NewInitialGenesisState(
+			types.NewInitialConsumerGenesisState(
 				cs, ibctmtypes.NewConsensusState(
 					time.Now(), commitmenttypes.NewMerkleRoot([]byte("apphash")), []byte("9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08")),
 				valUpdates, params),
@@ -200,7 +200,7 @@ func TestValidateInitialGenesisState(t *testing.T) {
 		},
 		{
 			"invalid new consumer genesis state: initial validator set does not match validator set hash",
-			types.NewInitialGenesisState(
+			types.NewInitialConsumerGenesisState(
 				cs, ibctmtypes.NewConsensusState(
 					time.Now(), commitmenttypes.NewMerkleRoot([]byte("apphash")), []byte("9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08")),
 				valUpdates, params),
@@ -208,7 +208,7 @@ func TestValidateInitialGenesisState(t *testing.T) {
 		},
 		{
 			"invalid new consumer genesis state: invalid params - ccvTimeoutPeriod",
-			types.NewInitialGenesisState(cs, consensusState, valUpdates,
+			types.NewInitialConsumerGenesisState(cs, consensusState, valUpdates,
 				types.NewParams(
 					true,
 					types.DefaultBlocksPerDistributionTransmission,
@@ -227,7 +227,7 @@ func TestValidateInitialGenesisState(t *testing.T) {
 		},
 		{
 			"invalid new consumer genesis state: invalid params - distributionTransmissionChannel",
-			types.NewInitialGenesisState(cs, consensusState, valUpdates,
+			types.NewInitialConsumerGenesisState(cs, consensusState, valUpdates,
 				types.NewParams(
 					true,
 					types.DefaultBlocksPerDistributionTransmission,
@@ -256,9 +256,9 @@ func TestValidateInitialGenesisState(t *testing.T) {
 	}
 }
 
-// TestValidateRestartGenesisState tests a NewRestartGenesisState instantiation,
+// TestValidateRestartConsumerGenesisState tests a NewRestartGenesisState instantiation,
 // and its Validate() method over different genesis scenarios
-func TestValidateRestartGenesisState(t *testing.T) {
+func TestValidateRestartConsumerGenesisState(t *testing.T) {
 	// generate validator private/public key
 	cId := crypto.NewCryptoIdentityFromIntSeed(234234)
 	pubKey := cId.TMCryptoPubKey()
@@ -299,25 +299,25 @@ func TestValidateRestartGenesisState(t *testing.T) {
 
 	cases := []struct {
 		name     string
-		gs       *types.GenesisState
+		gs       *types.ConsumerGenesisState
 		expError bool
 	}{
 		{
 			"valid restart consumer genesis state: empty maturing packets",
-			types.NewRestartGenesisState("ccvclient", "ccvchannel", nil, valUpdates, heightToValsetUpdateID,
+			types.NewRestartConsumerGenesisState("ccvclient", "ccvchannel", nil, valUpdates, heightToValsetUpdateID,
 				types.ConsumerPacketDataList{List: []types.ConsumerPacketData{matConsumerPacket, slashConsumerPacket}},
 				nil, types.LastTransmissionBlockHeight{Height: 100}, params),
 			false,
 		},
 		{
 			"valid restart consumer genesis state: handshake in progress ",
-			types.NewRestartGenesisState("ccvclient", "", nil, valUpdates, heightToValsetUpdateID,
+			types.NewRestartConsumerGenesisState("ccvclient", "", nil, valUpdates, heightToValsetUpdateID,
 				types.ConsumerPacketDataList{List: []types.ConsumerPacketData{slashConsumerPacket}}, nil, types.LastTransmissionBlockHeight{}, params),
 			false,
 		},
 		{
 			"valid restart consumer genesis state: maturing packets",
-			types.NewRestartGenesisState("ccvclient", "ccvchannel", []types.MaturingVSCPacket{
+			types.NewRestartConsumerGenesisState("ccvclient", "ccvchannel", []types.MaturingVSCPacket{
 				{VscId: 1, MaturityTime: time.Now().UTC()},
 				{VscId: 3, MaturityTime: time.Now().UTC()},
 				{VscId: 5, MaturityTime: time.Now().UTC()},
@@ -328,26 +328,26 @@ func TestValidateRestartGenesisState(t *testing.T) {
 		},
 		{
 			"invalid restart consumer genesis state: provider id is empty",
-			types.NewRestartGenesisState("", "ccvchannel", nil, valUpdates, heightToValsetUpdateID, types.ConsumerPacketDataList{}, nil, types.LastTransmissionBlockHeight{}, params),
+			types.NewRestartConsumerGenesisState("", "ccvchannel", nil, valUpdates, heightToValsetUpdateID, types.ConsumerPacketDataList{}, nil, types.LastTransmissionBlockHeight{}, params),
 			true,
 		},
 		{
 			"invalid restart consumer genesis state: maturing packet vscId is invalid",
-			types.NewRestartGenesisState("ccvclient", "ccvchannel", []types.MaturingVSCPacket{
+			types.NewRestartConsumerGenesisState("ccvclient", "ccvchannel", []types.MaturingVSCPacket{
 				{VscId: 0, MaturityTime: time.Now().UTC()},
 			}, valUpdates, nil, types.ConsumerPacketDataList{}, nil, types.LastTransmissionBlockHeight{}, params),
 			true,
 		},
 		{
 			"invalid restart consumer genesis state: maturing packet time is invalid",
-			types.NewRestartGenesisState("ccvclient", "ccvchannel", []types.MaturingVSCPacket{
+			types.NewRestartConsumerGenesisState("ccvclient", "ccvchannel", []types.MaturingVSCPacket{
 				{VscId: 1, MaturityTime: time.Time{}},
 			}, valUpdates, nil, types.ConsumerPacketDataList{}, nil, types.LastTransmissionBlockHeight{}, params),
 			true,
 		},
 		{
 			"invalid restart consumer genesis: client state defined",
-			&types.GenesisState{
+			&types.ConsumerGenesisState{
 				Params:                      params,
 				ProviderClientId:            "ccvclient",
 				ProviderChannelId:           "ccvchannel",
@@ -366,7 +366,7 @@ func TestValidateRestartGenesisState(t *testing.T) {
 		},
 		{
 			"invalid restart consumer genesis: consensus state defined",
-			&types.GenesisState{
+			&types.ConsumerGenesisState{
 				Params:                      params,
 				ProviderClientId:            "ccvclient",
 				ProviderChannelId:           "ccvchannel",
@@ -385,37 +385,37 @@ func TestValidateRestartGenesisState(t *testing.T) {
 		},
 		{
 			"invalid restart consumer genesis state: nil initial validator set",
-			types.NewRestartGenesisState("ccvclient", "ccvchannel", nil, nil, nil, types.ConsumerPacketDataList{}, nil, types.LastTransmissionBlockHeight{}, params),
+			types.NewRestartConsumerGenesisState("ccvclient", "ccvchannel", nil, nil, nil, types.ConsumerPacketDataList{}, nil, types.LastTransmissionBlockHeight{}, params),
 			true,
 		},
 		{
 			"invalid restart consumer genesis state: nil height to validator set id mapping",
-			types.NewRestartGenesisState("ccvclient", "",
+			types.NewRestartConsumerGenesisState("ccvclient", "",
 				[]types.MaturingVSCPacket{{VscId: 1, MaturityTime: time.Time{}}}, valUpdates, nil, types.ConsumerPacketDataList{}, nil, types.LastTransmissionBlockHeight{}, params),
 			true,
 		},
 		{
 			"invalid restart consumer genesis state: maturing packet defined when handshake is still in progress",
-			types.NewRestartGenesisState("ccvclient", "",
+			types.NewRestartConsumerGenesisState("ccvclient", "",
 				[]types.MaturingVSCPacket{{VscId: 1, MaturityTime: time.Time{}}}, valUpdates, heightToValsetUpdateID, types.ConsumerPacketDataList{}, nil, types.LastTransmissionBlockHeight{}, params),
 			true,
 		},
 		{
 			"invalid restart consumer genesis state: outstanding downtime defined when handshake is still in progress",
-			types.NewRestartGenesisState("ccvclient", "",
+			types.NewRestartConsumerGenesisState("ccvclient", "",
 				nil, valUpdates, heightToValsetUpdateID, types.ConsumerPacketDataList{}, []types.OutstandingDowntime{{ValidatorConsensusAddress: "cosmosvalconsxxx"}},
 				types.LastTransmissionBlockHeight{}, params),
 			true,
 		},
 		{
 			"invalid restart consumer genesis state: last transmission block height defined when handshake is still in progress",
-			types.NewRestartGenesisState("ccvclient", "",
+			types.NewRestartConsumerGenesisState("ccvclient", "",
 				nil, valUpdates, heightToValsetUpdateID, types.ConsumerPacketDataList{}, nil, types.LastTransmissionBlockHeight{Height: int64(1)}, params),
 			true,
 		},
 		{
 			"invalid restart consumer genesis state: pending maturing packets defined when handshake is still in progress",
-			types.NewRestartGenesisState("ccvclient", "",
+			types.NewRestartConsumerGenesisState("ccvclient", "",
 				nil, valUpdates, heightToValsetUpdateID, types.ConsumerPacketDataList{
 					List: []types.ConsumerPacketData{
 						{
@@ -428,7 +428,7 @@ func TestValidateRestartGenesisState(t *testing.T) {
 		},
 		{
 			"invalid restart consumer genesis state: invalid params",
-			types.NewRestartGenesisState("ccvclient", "ccvchannel", nil, valUpdates, nil, types.ConsumerPacketDataList{}, nil, types.LastTransmissionBlockHeight{},
+			types.NewRestartConsumerGenesisState("ccvclient", "ccvchannel", nil, valUpdates, nil, types.ConsumerPacketDataList{}, nil, types.LastTransmissionBlockHeight{},
 				types.NewParams(
 					true,
 					types.DefaultBlocksPerDistributionTransmission,
diff --git a/x/ccv/consumer/types/params_test.go b/x/ccv/consumer/types/params_test.go
index ff5d0f325f..e401ba3e47 100644
--- a/x/ccv/consumer/types/params_test.go
+++ b/x/ccv/consumer/types/params_test.go
@@ -13,7 +13,7 @@ import (
 func TestValidateParams(t *testing.T) {
 	testCases := []struct {
 		name    string
-		params  ccvtypes.Params
+		params  ccvtypes.ConsumerParams
 		expPass bool
 	}{
 		{"default params", ccvtypes.DefaultParams(), true},
diff --git a/x/ccv/consumer/types/query.pb.go b/x/ccv/consumer/types/query.pb.go
index 5ed38da3f8..45e3586424 100644
--- a/x/ccv/consumer/types/query.pb.go
+++ b/x/ccv/consumer/types/query.pb.go
@@ -253,7 +253,7 @@ var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo
 // QueryParamsResponse is response type for the Query/Params RPC method.
 type QueryParamsResponse struct {
 	// params holds all the parameters of this module.
-	Params types.Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
+	Params types.ConsumerParams `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
 }
 
 func (m *QueryParamsResponse) Reset()         { *m = QueryParamsResponse{} }
@@ -289,11 +289,11 @@ func (m *QueryParamsResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo
 
-func (m *QueryParamsResponse) GetParams() types.Params {
+func (m *QueryParamsResponse) GetParams() types.ConsumerParams {
 	if m != nil {
 		return m.Params
 	}
-	return types.Params{}
+	return types.ConsumerParams{}
 }
 
 type QueryProviderInfoRequest struct {
@@ -468,50 +468,51 @@ func init() {
 }
 
 var fileDescriptor_f627751d3cc10225 = []byte{
-	// 686 bytes of a gzipped FileDescriptorProto
+	// 689 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x4f, 0x6b, 0x13, 0x41,
-	0x14, 0xcf, 0xa6, 0x4d, 0xdb, 0x4c, 0xf5, 0xe0, 0x18, 0x21, 0xae, 0x65, 0x2d, 0xab, 0x60, 0x14,
-	0xb2, 0xdb, 0xb4, 0x87, 0xea, 0xa1, 0x5a, 0x6c, 0x2c, 0x06, 0x54, 0xea, 0x22, 0x14, 0xbc, 0x94,
-	0xe9, 0x64, 0x9a, 0x0c, 0x24, 0x33, 0xe9, 0xcc, 0xec, 0xd2, 0xde, 0x44, 0xf1, 0x2a, 0x82, 0xdf,
-	0xc4, 0x2f, 0xe0, 0xb5, 0xe0, 0xa5, 0xe0, 0xc5, 0x93, 0x48, 0xeb, 0x87, 0xf0, 0x28, 0x3b, 0x3b,
-	0x9b, 0x6e, 0xe8, 0xbf, 0xad, 0x7a, 0x9b, 0x79, 0xbf, 0xf7, 0x7e, 0xef, 0xf7, 0xde, 0xbc, 0xb7,
-	0x0b, 0x7c, 0xca, 0x14, 0x11, 0xb8, 0x8b, 0x28, 0xdb, 0x90, 0x04, 0x87, 0x82, 0xaa, 0x5d, 0x1f,
-	0xe3, 0xc8, 0xc7, 0x9c, 0xc9, 0xb0, 0x4f, 0x84, 0x1f, 0x35, 0xfc, 0xed, 0x90, 0x88, 0x5d, 0x6f,
-	0x20, 0xb8, 0xe2, 0xf0, 0xd6, 0x09, 0x01, 0x1e, 0xc6, 0x91, 0x97, 0x06, 0x78, 0x51, 0xc3, 0x9e,
-	0x3b, 0x8d, 0x35, 0x6a, 0xf8, 0xb2, 0x8b, 0x04, 0x69, 0x6f, 0x0c, 0xdd, 0x35, 0xad, 0x5d, 0xe9,
-	0xf0, 0x0e, 0xd7, 0x47, 0x3f, 0x3e, 0x19, 0xeb, 0x4c, 0x87, 0xf3, 0x4e, 0x8f, 0xf8, 0x68, 0x40,
-	0x7d, 0xc4, 0x18, 0x57, 0x48, 0x51, 0xce, 0xa4, 0x41, 0xe7, 0xf3, 0x68, 0x1f, 0xcd, 0xe3, 0x7e,
-	0x28, 0x82, 0x1b, 0x2f, 0xc8, 0x8e, 0x5a, 0x25, 0xa4, 0x49, 0xa5, 0x12, 0x74, 0x33, 0x8c, 0x29,
-	0x9f, 0x48, 0x45, 0xfb, 0x48, 0x11, 0x78, 0x1b, 0x5c, 0xc6, 0xa1, 0x10, 0x84, 0xa9, 0xa7, 0x84,
-	0x76, 0xba, 0xaa, 0x6a, 0xcd, 0x5a, 0xb5, 0xb1, 0x60, 0xd4, 0x08, 0x1d, 0x00, 0x7a, 0x48, 0xa6,
-	0x2e, 0x45, 0xed, 0x92, 0xb1, 0xc4, 0x38, 0x23, 0x3b, 0x29, 0x3e, 0x96, 0xe0, 0x47, 0x16, 0xb8,
-	0x00, 0xae, 0xb5, 0x33, 0xd9, 0x37, 0xb6, 0x04, 0xc2, 0xf1, 0xa1, 0x3a, 0x3e, 0x6b, 0xd5, 0xca,
-	0x41, 0x25, 0x0b, 0xae, 0x1a, 0x0c, 0x56, 0x40, 0x49, 0x71, 0x85, 0x7a, 0xd5, 0x92, 0x76, 0x4a,
-	0x2e, 0x71, 0x2a, 0xc5, 0xd7, 0x04, 0x8f, 0x68, 0x9b, 0x88, 0xea, 0x84, 0x86, 0x32, 0x96, 0x04,
-	0x5f, 0x31, 0x4d, 0xa8, 0x4e, 0xa6, 0x78, 0x6a, 0x71, 0xef, 0x82, 0x3b, 0x2f, 0xe3, 0xe7, 0x3d,
-	0xa3, 0x29, 0x01, 0xd9, 0x0e, 0x89, 0x54, 0xee, 0x1b, 0x0b, 0xd4, 0xce, 0xf7, 0x95, 0x03, 0xce,
-	0x24, 0x81, 0xaf, 0xc0, 0x78, 0x1b, 0x29, 0xa4, 0xfb, 0x37, 0x3d, 0xbf, 0xec, 0xe5, 0x18, 0x1b,
-	0xef, 0x2c, 0x5e, 0xcd, 0xe6, 0x56, 0x00, 0xd4, 0x0a, 0xd6, 0x90, 0x40, 0x7d, 0x99, 0x0a, 0x5b,
-	0x07, 0x57, 0x47, 0xac, 0x46, 0xc2, 0x32, 0x98, 0x18, 0x68, 0x8b, 0x11, 0xe1, 0x9e, 0x2a, 0x22,
-	0x6a, 0x78, 0x49, 0xec, 0xe3, 0xf1, 0xbd, 0x1f, 0x37, 0x0b, 0x81, 0x89, 0x73, 0x6d, 0x50, 0x4d,
-	0x88, 0x4d, 0x37, 0x5b, 0x6c, 0x8b, 0xa7, 0x49, 0xbf, 0x58, 0xe0, 0xfa, 0x09, 0xa0, 0xc9, 0xbd,
-	0x06, 0xa6, 0xd2, 0xca, 0x4c, 0x76, 0x2f, 0x57, 0x0b, 0x56, 0x62, 0x38, 0x66, 0x32, 0x4a, 0x86,
-	0x2c, 0x31, 0xe3, 0x20, 0x7d, 0xe6, 0xe2, 0xbf, 0x30, 0xa6, 0x2c, 0xee, 0x3b, 0x0b, 0x94, 0x87,
-	0x28, 0xac, 0x82, 0x49, 0xcd, 0xd4, 0x6a, 0x6a, 0xc1, 0xe5, 0x20, 0xbd, 0x42, 0x1b, 0x4c, 0xe1,
-	0x1e, 0x25, 0x4c, 0xb5, 0x9a, 0x3a, 0x73, 0x39, 0x18, 0xde, 0xa1, 0x0b, 0x2e, 0x61, 0xce, 0x18,
-	0xd1, 0x23, 0xda, 0x6a, 0xea, 0x59, 0x2f, 0x07, 0x23, 0x36, 0x38, 0x03, 0xca, 0xb8, 0x8b, 0x18,
-	0x23, 0xbd, 0x56, 0xd3, 0x4c, 0xf8, 0x91, 0x61, 0xfe, 0x7d, 0x09, 0x94, 0x74, 0x1f, 0xe1, 0x6f,
-	0xcb, 0xb4, 0xfb, 0x84, 0x39, 0x80, 0xcf, 0x72, 0x15, 0x9b, 0x73, 0x94, 0xed, 0xe7, 0xff, 0x89,
-	0x2d, 0x79, 0x6d, 0xf7, 0xd1, 0xdb, 0x6f, 0xbf, 0x3e, 0x15, 0x1f, 0xc0, 0xc5, 0xf3, 0x3f, 0xa7,
-	0xf1, 0x57, 0xa0, 0xbe, 0x45, 0x48, 0x3d, 0xbb, 0xe3, 0xf0, 0xb3, 0x05, 0xa6, 0x33, 0x23, 0x0c,
-	0x17, 0xf3, 0xeb, 0x1b, 0x59, 0x05, 0xfb, 0xfe, 0xc5, 0x03, 0x4d, 0x0d, 0x73, 0xba, 0x86, 0x7b,
-	0xb0, 0x76, 0x7e, 0x0d, 0xc9, 0x76, 0xc0, 0xaf, 0x16, 0xb8, 0x72, 0x6c, 0x03, 0xe0, 0xd2, 0x05,
-	0x14, 0x1c, 0x5f, 0x2b, 0xfb, 0xe1, 0xdf, 0x86, 0x9b, 0x32, 0x16, 0x75, 0x19, 0x0d, 0xe8, 0xe7,
-	0x28, 0xc3, 0xc4, 0xd7, 0x69, 0xbc, 0x1d, 0xeb, 0x7b, 0x07, 0x8e, 0xb5, 0x7f, 0xe0, 0x58, 0x3f,
-	0x0f, 0x1c, 0xeb, 0xe3, 0xa1, 0x53, 0xd8, 0x3f, 0x74, 0x0a, 0xdf, 0x0f, 0x9d, 0xc2, 0xeb, 0xa5,
-	0x0e, 0x55, 0xdd, 0x70, 0xd3, 0xc3, 0xbc, 0xef, 0x63, 0x2e, 0xfb, 0x5c, 0x66, 0xb8, 0xeb, 0x43,
-	0xee, 0x68, 0xc1, 0xdf, 0x19, 0x4d, 0xa0, 0x76, 0x07, 0x44, 0x6e, 0x4e, 0xe8, 0x3f, 0xcf, 0xc2,
-	0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x18, 0x69, 0x59, 0x43, 0x6b, 0x07, 0x00, 0x00,
+	0x14, 0xcf, 0xa6, 0x4d, 0xdb, 0x4c, 0xf5, 0xe0, 0x18, 0x61, 0x5d, 0xcb, 0x5a, 0x56, 0xc1, 0x58,
+	0xc8, 0x6e, 0xd3, 0x1e, 0xaa, 0x87, 0xaa, 0xd8, 0x58, 0x1a, 0x50, 0xa9, 0x8b, 0x20, 0x78, 0x09,
+	0xd3, 0xc9, 0x34, 0x59, 0x48, 0x66, 0xd2, 0x99, 0xd9, 0xa5, 0xbd, 0x89, 0xe2, 0x55, 0x04, 0xbf,
+	0x89, 0x5f, 0xc0, 0x6b, 0xc1, 0x4b, 0xc1, 0x8b, 0x27, 0x91, 0xd6, 0x0f, 0xe1, 0x51, 0x76, 0x76,
+	0x36, 0xdd, 0xd0, 0x3f, 0xd9, 0xaa, 0xb7, 0x99, 0xf7, 0x7b, 0xef, 0xf7, 0x7e, 0xef, 0xcd, 0x7b,
+	0xbb, 0xc0, 0x0b, 0xa8, 0x24, 0x1c, 0x77, 0x51, 0x40, 0x5b, 0x82, 0xe0, 0x90, 0x07, 0x72, 0xcf,
+	0xc3, 0x38, 0xf2, 0x30, 0xa3, 0x22, 0xec, 0x13, 0xee, 0x45, 0x75, 0x6f, 0x27, 0x24, 0x7c, 0xcf,
+	0x1d, 0x70, 0x26, 0x19, 0xbc, 0x75, 0x4a, 0x80, 0x8b, 0x71, 0xe4, 0xa6, 0x01, 0x6e, 0x54, 0xb7,
+	0x16, 0xcf, 0x62, 0x8d, 0xea, 0x9e, 0xe8, 0x22, 0x4e, 0xda, 0xad, 0xa1, 0xbb, 0xa2, 0xb5, 0x2a,
+	0x1d, 0xd6, 0x61, 0xea, 0xe8, 0xc5, 0x27, 0x6d, 0x9d, 0xeb, 0x30, 0xd6, 0xe9, 0x11, 0x0f, 0x0d,
+	0x02, 0x0f, 0x51, 0xca, 0x24, 0x92, 0x01, 0xa3, 0x42, 0xa3, 0x4b, 0x79, 0xb4, 0x8f, 0xe6, 0x71,
+	0x3e, 0x14, 0xc1, 0x8d, 0xe7, 0x64, 0x57, 0xae, 0x13, 0xd2, 0x08, 0x84, 0xe4, 0xc1, 0x56, 0x18,
+	0x53, 0x3e, 0x11, 0x32, 0xe8, 0x23, 0x49, 0xe0, 0x6d, 0x70, 0x19, 0x87, 0x9c, 0x13, 0x2a, 0x37,
+	0x48, 0xd0, 0xe9, 0x4a, 0xd3, 0x98, 0x37, 0xaa, 0x13, 0xfe, 0xa8, 0x11, 0xda, 0x00, 0xf4, 0x90,
+	0x48, 0x5d, 0x8a, 0xca, 0x25, 0x63, 0x89, 0x71, 0x4a, 0x76, 0x53, 0x7c, 0x22, 0xc1, 0x8f, 0x2d,
+	0x70, 0x19, 0x5c, 0x6b, 0x67, 0xb2, 0xb7, 0xb6, 0x39, 0xc2, 0xf1, 0xc1, 0x9c, 0x9c, 0x37, 0xaa,
+	0x65, 0xbf, 0x92, 0x05, 0xd7, 0x35, 0x06, 0x2b, 0xa0, 0x24, 0x99, 0x44, 0x3d, 0xb3, 0xa4, 0x9c,
+	0x92, 0x4b, 0x9c, 0x4a, 0xb2, 0x4d, 0xce, 0xa2, 0xa0, 0x4d, 0xb8, 0x39, 0xa5, 0xa0, 0x8c, 0x25,
+	0xc1, 0xd7, 0x74, 0x13, 0xcc, 0xe9, 0x14, 0x4f, 0x2d, 0xce, 0x5d, 0x70, 0xe7, 0x45, 0xfc, 0xbc,
+	0xe7, 0x34, 0xc5, 0x27, 0x3b, 0x21, 0x11, 0xd2, 0x79, 0x63, 0x80, 0xea, 0x78, 0x5f, 0x31, 0x60,
+	0x54, 0x10, 0xf8, 0x12, 0x4c, 0xb6, 0x91, 0x44, 0xaa, 0x7f, 0xb3, 0x4b, 0x8f, 0xdc, 0x1c, 0x63,
+	0xe3, 0x9e, 0xc7, 0xab, 0xd8, 0x9c, 0x0a, 0x80, 0x4a, 0xc1, 0x26, 0xe2, 0xa8, 0x2f, 0x52, 0x61,
+	0x2d, 0x70, 0x75, 0xc4, 0xaa, 0x25, 0x6c, 0x80, 0xa9, 0x81, 0xb2, 0x68, 0x11, 0x0b, 0x67, 0x8a,
+	0x88, 0xea, 0x6e, 0xda, 0x90, 0x84, 0xe3, 0xf1, 0xe4, 0xfe, 0x8f, 0x9b, 0x05, 0x5f, 0xc7, 0x3b,
+	0x16, 0x30, 0x93, 0x04, 0xba, 0xab, 0x4d, 0xba, 0xcd, 0xd2, 0xe4, 0x5f, 0x0c, 0x70, 0xfd, 0x14,
+	0x50, 0x6b, 0xd8, 0x04, 0x33, 0x69, 0x85, 0x5a, 0x85, 0x9b, 0xab, 0x15, 0x6b, 0x31, 0x1c, 0x33,
+	0x69, 0x25, 0x43, 0x96, 0x98, 0x71, 0x90, 0x3e, 0x77, 0xf1, 0x5f, 0x18, 0x53, 0x16, 0xe7, 0x9d,
+	0x01, 0xca, 0x43, 0x14, 0x9a, 0x60, 0x5a, 0x31, 0x35, 0x1b, 0x4a, 0x70, 0xd9, 0x4f, 0xaf, 0xd0,
+	0x02, 0x33, 0xb8, 0x17, 0x10, 0x2a, 0x9b, 0x0d, 0x95, 0xb9, 0xec, 0x0f, 0xef, 0xd0, 0x01, 0x97,
+	0x30, 0xa3, 0x94, 0xa8, 0x51, 0x6d, 0x36, 0xd4, 0xcc, 0x97, 0xfd, 0x11, 0x1b, 0x9c, 0x03, 0x65,
+	0xdc, 0x45, 0x94, 0x92, 0x5e, 0xb3, 0xa1, 0x27, 0xfd, 0xd8, 0xb0, 0xf4, 0xbe, 0x04, 0x4a, 0xaa,
+	0x8f, 0xf0, 0xb7, 0xa1, 0xdb, 0x7d, 0xca, 0x3c, 0xc0, 0xa7, 0xb9, 0x8a, 0xcd, 0x39, 0xd2, 0xd6,
+	0xb3, 0xff, 0xc4, 0x96, 0xbc, 0xb6, 0xf3, 0xf0, 0xed, 0xb7, 0x5f, 0x9f, 0x8a, 0xf7, 0xe1, 0xca,
+	0xf8, 0xcf, 0x6a, 0xfc, 0x35, 0xa8, 0x6d, 0x13, 0x52, 0xcb, 0xee, 0x3a, 0xfc, 0x6c, 0x80, 0xd9,
+	0xcc, 0x28, 0xc3, 0x95, 0xfc, 0xfa, 0x46, 0x56, 0xc2, 0xba, 0x77, 0xf1, 0x40, 0x5d, 0xc3, 0xa2,
+	0xaa, 0x61, 0x01, 0x56, 0xc7, 0xd7, 0x90, 0x6c, 0x07, 0xfc, 0x6a, 0x80, 0x2b, 0x27, 0x36, 0x00,
+	0xae, 0x5e, 0x40, 0xc1, 0xc9, 0xb5, 0xb2, 0x1e, 0xfc, 0x6d, 0xb8, 0x2e, 0x63, 0x45, 0x95, 0x51,
+	0x87, 0x5e, 0x8e, 0x32, 0x74, 0x7c, 0x2d, 0x88, 0xb7, 0xe3, 0xd5, 0xfe, 0xa1, 0x6d, 0x1c, 0x1c,
+	0xda, 0xc6, 0xcf, 0x43, 0xdb, 0xf8, 0x78, 0x64, 0x17, 0x0e, 0x8e, 0xec, 0xc2, 0xf7, 0x23, 0xbb,
+	0xf0, 0x7a, 0xb5, 0x13, 0xc8, 0x6e, 0xb8, 0xe5, 0x62, 0xd6, 0xf7, 0x30, 0x13, 0x7d, 0x26, 0x32,
+	0xdc, 0xb5, 0x21, 0x77, 0xb4, 0xec, 0xed, 0x8e, 0x26, 0x90, 0x7b, 0x03, 0x22, 0xb6, 0xa6, 0xd4,
+	0x1f, 0x68, 0xf9, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x91, 0xe8, 0xb3, 0x96, 0x73, 0x07, 0x00,
+	0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/x/ccv/provider/keeper/genesis_test.go b/x/ccv/provider/keeper/genesis_test.go
index 8b101a1ce9..ecde91253c 100644
--- a/x/ccv/provider/keeper/genesis_test.go
+++ b/x/ccv/provider/keeper/genesis_test.go
@@ -71,7 +71,7 @@ func TestInitAndExportGenesis(t *testing.T) {
 				expClientID,
 				"channel",
 				initHeight,
-				*ccv.DefaultGenesisState(),
+				*ccv.DefaultConsumerGenesisState(),
 				[]providertypes.VscUnbondingOps{
 					{VscId: vscID, UnbondingOpIds: ubdIndex},
 				},
@@ -83,7 +83,7 @@ func TestInitAndExportGenesis(t *testing.T) {
 				expClientID,
 				"",
 				0,
-				*ccv.DefaultGenesisState(),
+				*ccv.DefaultConsumerGenesisState(),
 				nil,
 				[]ccv.ValidatorSetChangePacketData{{ValsetUpdateId: vscID}},
 				nil,
@@ -218,7 +218,7 @@ func assertConsumerChainStates(t *testing.T, ctx sdk.Context, pk keeper.Keeper,
 		chainID := cs.ChainId
 		gen, found := pk.GetConsumerGenesis(ctx, chainID)
 		require.True(t, found)
-		require.Equal(t, *ccv.DefaultGenesisState(), gen)
+		require.Equal(t, *ccv.DefaultConsumerGenesisState(), gen)
 
 		clientID, found := pk.GetConsumerClientId(ctx, chainID)
 		require.True(t, found)
diff --git a/x/ccv/provider/keeper/keeper.go b/x/ccv/provider/keeper/keeper.go
index bebef70c56..e9bb1d1bd0 100644
--- a/x/ccv/provider/keeper/keeper.go
+++ b/x/ccv/provider/keeper/keeper.go
@@ -251,7 +251,7 @@ func (k Keeper) GetAllChannelToChains(ctx sdk.Context) (channels []types.Channel
 	return channels
 }
 
-func (k Keeper) SetConsumerGenesis(ctx sdk.Context, chainID string, gen ccv.GenesisState) error {
+func (k Keeper) SetConsumerGenesis(ctx sdk.Context, chainID string, gen ccv.ConsumerGenesisState) error {
 	store := ctx.KVStore(k.storeKey)
 	bz, err := gen.Marshal()
 	if err != nil {
@@ -262,14 +262,14 @@ func (k Keeper) SetConsumerGenesis(ctx sdk.Context, chainID string, gen ccv.Gene
 	return nil
 }
 
-func (k Keeper) GetConsumerGenesis(ctx sdk.Context, chainID string) (ccv.GenesisState, bool) {
+func (k Keeper) GetConsumerGenesis(ctx sdk.Context, chainID string) (ccv.ConsumerGenesisState, bool) {
 	store := ctx.KVStore(k.storeKey)
 	bz := store.Get(types.ConsumerGenesisKey(chainID))
 	if bz == nil {
-		return ccv.GenesisState{}, false
+		return ccv.ConsumerGenesisState{}, false
 	}
 
-	var data ccv.GenesisState
+	var data ccv.ConsumerGenesisState
 	if err := data.Unmarshal(bz); err != nil {
 		// An error here would indicate something is very wrong,
 		// the ConsumerGenesis is assumed to be correctly serialized in SetConsumerGenesis.
diff --git a/x/ccv/provider/keeper/key_assignment_test.go b/x/ccv/provider/keeper/key_assignment_test.go
index 8da633a5c9..e9cb1dd646 100644
--- a/x/ccv/provider/keeper/key_assignment_test.go
+++ b/x/ccv/provider/keeper/key_assignment_test.go
@@ -346,6 +346,7 @@ func checkCorrectPruningProperty(ctx sdk.Context, k providerkeeper.Keeper, chain
 
 	good := true
 	for _, valByConsAddr := range k.GetAllValidatorsByConsumerAddr(ctx, nil) {
+		valByConsAddr := valByConsAddr // Fix linter error G601
 		if _, ok := willBePruned[string(valByConsAddr.ConsumerAddr)]; ok {
 			// Address will be pruned, everything is fine.
 			continue
diff --git a/x/ccv/provider/keeper/proposal.go b/x/ccv/provider/keeper/proposal.go
index 53c5f4396f..7ea7433770 100644
--- a/x/ccv/provider/keeper/proposal.go
+++ b/x/ccv/provider/keeper/proposal.go
@@ -238,7 +238,7 @@ func (k Keeper) StopConsumerChain(ctx sdk.Context, chainID string, closeChan boo
 func (k Keeper) MakeConsumerGenesis(
 	ctx sdk.Context,
 	prop *types.ConsumerAdditionProposal,
-) (gen ccv.GenesisState, nextValidatorsHash []byte, err error) {
+) (gen ccv.ConsumerGenesisState, nextValidatorsHash []byte, err error) {
 	chainID := prop.ChainId
 	providerUnbondingPeriod := k.stakingKeeper.UnbondingTime(ctx)
 	height := clienttypes.GetSelfHeight(ctx)
@@ -316,7 +316,7 @@ func (k Keeper) MakeConsumerGenesis(
 		[]string{},
 	)
 
-	gen = *ccv.NewInitialGenesisState(
+	gen = *ccv.NewInitialConsumerGenesisState(
 		clientState,
 		consState.(*ibctmtypes.ConsensusState),
 		initialUpdatesWithConsumerKeys,
diff --git a/x/ccv/provider/keeper/proposal_test.go b/x/ccv/provider/keeper/proposal_test.go
index e6b8573e24..135e16eaae 100644
--- a/x/ccv/provider/keeper/proposal_test.go
+++ b/x/ccv/provider/keeper/proposal_test.go
@@ -907,7 +907,7 @@ func TestMakeConsumerGenesis(t *testing.T) {
 		]
 	}`
 
-	var expectedGenesis ccvtypes.GenesisState
+	var expectedGenesis ccvtypes.ConsumerGenesisState
 	err = json.Unmarshal([]byte(jsonString), &expectedGenesis) // ignores tabs, newlines and spaces
 	require.NoError(t, err)
 
diff --git a/x/ccv/provider/types/consumer.go b/x/ccv/provider/types/consumer.go
index b9eefc3b45..b2621dd001 100644
--- a/x/ccv/provider/types/consumer.go
+++ b/x/ccv/provider/types/consumer.go
@@ -9,7 +9,7 @@ func NewConsumerStates(
 	clientID,
 	channelID string,
 	initialHeight uint64,
-	genesis ccv.GenesisState,
+	genesis ccv.ConsumerGenesisState,
 	unbondingOpsIndexes []VscUnbondingOps,
 	pendingValsetChanges []ccv.ValidatorSetChangePacketData,
 	slashDowntimeAck []string,
diff --git a/x/ccv/provider/types/genesis.pb.go b/x/ccv/provider/types/genesis.pb.go
index fa952b9b13..e08947ea5e 100644
--- a/x/ccv/provider/types/genesis.pb.go
+++ b/x/ccv/provider/types/genesis.pb.go
@@ -189,7 +189,7 @@ type ConsumerState struct {
 	// InitalHeight defines the initial block height for the consumer chain
 	InitialHeight uint64 `protobuf:"varint,4,opt,name=initial_height,json=initialHeight,proto3" json:"initial_height,omitempty"`
 	// ConsumerGenesis defines the initial consumer chain genesis states
-	ConsumerGenesis types.GenesisState `protobuf:"bytes,5,opt,name=consumer_genesis,json=consumerGenesis,proto3" json:"consumer_genesis"`
+	ConsumerGenesis types.ConsumerGenesisState `protobuf:"bytes,5,opt,name=consumer_genesis,json=consumerGenesis,proto3" json:"consumer_genesis"`
 	// PendingValsetChanges defines the pending validator set changes for the
 	// consumer chain
 	PendingValsetChanges []types.ValidatorSetChangePacketData `protobuf:"bytes,6,rep,name=pending_valset_changes,json=pendingValsetChanges,proto3" json:"pending_valset_changes"`
@@ -260,11 +260,11 @@ func (m *ConsumerState) GetInitialHeight() uint64 {
 	return 0
 }
 
-func (m *ConsumerState) GetConsumerGenesis() types.GenesisState {
+func (m *ConsumerState) GetConsumerGenesis() types.ConsumerGenesisState {
 	if m != nil {
 		return m.ConsumerGenesis
 	}
-	return types.GenesisState{}
+	return types.ConsumerGenesisState{}
 }
 
 func (m *ConsumerState) GetPendingValsetChanges() []types.ValidatorSetChangePacketData {
@@ -353,66 +353,65 @@ func init() {
 }
 
 var fileDescriptor_48411d9c7900d48e = []byte{
-	// 929 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xcd, 0x6e, 0x1b, 0x37,
-	0x17, 0xf5, 0xd8, 0x8e, 0x63, 0xd1, 0x3f, 0x9f, 0x3f, 0xd6, 0x55, 0xc6, 0x76, 0xaa, 0x18, 0x2a,
-	0x02, 0x08, 0x68, 0xab, 0x89, 0x9c, 0x2e, 0xd2, 0x9f, 0x2c, 0xe2, 0xa4, 0x68, 0x85, 0xa2, 0xa8,
-	0x20, 0x3b, 0x2e, 0x9a, 0x2e, 0x08, 0x8a, 0x24, 0x24, 0xc6, 0x33, 0xe4, 0x80, 0xe4, 0x8c, 0x2d,
-	0x14, 0x05, 0x5a, 0xb4, 0x0f, 0xd0, 0xc7, 0xca, 0xd2, 0xcb, 0xae, 0x82, 0xc2, 0x7e, 0x83, 0xae,
-	0xba, 0x2c, 0x86, 0xc3, 0x99, 0x8c, 0x5c, 0x39, 0x90, 0xba, 0xb2, 0xc5, 0xc3, 0x7b, 0xce, 0xb9,
-	0xbc, 0xe4, 0xbd, 0x03, 0x3a, 0x5c, 0x18, 0xa6, 0xc8, 0x08, 0x73, 0x81, 0x34, 0x23, 0x89, 0xe2,
-	0x66, 0x1c, 0x10, 0x92, 0x06, 0xb1, 0x92, 0x29, 0xa7, 0x4c, 0x05, 0x69, 0x27, 0x18, 0x32, 0xc1,
-	0x34, 0xd7, 0xed, 0x58, 0x49, 0x23, 0xe1, 0xfb, 0x53, 0x42, 0xda, 0x84, 0xa4, 0xed, 0x22, 0xa4,
-	0x9d, 0x76, 0x76, 0xb7, 0x87, 0x72, 0x28, 0xed, 0xfe, 0x20, 0xfb, 0x2f, 0x0f, 0xdd, 0x7d, 0x70,
-	0x93, 0x5a, 0xda, 0x09, 0xf4, 0x08, 0x2b, 0x46, 0x11, 0x91, 0x42, 0x27, 0x11, 0x53, 0x2e, 0xe2,
-	0xfe, 0x5b, 0x22, 0xce, 0xb8, 0x62, 0x6e, 0xdb, 0xc1, 0x2c, 0x69, 0x94, 0xfe, 0xf2, 0x98, 0xbb,
-	0x86, 0x09, 0xca, 0x54, 0xc4, 0x85, 0x09, 0x88, 0x1a, 0xc7, 0x46, 0x06, 0xa7, 0x6c, 0xec, 0xb2,
-	0x6c, 0x5e, 0xac, 0x81, 0xf5, 0x2f, 0xf3, 0xbc, 0x8f, 0x0c, 0x36, 0x0c, 0xb6, 0xc0, 0x56, 0x8a,
-	0x43, 0xcd, 0x0c, 0x4a, 0x62, 0x8a, 0x0d, 0x43, 0x9c, 0xfa, 0xde, 0xbe, 0xd7, 0x5a, 0xee, 0x6f,
-	0xe6, 0xeb, 0xcf, 0xed, 0x72, 0x97, 0xc2, 0x1f, 0xc1, 0xff, 0x8a, 0x2c, 0x90, 0xce, 0x62, 0xb5,
-	0xbf, 0xb8, 0xbf, 0xd4, 0x5a, 0x3b, 0x38, 0x68, 0xcf, 0x70, 0x74, 0xed, 0xa7, 0x2e, 0xd6, 0xca,
-	0x1e, 0x36, 0x5e, 0xbd, 0xbe, 0xb7, 0xf0, 0xd7, 0xeb, 0x7b, 0xf5, 0x31, 0x8e, 0xc2, 0x4f, 0x9b,
-	0xd7, 0x88, 0x9b, 0xfd, 0x4d, 0x52, 0xdd, 0xae, 0xe1, 0x0f, 0x60, 0x23, 0x11, 0x03, 0x29, 0x28,
-	0x17, 0x43, 0x24, 0x63, 0xed, 0x2f, 0x59, 0xe9, 0x07, 0x33, 0x49, 0x3f, 0x2f, 0x22, 0xbf, 0x8d,
-	0x0f, 0x97, 0x33, 0xe1, 0xfe, 0x7a, 0xf2, 0x66, 0x49, 0xc3, 0x97, 0x60, 0x3b, 0xc2, 0x26, 0x51,
-	0x0c, 0x4d, 0x6a, 0x2c, 0xef, 0x7b, 0xad, 0xb5, 0x83, 0x47, 0x33, 0x69, 0x7c, 0x63, 0x09, 0x68,
-	0x45, 0x4a, 0xf7, 0x61, 0xce, 0x5a, 0x5d, 0x83, 0x3f, 0x81, 0xdd, 0xeb, 0xe7, 0x8d, 0x8c, 0x44,
-	0x23, 0xc6, 0x87, 0x23, 0xe3, 0xdf, 0xb2, 0x59, 0x7d, 0x36, 0x93, 0xe2, 0xc9, 0x44, 0x79, 0x8e,
-	0xe5, 0x57, 0x96, 0xc2, 0x25, 0x58, 0x4f, 0xa7, 0xa2, 0xf0, 0x57, 0x0f, 0xec, 0x95, 0x87, 0x8d,
-	0x29, 0xe5, 0x86, 0x4b, 0x81, 0x62, 0x25, 0x63, 0xa9, 0x71, 0xa8, 0xfd, 0x15, 0x6b, 0xe0, 0xf1,
-	0x5c, 0x15, 0x7d, 0xe2, 0x68, 0x7a, 0x8e, 0xc5, 0x59, 0xd8, 0x21, 0x37, 0xe0, 0x1a, 0xfe, 0xec,
-	0x81, 0xdd, 0xd2, 0x85, 0x62, 0x91, 0x4c, 0x71, 0x58, 0x31, 0x71, 0xdb, 0x9a, 0xf8, 0x7c, 0x2e,
-	0x13, 0xfd, 0x9c, 0xe5, 0x9a, 0x07, 0x9f, 0x4c, 0x87, 0x35, 0xec, 0x82, 0x95, 0x18, 0x2b, 0x1c,
-	0x69, 0x7f, 0xd5, 0x56, 0xf9, 0x83, 0x99, 0xd4, 0x7a, 0x36, 0xc4, 0x91, 0x3b, 0x02, 0x9b, 0x4d,
-	0x8a, 0x43, 0x4e, 0xb1, 0x91, 0xaa, 0x7c, 0xe9, 0x28, 0x4e, 0x06, 0xd9, 0xc3, 0xf3, 0x6b, 0x73,
-	0x64, 0x73, 0x52, 0xd0, 0x14, 0x69, 0xf5, 0x92, 0xc1, 0xd7, 0x6c, 0x5c, 0x64, 0x93, 0x4e, 0x81,
-	0x33, 0x0d, 0xf8, 0x8b, 0x07, 0xf6, 0x4a, 0x50, 0xa3, 0xc1, 0x18, 0x55, 0x8b, 0xac, 0x7c, 0xf0,
-	0x5f, 0x3c, 0x1c, 0x8e, 0x2b, 0x15, 0x56, 0xff, 0xf2, 0xa0, 0x27, 0x71, 0x98, 0x82, 0x3b, 0x13,
-	0xa2, 0x3a, 0xbb, 0xd7, 0xb1, 0x4a, 0x04, 0xf3, 0xd7, 0xac, 0xfc, 0x27, 0xf3, 0xde, 0x2a, 0xa5,
-	0x8f, 0x65, 0x2f, 0x23, 0x70, 0xda, 0xdb, 0x64, 0x0a, 0x06, 0xcf, 0xc0, 0x1d, 0x2e, 0xb8, 0x41,
-	0x86, 0x47, 0x4c, 0x26, 0xf9, 0x5f, 0x6d, 0x70, 0x14, 0x6b, 0x7f, 0x7d, 0x0e, 0xdd, 0xae, 0xe0,
-	0xe6, 0x38, 0xa7, 0x38, 0x2e, 0x18, 0x9c, 0xee, 0xbb, 0x7c, 0x0a, 0xa6, 0xe1, 0x6f, 0x1e, 0xb8,
-	0xcb, 0xce, 0x63, 0xa9, 0x0c, 0xa3, 0x28, 0xd5, 0x04, 0x69, 0x26, 0x68, 0x55, 0x7e, 0x63, 0x8e,
-	0xc7, 0xf4, 0x85, 0x23, 0x3a, 0xd1, 0xe4, 0x88, 0x09, 0x7a, 0xdd, 0xc2, 0x0e, 0xbb, 0x01, 0xd7,
-	0xcd, 0xbf, 0x97, 0xc0, 0xc6, 0x44, 0x73, 0x85, 0x3b, 0x60, 0x35, 0x57, 0x73, 0xbd, 0xbc, 0xd6,
-	0xbf, 0x6d, 0x7f, 0x77, 0x29, 0x7c, 0x0f, 0x00, 0x32, 0xc2, 0x42, 0xb0, 0x30, 0x03, 0x17, 0x2d,
-	0x58, 0x73, 0x2b, 0x5d, 0x0a, 0xf7, 0x40, 0x8d, 0x84, 0x9c, 0x09, 0x93, 0xa1, 0x4b, 0x16, 0x5d,
-	0xcd, 0x17, 0xba, 0x14, 0xde, 0x07, 0x9b, 0xd9, 0x41, 0x70, 0x1c, 0x16, 0xed, 0x6a, 0xd9, 0x0e,
-	0x8a, 0x0d, 0xb7, 0xea, 0x5a, 0xcc, 0xf7, 0x60, 0xab, 0xbc, 0x07, 0x6e, 0xc4, 0xfa, 0xb7, 0xec,
-	0x1b, 0x6b, 0xdd, 0x78, 0x12, 0x69, 0xa7, 0x5d, 0x9d, 0x4a, 0x2e, 0xe9, 0x72, 0xde, 0x38, 0x0c,
-	0x1a, 0x50, 0x8f, 0x59, 0xde, 0x9f, 0x5d, 0x13, 0xcd, 0xac, 0x0f, 0x59, 0xd1, 0xb7, 0x1e, 0xbd,
-	0x4d, 0xa0, 0xbc, 0xd7, 0x47, 0xcc, 0x3c, 0xb5, 0x61, 0x3d, 0x4c, 0x4e, 0x99, 0x79, 0x86, 0x0d,
-	0x2e, 0x2e, 0x98, 0x63, 0xcf, 0x5b, 0x6b, 0xbe, 0x49, 0xc3, 0x0f, 0x01, 0xd4, 0x21, 0xd6, 0x23,
-	0x44, 0xe5, 0x99, 0xc8, 0xca, 0x8b, 0x30, 0x39, 0xb5, 0x4d, 0xaa, 0xd6, 0xdf, 0xb2, 0xc8, 0x33,
-	0x07, 0x3c, 0x21, 0xa7, 0xf0, 0x25, 0x78, 0x67, 0x62, 0x8a, 0x20, 0x2e, 0x28, 0x3b, 0xf7, 0x57,
-	0xad, 0xc1, 0x8f, 0x67, 0x7b, 0x81, 0x9a, 0x54, 0x67, 0x86, 0x33, 0xf7, 0xff, 0xea, 0xcc, 0xea,
-	0x66, 0xa4, 0xcd, 0x17, 0xa0, 0x3e, 0x7d, 0x0a, 0xcc, 0x31, 0xd6, 0xeb, 0x60, 0xc5, 0x55, 0x73,
-	0xd1, 0xe2, 0xee, 0xd7, 0xe1, 0x77, 0xaf, 0x2e, 0x1b, 0xde, 0xc5, 0x65, 0xc3, 0xfb, 0xf3, 0xb2,
-	0xe1, 0xfd, 0x7e, 0xd5, 0x58, 0xb8, 0xb8, 0x6a, 0x2c, 0xfc, 0x71, 0xd5, 0x58, 0x78, 0xf1, 0x78,
-	0xc8, 0xcd, 0x28, 0x19, 0xb4, 0x89, 0x8c, 0x02, 0x22, 0x75, 0x24, 0x75, 0xf0, 0x26, 0xab, 0x8f,
-	0xca, 0xef, 0x94, 0xf4, 0x61, 0x70, 0x3e, 0xf9, 0xb1, 0x62, 0xc6, 0x31, 0xd3, 0x83, 0x15, 0xfb,
-	0x25, 0xf2, 0xf0, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x76, 0xce, 0xb9, 0x61, 0xa4, 0x09, 0x00,
-	0x00,
+	// 925 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xdd, 0x6e, 0xdb, 0x36,
+	0x14, 0x8e, 0x12, 0x37, 0x8d, 0x99, 0x9f, 0x65, 0x5c, 0xe6, 0x2a, 0x49, 0xe7, 0x06, 0x1e, 0x0a,
+	0x04, 0xd8, 0x66, 0x35, 0xe9, 0x2e, 0xba, 0x9f, 0x5e, 0x34, 0xed, 0xb0, 0x19, 0xc3, 0x30, 0xc3,
+	0x49, 0x33, 0xa0, 0xbb, 0x20, 0x68, 0x92, 0xb0, 0xd9, 0x48, 0xa4, 0x40, 0x52, 0x4a, 0x8c, 0x61,
+	0x40, 0x87, 0xed, 0x01, 0xf6, 0x58, 0xbd, 0xcc, 0xe5, 0xae, 0x8a, 0x21, 0x79, 0x83, 0x3d, 0xc1,
+	0x20, 0x8a, 0x52, 0xe5, 0xcc, 0x2e, 0xec, 0x5d, 0xd9, 0x3a, 0x1f, 0xcf, 0xf7, 0x9d, 0xc3, 0x43,
+	0x9e, 0x43, 0x70, 0xc0, 0x85, 0x61, 0x8a, 0x0c, 0x31, 0x17, 0x48, 0x33, 0x92, 0x28, 0x6e, 0x46,
+	0x01, 0x21, 0x69, 0x10, 0x2b, 0x99, 0x72, 0xca, 0x54, 0x90, 0x1e, 0x04, 0x03, 0x26, 0x98, 0xe6,
+	0xba, 0x1d, 0x2b, 0x69, 0x24, 0xfc, 0x78, 0x82, 0x4b, 0x9b, 0x90, 0xb4, 0x5d, 0xb8, 0xb4, 0xd3,
+	0x83, 0x9d, 0xad, 0x81, 0x1c, 0x48, 0xbb, 0x3e, 0xc8, 0xfe, 0xe5, 0xae, 0x3b, 0x0f, 0xa6, 0xa9,
+	0xa5, 0x07, 0x81, 0x1e, 0x62, 0xc5, 0x28, 0x22, 0x52, 0xe8, 0x24, 0x62, 0xca, 0x79, 0xdc, 0x7f,
+	0x87, 0xc7, 0x39, 0x57, 0xcc, 0x2d, 0x3b, 0x9c, 0x25, 0x8d, 0x32, 0xbe, 0xdc, 0xe7, 0xae, 0x61,
+	0x82, 0x32, 0x15, 0x71, 0x61, 0x02, 0xa2, 0x46, 0xb1, 0x91, 0xc1, 0x19, 0x1b, 0xb9, 0x2c, 0x5b,
+	0x97, 0xab, 0x60, 0xed, 0xdb, 0x3c, 0xef, 0x63, 0x83, 0x0d, 0x83, 0xfb, 0x60, 0x33, 0xc5, 0xa1,
+	0x66, 0x06, 0x25, 0x31, 0xc5, 0x86, 0x21, 0x4e, 0x7d, 0x6f, 0xcf, 0xdb, 0xaf, 0xf5, 0x36, 0x72,
+	0xfb, 0x73, 0x6b, 0xee, 0x50, 0xf8, 0x0b, 0x78, 0xaf, 0xc8, 0x02, 0xe9, 0xcc, 0x57, 0xfb, 0x8b,
+	0x7b, 0x4b, 0xfb, 0xab, 0x87, 0x87, 0xed, 0x19, 0xb6, 0xae, 0xfd, 0xd4, 0xf9, 0x5a, 0xd9, 0xa3,
+	0xe6, 0xeb, 0x37, 0xf7, 0x16, 0xfe, 0x79, 0x73, 0xaf, 0x31, 0xc2, 0x51, 0xf8, 0x65, 0xeb, 0x06,
+	0x71, 0xab, 0xb7, 0x41, 0xaa, 0xcb, 0x35, 0xfc, 0x19, 0xac, 0x27, 0xa2, 0x2f, 0x05, 0xe5, 0x62,
+	0x80, 0x64, 0xac, 0xfd, 0x25, 0x2b, 0xfd, 0x60, 0x26, 0xe9, 0xe7, 0x85, 0xe7, 0x8f, 0xf1, 0x51,
+	0x2d, 0x13, 0xee, 0xad, 0x25, 0x6f, 0x4d, 0x1a, 0xbe, 0x04, 0x5b, 0x11, 0x36, 0x89, 0x62, 0x68,
+	0x5c, 0xa3, 0xb6, 0xe7, 0xed, 0xaf, 0x1e, 0x3e, 0x9a, 0x49, 0xe3, 0x07, 0x4b, 0x40, 0x2b, 0x52,
+	0xba, 0x07, 0x73, 0xd6, 0xaa, 0x0d, 0xfe, 0x0a, 0x76, 0x6e, 0xee, 0x37, 0x32, 0x12, 0x0d, 0x19,
+	0x1f, 0x0c, 0x8d, 0x7f, 0xcb, 0x66, 0xf5, 0xd5, 0x4c, 0x8a, 0xa7, 0x63, 0xe5, 0x39, 0x91, 0xdf,
+	0x59, 0x0a, 0x97, 0x60, 0x23, 0x9d, 0x88, 0xc2, 0xdf, 0x3d, 0xb0, 0x5b, 0x6e, 0x36, 0xa6, 0x94,
+	0x1b, 0x2e, 0x05, 0x8a, 0x95, 0x8c, 0xa5, 0xc6, 0xa1, 0xf6, 0x97, 0x6d, 0x00, 0x8f, 0xe7, 0xaa,
+	0xe8, 0x13, 0x47, 0xd3, 0x75, 0x2c, 0x2e, 0x84, 0x6d, 0x32, 0x05, 0xd7, 0xf0, 0x95, 0x07, 0x76,
+	0xca, 0x28, 0x14, 0x8b, 0x64, 0x8a, 0xc3, 0x4a, 0x10, 0xb7, 0x6d, 0x10, 0x5f, 0xcf, 0x15, 0x44,
+	0x2f, 0x67, 0xb9, 0x11, 0x83, 0x4f, 0x26, 0xc3, 0x1a, 0x76, 0xc0, 0x72, 0x8c, 0x15, 0x8e, 0xb4,
+	0xbf, 0x62, 0xab, 0xfc, 0xc9, 0x4c, 0x6a, 0x5d, 0xeb, 0xe2, 0xc8, 0x1d, 0x81, 0xcd, 0x26, 0xc5,
+	0x21, 0xa7, 0xd8, 0x48, 0x55, 0xde, 0x74, 0x14, 0x27, 0xfd, 0xec, 0xe2, 0xf9, 0xf5, 0x39, 0xb2,
+	0x39, 0x2d, 0x68, 0x8a, 0xb4, 0xba, 0x49, 0xff, 0x7b, 0x36, 0x2a, 0xb2, 0x49, 0x27, 0xc0, 0x99,
+	0x06, 0xfc, 0xcd, 0x03, 0xbb, 0x25, 0xa8, 0x51, 0x7f, 0x84, 0xaa, 0x45, 0x56, 0x3e, 0xf8, 0x3f,
+	0x31, 0x1c, 0x8d, 0x2a, 0x15, 0x56, 0xff, 0x89, 0x41, 0x8f, 0xe3, 0x30, 0x05, 0x77, 0xc6, 0x44,
+	0x75, 0x76, 0xae, 0x63, 0x95, 0x08, 0xe6, 0xaf, 0x5a, 0xf9, 0x2f, 0xe6, 0x3d, 0x55, 0x4a, 0x9f,
+	0xc8, 0x6e, 0x46, 0xe0, 0xb4, 0xb7, 0xc8, 0x04, 0x0c, 0x9e, 0x83, 0x3b, 0x5c, 0x70, 0x83, 0x0c,
+	0x8f, 0x98, 0x4c, 0xf2, 0x5f, 0x6d, 0x70, 0x14, 0x6b, 0x7f, 0x6d, 0x0e, 0xdd, 0x8e, 0xe0, 0xe6,
+	0x24, 0xa7, 0x38, 0x29, 0x18, 0x9c, 0xee, 0x87, 0x7c, 0x02, 0xa6, 0xe1, 0x1f, 0x1e, 0xb8, 0xcb,
+	0x2e, 0x62, 0xa9, 0x0c, 0xa3, 0x28, 0xd5, 0x04, 0x69, 0x26, 0x68, 0x55, 0x7e, 0x7d, 0x8e, 0xcb,
+	0xf4, 0x8d, 0x23, 0x3a, 0xd5, 0xe4, 0x98, 0x09, 0x7a, 0x33, 0x84, 0x6d, 0x36, 0x05, 0xd7, 0xad,
+	0x57, 0x35, 0xb0, 0x3e, 0xd6, 0x5c, 0xe1, 0x36, 0x58, 0xc9, 0xd5, 0x5c, 0x2f, 0xaf, 0xf7, 0x6e,
+	0xdb, 0xef, 0x0e, 0x85, 0x1f, 0x01, 0x40, 0x86, 0x58, 0x08, 0x16, 0x66, 0xe0, 0xa2, 0x05, 0xeb,
+	0xce, 0xd2, 0xa1, 0x70, 0x17, 0xd4, 0x49, 0xc8, 0x99, 0x30, 0x19, 0xba, 0x64, 0xd1, 0x95, 0xdc,
+	0xd0, 0xa1, 0xf0, 0x3e, 0xd8, 0xc8, 0x36, 0x82, 0xe3, 0xb0, 0x68, 0x57, 0x35, 0x3b, 0x28, 0xd6,
+	0x9d, 0xd5, 0xb5, 0x18, 0x0c, 0x36, 0xcb, 0x73, 0xe0, 0x46, 0xac, 0x7f, 0xcb, 0xde, 0xb1, 0xe9,
+	0xdd, 0xba, 0x52, 0xf7, 0xea, 0x74, 0x72, 0xc9, 0x97, 0x73, 0xc7, 0x61, 0xd0, 0x80, 0x46, 0xcc,
+	0xf2, 0x3e, 0xed, 0x9a, 0x69, 0x96, 0xc2, 0x80, 0x15, 0xfd, 0xeb, 0xd1, 0xbb, 0x84, 0xca, 0xf3,
+	0x7d, 0xcc, 0xcc, 0x53, 0xeb, 0xd6, 0xc5, 0xe4, 0x8c, 0x99, 0x67, 0xd8, 0xe0, 0xe2, 0xa0, 0x39,
+	0xf6, 0xbc, 0xc5, 0xe6, 0x8b, 0x34, 0xfc, 0x14, 0x40, 0x1d, 0x62, 0x3d, 0x44, 0x54, 0x9e, 0x8b,
+	0xac, 0xcc, 0x08, 0x93, 0x33, 0xdb, 0xac, 0xea, 0xbd, 0x4d, 0x8b, 0x3c, 0x73, 0xc0, 0x13, 0x72,
+	0x06, 0x5f, 0x82, 0x0f, 0xc6, 0xa6, 0x09, 0xe2, 0x82, 0xb2, 0x0b, 0x7f, 0xc5, 0x06, 0xf8, 0xf9,
+	0x6c, 0x37, 0x51, 0x93, 0xea, 0xec, 0x70, 0xc1, 0xbd, 0x5f, 0x9d, 0x5d, 0x9d, 0x8c, 0xb4, 0xf5,
+	0x02, 0x34, 0x26, 0x4f, 0x83, 0x39, 0xc6, 0x7b, 0x03, 0x2c, 0xbb, 0xaa, 0x2e, 0x5a, 0xdc, 0x7d,
+	0x1d, 0xfd, 0xf4, 0xfa, 0xaa, 0xe9, 0x5d, 0x5e, 0x35, 0xbd, 0xbf, 0xaf, 0x9a, 0xde, 0x9f, 0xd7,
+	0xcd, 0x85, 0xcb, 0xeb, 0xe6, 0xc2, 0x5f, 0xd7, 0xcd, 0x85, 0x17, 0x8f, 0x07, 0xdc, 0x0c, 0x93,
+	0x7e, 0x9b, 0xc8, 0x28, 0x20, 0x52, 0x47, 0x52, 0x07, 0x6f, 0xb3, 0xfa, 0xac, 0x7c, 0xaf, 0xa4,
+	0x0f, 0x83, 0x8b, 0xf1, 0x47, 0x8b, 0x19, 0xc5, 0x4c, 0xf7, 0x97, 0xed, 0x8b, 0xe4, 0xe1, 0xbf,
+	0x01, 0x00, 0x00, 0xff, 0xff, 0x3f, 0x6e, 0x42, 0x2b, 0xac, 0x09, 0x00, 0x00,
 }
 
 func (m *GenesisState) Marshal() (dAtA []byte, err error) {
diff --git a/x/ccv/provider/types/genesis_test.go b/x/ccv/provider/types/genesis_test.go
index aba1a72e0e..7878afb0a4 100644
--- a/x/ccv/provider/types/genesis_test.go
+++ b/x/ccv/provider/types/genesis_test.go
@@ -452,7 +452,7 @@ func TestValidateGenesisState(t *testing.T) {
 				nil,
 				[]types.ConsumerState{{
 					ChainId: "chainid", ChannelId: "channel-0", ClientId: "client-id",
-					ConsumerGenesis: ccv.GenesisState{},
+					ConsumerGenesis: ccv.ConsumerGenesisState{},
 				}},
 				nil,
 				nil,
@@ -757,7 +757,7 @@ func TestValidateGenesisState(t *testing.T) {
 	}
 }
 
-func getInitialConsumerGenesis(t *testing.T, chainID string) ccv.GenesisState {
+func getInitialConsumerGenesis(t *testing.T, chainID string) ccv.ConsumerGenesisState {
 	t.Helper()
 	// generate validator public key
 	cId := crypto.NewCryptoIdentityFromIntSeed(239668)
@@ -782,5 +782,5 @@ func getInitialConsumerGenesis(t *testing.T, chainID string) ccv.GenesisState {
 
 	params := ccv.DefaultParams()
 	params.Enabled = true
-	return *ccv.NewInitialGenesisState(cs, consensusState, valUpdates, params)
+	return *ccv.NewInitialConsumerGenesisState(cs, consensusState, valUpdates, params)
 }
diff --git a/x/ccv/provider/types/query.pb.go b/x/ccv/provider/types/query.pb.go
index 9fc9178e09..eac75ded70 100644
--- a/x/ccv/provider/types/query.pb.go
+++ b/x/ccv/provider/types/query.pb.go
@@ -79,7 +79,7 @@ func (m *QueryConsumerGenesisRequest) GetChainId() string {
 }
 
 type QueryConsumerGenesisResponse struct {
-	GenesisState types.GenesisState `protobuf:"bytes,1,opt,name=genesis_state,json=genesisState,proto3" json:"genesis_state"`
+	GenesisState types.ConsumerGenesisState `protobuf:"bytes,1,opt,name=genesis_state,json=genesisState,proto3" json:"genesis_state"`
 }
 
 func (m *QueryConsumerGenesisResponse) Reset()         { *m = QueryConsumerGenesisResponse{} }
@@ -115,11 +115,11 @@ func (m *QueryConsumerGenesisResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryConsumerGenesisResponse proto.InternalMessageInfo
 
-func (m *QueryConsumerGenesisResponse) GetGenesisState() types.GenesisState {
+func (m *QueryConsumerGenesisResponse) GetGenesisState() types.ConsumerGenesisState {
 	if m != nil {
 		return m.GenesisState
 	}
-	return types.GenesisState{}
+	return types.ConsumerGenesisState{}
 }
 
 type QueryConsumerChainsRequest struct {
@@ -1068,90 +1068,90 @@ func init() {
 }
 
 var fileDescriptor_422512d7b7586cd7 = []byte{
-	// 1323 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xcf, 0x6f, 0x1b, 0xc5,
-	0x1f, 0xf5, 0x3a, 0x69, 0x9a, 0x4c, 0xfa, 0xfd, 0xb6, 0x4c, 0x4b, 0x71, 0xb7, 0x95, 0x5d, 0xb6,
-	0x02, 0xd2, 0x16, 0x76, 0x1b, 0x57, 0x48, 0x6d, 0x21, 0x75, 0xed, 0x24, 0xa4, 0x51, 0x1b, 0x35,
-	0xac, 0xab, 0x56, 0x02, 0xd4, 0x65, 0xb2, 0x3b, 0xd8, 0x2b, 0xd6, 0x3b, 0xdb, 0x99, 0xb1, 0xd3,
-	0x80, 0x38, 0x00, 0x12, 0xf4, 0x58, 0x09, 0x71, 0xe3, 0xd0, 0x13, 0xff, 0x05, 0xf7, 0xde, 0xa8,
-	0xe8, 0xa5, 0xa7, 0x82, 0x12, 0x0e, 0x1c, 0x11, 0x77, 0x24, 0xb4, 0xb3, 0xb3, 0xfe, 0x11, 0x6f,
-	0xec, 0xb5, 0x9b, 0x9b, 0x3d, 0x3b, 0x9f, 0xf7, 0x79, 0xef, 0xe9, 0x33, 0xb3, 0x6f, 0x81, 0xe1,
-	0xfa, 0x1c, 0x53, 0xbb, 0x8e, 0x5c, 0xdf, 0x62, 0xd8, 0x6e, 0x52, 0x97, 0x6f, 0x19, 0xb6, 0xdd,
-	0x32, 0x02, 0x4a, 0x5a, 0xae, 0x83, 0xa9, 0xd1, 0x9a, 0x37, 0xee, 0x37, 0x31, 0xdd, 0xd2, 0x03,
-	0x4a, 0x38, 0x81, 0x67, 0x12, 0x0a, 0x74, 0xdb, 0x6e, 0xe9, 0x71, 0x81, 0xde, 0x9a, 0x57, 0x4f,
-	0xd5, 0x08, 0xa9, 0x79, 0xd8, 0x40, 0x81, 0x6b, 0x20, 0xdf, 0x27, 0x1c, 0x71, 0x97, 0xf8, 0x2c,
-	0x82, 0x50, 0x8f, 0xd5, 0x48, 0x8d, 0x88, 0x9f, 0x46, 0xf8, 0x4b, 0xae, 0x16, 0x64, 0x8d, 0xf8,
-	0xb7, 0xd1, 0xfc, 0xcc, 0xe0, 0x6e, 0x03, 0x33, 0x8e, 0x1a, 0x81, 0xdc, 0x50, 0x4c, 0x43, 0xb5,
-	0xcd, 0x22, 0xaa, 0xb9, 0xb0, 0x57, 0x4d, 0x6b, 0xde, 0x60, 0x75, 0x44, 0xb1, 0x63, 0xd9, 0xc4,
-	0x67, 0xcd, 0x46, 0xbb, 0xe2, 0x8d, 0x01, 0x15, 0x9b, 0x2e, 0xc5, 0xd1, 0x36, 0xed, 0x12, 0x38,
-	0xf9, 0x61, 0xe8, 0xca, 0xa2, 0xac, 0x5e, 0xc1, 0x3e, 0x66, 0x2e, 0x33, 0xf1, 0xfd, 0x26, 0x66,
-	0x1c, 0x9e, 0x00, 0xd3, 0x11, 0x84, 0xeb, 0xe4, 0x94, 0xd3, 0xca, 0xdc, 0x8c, 0x79, 0x50, 0xfc,
-	0x5f, 0x75, 0x34, 0x06, 0x4e, 0x25, 0x57, 0xb2, 0x80, 0xf8, 0x0c, 0xc3, 0x2a, 0xf8, 0x5f, 0x2d,
-	0x5a, 0xb2, 0x18, 0x47, 0x1c, 0x8b, 0xfa, 0xd9, 0xe2, 0x9c, 0xbe, 0x97, 0xf1, 0xad, 0x79, 0x5d,
-	0x62, 0x54, 0xc3, 0xfd, 0x95, 0xc9, 0x27, 0x2f, 0x0a, 0x19, 0xf3, 0x50, 0xad, 0x6b, 0x4d, 0x3b,
-	0x05, 0xd4, 0x9e, 0xa6, 0x8b, 0x21, 0x4c, 0xcc, 0x56, 0x43, 0xbb, 0xc4, 0xc4, 0x4f, 0x25, 0xa3,
-	0x0a, 0x98, 0x12, 0x6d, 0x59, 0x4e, 0x39, 0x3d, 0x31, 0x37, 0x5b, 0x3c, 0xa7, 0xa7, 0x98, 0x01,
-	0x5d, 0x80, 0x98, 0xb2, 0x52, 0x3b, 0x0b, 0xde, 0xea, 0x6f, 0x51, 0xe5, 0x88, 0xf2, 0x75, 0x4a,
-	0x02, 0xc2, 0x90, 0xd7, 0x66, 0xf3, 0x50, 0x01, 0x73, 0xc3, 0xf7, 0x4a, 0x6e, 0x9f, 0x80, 0x99,
-	0x20, 0x5e, 0x94, 0x4e, 0x5d, 0x4d, 0x47, 0x4f, 0x82, 0x97, 0x1d, 0xc7, 0x0d, 0x87, 0xb3, 0x03,
-	0xdd, 0x01, 0xd4, 0xe6, 0xc0, 0x9b, 0x49, 0x4c, 0x48, 0xd0, 0x47, 0xfa, 0x3b, 0x25, 0x59, 0x60,
-	0xcf, 0x56, 0xc9, 0xf9, 0xe3, 0x7e, 0xce, 0x0b, 0x23, 0x71, 0x36, 0x71, 0x83, 0xb4, 0x90, 0x97,
-	0x48, 0xb9, 0x04, 0x0e, 0x88, 0xd6, 0x03, 0x46, 0x10, 0x9e, 0x04, 0x33, 0xb6, 0xe7, 0x62, 0x9f,
-	0x87, 0xcf, 0xb2, 0xe2, 0xd9, 0x74, 0xb4, 0xb0, 0xea, 0x68, 0xdf, 0x2b, 0xe0, 0x75, 0xa1, 0xe4,
-	0x0e, 0xf2, 0x5c, 0x07, 0x71, 0x42, 0xbb, 0xac, 0xa2, 0xc3, 0x07, 0x1c, 0x2e, 0x80, 0x23, 0x31,
-	0x69, 0x0b, 0x39, 0x0e, 0xc5, 0x8c, 0x45, 0x4d, 0x2a, 0xf0, 0x9f, 0x17, 0x85, 0xff, 0x6f, 0xa1,
-	0x86, 0x77, 0x45, 0x93, 0x0f, 0x34, 0xf3, 0x70, 0xbc, 0xb7, 0x1c, 0xad, 0x5c, 0x99, 0x7e, 0xf8,
-	0xb8, 0x90, 0xf9, 0xeb, 0x71, 0x21, 0xa3, 0xdd, 0x02, 0xda, 0x20, 0x22, 0xd2, 0xcd, 0xb3, 0xe0,
-	0x48, 0x7c, 0x84, 0xdb, 0xed, 0x22, 0x46, 0x87, 0xed, 0xae, 0xfd, 0x61, 0xb3, 0x7e, 0x69, 0xeb,
-	0x5d, 0xcd, 0xd3, 0x49, 0xeb, 0xeb, 0x35, 0x40, 0xda, 0xae, 0xfe, 0x83, 0xa4, 0xf5, 0x12, 0xe9,
-	0x48, 0xeb, 0x73, 0x52, 0x4a, 0xdb, 0xe5, 0x9a, 0x76, 0x12, 0x9c, 0x10, 0x80, 0xb7, 0xeb, 0x94,
-	0x70, 0xee, 0x61, 0x71, 0xec, 0xe3, 0xe1, 0xfc, 0x39, 0x2b, 0x8f, 0xff, 0xae, 0xa7, 0xb2, 0x4d,
-	0x01, 0xcc, 0x32, 0x0f, 0xb1, 0xba, 0xd5, 0xc0, 0x1c, 0x53, 0xd1, 0x61, 0xc2, 0x04, 0x62, 0x69,
-	0x2d, 0x5c, 0x81, 0x45, 0xf0, 0x6a, 0xd7, 0x06, 0x0b, 0x79, 0x1e, 0xd9, 0x44, 0xbe, 0x8d, 0x85,
-	0xf6, 0x09, 0xf3, 0x68, 0x67, 0x6b, 0x39, 0x7e, 0x04, 0xef, 0x81, 0x9c, 0x8f, 0x1f, 0x70, 0x8b,
-	0xe2, 0xc0, 0xc3, 0xbe, 0xcb, 0xea, 0x96, 0x8d, 0x7c, 0x27, 0x14, 0x8b, 0x73, 0x13, 0x62, 0xe6,
-	0x55, 0x3d, 0xba, 0xf1, 0xf5, 0xf8, 0xc6, 0xd7, 0x6f, 0xc7, 0x37, 0x7e, 0x65, 0x3a, 0xbc, 0xc3,
-	0x1e, 0xfd, 0x5e, 0x50, 0xcc, 0xe3, 0x21, 0x8a, 0x19, 0x83, 0x2c, 0xc6, 0x18, 0xb0, 0x0a, 0x0e,
-	0x06, 0xc8, 0xfe, 0x1c, 0x73, 0x96, 0x9b, 0x14, 0xb7, 0xd2, 0xe5, 0x54, 0x47, 0x28, 0x76, 0xc0,
-	0xa9, 0x86, 0x9c, 0xd7, 0x05, 0x82, 0x19, 0x23, 0x69, 0x4b, 0xf2, 0x10, 0xb7, 0x77, 0xc5, 0x13,
-	0x17, 0x6d, 0x5c, 0x42, 0x1c, 0xa5, 0xb8, 0xe1, 0x7f, 0x8b, 0x2f, 0xb0, 0x81, 0x30, 0xd2, 0xfc,
-	0x01, 0xd3, 0x06, 0xc1, 0x24, 0x73, 0xbf, 0x88, 0x5c, 0x9e, 0x34, 0xc5, 0x6f, 0xb8, 0x09, 0x8e,
-	0x06, 0x6d, 0x90, 0x55, 0x9f, 0xf1, 0xd0, 0x6c, 0x96, 0x9b, 0x10, 0x16, 0x94, 0x46, 0xb3, 0xa0,
-	0xc3, 0xe6, 0x2e, 0x45, 0x41, 0x80, 0xa9, 0x7c, 0x75, 0x24, 0x75, 0xd0, 0x7e, 0x51, 0xc0, 0xb1,
-	0x24, 0xf3, 0xe0, 0x3d, 0x70, 0xa8, 0xe6, 0x91, 0x0d, 0xe4, 0x59, 0xd8, 0xe7, 0x74, 0x4b, 0x5e,
-	0x68, 0xef, 0xa6, 0xa2, 0xb2, 0x22, 0x0a, 0x05, 0xda, 0x72, 0x58, 0x2c, 0x09, 0xcc, 0x46, 0x80,
-	0x62, 0x09, 0x2e, 0x83, 0x49, 0x07, 0x71, 0x24, 0x5c, 0x98, 0x2d, 0x9e, 0x1f, 0xf4, 0x1a, 0xec,
-	0xa2, 0x15, 0x92, 0x97, 0x68, 0xa2, 0x5c, 0x7b, 0xae, 0x00, 0x75, 0x6f, 0xe5, 0x70, 0x1d, 0x1c,
-	0x8a, 0x46, 0x3c, 0xd2, 0x2e, 0x55, 0x8c, 0xd2, 0xed, 0x7a, 0xc6, 0x8c, 0x8e, 0x91, 0xf4, 0xe5,
-	0x53, 0x00, 0x5b, 0xcc, 0xb6, 0x1a, 0x88, 0x37, 0xc3, 0x98, 0x21, 0x71, 0x23, 0x15, 0x17, 0x06,
-	0xe1, 0xde, 0xa9, 0x2e, 0xae, 0x45, 0x45, 0x3d, 0xe0, 0x47, 0x5a, 0xcc, 0xee, 0x59, 0xaf, 0x4c,
-	0x45, 0xce, 0x68, 0x6f, 0x83, 0x73, 0x62, 0xdc, 0x4c, 0x5c, 0x73, 0x19, 0xc7, 0xb4, 0x33, 0x6f,
-	0x26, 0xde, 0x44, 0xd4, 0x59, 0xc2, 0x3e, 0x69, 0xb4, 0xdf, 0x54, 0xcb, 0xe0, 0x7c, 0xaa, 0xdd,
-	0x72, 0x3e, 0x8f, 0x83, 0x29, 0x47, 0xac, 0x88, 0x97, 0xff, 0x8c, 0x29, 0xff, 0x15, 0x7f, 0x7a,
-	0x05, 0x1c, 0x10, 0x38, 0x70, 0x5b, 0x01, 0xc7, 0x92, 0x12, 0x0d, 0xbc, 0x96, 0x6a, 0x06, 0x06,
-	0xc4, 0x28, 0xb5, 0xfc, 0x12, 0x08, 0x11, 0x7f, 0x6d, 0xf9, 0x9b, 0x67, 0x7f, 0xfe, 0x90, 0x2d,
-	0xc1, 0x85, 0xe1, 0x49, 0xb7, 0x7d, 0xb5, 0xcb, 0xe8, 0x64, 0x7c, 0x19, 0x9f, 0xcc, 0xaf, 0xe0,
-	0x33, 0x05, 0x1c, 0x4d, 0xc8, 0x48, 0xb0, 0x34, 0x3a, 0xc3, 0x9e, 0xec, 0xa5, 0x5e, 0x1b, 0x1f,
-	0x40, 0x2a, 0xbc, 0x2c, 0x14, 0x5e, 0x84, 0xf3, 0x23, 0x28, 0x8c, 0x52, 0x19, 0xfc, 0x3a, 0x0b,
-	0x72, 0x7b, 0x44, 0x2d, 0x06, 0x6f, 0x8e, 0xc9, 0x2c, 0x31, 0xd5, 0xa9, 0x6b, 0xfb, 0x84, 0x26,
-	0x45, 0x5f, 0x17, 0xa2, 0x2b, 0xf0, 0xda, 0xa8, 0xa2, 0xc3, 0x50, 0x4d, 0xb9, 0xd5, 0x0e, 0x4c,
-	0xf0, 0x5f, 0x05, 0xbc, 0x96, 0x9c, 0xdc, 0x18, 0xbc, 0x31, 0x36, 0xe9, 0xfe, 0x88, 0xa8, 0xde,
-	0xdc, 0x1f, 0x30, 0x69, 0xc0, 0x8a, 0x30, 0xa0, 0x0c, 0x4b, 0x63, 0x18, 0x40, 0x82, 0x2e, 0xfd,
-	0x7f, 0x2b, 0x32, 0x1c, 0x24, 0xc6, 0x2c, 0xf8, 0x41, 0x7a, 0xd6, 0x83, 0x02, 0xa3, 0xba, 0xf2,
-	0xd2, 0x38, 0x52, 0x78, 0x59, 0x08, 0x7f, 0x0f, 0x5e, 0x4e, 0xf1, 0xe9, 0x1a, 0x03, 0x59, 0x3d,
-	0xa9, 0x2d, 0x41, 0x72, 0x77, 0xfc, 0x1a, 0x4b, 0x72, 0x42, 0x90, 0x1c, 0x4b, 0x72, 0x52, 0x0e,
-	0x1c, 0x4f, 0x72, 0x4f, 0x72, 0x84, 0xbf, 0x2a, 0x00, 0xf6, 0x47, 0x40, 0x78, 0x35, 0x3d, 0xc5,
-	0xa4, 0x64, 0xa9, 0x96, 0xc6, 0xae, 0x97, 0xd2, 0x2e, 0x09, 0x69, 0x45, 0x78, 0x61, 0xb8, 0x34,
-	0x2e, 0x01, 0xa2, 0xcf, 0x62, 0xf8, 0x6d, 0x16, 0x9c, 0x1e, 0x96, 0xb2, 0x46, 0xb9, 0xc3, 0x86,
-	0x67, 0xbe, 0x51, 0xee, 0xb0, 0x14, 0xd1, 0x4f, 0xab, 0x08, 0xed, 0xef, 0xc3, 0x2b, 0xc3, 0xb5,
-	0x07, 0xd8, 0x77, 0x5c, 0xbf, 0xd6, 0x99, 0x63, 0x99, 0x58, 0xe1, 0x8f, 0x59, 0x70, 0x26, 0xc5,
-	0xeb, 0x1c, 0xde, 0x4a, 0x4f, 0x3d, 0x55, 0x8c, 0x50, 0xd7, 0xf7, 0x0f, 0x50, 0xda, 0x71, 0x43,
-	0xd8, 0xb1, 0x0c, 0x17, 0x87, 0xdb, 0x41, 0xdb, 0x88, 0x1d, 0x47, 0xa8, 0xc0, 0xb4, 0xa2, 0x78,
-	0x52, 0xb9, 0xfb, 0x64, 0x3b, 0xaf, 0x3c, 0xdd, 0xce, 0x2b, 0x7f, 0x6c, 0xe7, 0x95, 0x47, 0x3b,
-	0xf9, 0xcc, 0xd3, 0x9d, 0x7c, 0xe6, 0xf9, 0x4e, 0x3e, 0xf3, 0xd1, 0x42, 0xcd, 0xe5, 0xf5, 0xe6,
-	0x86, 0x6e, 0x93, 0x86, 0x61, 0x13, 0xd6, 0x20, 0xac, 0xab, 0xdf, 0x3b, 0xed, 0x7e, 0xad, 0x8b,
-	0xc6, 0x83, 0x5d, 0xf3, 0xb7, 0x15, 0x60, 0xb6, 0x31, 0x25, 0xbe, 0x56, 0x2e, 0xfe, 0x17, 0x00,
-	0x00, 0xff, 0xff, 0x84, 0xab, 0xda, 0x7b, 0x39, 0x13, 0x00, 0x00,
+	// 1321 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xcf, 0x8f, 0x14, 0x45,
+	0x18, 0x9d, 0x9e, 0x5d, 0x96, 0xdd, 0x5a, 0x14, 0x2c, 0x10, 0x87, 0x86, 0xcc, 0x60, 0x13, 0x75,
+	0x01, 0xed, 0x66, 0x87, 0x98, 0x00, 0xba, 0x0c, 0x33, 0xcb, 0xba, 0x10, 0x20, 0xac, 0xbd, 0x04,
+	0x12, 0x35, 0xb4, 0xb5, 0xdd, 0xe5, 0x4c, 0xc7, 0x9e, 0xae, 0xa6, 0xaa, 0x66, 0x96, 0x95, 0x78,
+	0x50, 0x13, 0xe5, 0x48, 0x62, 0xbc, 0x79, 0xe0, 0xe4, 0x7f, 0xe1, 0x9d, 0x9b, 0x44, 0x2e, 0x9c,
+	0xd0, 0x2c, 0x1e, 0x3c, 0x1a, 0xef, 0x26, 0xa6, 0xab, 0xab, 0x7b, 0x7e, 0xf5, 0xce, 0xf4, 0x0c,
+	0xdc, 0x66, 0xaa, 0xeb, 0x7b, 0xdf, 0x7b, 0x6f, 0xbe, 0xaa, 0x7e, 0x03, 0x0c, 0xd7, 0xe7, 0x98,
+	0xda, 0x0d, 0xe4, 0xfa, 0x16, 0xc3, 0x76, 0x8b, 0xba, 0x7c, 0xcb, 0xb0, 0xed, 0xb6, 0x11, 0x50,
+	0xd2, 0x76, 0x1d, 0x4c, 0x8d, 0xf6, 0xa2, 0x71, 0xa7, 0x85, 0xe9, 0x96, 0x1e, 0x50, 0xc2, 0x09,
+	0x3c, 0x96, 0x52, 0xa0, 0xdb, 0x76, 0x5b, 0x8f, 0x0b, 0xf4, 0xf6, 0xa2, 0x7a, 0xa4, 0x4e, 0x48,
+	0xdd, 0xc3, 0x06, 0x0a, 0x5c, 0x03, 0xf9, 0x3e, 0xe1, 0x88, 0xbb, 0xc4, 0x67, 0x11, 0x84, 0x7a,
+	0xa0, 0x4e, 0xea, 0x44, 0x7c, 0x34, 0xc2, 0x4f, 0x72, 0xb5, 0x24, 0x6b, 0xc4, 0xb7, 0x8d, 0xd6,
+	0x17, 0x06, 0x77, 0x9b, 0x98, 0x71, 0xd4, 0x0c, 0xe4, 0x86, 0x72, 0x16, 0xaa, 0x09, 0x8b, 0xa8,
+	0xe6, 0xd4, 0x4e, 0x35, 0xed, 0x45, 0x83, 0x35, 0x10, 0xc5, 0x8e, 0x65, 0x13, 0x9f, 0xb5, 0x9a,
+	0x49, 0xc5, 0x5b, 0x43, 0x2a, 0x36, 0x5d, 0x8a, 0xa3, 0x6d, 0xda, 0x19, 0x70, 0xf8, 0xe3, 0xd0,
+	0x95, 0x65, 0x59, 0xbd, 0x8a, 0x7d, 0xcc, 0x5c, 0x66, 0xe2, 0x3b, 0x2d, 0xcc, 0x38, 0x3c, 0x04,
+	0x66, 0x23, 0x08, 0xd7, 0x29, 0x28, 0x47, 0x95, 0x85, 0x39, 0x73, 0xb7, 0xf8, 0x7e, 0xd9, 0xd1,
+	0xee, 0x81, 0x23, 0xe9, 0x95, 0x2c, 0x20, 0x3e, 0xc3, 0xf0, 0x53, 0xf0, 0x4a, 0x3d, 0x5a, 0xb2,
+	0x18, 0x47, 0x1c, 0x8b, 0xfa, 0xf9, 0xf2, 0x29, 0x7d, 0x27, 0xe3, 0xdb, 0x8b, 0x7a, 0x1f, 0xd6,
+	0x7a, 0x58, 0x57, 0x9b, 0x7e, 0xf4, 0xac, 0x94, 0x33, 0xf7, 0xd4, 0xbb, 0xd6, 0xb4, 0x23, 0x40,
+	0xed, 0x69, 0xbe, 0x1c, 0xc2, 0xc5, 0xac, 0x35, 0xd4, 0x27, 0x2a, 0x7e, 0x2a, 0x99, 0xd5, 0xc0,
+	0x8c, 0x68, 0xcf, 0x0a, 0xca, 0xd1, 0xa9, 0x85, 0xf9, 0xf2, 0x09, 0x3d, 0xc3, 0x2c, 0xe8, 0x02,
+	0xc4, 0x94, 0x95, 0xda, 0x71, 0xf0, 0xce, 0x60, 0x8b, 0x75, 0x8e, 0x28, 0x5f, 0xa3, 0x24, 0x20,
+	0x0c, 0x79, 0x09, 0x9b, 0xfb, 0x0a, 0x58, 0x18, 0xbd, 0x57, 0x72, 0xfb, 0x0c, 0xcc, 0x05, 0xf1,
+	0xa2, 0x74, 0xec, 0x7c, 0x36, 0x7a, 0x12, 0xbc, 0xea, 0x38, 0x6e, 0x38, 0xa4, 0x1d, 0xe8, 0x0e,
+	0xa0, 0xb6, 0x00, 0xde, 0x4e, 0x63, 0x42, 0x82, 0x01, 0xd2, 0xdf, 0x2b, 0xe9, 0x02, 0x7b, 0xb6,
+	0x26, 0xbf, 0xf4, 0x00, 0xe7, 0xa5, 0xb1, 0x38, 0x9b, 0xb8, 0x49, 0xda, 0xc8, 0x4b, 0xa5, 0x5c,
+	0x01, 0xbb, 0x44, 0xeb, 0x21, 0xa3, 0x08, 0x0f, 0x83, 0x39, 0xdb, 0x73, 0xb1, 0xcf, 0xc3, 0x67,
+	0x79, 0xf1, 0x6c, 0x36, 0x5a, 0xb8, 0xec, 0x68, 0x3f, 0x28, 0xe0, 0x4d, 0xa1, 0xe4, 0x26, 0xf2,
+	0x5c, 0x07, 0x71, 0x42, 0xbb, 0xac, 0xa2, 0xa3, 0x07, 0x1d, 0x2e, 0x81, 0x7d, 0x31, 0x69, 0x0b,
+	0x39, 0x0e, 0xc5, 0x8c, 0x45, 0x4d, 0x6a, 0xf0, 0xdf, 0x67, 0xa5, 0x57, 0xb7, 0x50, 0xd3, 0x3b,
+	0xa7, 0xc9, 0x07, 0x9a, 0xb9, 0x37, 0xde, 0x5b, 0x8d, 0x56, 0xce, 0xcd, 0xde, 0x7f, 0x58, 0xca,
+	0xfd, 0xfd, 0xb0, 0x94, 0xd3, 0xae, 0x03, 0x6d, 0x18, 0x11, 0xe9, 0xe6, 0x71, 0xb0, 0x2f, 0x3e,
+	0xca, 0x49, 0xbb, 0x88, 0xd1, 0x5e, 0xbb, 0x6b, 0x7f, 0xd8, 0x6c, 0x50, 0xda, 0x5a, 0x57, 0xf3,
+	0x6c, 0xd2, 0x06, 0x7a, 0x0d, 0x91, 0xd6, 0xd7, 0x7f, 0x98, 0xb4, 0x5e, 0x22, 0x1d, 0x69, 0x03,
+	0x4e, 0x4a, 0x69, 0x7d, 0xae, 0x69, 0x87, 0xc1, 0x21, 0x01, 0x78, 0xa3, 0x41, 0x09, 0xe7, 0x1e,
+	0x16, 0xc7, 0x3e, 0x1e, 0xce, 0x5f, 0xf2, 0xf2, 0xf8, 0xf7, 0x3d, 0x95, 0x6d, 0x4a, 0x60, 0x9e,
+	0x79, 0x88, 0x35, 0xac, 0x26, 0xe6, 0x98, 0x8a, 0x0e, 0x53, 0x26, 0x10, 0x4b, 0xd7, 0xc2, 0x15,
+	0x58, 0x06, 0xaf, 0x77, 0x6d, 0xb0, 0x90, 0xe7, 0x91, 0x4d, 0xe4, 0xdb, 0x58, 0x68, 0x9f, 0x32,
+	0xf7, 0x77, 0xb6, 0x56, 0xe3, 0x47, 0xf0, 0x36, 0x28, 0xf8, 0xf8, 0x2e, 0xb7, 0x28, 0x0e, 0x3c,
+	0xec, 0xbb, 0xac, 0x61, 0xd9, 0xc8, 0x77, 0x42, 0xb1, 0xb8, 0x30, 0x25, 0x66, 0x5e, 0xd5, 0xa3,
+	0x9b, 0x5f, 0x8f, 0x6f, 0x7e, 0xfd, 0x46, 0x7c, 0xf3, 0xd7, 0x66, 0xc3, 0x3b, 0xec, 0xc1, 0x1f,
+	0x25, 0xc5, 0x3c, 0x18, 0xa2, 0x98, 0x31, 0xc8, 0x72, 0x8c, 0x01, 0xd7, 0xc1, 0xee, 0x00, 0xd9,
+	0x5f, 0x62, 0xce, 0x0a, 0xd3, 0xe2, 0x56, 0x3a, 0x9b, 0xe9, 0x08, 0xc5, 0x0e, 0x38, 0xeb, 0x21,
+	0xe7, 0x35, 0x81, 0x60, 0xc6, 0x48, 0xda, 0x45, 0x79, 0x88, 0x93, 0x5d, 0xf1, 0xc4, 0x45, 0x1b,
+	0x2f, 0x22, 0x8e, 0x32, 0xdc, 0xf4, 0xbf, 0xc7, 0x17, 0xd8, 0x50, 0x18, 0x69, 0xfe, 0x90, 0x69,
+	0x83, 0x60, 0x9a, 0xb9, 0x5f, 0x45, 0x2e, 0x4f, 0x9b, 0xe2, 0x33, 0xdc, 0x04, 0xfb, 0x83, 0x04,
+	0xe4, 0xb2, 0xcf, 0x78, 0x68, 0x36, 0x2b, 0x4c, 0x09, 0x0b, 0x2a, 0xe3, 0x59, 0xd0, 0x61, 0x73,
+	0x8b, 0xa2, 0x20, 0xc0, 0x54, 0xbe, 0x3a, 0xd2, 0x3a, 0x68, 0xbf, 0x2a, 0xe0, 0x40, 0x9a, 0x79,
+	0xf0, 0x36, 0xd8, 0x53, 0xf7, 0xc8, 0x06, 0xf2, 0x2c, 0xec, 0x73, 0xba, 0x25, 0x2f, 0xb4, 0xf7,
+	0x33, 0x51, 0x59, 0x15, 0x85, 0x02, 0x6d, 0x25, 0x2c, 0x96, 0x04, 0xe6, 0x23, 0x40, 0xb1, 0x04,
+	0x57, 0xc0, 0xb4, 0x83, 0x38, 0x12, 0x2e, 0xcc, 0x97, 0x4f, 0x0e, 0x7b, 0x1d, 0x76, 0xd1, 0x0a,
+	0xc9, 0x4b, 0x34, 0x51, 0xae, 0x3d, 0x55, 0x80, 0xba, 0xb3, 0x72, 0xb8, 0x06, 0xf6, 0x44, 0x23,
+	0x1e, 0x69, 0x97, 0x2a, 0xc6, 0xe9, 0x76, 0x29, 0x67, 0x46, 0xc7, 0x48, 0xfa, 0xf2, 0x39, 0x80,
+	0x6d, 0x66, 0x5b, 0x4d, 0xc4, 0x5b, 0x61, 0xdc, 0x90, 0xb8, 0xf9, 0xd1, 0x2f, 0xf5, 0x9b, 0xeb,
+	0xcb, 0xd7, 0xa2, 0xa2, 0x1e, 0xf0, 0x7d, 0x6d, 0x66, 0xf7, 0xac, 0xd7, 0x66, 0x22, 0x67, 0xb4,
+	0x77, 0xc1, 0x09, 0x31, 0x6e, 0x26, 0xae, 0xbb, 0x8c, 0x63, 0xda, 0x99, 0x37, 0x13, 0x6f, 0x22,
+	0xea, 0x5c, 0xc4, 0x3e, 0x69, 0x26, 0x6f, 0xaa, 0x15, 0x70, 0x32, 0xd3, 0x6e, 0x39, 0x9f, 0x07,
+	0xc1, 0x8c, 0x23, 0x56, 0xc4, 0xcb, 0x7f, 0xce, 0x94, 0xdf, 0xca, 0x3f, 0xbf, 0x06, 0x76, 0x09,
+	0x1c, 0xb8, 0xad, 0x80, 0x03, 0x69, 0xc9, 0x06, 0x5e, 0xc8, 0x34, 0x03, 0x43, 0xe2, 0x94, 0x5a,
+	0x7d, 0x01, 0x84, 0x88, 0xbf, 0xb6, 0xf2, 0xed, 0x93, 0xbf, 0x7e, 0xcc, 0x57, 0xe0, 0xd2, 0xe8,
+	0xc4, 0x9b, 0x5c, 0xed, 0x32, 0x3a, 0x19, 0xf7, 0xe2, 0x93, 0xf9, 0x35, 0x7c, 0xa2, 0x80, 0xfd,
+	0x29, 0x19, 0x09, 0x56, 0xc6, 0x67, 0xd8, 0x93, 0xbd, 0xd4, 0x0b, 0x93, 0x03, 0x48, 0x85, 0x67,
+	0x85, 0xc2, 0xd3, 0x70, 0x71, 0x0c, 0x85, 0x51, 0x2a, 0x83, 0xdf, 0xe4, 0x41, 0x61, 0x87, 0xa8,
+	0xc5, 0xe0, 0xd5, 0x09, 0x99, 0xa5, 0xa6, 0x3a, 0xf5, 0xda, 0x4b, 0x42, 0x93, 0xa2, 0x2f, 0x09,
+	0xd1, 0x35, 0x78, 0x61, 0x5c, 0xd1, 0x61, 0xb8, 0xa6, 0xdc, 0x4a, 0x02, 0x13, 0xfc, 0x4f, 0x01,
+	0x6f, 0xa4, 0x27, 0x37, 0x06, 0xaf, 0x4c, 0x4c, 0x7a, 0x30, 0x22, 0xaa, 0x57, 0x5f, 0x0e, 0x98,
+	0x34, 0x60, 0x55, 0x18, 0x50, 0x85, 0x95, 0x09, 0x0c, 0x20, 0x41, 0x97, 0xfe, 0x7f, 0x14, 0x19,
+	0x0e, 0x52, 0x63, 0x16, 0xfc, 0x28, 0x3b, 0xeb, 0x61, 0x81, 0x51, 0x5d, 0x7d, 0x61, 0x1c, 0x29,
+	0xbc, 0x2a, 0x84, 0x7f, 0x00, 0xcf, 0x66, 0xf8, 0x0b, 0x1b, 0x03, 0x59, 0x3d, 0xa9, 0x2d, 0x45,
+	0x72, 0x77, 0xfc, 0x9a, 0x48, 0x72, 0x4a, 0x90, 0x9c, 0x48, 0x72, 0x5a, 0x0e, 0x9c, 0x4c, 0x72,
+	0x4f, 0x72, 0x84, 0xbf, 0x29, 0x00, 0x0e, 0x46, 0x40, 0x78, 0x3e, 0x3b, 0xc5, 0xb4, 0x64, 0xa9,
+	0x56, 0x26, 0xae, 0x97, 0xd2, 0xce, 0x08, 0x69, 0x65, 0x78, 0x6a, 0xb4, 0x34, 0x2e, 0x01, 0xa2,
+	0xbf, 0xc7, 0xf0, 0xbb, 0x3c, 0x38, 0x3a, 0x2a, 0x65, 0x8d, 0x73, 0x87, 0x8d, 0xce, 0x7c, 0xe3,
+	0xdc, 0x61, 0x19, 0xa2, 0x9f, 0x56, 0x13, 0xda, 0x3f, 0x84, 0xe7, 0x46, 0x6b, 0x0f, 0xb0, 0xef,
+	0xb8, 0x7e, 0xbd, 0x33, 0xc7, 0x32, 0xb1, 0xc2, 0x9f, 0xf2, 0xe0, 0x58, 0x86, 0xd7, 0x39, 0xbc,
+	0x9e, 0x9d, 0x7a, 0xa6, 0x18, 0xa1, 0xae, 0xbd, 0x3c, 0x40, 0x69, 0xc7, 0x15, 0x61, 0xc7, 0x0a,
+	0x5c, 0x1e, 0x6d, 0x07, 0x4d, 0x10, 0x3b, 0x8e, 0x50, 0x81, 0x69, 0x45, 0xf1, 0xa4, 0x76, 0xeb,
+	0xd1, 0x76, 0x51, 0x79, 0xbc, 0x5d, 0x54, 0xfe, 0xdc, 0x2e, 0x2a, 0x0f, 0x9e, 0x17, 0x73, 0x8f,
+	0x9f, 0x17, 0x73, 0x4f, 0x9f, 0x17, 0x73, 0x9f, 0x2c, 0xd5, 0x5d, 0xde, 0x68, 0x6d, 0xe8, 0x36,
+	0x69, 0x1a, 0x36, 0x61, 0x4d, 0xc2, 0xba, 0xfa, 0xbd, 0x97, 0xf4, 0x6b, 0x9f, 0x36, 0xee, 0xf6,
+	0xcd, 0xdf, 0x56, 0x80, 0xd9, 0xc6, 0x8c, 0xf8, 0xb7, 0x72, 0xfa, 0xff, 0x00, 0x00, 0x00, 0xff,
+	0xff, 0x03, 0xbe, 0x75, 0x9c, 0x41, 0x13, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/x/ccv/types/genesis.go b/x/ccv/types/genesis.go
index ff18480ecb..5aae1ed9b5 100644
--- a/x/ccv/types/genesis.go
+++ b/x/ccv/types/genesis.go
@@ -8,11 +8,11 @@ import (
 	abci "github.com/cometbft/cometbft/abci/types"
 )
 
-// NewInitialGenesisState returns a consumer GenesisState for a completely new consumer chain.
-func NewInitialGenesisState(cs *ibctmtypes.ClientState, consState *ibctmtypes.ConsensusState,
-	initValSet []abci.ValidatorUpdate, params Params,
-) *GenesisState {
-	return &GenesisState{
+// NewInitialConsumerGenesisState returns a ConsumerGenesisState for a completely new consumer chain.
+func NewInitialConsumerGenesisState(cs *ibctmtypes.ClientState, consState *ibctmtypes.ConsensusState,
+	initValSet []abci.ValidatorUpdate, params ConsumerParams,
+) *ConsumerGenesisState {
+	return &ConsumerGenesisState{
 		Params:                 params,
 		NewChain:               true,
 		ProviderClientState:    cs,
@@ -21,8 +21,8 @@ func NewInitialGenesisState(cs *ibctmtypes.ClientState, consState *ibctmtypes.Co
 	}
 }
 
-// NewRestartGenesisState returns a consumer GenesisState that has already been established.
-func NewRestartGenesisState(
+// NewRestartConsumerGenesisState returns a ConsumerGenesisState that has already been established.
+func NewRestartConsumerGenesisState(
 	clientID, channelID string,
 	maturingPackets []MaturingVSCPacket,
 	initValSet []abci.ValidatorUpdate,
@@ -30,9 +30,9 @@ func NewRestartGenesisState(
 	pendingConsumerPackets ConsumerPacketDataList,
 	outstandingDowntimes []OutstandingDowntime,
 	lastTransBlockHeight LastTransmissionBlockHeight,
-	params Params,
-) *GenesisState {
-	return &GenesisState{
+	params ConsumerParams,
+) *ConsumerGenesisState {
+	return &ConsumerGenesisState{
 		Params:                      params,
 		ProviderClientId:            clientID,
 		ProviderChannelId:           channelID,
@@ -46,10 +46,10 @@ func NewRestartGenesisState(
 	}
 }
 
-// DefaultGenesisState returns a default disabled consumer chain genesis state. This allows the module to be hooked up to app without getting use
+// DefaultConsumerGenesisState returns a default disabled consumer chain genesis state. This allows the module to be hooked up to app without getting use
 // unless explicitly specified in genesis.
-func DefaultGenesisState() *GenesisState {
-	return &GenesisState{
+func DefaultConsumerGenesisState() *ConsumerGenesisState {
+	return &ConsumerGenesisState{
 		Params: DefaultParams(),
 	}
 }
@@ -71,7 +71,7 @@ func DefaultGenesisState() *GenesisState {
 //   - MaturingVSCPackets, OutstandingDowntime, PendingConsumerPacket, LastTransmissionBlockHeight // optional
 //
 
-func (gs GenesisState) Validate() error {
+func (gs ConsumerGenesisState) Validate() error {
 	if !gs.Params.Enabled {
 		return nil
 	}
diff --git a/x/ccv/types/params.go b/x/ccv/types/params.go
index 6a903c0d8f..1e2d6d180a 100644
--- a/x/ccv/types/params.go
+++ b/x/ccv/types/params.go
@@ -58,7 +58,7 @@ var (
 
 // ParamKeyTable type declaration for parameters
 func ParamKeyTable() paramtypes.KeyTable {
-	return paramtypes.NewKeyTable().RegisterParamSet(&Params{})
+	return paramtypes.NewKeyTable().RegisterParamSet(&ConsumerParams{})
 }
 
 // NewParams creates new consumer parameters with provided arguments
@@ -67,8 +67,8 @@ func NewParams(enabled bool, blocksPerDistributionTransmission int64,
 	ccvTimeoutPeriod, transferTimeoutPeriod time.Duration,
 	consumerRedistributionFraction string, historicalEntries int64,
 	consumerUnbondingPeriod time.Duration, softOptOutThreshold string, rewardDenoms, providerRewardDenoms []string,
-) Params {
-	return Params{
+) ConsumerParams {
+	return ConsumerParams{
 		Enabled:                           enabled,
 		BlocksPerDistributionTransmission: blocksPerDistributionTransmission,
 		DistributionTransmissionChannel:   distributionTransmissionChannel,
@@ -85,7 +85,7 @@ func NewParams(enabled bool, blocksPerDistributionTransmission int64,
 }
 
 // DefaultParams is the default params for the consumer module
-func DefaultParams() Params {
+func DefaultParams() ConsumerParams {
 	var rewardDenoms []string
 	var provideRewardDenoms []string
 	return NewParams(
@@ -105,7 +105,7 @@ func DefaultParams() Params {
 }
 
 // Validate all ccv-consumer module parameters
-func (p Params) Validate() error {
+func (p ConsumerParams) Validate() error {
 	if err := ValidateBool(p.Enabled); err != nil {
 		return err
 	}
@@ -146,7 +146,7 @@ func (p Params) Validate() error {
 }
 
 // ParamSetPairs implements params.ParamSet
-func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
+func (p *ConsumerParams) ParamSetPairs() paramtypes.ParamSetPairs {
 	return paramtypes.ParamSetPairs{
 		paramtypes.NewParamSetPair(KeyEnabled, p.Enabled, ValidateBool),
 		paramtypes.NewParamSetPair(KeyBlocksPerDistributionTransmission,
diff --git a/x/ccv/types/shared_consumer.pb.go b/x/ccv/types/shared_consumer.pb.go
index 4cf8860269..d52508dc6b 100644
--- a/x/ccv/types/shared_consumer.pb.go
+++ b/x/ccv/types/shared_consumer.pb.go
@@ -31,13 +31,11 @@ var _ = time.Kitchen
 // proto package needs to be updated.
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
-// Params defines the parameters for CCV consumer module.
+// ConsumerParams defines the parameters for CCV consumer module.
 //
 // Note this type is referenced in both the consumer and provider CCV modules,
 // and persisted on the provider, see MakeConsumerGenesis and SetConsumerGenesis.
-//
-// TODO: Rename to ConsumerParams. See https://github.com/cosmos/interchain-security/issues/1206
-type Params struct {
+type ConsumerParams struct {
 	// TODO: Remove enabled flag and find a better way to setup integration tests
 	// See: https://github.com/cosmos/interchain-security/issues/339
 	Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
@@ -81,18 +79,18 @@ type Params struct {
 	ProviderRewardDenoms []string `protobuf:"bytes,12,rep,name=provider_reward_denoms,json=providerRewardDenoms,proto3" json:"provider_reward_denoms,omitempty"`
 }
 
-func (m *Params) Reset()         { *m = Params{} }
-func (m *Params) String() string { return proto.CompactTextString(m) }
-func (*Params) ProtoMessage()    {}
-func (*Params) Descriptor() ([]byte, []int) {
+func (m *ConsumerParams) Reset()         { *m = ConsumerParams{} }
+func (m *ConsumerParams) String() string { return proto.CompactTextString(m) }
+func (*ConsumerParams) ProtoMessage()    {}
+func (*ConsumerParams) Descriptor() ([]byte, []int) {
 	return fileDescriptor_d0a8be0efc64dfbc, []int{0}
 }
-func (m *Params) XXX_Unmarshal(b []byte) error {
+func (m *ConsumerParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *ConsumerParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_Params.Marshal(b, m, deterministic)
+		return xxx_messageInfo_ConsumerParams.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -102,113 +100,111 @@ func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
-func (m *Params) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Params.Merge(m, src)
+func (m *ConsumerParams) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ConsumerParams.Merge(m, src)
 }
-func (m *Params) XXX_Size() int {
+func (m *ConsumerParams) XXX_Size() int {
 	return m.Size()
 }
-func (m *Params) XXX_DiscardUnknown() {
-	xxx_messageInfo_Params.DiscardUnknown(m)
+func (m *ConsumerParams) XXX_DiscardUnknown() {
+	xxx_messageInfo_ConsumerParams.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_Params proto.InternalMessageInfo
+var xxx_messageInfo_ConsumerParams proto.InternalMessageInfo
 
-func (m *Params) GetEnabled() bool {
+func (m *ConsumerParams) GetEnabled() bool {
 	if m != nil {
 		return m.Enabled
 	}
 	return false
 }
 
-func (m *Params) GetBlocksPerDistributionTransmission() int64 {
+func (m *ConsumerParams) GetBlocksPerDistributionTransmission() int64 {
 	if m != nil {
 		return m.BlocksPerDistributionTransmission
 	}
 	return 0
 }
 
-func (m *Params) GetDistributionTransmissionChannel() string {
+func (m *ConsumerParams) GetDistributionTransmissionChannel() string {
 	if m != nil {
 		return m.DistributionTransmissionChannel
 	}
 	return ""
 }
 
-func (m *Params) GetProviderFeePoolAddrStr() string {
+func (m *ConsumerParams) GetProviderFeePoolAddrStr() string {
 	if m != nil {
 		return m.ProviderFeePoolAddrStr
 	}
 	return ""
 }
 
-func (m *Params) GetCcvTimeoutPeriod() time.Duration {
+func (m *ConsumerParams) GetCcvTimeoutPeriod() time.Duration {
 	if m != nil {
 		return m.CcvTimeoutPeriod
 	}
 	return 0
 }
 
-func (m *Params) GetTransferTimeoutPeriod() time.Duration {
+func (m *ConsumerParams) GetTransferTimeoutPeriod() time.Duration {
 	if m != nil {
 		return m.TransferTimeoutPeriod
 	}
 	return 0
 }
 
-func (m *Params) GetConsumerRedistributionFraction() string {
+func (m *ConsumerParams) GetConsumerRedistributionFraction() string {
 	if m != nil {
 		return m.ConsumerRedistributionFraction
 	}
 	return ""
 }
 
-func (m *Params) GetHistoricalEntries() int64 {
+func (m *ConsumerParams) GetHistoricalEntries() int64 {
 	if m != nil {
 		return m.HistoricalEntries
 	}
 	return 0
 }
 
-func (m *Params) GetUnbondingPeriod() time.Duration {
+func (m *ConsumerParams) GetUnbondingPeriod() time.Duration {
 	if m != nil {
 		return m.UnbondingPeriod
 	}
 	return 0
 }
 
-func (m *Params) GetSoftOptOutThreshold() string {
+func (m *ConsumerParams) GetSoftOptOutThreshold() string {
 	if m != nil {
 		return m.SoftOptOutThreshold
 	}
 	return ""
 }
 
-func (m *Params) GetRewardDenoms() []string {
+func (m *ConsumerParams) GetRewardDenoms() []string {
 	if m != nil {
 		return m.RewardDenoms
 	}
 	return nil
 }
 
-func (m *Params) GetProviderRewardDenoms() []string {
+func (m *ConsumerParams) GetProviderRewardDenoms() []string {
 	if m != nil {
 		return m.ProviderRewardDenoms
 	}
 	return nil
 }
 
-// GenesisState defines the CCV consumer chain genesis state.
+// ConsumerGenesisState defines the CCV consumer chain genesis state.
 //
 // Note this type is referenced in both the consumer and provider CCV modules,
 // and persisted on the provider, see MakeConsumerGenesis and SetConsumerGenesis.
-//
-// TODO: Rename to ConsumerGenesisState. See https://github.com/cosmos/interchain-security/issues/1206
-type GenesisState struct {
-	Params            Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
-	ProviderClientId  string `protobuf:"bytes,2,opt,name=provider_client_id,json=providerClientId,proto3" json:"provider_client_id,omitempty"`
-	ProviderChannelId string `protobuf:"bytes,3,opt,name=provider_channel_id,json=providerChannelId,proto3" json:"provider_channel_id,omitempty"`
-	NewChain          bool   `protobuf:"varint,4,opt,name=new_chain,json=newChain,proto3" json:"new_chain,omitempty"`
+type ConsumerGenesisState struct {
+	Params            ConsumerParams `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
+	ProviderClientId  string         `protobuf:"bytes,2,opt,name=provider_client_id,json=providerClientId,proto3" json:"provider_client_id,omitempty"`
+	ProviderChannelId string         `protobuf:"bytes,3,opt,name=provider_channel_id,json=providerChannelId,proto3" json:"provider_channel_id,omitempty"`
+	NewChain          bool           `protobuf:"varint,4,opt,name=new_chain,json=newChain,proto3" json:"new_chain,omitempty"`
 	// ProviderClientState filled in on new chain, nil on restart.
 	ProviderClientState *_07_tendermint.ClientState `protobuf:"bytes,5,opt,name=provider_client_state,json=providerClientState,proto3" json:"provider_client_state,omitempty"`
 	// ProviderConsensusState filled in on new chain, nil on restart.
@@ -228,18 +224,18 @@ type GenesisState struct {
 	PreCCV                      bool                        `protobuf:"varint,13,opt,name=preCCV,proto3" json:"preCCV,omitempty"`
 }
 
-func (m *GenesisState) Reset()         { *m = GenesisState{} }
-func (m *GenesisState) String() string { return proto.CompactTextString(m) }
-func (*GenesisState) ProtoMessage()    {}
-func (*GenesisState) Descriptor() ([]byte, []int) {
+func (m *ConsumerGenesisState) Reset()         { *m = ConsumerGenesisState{} }
+func (m *ConsumerGenesisState) String() string { return proto.CompactTextString(m) }
+func (*ConsumerGenesisState) ProtoMessage()    {}
+func (*ConsumerGenesisState) Descriptor() ([]byte, []int) {
 	return fileDescriptor_d0a8be0efc64dfbc, []int{1}
 }
-func (m *GenesisState) XXX_Unmarshal(b []byte) error {
+func (m *ConsumerGenesisState) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *ConsumerGenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_GenesisState.Marshal(b, m, deterministic)
+		return xxx_messageInfo_ConsumerGenesisState.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -249,103 +245,103 @@ func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return b[:n], nil
 	}
 }
-func (m *GenesisState) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GenesisState.Merge(m, src)
+func (m *ConsumerGenesisState) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ConsumerGenesisState.Merge(m, src)
 }
-func (m *GenesisState) XXX_Size() int {
+func (m *ConsumerGenesisState) XXX_Size() int {
 	return m.Size()
 }
-func (m *GenesisState) XXX_DiscardUnknown() {
-	xxx_messageInfo_GenesisState.DiscardUnknown(m)
+func (m *ConsumerGenesisState) XXX_DiscardUnknown() {
+	xxx_messageInfo_ConsumerGenesisState.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_GenesisState proto.InternalMessageInfo
+var xxx_messageInfo_ConsumerGenesisState proto.InternalMessageInfo
 
-func (m *GenesisState) GetParams() Params {
+func (m *ConsumerGenesisState) GetParams() ConsumerParams {
 	if m != nil {
 		return m.Params
 	}
-	return Params{}
+	return ConsumerParams{}
 }
 
-func (m *GenesisState) GetProviderClientId() string {
+func (m *ConsumerGenesisState) GetProviderClientId() string {
 	if m != nil {
 		return m.ProviderClientId
 	}
 	return ""
 }
 
-func (m *GenesisState) GetProviderChannelId() string {
+func (m *ConsumerGenesisState) GetProviderChannelId() string {
 	if m != nil {
 		return m.ProviderChannelId
 	}
 	return ""
 }
 
-func (m *GenesisState) GetNewChain() bool {
+func (m *ConsumerGenesisState) GetNewChain() bool {
 	if m != nil {
 		return m.NewChain
 	}
 	return false
 }
 
-func (m *GenesisState) GetProviderClientState() *_07_tendermint.ClientState {
+func (m *ConsumerGenesisState) GetProviderClientState() *_07_tendermint.ClientState {
 	if m != nil {
 		return m.ProviderClientState
 	}
 	return nil
 }
 
-func (m *GenesisState) GetProviderConsensusState() *_07_tendermint.ConsensusState {
+func (m *ConsumerGenesisState) GetProviderConsensusState() *_07_tendermint.ConsensusState {
 	if m != nil {
 		return m.ProviderConsensusState
 	}
 	return nil
 }
 
-func (m *GenesisState) GetMaturingPackets() []MaturingVSCPacket {
+func (m *ConsumerGenesisState) GetMaturingPackets() []MaturingVSCPacket {
 	if m != nil {
 		return m.MaturingPackets
 	}
 	return nil
 }
 
-func (m *GenesisState) GetInitialValSet() []types.ValidatorUpdate {
+func (m *ConsumerGenesisState) GetInitialValSet() []types.ValidatorUpdate {
 	if m != nil {
 		return m.InitialValSet
 	}
 	return nil
 }
 
-func (m *GenesisState) GetHeightToValsetUpdateId() []HeightToValsetUpdateID {
+func (m *ConsumerGenesisState) GetHeightToValsetUpdateId() []HeightToValsetUpdateID {
 	if m != nil {
 		return m.HeightToValsetUpdateId
 	}
 	return nil
 }
 
-func (m *GenesisState) GetOutstandingDowntimeSlashing() []OutstandingDowntime {
+func (m *ConsumerGenesisState) GetOutstandingDowntimeSlashing() []OutstandingDowntime {
 	if m != nil {
 		return m.OutstandingDowntimeSlashing
 	}
 	return nil
 }
 
-func (m *GenesisState) GetPendingConsumerPackets() ConsumerPacketDataList {
+func (m *ConsumerGenesisState) GetPendingConsumerPackets() ConsumerPacketDataList {
 	if m != nil {
 		return m.PendingConsumerPackets
 	}
 	return ConsumerPacketDataList{}
 }
 
-func (m *GenesisState) GetLastTransmissionBlockHeight() LastTransmissionBlockHeight {
+func (m *ConsumerGenesisState) GetLastTransmissionBlockHeight() LastTransmissionBlockHeight {
 	if m != nil {
 		return m.LastTransmissionBlockHeight
 	}
 	return LastTransmissionBlockHeight{}
 }
 
-func (m *GenesisState) GetPreCCV() bool {
+func (m *ConsumerGenesisState) GetPreCCV() bool {
 	if m != nil {
 		return m.PreCCV
 	}
@@ -607,8 +603,8 @@ func (m *ConsumerPacketDataList) GetList() []ConsumerPacketData {
 }
 
 func init() {
-	proto.RegisterType((*Params)(nil), "interchain_security.ccv.v1.Params")
-	proto.RegisterType((*GenesisState)(nil), "interchain_security.ccv.v1.GenesisState")
+	proto.RegisterType((*ConsumerParams)(nil), "interchain_security.ccv.v1.ConsumerParams")
+	proto.RegisterType((*ConsumerGenesisState)(nil), "interchain_security.ccv.v1.ConsumerGenesisState")
 	proto.RegisterType((*HeightToValsetUpdateID)(nil), "interchain_security.ccv.v1.HeightToValsetUpdateID")
 	proto.RegisterType((*OutstandingDowntime)(nil), "interchain_security.ccv.v1.OutstandingDowntime")
 	proto.RegisterType((*LastTransmissionBlockHeight)(nil), "interchain_security.ccv.v1.LastTransmissionBlockHeight")
@@ -621,84 +617,84 @@ func init() {
 }
 
 var fileDescriptor_d0a8be0efc64dfbc = []byte{
-	// 1178 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x4d, 0x6f, 0x1b, 0x45,
-	0x18, 0x8e, 0x9b, 0x34, 0xb5, 0x27, 0x09, 0x4d, 0x27, 0xad, 0xd9, 0x26, 0xc2, 0x71, 0x0d, 0x48,
-	0x96, 0xa0, 0xbb, 0x24, 0x2d, 0x42, 0xe2, 0x80, 0x68, 0x6c, 0x4a, 0x83, 0x4a, 0x13, 0x36, 0x69,
-	0x0e, 0x45, 0x62, 0x34, 0x9e, 0x99, 0xd8, 0xa3, 0xae, 0x67, 0xac, 0x99, 0xd9, 0x0d, 0xb9, 0x22,
-	0x7e, 0x40, 0x8f, 0xfc, 0xa4, 0x1e, 0x7b, 0xe4, 0x04, 0xa8, 0xfd, 0x23, 0x68, 0x3e, 0xd6, 0xb1,
-	0xf3, 0x61, 0xca, 0x6d, 0x67, 0xde, 0xe7, 0x79, 0xbf, 0xdf, 0x79, 0x17, 0x7c, 0xc1, 0x85, 0x61,
-	0x8a, 0x0c, 0x30, 0x17, 0x48, 0x33, 0x92, 0x2b, 0x6e, 0x4e, 0x13, 0x42, 0x8a, 0xa4, 0xd8, 0x4a,
-	0xf4, 0x00, 0x2b, 0x46, 0x11, 0x91, 0x42, 0xe7, 0x43, 0xa6, 0xe2, 0x91, 0x92, 0x46, 0xc2, 0xf5,
-	0x4b, 0x18, 0x31, 0x21, 0x45, 0x5c, 0x6c, 0xad, 0x6f, 0x18, 0x26, 0x28, 0x53, 0x43, 0x2e, 0x4c,
-	0x82, 0x7b, 0x84, 0x27, 0xe6, 0x74, 0xc4, 0xb4, 0x27, 0xae, 0x27, 0xbc, 0x47, 0x92, 0x8c, 0xf7,
-	0x07, 0x86, 0x64, 0x9c, 0x09, 0xa3, 0x93, 0x09, 0x74, 0xb1, 0x35, 0x71, 0x0a, 0x84, 0x7b, 0x96,
-	0x40, 0xa4, 0x62, 0x09, 0x19, 0x60, 0x21, 0x58, 0x66, 0x51, 0xe1, 0x33, 0x40, 0x1a, 0x7d, 0x29,
-	0xfb, 0x19, 0x4b, 0xdc, 0xa9, 0x97, 0x1f, 0x27, 0x34, 0x57, 0xd8, 0x70, 0x29, 0x82, 0xfc, 0x76,
-	0x5f, 0xf6, 0xa5, 0xfb, 0x4c, 0xec, 0x57, 0xb8, 0xfd, 0x74, 0x46, 0xd0, 0x27, 0x5c, 0xb1, 0x00,
-	0xdb, 0x3c, 0xaf, 0xdc, 0xf0, 0x21, 0xd3, 0x06, 0x0f, 0x47, 0x1e, 0xd0, 0xfa, 0x7d, 0x11, 0x2c,
-	0xee, 0x63, 0x85, 0x87, 0x1a, 0x46, 0xe0, 0x06, 0x13, 0xb8, 0x97, 0x31, 0x1a, 0x55, 0x9a, 0x95,
-	0x76, 0x35, 0x2d, 0x8f, 0x70, 0x0f, 0x7c, 0xd2, 0xcb, 0x24, 0x79, 0xa9, 0xd1, 0x88, 0x29, 0x44,
-	0xb9, 0x36, 0x8a, 0xf7, 0x72, 0xeb, 0x23, 0x32, 0x0a, 0x0b, 0x3d, 0xe4, 0x5a, 0x73, 0x29, 0xa2,
-	0x6b, 0xcd, 0x4a, 0x7b, 0x3e, 0xbd, 0xe7, 0xb1, 0xfb, 0x4c, 0x75, 0x27, 0x90, 0x87, 0x13, 0x40,
-	0xf8, 0x03, 0xb8, 0x77, 0xa5, 0x16, 0x14, 0xd2, 0x13, 0xcd, 0x37, 0x2b, 0xed, 0x5a, 0xba, 0x49,
-	0xaf, 0x50, 0xd2, 0xf1, 0x30, 0xf8, 0x35, 0x58, 0x1f, 0x29, 0x59, 0x70, 0xca, 0x14, 0x3a, 0x66,
-	0x0c, 0x8d, 0xa4, 0xcc, 0x10, 0xa6, 0x54, 0x21, 0x6d, 0x54, 0xb4, 0xe0, 0x94, 0xd4, 0x4b, 0xc4,
-	0x63, 0xc6, 0xf6, 0xa5, 0xcc, 0x1e, 0x51, 0xaa, 0x0e, 0x8c, 0x82, 0x3f, 0x01, 0x48, 0x48, 0x81,
-	0x6c, 0x52, 0x64, 0x6e, 0x6c, 0x74, 0x5c, 0xd2, 0xe8, 0x7a, 0xb3, 0xd2, 0x5e, 0xda, 0xbe, 0x1b,
-	0xfb, 0xdc, 0xc5, 0x65, 0xee, 0xe2, 0x6e, 0x28, 0xcc, 0x4e, 0xf5, 0xf5, 0x5f, 0x9b, 0x73, 0x7f,
-	0xfc, 0xbd, 0x59, 0x49, 0x57, 0x09, 0x29, 0x0e, 0x3d, 0x7b, 0xdf, 0x91, 0xe1, 0xcf, 0xe0, 0x43,
-	0x17, 0xcd, 0x31, 0x53, 0xe7, 0xf5, 0x2e, 0xbe, 0xbf, 0xde, 0x3b, 0xa5, 0x8e, 0x69, 0xe5, 0x4f,
-	0x40, 0xb3, 0x6c, 0x65, 0xa4, 0xd8, 0x54, 0x0a, 0x8f, 0x15, 0x26, 0xf6, 0x23, 0xba, 0xe1, 0x22,
-	0x6e, 0x94, 0xb8, 0x74, 0x0a, 0xf6, 0x38, 0xa0, 0xe0, 0x7d, 0x00, 0x07, 0x5c, 0x1b, 0xa9, 0x38,
-	0xc1, 0x19, 0x62, 0xc2, 0x28, 0xce, 0x74, 0x54, 0x75, 0x05, 0xbc, 0x75, 0x26, 0xf9, 0xce, 0x0b,
-	0xe0, 0x33, 0xb0, 0x9a, 0x8b, 0x9e, 0x14, 0x94, 0x8b, 0x7e, 0x19, 0x4e, 0xed, 0xfd, 0xc3, 0xb9,
-	0x39, 0x26, 0x87, 0x40, 0x1e, 0x80, 0xba, 0x96, 0xc7, 0x06, 0xc9, 0x91, 0x41, 0x36, 0x43, 0x66,
-	0xa0, 0x98, 0x1e, 0xc8, 0x8c, 0x46, 0xc0, 0xb9, 0xbf, 0x66, 0xa5, 0x7b, 0x23, 0xb3, 0x97, 0x9b,
-	0xc3, 0x52, 0x04, 0x3f, 0x06, 0x2b, 0x8a, 0x9d, 0x60, 0x45, 0x11, 0x65, 0x42, 0x0e, 0x75, 0xb4,
-	0xd4, 0x9c, 0x6f, 0xd7, 0xd2, 0x65, 0x7f, 0xd9, 0x75, 0x77, 0xf0, 0x21, 0x18, 0x17, 0x1b, 0x4d,
-	0xa3, 0x97, 0x1d, 0xfa, 0x76, 0x29, 0x4d, 0x27, 0x58, 0xad, 0xd7, 0x55, 0xb0, 0xfc, 0x3d, 0x13,
-	0x4c, 0x73, 0x7d, 0x60, 0xb0, 0x61, 0xf0, 0x5b, 0xb0, 0x38, 0x72, 0x63, 0xe1, 0x66, 0x61, 0x69,
-	0xbb, 0x15, 0x5f, 0xfd, 0x66, 0xc4, 0x7e, 0x80, 0x76, 0x16, 0x6c, 0xbc, 0x69, 0xe0, 0xc1, 0xcf,
-	0x01, 0x1c, 0x3b, 0xe2, 0x5f, 0x0b, 0xc4, 0xa9, 0x1b, 0x91, 0x5a, 0xba, 0x5a, 0x4a, 0x3a, 0x4e,
-	0xb0, 0x4b, 0x61, 0x0c, 0xd6, 0xce, 0xd0, 0xbe, 0xb3, 0x2d, 0xdc, 0xcf, 0xc0, 0xad, 0x31, 0xdc,
-	0x4b, 0x76, 0x29, 0xdc, 0x00, 0x35, 0xc1, 0x4e, 0x90, 0xf3, 0xc7, 0x35, 0x79, 0x35, 0xad, 0x0a,
-	0x76, 0xd2, 0xb1, 0x67, 0x88, 0xc0, 0x9d, 0xf3, 0xa6, 0xb5, 0x8d, 0x2a, 0x74, 0xf6, 0x67, 0x31,
-	0xef, 0x91, 0x78, 0xf2, 0x19, 0x8b, 0x27, 0x1e, 0xae, 0x62, 0x2b, 0xf6, 0x5e, 0xb9, 0x44, 0xa4,
-	0x6b, 0xd3, 0xae, 0xfa, 0xec, 0x0c, 0x40, 0x74, 0x66, 0x40, 0x0a, 0xcd, 0x84, 0xce, 0x75, 0xb0,
-	0xe1, 0xbb, 0x3c, 0xfe, 0x4f, 0x1b, 0x25, 0xcd, 0x9b, 0x19, 0x17, 0x6d, 0xfa, 0x1e, 0xfe, 0x02,
-	0x56, 0x87, 0xd8, 0xe4, 0xca, 0xf5, 0x1d, 0x26, 0x2f, 0x99, 0xd1, 0xd1, 0x8d, 0xe6, 0x7c, 0x7b,
-	0x69, 0xfb, 0xfe, 0xac, 0x8a, 0xfc, 0x18, 0x38, 0x47, 0x07, 0x9d, 0x7d, 0xc7, 0x0a, 0xc5, 0xb9,
-	0x59, 0x2a, 0xf3, 0xb7, 0xb6, 0xb1, 0x6f, 0x72, 0xc1, 0x0d, 0xc7, 0x19, 0x2a, 0x70, 0x86, 0x34,
-	0x33, 0x51, 0xd5, 0xa9, 0x6f, 0x4e, 0xfa, 0x6b, 0x17, 0x41, 0x7c, 0x84, 0x33, 0x4e, 0xb1, 0x91,
-	0xea, 0xf9, 0x88, 0x62, 0xc3, 0x82, 0xc6, 0x95, 0x40, 0x3f, 0xc2, 0xd9, 0x01, 0x33, 0xd0, 0x80,
-	0xf5, 0x01, 0xb3, 0x51, 0x23, 0x23, 0xad, 0x46, 0xcd, 0x0c, 0xca, 0x1d, 0xde, 0x96, 0xb3, 0xe6,
-	0x54, 0x6f, 0xcf, 0xf2, 0xfc, 0x89, 0x63, 0x1f, 0xca, 0x23, 0xc7, 0xf5, 0xa6, 0x76, 0xbb, 0xc1,
-	0x58, 0x7d, 0x70, 0x99, 0x94, 0xc2, 0x53, 0xf0, 0x91, 0xcc, 0x8d, 0x36, 0xd8, 0x0f, 0x28, 0x95,
-	0x27, 0xc2, 0xbe, 0x3d, 0x48, 0x67, 0x58, 0x0f, 0xb8, 0xe8, 0x47, 0xc0, 0x19, 0x4e, 0x66, 0x19,
-	0xde, 0x3b, 0x53, 0xd0, 0x0d, 0xfc, 0x60, 0x75, 0x43, 0x5e, 0x14, 0x1d, 0x04, 0xcd, 0x50, 0x81,
-	0x68, 0xc4, 0xbc, 0xd9, 0xf1, 0xd3, 0x54, 0x16, 0x6a, 0xc9, 0xb5, 0xc2, 0xcc, 0x70, 0x3b, 0x81,
-	0xe3, 0xeb, 0xd1, 0xc5, 0x06, 0x3f, 0xe5, 0xba, 0xac, 0x56, 0x3d, 0x68, 0x9e, 0x06, 0x69, 0xf8,
-	0x5b, 0x05, 0x34, 0x32, 0xac, 0xcd, 0xf4, 0xde, 0x70, 0x6b, 0x07, 0xf9, 0x0c, 0x45, 0xcb, 0xce,
-	0xf4, 0x57, 0xb3, 0x4c, 0x3f, 0xc5, 0xda, 0x4c, 0x2e, 0x94, 0x1d, 0xcb, 0xf7, 0xe9, 0x2f, 0x03,
-	0xcf, 0xae, 0x86, 0xc0, 0x3a, 0x58, 0x1c, 0x29, 0xd6, 0xe9, 0x1c, 0x45, 0x2b, 0x6e, 0xfc, 0xc2,
-	0xa9, 0xf5, 0x02, 0xd4, 0x2f, 0xaf, 0xa1, 0x65, 0x04, 0xef, 0xec, 0x9b, 0xb2, 0x90, 0x86, 0x13,
-	0x6c, 0x83, 0xd5, 0x0b, 0x9d, 0x72, 0xcd, 0x21, 0x3e, 0x28, 0xa6, 0xea, 0xdc, 0x7a, 0x0e, 0xd6,
-	0x2e, 0x29, 0x13, 0xfc, 0x06, 0x6c, 0x14, 0x65, 0x73, 0x4e, 0xcc, 0xa3, 0x5d, 0x82, 0x4c, 0xfb,
-	0x17, 0xac, 0x96, 0xde, 0x1d, 0x43, 0xc6, 0x23, 0xf6, 0xc8, 0x03, 0x5a, 0x5f, 0x82, 0x8d, 0xa7,
-	0xb3, 0x23, 0x9d, 0xf0, 0x7b, 0xbe, 0xf4, 0xbb, 0x65, 0xc0, 0xad, 0x0b, 0x73, 0x06, 0x6f, 0x83,
-	0xeb, 0x85, 0x26, 0xbb, 0x34, 0xc4, 0xe8, 0x0f, 0x70, 0x17, 0xac, 0xf8, 0xc9, 0x33, 0xa7, 0x6e,
-	0x2b, 0xba, 0xf8, 0x96, 0xb6, 0xd7, 0x2f, 0x2c, 0x8f, 0xc3, 0xf2, 0xff, 0xc4, 0x6f, 0x8f, 0x57,
-	0x76, 0x7b, 0x2c, 0x97, 0x54, 0x2b, 0x6c, 0xf5, 0x40, 0xfd, 0xf2, 0xa6, 0x81, 0x4f, 0xc0, 0x42,
-	0xc6, 0xb5, 0xf5, 0x72, 0xde, 0xbf, 0x40, 0xff, 0xa7, 0xed, 0x42, 0xc9, 0x9d, 0x86, 0x9d, 0x67,
-	0xaf, 0xdf, 0x36, 0x2a, 0x6f, 0xde, 0x36, 0x2a, 0xff, 0xbc, 0x6d, 0x54, 0x5e, 0xbd, 0x6b, 0xcc,
-	0xbd, 0x79, 0xd7, 0x98, 0xfb, 0xf3, 0x5d, 0x63, 0xee, 0xc5, 0xc3, 0x3e, 0x37, 0x83, 0xbc, 0x17,
-	0x13, 0x39, 0x4c, 0x88, 0xd4, 0x43, 0xa9, 0x93, 0x33, 0x33, 0xf7, 0xc7, 0x7f, 0x62, 0xc5, 0x83,
-	0xe4, 0x57, 0xf7, 0x3b, 0xe6, 0xfe, 0x1e, 0x7b, 0x8b, 0x2e, 0xbe, 0x07, 0xff, 0x06, 0x00, 0x00,
-	0xff, 0xff, 0xd1, 0x28, 0xd8, 0xb6, 0xab, 0x0a, 0x00, 0x00,
-}
-
-func (m *Params) Marshal() (dAtA []byte, err error) {
+	// 1182 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x4f, 0x53, 0x1b, 0x37,
+	0x14, 0xc7, 0x81, 0x10, 0x5b, 0x40, 0x42, 0x04, 0x71, 0x37, 0x30, 0x35, 0x8e, 0xdb, 0xce, 0x78,
+	0xda, 0x66, 0xb7, 0x21, 0xe9, 0x74, 0xa6, 0x87, 0xce, 0x04, 0xd3, 0x14, 0x3a, 0x69, 0xa0, 0x0b,
+	0xe1, 0x90, 0xce, 0x54, 0x23, 0x4b, 0xc2, 0xd6, 0x64, 0x2d, 0x79, 0x24, 0xed, 0x52, 0xae, 0x3d,
+	0xf7, 0x90, 0x63, 0x3f, 0x52, 0x8e, 0x39, 0xe6, 0xd4, 0x76, 0x92, 0x2f, 0xd2, 0xd1, 0x9f, 0x35,
+	0x76, 0x00, 0x97, 0xde, 0x56, 0x7a, 0xbf, 0xdf, 0xfb, 0xff, 0xf4, 0x16, 0x7c, 0xc5, 0x85, 0x61,
+	0x8a, 0xf4, 0x31, 0x17, 0x48, 0x33, 0x92, 0x2b, 0x6e, 0x4e, 0x13, 0x42, 0x8a, 0xa4, 0x78, 0x90,
+	0xe8, 0x3e, 0x56, 0x8c, 0x22, 0x22, 0x85, 0xce, 0x07, 0x4c, 0xc5, 0x43, 0x25, 0x8d, 0x84, 0x6b,
+	0x17, 0x30, 0x62, 0x42, 0x8a, 0xb8, 0x78, 0xb0, 0xb6, 0x6e, 0x98, 0xa0, 0x4c, 0x0d, 0xb8, 0x30,
+	0x09, 0xee, 0x12, 0x9e, 0x98, 0xd3, 0x21, 0xd3, 0x9e, 0xb8, 0x96, 0xf0, 0x2e, 0x49, 0x32, 0xde,
+	0xeb, 0x1b, 0x92, 0x71, 0x26, 0x8c, 0x4e, 0xc6, 0xd0, 0xc5, 0x83, 0xb1, 0x53, 0x20, 0xdc, 0xb3,
+	0x04, 0x22, 0x15, 0x4b, 0x48, 0x1f, 0x0b, 0xc1, 0x32, 0x8b, 0x0a, 0x9f, 0x01, 0xd2, 0xe8, 0x49,
+	0xd9, 0xcb, 0x58, 0xe2, 0x4e, 0xdd, 0xfc, 0x38, 0xa1, 0xb9, 0xc2, 0x86, 0x4b, 0x11, 0xe4, 0xab,
+	0x3d, 0xd9, 0x93, 0xee, 0x33, 0xb1, 0x5f, 0xe1, 0xf6, 0xb3, 0x29, 0x41, 0x9f, 0x70, 0xc5, 0x02,
+	0x6c, 0xe3, 0x43, 0xe5, 0x86, 0x0f, 0x98, 0x36, 0x78, 0x30, 0xf4, 0x80, 0xd6, 0x1f, 0xf3, 0xe0,
+	0x66, 0x27, 0x64, 0x67, 0x1f, 0x2b, 0x3c, 0xd0, 0x30, 0x02, 0x37, 0x98, 0xc0, 0xdd, 0x8c, 0xd1,
+	0xa8, 0xd2, 0xac, 0xb4, 0xab, 0x69, 0x79, 0x84, 0x7b, 0xe0, 0xd3, 0x6e, 0x26, 0xc9, 0x4b, 0x8d,
+	0x86, 0x4c, 0x21, 0xca, 0xb5, 0x51, 0xbc, 0x9b, 0x5b, 0x5f, 0x91, 0x51, 0x58, 0xe8, 0x01, 0xd7,
+	0x9a, 0x4b, 0x11, 0x5d, 0x6b, 0x56, 0xda, 0xb3, 0xe9, 0x3d, 0x8f, 0xdd, 0x67, 0x6a, 0x7b, 0x0c,
+	0x79, 0x38, 0x06, 0x84, 0x3f, 0x82, 0x7b, 0x97, 0x6a, 0x41, 0x21, 0x4d, 0xd1, 0x6c, 0xb3, 0xd2,
+	0xae, 0xa5, 0x1b, 0xf4, 0x12, 0x25, 0x1d, 0x0f, 0x83, 0xdf, 0x82, 0xb5, 0xa1, 0x92, 0x05, 0xa7,
+	0x4c, 0xa1, 0x63, 0xc6, 0xd0, 0x50, 0xca, 0x0c, 0x61, 0x4a, 0x15, 0xd2, 0x46, 0x45, 0x73, 0x4e,
+	0x49, 0xbd, 0x44, 0x3c, 0x61, 0x6c, 0x5f, 0xca, 0xec, 0x31, 0xa5, 0xea, 0xc0, 0x28, 0xf8, 0x33,
+	0x80, 0x84, 0x14, 0xc8, 0x26, 0x47, 0xe6, 0xc6, 0x46, 0xc7, 0x25, 0x8d, 0xae, 0x37, 0x2b, 0xed,
+	0x85, 0xcd, 0xbb, 0xb1, 0xcf, 0x61, 0x5c, 0xe6, 0x30, 0xde, 0x0e, 0x05, 0xda, 0xaa, 0xbe, 0xfe,
+	0x6b, 0x63, 0xe6, 0xcf, 0xbf, 0x37, 0x2a, 0xe9, 0x32, 0x21, 0xc5, 0xa1, 0x67, 0xef, 0x3b, 0x32,
+	0xfc, 0x05, 0x7c, 0xe4, 0xa2, 0x39, 0x66, 0xea, 0x43, 0xbd, 0xf3, 0x57, 0xd7, 0x7b, 0xa7, 0xd4,
+	0x31, 0xa9, 0x7c, 0x07, 0x34, 0xcb, 0x96, 0x46, 0x8a, 0x4d, 0xa4, 0xf0, 0x58, 0x61, 0x62, 0x3f,
+	0xa2, 0x1b, 0x2e, 0xe2, 0x46, 0x89, 0x4b, 0x27, 0x60, 0x4f, 0x02, 0x0a, 0xde, 0x07, 0xb0, 0xcf,
+	0xb5, 0x91, 0x8a, 0x13, 0x9c, 0x21, 0x26, 0x8c, 0xe2, 0x4c, 0x47, 0x55, 0x57, 0xc0, 0xdb, 0x67,
+	0x92, 0xef, 0xbd, 0x00, 0x3e, 0x03, 0xcb, 0xb9, 0xe8, 0x4a, 0x41, 0xb9, 0xe8, 0x95, 0xe1, 0xd4,
+	0xae, 0x1e, 0xce, 0xad, 0x11, 0x39, 0x04, 0xf2, 0x10, 0xd4, 0xb5, 0x3c, 0x36, 0x48, 0x0e, 0x0d,
+	0xb2, 0x19, 0x32, 0x7d, 0xc5, 0x74, 0x5f, 0x66, 0x34, 0x02, 0xce, 0xfd, 0x15, 0x2b, 0xdd, 0x1b,
+	0x9a, 0xbd, 0xdc, 0x1c, 0x96, 0x22, 0xf8, 0x09, 0x58, 0x52, 0xec, 0x04, 0x2b, 0x8a, 0x28, 0x13,
+	0x72, 0xa0, 0xa3, 0x85, 0xe6, 0x6c, 0xbb, 0x96, 0x2e, 0xfa, 0xcb, 0x6d, 0x77, 0x07, 0x1f, 0x81,
+	0x51, 0xb1, 0xd1, 0x24, 0x7a, 0xd1, 0xa1, 0x57, 0x4b, 0x69, 0x3a, 0xc6, 0x6a, 0xbd, 0xad, 0x82,
+	0xd5, 0x72, 0x1c, 0x7e, 0x60, 0x82, 0x69, 0xae, 0x0f, 0x0c, 0x36, 0x0c, 0xee, 0x80, 0xf9, 0xa1,
+	0x1b, 0x0f, 0x37, 0x13, 0x0b, 0x9b, 0x9f, 0xc7, 0x97, 0xbf, 0x21, 0xf1, 0xe4, 0x40, 0x6d, 0xcd,
+	0xd9, 0xf8, 0xd3, 0xc0, 0x87, 0x5f, 0x02, 0x38, 0x72, 0xcc, 0xbf, 0x22, 0x88, 0x53, 0x37, 0x32,
+	0xb5, 0x74, 0xb9, 0x94, 0x74, 0x9c, 0x60, 0x97, 0xc2, 0x18, 0xac, 0x9c, 0xa1, 0x7d, 0xa7, 0x5b,
+	0xb8, 0x9f, 0x89, 0xdb, 0x23, 0xb8, 0x97, 0xec, 0x52, 0xb8, 0x0e, 0x6a, 0x82, 0x9d, 0x20, 0xe7,
+	0x97, 0x6b, 0xfa, 0x6a, 0x5a, 0x15, 0xec, 0xa4, 0x63, 0xcf, 0x10, 0x81, 0x3b, 0x1f, 0x9a, 0xd6,
+	0x36, 0xba, 0xd0, 0xe9, 0x5f, 0xc4, 0xbc, 0x4b, 0xe2, 0xf1, 0xe7, 0x2d, 0x1e, 0x7b, 0xd0, 0x6c,
+	0x5c, 0xee, 0xd6, 0x25, 0x24, 0x5d, 0x99, 0x74, 0xd5, 0x67, 0xa9, 0x0f, 0xa2, 0x33, 0x03, 0x52,
+	0x68, 0x26, 0x74, 0xae, 0x83, 0x0d, 0xdf, 0xf5, 0xf1, 0x7f, 0xda, 0x28, 0x69, 0xde, 0xcc, 0xa8,
+	0x88, 0x93, 0xf7, 0xf0, 0x57, 0xb0, 0x3c, 0xc0, 0x26, 0x57, 0xae, 0x0f, 0x31, 0x79, 0xc9, 0x8c,
+	0x8e, 0x6e, 0x34, 0x67, 0xdb, 0x0b, 0x9b, 0xf7, 0xa7, 0x55, 0xe6, 0xa7, 0xc0, 0x39, 0x3a, 0xe8,
+	0xec, 0x3b, 0x56, 0x28, 0xce, 0xad, 0x52, 0x99, 0xbf, 0xb5, 0x8d, 0x7e, 0x8b, 0x0b, 0x6e, 0x38,
+	0xce, 0x50, 0x81, 0x33, 0xa4, 0x99, 0x89, 0xaa, 0x4e, 0x7d, 0x73, 0xdc, 0x5f, 0xbb, 0x20, 0xe2,
+	0x23, 0x9c, 0x71, 0x8a, 0x8d, 0x54, 0xcf, 0x87, 0x14, 0x1b, 0x16, 0x34, 0x2e, 0x05, 0xfa, 0x11,
+	0xce, 0x0e, 0x98, 0x81, 0x06, 0xac, 0xf5, 0x99, 0x8d, 0x1a, 0x19, 0x69, 0x35, 0x6a, 0x66, 0x50,
+	0xee, 0xf0, 0xb6, 0x9c, 0x35, 0xa7, 0x7a, 0x73, 0x9a, 0xe7, 0x3b, 0x8e, 0x7d, 0x28, 0x8f, 0x1c,
+	0xd7, 0x9b, 0xda, 0xdd, 0x0e, 0xc6, 0xea, 0xfd, 0x8b, 0xa4, 0x14, 0x9e, 0x82, 0x8f, 0x65, 0x6e,
+	0xb4, 0xc1, 0x7e, 0x60, 0xa9, 0x3c, 0x11, 0xf6, 0x2d, 0x42, 0x3a, 0xc3, 0xba, 0xcf, 0x45, 0x2f,
+	0x02, 0xce, 0x70, 0x32, 0xcd, 0xf0, 0xde, 0x99, 0x82, 0xed, 0xc0, 0x0f, 0x56, 0xd7, 0xe5, 0x79,
+	0xd1, 0x41, 0xd0, 0x0c, 0x15, 0x88, 0x86, 0xcc, 0x9b, 0x1d, 0x3d, 0x55, 0x65, 0xa1, 0x16, 0x5c,
+	0x2b, 0x6c, 0x5e, 0x6d, 0x84, 0x2c, 0x65, 0x1b, 0x1b, 0xfc, 0x94, 0xeb, 0xb2, 0x5a, 0xf5, 0xa0,
+	0x79, 0x12, 0xa4, 0xe1, 0xef, 0x15, 0xd0, 0xc8, 0xb0, 0x36, 0x93, 0x7b, 0xc4, 0xad, 0x21, 0xe4,
+	0x33, 0x14, 0x2d, 0x3a, 0xd3, 0xdf, 0x4c, 0x33, 0xfd, 0x14, 0x6b, 0x33, 0xbe, 0x60, 0xb6, 0x2c,
+	0xdf, 0xa7, 0xbf, 0x0c, 0x3c, 0xbb, 0x1c, 0x02, 0xeb, 0x60, 0x7e, 0xa8, 0x58, 0xa7, 0x73, 0x14,
+	0x2d, 0xb9, 0xf1, 0x0b, 0xa7, 0xd6, 0x0b, 0x50, 0xbf, 0xb8, 0x86, 0x96, 0x11, 0xbc, 0xb3, 0x6f,
+	0xcb, 0x5c, 0x1a, 0x4e, 0xb0, 0x0d, 0x96, 0xcf, 0x75, 0xca, 0x35, 0x87, 0xb8, 0x59, 0x4c, 0xd4,
+	0xb9, 0xf5, 0x1c, 0xac, 0x5c, 0x50, 0x26, 0xf8, 0x1d, 0x58, 0x2f, 0xca, 0xe6, 0x1c, 0x9b, 0x47,
+	0xbb, 0x14, 0x99, 0xf6, 0x2f, 0x59, 0x2d, 0xbd, 0x3b, 0x82, 0x8c, 0x46, 0xec, 0xb1, 0x07, 0xb4,
+	0xbe, 0x06, 0xeb, 0x4f, 0xa7, 0x47, 0x3a, 0xe6, 0xf7, 0x6c, 0xe9, 0x77, 0xcb, 0x80, 0xdb, 0xe7,
+	0xe6, 0x0c, 0xae, 0x82, 0xeb, 0x85, 0x26, 0xbb, 0x34, 0xc4, 0xe8, 0x0f, 0x70, 0x17, 0x2c, 0xf9,
+	0xc9, 0x33, 0xa7, 0x6e, 0x4b, 0xba, 0xf8, 0x16, 0x36, 0xd7, 0xce, 0x2d, 0x93, 0xc3, 0xf2, 0xbf,
+	0xc5, 0x6f, 0x93, 0x57, 0x76, 0x9b, 0x2c, 0x96, 0x54, 0x2b, 0x6c, 0x75, 0x41, 0xfd, 0xe2, 0xa6,
+	0x81, 0x3b, 0x60, 0x2e, 0xe3, 0xda, 0x7a, 0x39, 0xeb, 0x5f, 0xa0, 0xff, 0xd3, 0x76, 0xa1, 0xe4,
+	0x4e, 0xc3, 0xd6, 0xb3, 0xd7, 0xef, 0x1a, 0x95, 0x37, 0xef, 0x1a, 0x95, 0x7f, 0xde, 0x35, 0x2a,
+	0xaf, 0xde, 0x37, 0x66, 0xde, 0xbc, 0x6f, 0xcc, 0xbc, 0x7d, 0xdf, 0x98, 0x79, 0xf1, 0xa8, 0xc7,
+	0x4d, 0x3f, 0xef, 0xc6, 0x44, 0x0e, 0x12, 0x22, 0xf5, 0x40, 0xea, 0xe4, 0xcc, 0xcc, 0xfd, 0xd1,
+	0x1f, 0x5a, 0xf1, 0x30, 0xf9, 0xcd, 0xfd, 0xa6, 0xb9, 0xbf, 0xca, 0xee, 0xbc, 0x8b, 0xef, 0xe1,
+	0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xe0, 0xb5, 0xe5, 0x15, 0xc3, 0x0a, 0x00, 0x00,
+}
+
+func (m *ConsumerParams) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -708,12 +704,12 @@ func (m *Params) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Params) MarshalTo(dAtA []byte) (int, error) {
+func (m *ConsumerParams) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ConsumerParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -811,7 +807,7 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *GenesisState) Marshal() (dAtA []byte, err error) {
+func (m *ConsumerGenesisState) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -821,12 +817,12 @@ func (m *GenesisState) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *GenesisState) MarshalTo(dAtA []byte) (int, error) {
+func (m *ConsumerGenesisState) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ConsumerGenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -1153,7 +1149,7 @@ func encodeVarintSharedConsumer(dAtA []byte, offset int, v uint64) int {
 	dAtA[offset] = uint8(v)
 	return base
 }
-func (m *Params) Size() (n int) {
+func (m *ConsumerParams) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -1205,7 +1201,7 @@ func (m *Params) Size() (n int) {
 	return n
 }
 
-func (m *GenesisState) Size() (n int) {
+func (m *ConsumerGenesisState) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -1341,7 +1337,7 @@ func sovSharedConsumer(x uint64) (n int) {
 func sozSharedConsumer(x uint64) (n int) {
 	return sovSharedConsumer(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 }
-func (m *Params) Unmarshal(dAtA []byte) error {
+func (m *ConsumerParams) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1364,10 +1360,10 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Params: wiretype end group for non-group")
+			return fmt.Errorf("proto: ConsumerParams: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ConsumerParams: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -1740,7 +1736,7 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *GenesisState) Unmarshal(dAtA []byte) error {
+func (m *ConsumerGenesisState) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1763,10 +1759,10 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: GenesisState: wiretype end group for non-group")
+			return fmt.Errorf("proto: ConsumerGenesisState: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ConsumerGenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1: