diff --git a/proto/interchain_security/ccv/provider/v1/genesis.proto b/proto/interchain_security/ccv/provider/v1/genesis.proto
index f9ceed8309..6139dcb653 100644
--- a/proto/interchain_security/ccv/provider/v1/genesis.proto
+++ b/proto/interchain_security/ccv/provider/v1/genesis.proto
@@ -48,18 +48,15 @@ message ConsumerState {
   string client_id = 3;
   // InitalHeight defines the initial block height for the consumer chain
   uint64 initial_height = 4;
-  // LockUnbondingOnTimeout defines whether the unbonding funds should be released for this
-  // chain in case of a IBC channel timeout
-  bool lock_unbonding_on_timeout = 5;
   // ConsumerGenesis defines the initial consumer chain genesis states
-  interchain_security.ccv.consumer.v1.GenesisState consumer_genesis = 6
+  interchain_security.ccv.consumer.v1.GenesisState consumer_genesis = 5
   [ (gogoproto.nullable) = false ];
   // PendingValsetChanges defines the pending validator set changes for the consumer chain 
-  repeated interchain_security.ccv.v1.ValidatorSetChangePacketData pending_valset_changes = 7
+  repeated interchain_security.ccv.v1.ValidatorSetChangePacketData pending_valset_changes = 6
   [ (gogoproto.nullable) = false ];
-  repeated string slash_downtime_ack = 8;
+  repeated string slash_downtime_ack = 7;
   // UnbondingOpsIndex defines the unbonding operations on the consumer chain
-  repeated UnbondingOpIndex unbonding_ops_index = 9
+  repeated UnbondingOpIndex unbonding_ops_index = 8
   [ (gogoproto.nullable) = false ];
 }
 
diff --git a/proto/interchain_security/ccv/provider/v1/provider.proto b/proto/interchain_security/ccv/provider/v1/provider.proto
index 3824f8e9e8..6f758f8333 100644
--- a/proto/interchain_security/ccv/provider/v1/provider.proto
+++ b/proto/interchain_security/ccv/provider/v1/provider.proto
@@ -37,14 +37,10 @@ message ConsumerAdditionProposal {
     // will be responsible for starting their consumer chain validator node.
     google.protobuf.Timestamp spawn_time = 7
         [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
-    // Indicates whether the outstanding unbonding operations should be released
-    // in case of a channel time-outs. When set to true, a governance proposal
-    // on the provider chain would be necessary to release the locked funds.
-    bool lock_unbonding_on_timeout = 8;   
   }
 // ConsumerRemovalProposal is a governance proposal on the provider chain to remove (and stop) a consumer chain.
 // If it passes, all the consumer chain's state is removed from the provider chain. The outstanding unbonding
-// operation funds are released if the LockUnbondingOnTimeout parameter is set to false for the consumer chain ID.
+// operation funds are released.
  message ConsumerRemovalProposal {
     // the title of the proposal
     string title = 1;
diff --git a/tests/e2e/stop_consumer.go b/tests/e2e/stop_consumer.go
index 4267e16fd2..9a31c01114 100644
--- a/tests/e2e/stop_consumer.go
+++ b/tests/e2e/stop_consumer.go
@@ -42,7 +42,7 @@ func (s *CCVTestSuite) TestStopConsumerChain() {
 	// 	- setup CCV channel; establish CCV channel and set channelToChain, chainToChannel and initHeight mapping for the consumer chain ID
 	// 	- delegate the total bond amount to the chosed validator
 	// 	- undelegate the shares in four consecutive blocks evenly; create UnbondigOp and UnbondingOpIndex entries for the consumer chain ID
-	// 	- set SlashAck and LockUnbondingOnTimeout states for the consumer chain ID
+	// 	- set SlashAck state for the consumer chain ID
 	setupOperations := []struct {
 		fn func(suite *CCVTestSuite) error
 	}{
@@ -76,7 +76,6 @@ func (s *CCVTestSuite) TestStopConsumerChain() {
 		{
 			func(suite *CCVTestSuite) error {
 				providerKeeper.SetSlashAcks(s.providerCtx(), consumerChainID, []string{"validator-1", "validator-2", "validator-3"})
-				providerKeeper.SetLockUnbondingOnTimeout(s.providerCtx(), consumerChainID)
 				providerKeeper.AppendPendingPackets(s.providerCtx(), consumerChainID, ccv.ValidatorSetChangePacketData{ValsetUpdateId: 1})
 				return nil
 			},
@@ -89,7 +88,7 @@ func (s *CCVTestSuite) TestStopConsumerChain() {
 	}
 
 	// stop the consumer chain
-	err = providerKeeper.StopConsumerChain(s.providerCtx(), consumerChainID, false, true)
+	err = providerKeeper.StopConsumerChain(s.providerCtx(), consumerChainID, true)
 	s.Require().NoError(err)
 
 	// check all states are removed and the unbonding operation released
@@ -106,7 +105,7 @@ func (s *CCVTestSuite) TestStopConsumerOnChannelClosed() {
 	providerKeeper := s.providerApp.GetProviderKeeper()
 
 	// stop the consumer chain
-	err := providerKeeper.StopConsumerChain(s.providerCtx(), s.consumerChain.ChainID, true, true)
+	err := providerKeeper.StopConsumerChain(s.providerCtx(), s.consumerChain.ChainID, true)
 	s.Require().NoError(err)
 
 	err = s.path.EndpointA.UpdateClient()
@@ -160,7 +159,7 @@ func (s *CCVTestSuite) checkConsumerChainIsRemoved(chainID string, lockUbd bool,
 	// verify consumer chain's states are removed
 	_, found := providerKeeper.GetConsumerGenesis(s.providerCtx(), chainID)
 	s.Require().False(found)
-	s.Require().False(providerKeeper.GetLockUnbondingOnTimeout(s.providerCtx(), chainID))
+
 	_, found = providerKeeper.GetConsumerClientId(s.providerCtx(), chainID)
 	s.Require().False(found)
 
diff --git a/x/ccv/provider/keeper/genesis.go b/x/ccv/provider/keeper/genesis.go
index 25233404cc..ad5fc146f8 100644
--- a/x/ccv/provider/keeper/genesis.go
+++ b/x/ccv/provider/keeper/genesis.go
@@ -60,9 +60,7 @@ func (k Keeper) InitGenesis(ctx sdk.Context, genState *types.GenesisState) {
 		if err := k.SetConsumerGenesis(ctx, chainID, cs.ConsumerGenesis); err != nil {
 			panic(fmt.Errorf("consumer chain genesis could not be persisted: %w", err))
 		}
-		if cs.LockUnbondingOnTimeout {
-			k.SetLockUnbondingOnTimeout(ctx, chainID)
-		}
+
 		// check if the CCV channel was established
 		if cs.ChannelId != "" {
 			k.SetChannelToChain(ctx, cs.ChannelId, chainID)
@@ -93,10 +91,9 @@ func (k Keeper) ExportGenesis(ctx sdk.Context) *types.GenesisState {
 
 		// initial consumer chain states
 		cs := types.ConsumerState{
-			ChainId:                chainID,
-			ClientId:               clientID,
-			ConsumerGenesis:        gen,
-			LockUnbondingOnTimeout: k.GetLockUnbondingOnTimeout(ctx, chainID),
+			ChainId:         chainID,
+			ClientId:        clientID,
+			ConsumerGenesis: gen,
 		}
 
 		// try to find channel id for the current consumer chain
diff --git a/x/ccv/provider/keeper/genesis_test.go b/x/ccv/provider/keeper/genesis_test.go
index b7fc768bc0..c1a9de667e 100644
--- a/x/ccv/provider/keeper/genesis_test.go
+++ b/x/ccv/provider/keeper/genesis_test.go
@@ -135,8 +135,6 @@ func assertConsumerChainStates(ctx sdk.Context, t *testing.T, pk keeper.Keeper,
 			require.True(t, found)
 		}
 
-		require.Equal(t, cs.LockUnbondingOnTimeout, pk.GetLockUnbondingOnTimeout(ctx, chainID))
-
 		if expVSC := cs.GetPendingValsetChanges(); expVSC != nil {
 			gotVSC := pk.GetPendingPackets(ctx, chainID)
 			require.Equal(t, expVSC, gotVSC)
diff --git a/x/ccv/provider/keeper/keeper.go b/x/ccv/provider/keeper/keeper.go
index d61f30bfd8..6f314fd39f 100644
--- a/x/ccv/provider/keeper/keeper.go
+++ b/x/ccv/provider/keeper/keeper.go
@@ -751,26 +751,6 @@ func (k Keeper) DeletePendingPackets(ctx sdk.Context, chainID string) {
 	store.Delete(types.PendingVSCsKey(chainID))
 }
 
-// GetLockUnbondingOnTimeout returns the mapping from the given consumer chain ID to a boolean value indicating whether
-// the unbonding operation funds should be locked on CCV channel timeout
-func (k Keeper) GetLockUnbondingOnTimeout(ctx sdk.Context, chainID string) bool {
-	store := ctx.KVStore(k.storeKey)
-	bz := store.Get(types.LockUnbondingOnTimeoutKey(chainID))
-	return bz != nil
-}
-
-// SetLockUnbondingOnTimeout locks the unbonding operation funds in case of a CCV channel timeouts for the given consumer chain ID
-func (k Keeper) SetLockUnbondingOnTimeout(ctx sdk.Context, chainID string) {
-	store := ctx.KVStore(k.storeKey)
-	store.Set(types.LockUnbondingOnTimeoutKey(chainID), []byte{})
-}
-
-// DeleteLockUnbondingOnTimeout deletes the unbonding operation lock in case of a CCV channel timeouts for the given consumer chain ID
-func (k Keeper) DeleteLockUnbondingOnTimeout(ctx sdk.Context, chainID string) {
-	store := ctx.KVStore(k.storeKey)
-	store.Delete(types.LockUnbondingOnTimeoutKey(chainID))
-}
-
 // SetConsumerClientId sets the client ID for the given chain ID
 func (k Keeper) SetConsumerClientId(ctx sdk.Context, chainID, clientID string) {
 	store := ctx.KVStore(k.storeKey)
diff --git a/x/ccv/provider/keeper/proposal.go b/x/ccv/provider/keeper/proposal.go
index ae218acc6d..7c6d713b49 100644
--- a/x/ccv/provider/keeper/proposal.go
+++ b/x/ccv/provider/keeper/proposal.go
@@ -29,8 +29,7 @@ import (
 // Spec tag: [CCV-PCF-HCAPROP.1]
 func (k Keeper) HandleConsumerAdditionProposal(ctx sdk.Context, p *types.ConsumerAdditionProposal) error {
 	if !ctx.BlockTime().Before(p.SpawnTime) {
-		// lockUbdOnTimeout is set to be false, regardless of what the proposal says, until we can specify and test issues around this use case more thoroughly
-		return k.CreateConsumerClient(ctx, p.ChainId, p.InitialHeight, false)
+		return k.CreateConsumerClient(ctx, p.ChainId, p.InitialHeight)
 	}
 
 	err := k.SetPendingConsumerAdditionProp(ctx, p)
@@ -47,7 +46,7 @@ func (k Keeper) HandleConsumerAdditionProposal(ctx sdk.Context, p *types.Consume
 // See: https://github.com/cosmos/ibc/blob/main/spec/app/ics-028-cross-chain-validation/methods.md#ccv-pcf-crclient1
 // Spec tag: [CCV-PCF-CRCLIENT.1]
 func (k Keeper) CreateConsumerClient(ctx sdk.Context, chainID string,
-	initialHeight clienttypes.Height, lockUbdOnTimeout bool) error {
+	initialHeight clienttypes.Height) error {
 
 	// check that a client for this chain does not exist
 	if _, found := k.GetConsumerClientId(ctx, chainID); found {
@@ -91,11 +90,6 @@ func (k Keeper) CreateConsumerClient(ctx sdk.Context, chainID string,
 	ts := ctx.BlockTime().Add(k.GetParams(ctx).InitTimeoutPeriod)
 	k.SetInitTimeoutTimestamp(ctx, chainID, uint64(ts.UnixNano()))
 
-	// store LockUnbondingOnTimeout flag
-	if lockUbdOnTimeout {
-		k.SetLockUnbondingOnTimeout(ctx, chainID)
-	}
-
 	ctx.EventManager().EmitEvent(
 		sdk.NewEvent(
 			ccv.EventTypeConsumerClientCreated,
@@ -121,20 +115,20 @@ func (k Keeper) CreateConsumerClient(ctx sdk.Context, chainID string,
 func (k Keeper) HandleConsumerRemovalProposal(ctx sdk.Context, p *types.ConsumerRemovalProposal) error {
 
 	if !ctx.BlockTime().Before(p.StopTime) {
-		return k.StopConsumerChain(ctx, p.ChainId, false, true)
+		return k.StopConsumerChain(ctx, p.ChainId, true)
 	}
 
 	k.SetPendingConsumerRemovalProp(ctx, p.ChainId, p.StopTime)
 	return nil
 }
 
-// StopConsumerChain cleans up the states for the given consumer chain ID and, if the given lockUbd is false,
+// StopConsumerChain cleans up the states for the given consumer chain ID and
 // it completes the outstanding unbonding operations lock by the consumer chain.
 //
 // This method implements StopConsumerChain from spec.
 // See: https://github.com/cosmos/ibc/blob/main/spec/app/ics-028-cross-chain-validation/methods.md#ccv-pcf-stcc1
 // Spec tag: [CCV-PCF-STCC.1]
-func (k Keeper) StopConsumerChain(ctx sdk.Context, chainID string, lockUbd, closeChan bool) (err error) {
+func (k Keeper) StopConsumerChain(ctx sdk.Context, chainID string, closeChan bool) (err error) {
 	// check that a client for chainID exists
 	if _, found := k.GetConsumerClientId(ctx, chainID); !found {
 		// drop the proposal
@@ -144,7 +138,6 @@ func (k Keeper) StopConsumerChain(ctx sdk.Context, chainID string, lockUbd, clos
 	// clean up states
 	k.DeleteConsumerClientId(ctx, chainID)
 	k.DeleteConsumerGenesis(ctx, chainID)
-	k.DeleteLockUnbondingOnTimeout(ctx, chainID)
 	k.DeleteInitTimeoutTimestamp(ctx, chainID)
 
 	// close channel and delete the mappings between chain ID and channel ID
@@ -172,40 +165,38 @@ func (k Keeper) StopConsumerChain(ctx sdk.Context, chainID string, lockUbd, clos
 
 	// release unbonding operations if they aren't locked
 	var vscIDs []uint64
-	if !lockUbd {
-		// iterate over the consumer chain's unbonding operation VSC ids
-		k.IterateOverUnbondingOpIndex(ctx, chainID, func(vscID uint64, ids []uint64) (stop bool) {
-			// iterate over the unbonding operations for the current VSC ID
-			var maturedIds []uint64
-			for _, id := range ids {
-				unbondingOp, found := k.GetUnbondingOp(ctx, id)
-				if !found {
-					err = fmt.Errorf("could not find UnbondingOp according to index - id: %d", id)
-					return true // stop the iteration
-				}
-				// remove consumer chain ID from unbonding op record
-				unbondingOp.UnbondingConsumerChains, _ = removeStringFromSlice(unbondingOp.UnbondingConsumerChains, chainID)
-
-				// If unbonding op is completely unbonded from all relevant consumer chains
-				if len(unbondingOp.UnbondingConsumerChains) == 0 {
-					// Store id of matured unbonding op for later completion of unbonding in staking module
-					maturedIds = append(maturedIds, unbondingOp.Id)
-					// Delete unbonding op
-					k.DeleteUnbondingOp(ctx, unbondingOp.Id)
-				} else {
-					if err := k.SetUnbondingOp(ctx, unbondingOp); err != nil {
-						panic(fmt.Errorf("unbonding op could not be persisted: %w", err))
-					}
-				}
+	// iterate over the consumer chain's unbonding operation VSC ids
+	k.IterateOverUnbondingOpIndex(ctx, chainID, func(vscID uint64, ids []uint64) (stop bool) {
+		// iterate over the unbonding operations for the current VSC ID
+		var maturedIds []uint64
+		for _, id := range ids {
+			unbondingOp, found := k.GetUnbondingOp(ctx, id)
+			if !found {
+				err = fmt.Errorf("could not find UnbondingOp according to index - id: %d", id)
+				return true // stop the iteration
 			}
-			if err := k.AppendMaturedUnbondingOps(ctx, maturedIds); err != nil {
-				panic(fmt.Errorf("mature unbonding ops could not be appended: %w", err))
+			// remove consumer chain ID from unbonding op record
+			unbondingOp.UnbondingConsumerChains, _ = removeStringFromSlice(unbondingOp.UnbondingConsumerChains, chainID)
+
+			// If unbonding op is completely unbonded from all relevant consumer chains
+			if len(unbondingOp.UnbondingConsumerChains) == 0 {
+				// Store id of matured unbonding op for later completion of unbonding in staking module
+				maturedIds = append(maturedIds, unbondingOp.Id)
+				// Delete unbonding op
+				k.DeleteUnbondingOp(ctx, unbondingOp.Id)
+			} else {
+				if err := k.SetUnbondingOp(ctx, unbondingOp); err != nil {
+					panic(fmt.Errorf("unbonding op could not be persisted: %w", err))
+				}
 			}
+		}
+		if err := k.AppendMaturedUnbondingOps(ctx, maturedIds); err != nil {
+			panic(fmt.Errorf("mature unbonding ops could not be appended: %w", err))
+		}
 
-			vscIDs = append(vscIDs, vscID)
-			return false // do not stop the iteration
-		})
-	}
+		vscIDs = append(vscIDs, vscID)
+		return false // do not stop the iteration
+	})
 
 	if err != nil {
 		return err
@@ -323,8 +314,7 @@ func (k Keeper) BeginBlockInit(ctx sdk.Context) {
 	propsToExecute := k.ConsumerAdditionPropsToExecute(ctx)
 
 	for _, prop := range propsToExecute {
-		// lockUbdOnTimeout is set to be false, regardless of what the proposal says, until we can specify and test issues around this use case more thoroughly
-		err := k.CreateConsumerClient(ctx, prop.ChainId, prop.InitialHeight, false)
+		err := k.CreateConsumerClient(ctx, prop.ChainId, prop.InitialHeight)
 		if err != nil {
 			panic(fmt.Errorf("consumer client could not be created: %w", err))
 		}
@@ -448,7 +438,7 @@ func (k Keeper) BeginBlockCCR(ctx sdk.Context) {
 	propsToExecute := k.ConsumerRemovalPropsToExecute(ctx)
 
 	for _, prop := range propsToExecute {
-		err := k.StopConsumerChain(ctx, prop.ChainId, false, true)
+		err := k.StopConsumerChain(ctx, prop.ChainId, true)
 		if err != nil {
 			panic(fmt.Errorf("consumer chain failed to stop: %w", err))
 		}
diff --git a/x/ccv/provider/keeper/proposal_test.go b/x/ccv/provider/keeper/proposal_test.go
index 215fc91a0b..e55a8fc604 100644
--- a/x/ccv/provider/keeper/proposal_test.go
+++ b/x/ccv/provider/keeper/proposal_test.go
@@ -90,8 +90,6 @@ func TestHandleConsumerAdditionProposal(t *testing.T) {
 			)
 		}
 
-		tc.prop.LockUnbondingOnTimeout = false // Full functionality not implemented yet.
-
 		err := providerKeeper.HandleConsumerAdditionProposal(ctx, tc.prop)
 		require.NoError(t, err)
 
@@ -187,10 +185,6 @@ func testCreatedConsumerClient(t *testing.T,
 	require.True(t, found, "consumer client not found")
 	require.Equal(t, expectedClientID, clientId)
 
-	// Lock unbonding on timeout flag always false for now.
-	lockUbdOnTimeout := providerKeeper.GetLockUnbondingOnTimeout(ctx, expectedChainID)
-	require.False(t, lockUbdOnTimeout)
-
 	// Only assert that consumer genesis was set,
 	// more granular tests on consumer genesis should be defined in TestMakeConsumerGenesis
 	_, ok := providerKeeper.GetConsumerGenesis(ctx, expectedChainID)
@@ -438,7 +432,7 @@ func TestStopConsumerChain(t *testing.T) {
 		// Setup specific to test case
 		tc.setup(ctx, &providerKeeper, mocks)
 
-		err := providerKeeper.StopConsumerChain(ctx, "chainID", false, true)
+		err := providerKeeper.StopConsumerChain(ctx, "chainID", true)
 
 		if tc.expErr {
 			require.Error(t, err)
@@ -458,8 +452,6 @@ func testProviderStateIsCleaned(t *testing.T, ctx sdk.Context, providerKeeper pr
 
 	_, found := providerKeeper.GetConsumerClientId(ctx, expectedChainID)
 	require.False(t, found)
-	found = providerKeeper.GetLockUnbondingOnTimeout(ctx, expectedChainID)
-	require.False(t, found)
 	_, found = providerKeeper.GetChainToChannel(ctx, expectedChainID)
 	require.False(t, found)
 	_, found = providerKeeper.GetChannelToChain(ctx, expectedChannelID)
diff --git a/x/ccv/provider/keeper/relay.go b/x/ccv/provider/keeper/relay.go
index 3943301d20..e9493a69d4 100644
--- a/x/ccv/provider/keeper/relay.go
+++ b/x/ccv/provider/keeper/relay.go
@@ -96,9 +96,8 @@ func (k Keeper) OnAcknowledgementPacket(ctx sdk.Context, packet channeltypes.Pac
 		// The VSC packet data could not be successfully decoded.
 		// This should never happen.
 		if chainID, ok := k.GetChannelToChain(ctx, packet.SourceChannel); ok {
-			// stop consumer chain and uses the LockUnbondingOnTimeout flag
-			// to decide whether the unbonding operations should be released
-			return k.StopConsumerChain(ctx, chainID, k.GetLockUnbondingOnTimeout(ctx, chainID), false)
+			// stop consumer chain
+			return k.StopConsumerChain(ctx, chainID, false)
 		}
 		return sdkerrors.Wrapf(types.ErrUnknownConsumerChannelId, "recv ErrorAcknowledgement on unknown channel %s", packet.SourceChannel)
 	}
@@ -116,9 +115,8 @@ func (k Keeper) OnTimeoutPacket(ctx sdk.Context, packet channeltypes.Packet) err
 			packet.SourceChannel,
 		)
 	}
-	// stop consumer chain and uses the LockUnbondingOnTimeout flag
-	// to decide whether the unbonding operations should be released
-	return k.StopConsumerChain(ctx, chainID, k.GetLockUnbondingOnTimeout(ctx, chainID), false)
+	// stop consumer chain
+	return k.StopConsumerChain(ctx, chainID, false)
 }
 
 // EndBlockVSU contains the EndBlock logic needed for
@@ -343,7 +341,7 @@ func (k Keeper) EndBlockCCR(ctx sdk.Context) {
 		// stop the consumer chain and unlock the unbonding.
 		// Note that the CCV channel was not established,
 		// thus closeChan is irrelevant
-		err := k.StopConsumerChain(ctx, chainID, false, false)
+		err := k.StopConsumerChain(ctx, chainID, false)
 		if err != nil {
 			panic(fmt.Errorf("consumer chain failed to stop: %w", err))
 		}
@@ -372,14 +370,8 @@ func (k Keeper) EndBlockCCR(ctx sdk.Context) {
 	})
 	// remove consumers that timed out
 	for _, chainID := range chainIdsToRemove {
-		// stop the consumer chain and use lockUnbondingOnTimeout
-		// to decide whether to lock the unbonding
-		err := k.StopConsumerChain(
-			ctx,
-			chainID,
-			k.GetLockUnbondingOnTimeout(ctx, chainID),
-			true,
-		)
+		// stop the consumer chain
+		err := k.StopConsumerChain(ctx, chainID, true)
 		if err != nil {
 			panic(fmt.Errorf("consumer chain failed to stop: %w", err))
 		}
diff --git a/x/ccv/provider/types/consumer.go b/x/ccv/provider/types/consumer.go
index 4376678cc2..93a4363e84 100644
--- a/x/ccv/provider/types/consumer.go
+++ b/x/ccv/provider/types/consumer.go
@@ -17,14 +17,13 @@ func NewConsumerStates(
 	slashDowntimeAck []string,
 ) ConsumerState {
 	return ConsumerState{
-		ChainId:                chainID,
-		ClientId:               clientID,
-		ChannelId:              channelID,
-		InitialHeight:          initialHeight,
-		LockUnbondingOnTimeout: true,
-		UnbondingOpsIndex:      unbondingOpsIndexes,
-		PendingValsetChanges:   pendingValsetChanges,
-		ConsumerGenesis:        genesis,
-		SlashDowntimeAck:       slashDowntimeAck,
+		ChainId:              chainID,
+		ClientId:             clientID,
+		ChannelId:            channelID,
+		InitialHeight:        initialHeight,
+		UnbondingOpsIndex:    unbondingOpsIndexes,
+		PendingValsetChanges: pendingValsetChanges,
+		ConsumerGenesis:      genesis,
+		SlashDowntimeAck:     slashDowntimeAck,
 	}
 }
diff --git a/x/ccv/provider/types/genesis.pb.go b/x/ccv/provider/types/genesis.pb.go
index f092530348..6700343691 100644
--- a/x/ccv/provider/types/genesis.pb.go
+++ b/x/ccv/provider/types/genesis.pb.go
@@ -27,7 +27,7 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 // GenesisState defines the CCV provider chain genesis state
 type GenesisState struct {
-	// empty for a new chain
+	// strictly positive and set to 1 (DefaultValsetUpdateID) for a new chain
 	ValsetUpdateId uint64 `protobuf:"varint,1,opt,name=valset_update_id,json=valsetUpdateId,proto3" json:"valset_update_id,omitempty"`
 	// empty for a new chain
 	ConsumerStates []ConsumerState `protobuf:"bytes,2,rep,name=consumer_states,json=consumerStates,proto3" json:"consumer_states" yaml:"consumer_states"`
@@ -143,16 +143,13 @@ type ConsumerState struct {
 	ClientId string `protobuf:"bytes,3,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
 	// 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"`
-	// LockUnbondingOnTimeout defines whether the unbonding funds should be released for this
-	// chain in case of a IBC channel timeout
-	LockUnbondingOnTimeout bool `protobuf:"varint,5,opt,name=lock_unbonding_on_timeout,json=lockUnbondingOnTimeout,proto3" json:"lock_unbonding_on_timeout,omitempty"`
 	// ConsumerGenesis defines the initial consumer chain genesis states
-	ConsumerGenesis types1.GenesisState `protobuf:"bytes,6,opt,name=consumer_genesis,json=consumerGenesis,proto3" json:"consumer_genesis"`
+	ConsumerGenesis types1.GenesisState `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,7,rep,name=pending_valset_changes,json=pendingValsetChanges,proto3" json:"pending_valset_changes"`
-	SlashDowntimeAck     []string                             `protobuf:"bytes,8,rep,name=slash_downtime_ack,json=slashDowntimeAck,proto3" json:"slash_downtime_ack,omitempty"`
+	PendingValsetChanges []types.ValidatorSetChangePacketData `protobuf:"bytes,6,rep,name=pending_valset_changes,json=pendingValsetChanges,proto3" json:"pending_valset_changes"`
+	SlashDowntimeAck     []string                             `protobuf:"bytes,7,rep,name=slash_downtime_ack,json=slashDowntimeAck,proto3" json:"slash_downtime_ack,omitempty"`
 	// UnbondingOpsIndex defines the unbonding operations on the consumer chain
-	UnbondingOpsIndex []UnbondingOpIndex `protobuf:"bytes,9,rep,name=unbonding_ops_index,json=unbondingOpsIndex,proto3" json:"unbonding_ops_index"`
+	UnbondingOpsIndex []UnbondingOpIndex `protobuf:"bytes,8,rep,name=unbonding_ops_index,json=unbondingOpsIndex,proto3" json:"unbonding_ops_index"`
 }
 
 func (m *ConsumerState) Reset()         { *m = ConsumerState{} }
@@ -216,13 +213,6 @@ func (m *ConsumerState) GetInitialHeight() uint64 {
 	return 0
 }
 
-func (m *ConsumerState) GetLockUnbondingOnTimeout() bool {
-	if m != nil {
-		return m.LockUnbondingOnTimeout
-	}
-	return false
-}
-
 func (m *ConsumerState) GetConsumerGenesis() types1.GenesisState {
 	if m != nil {
 		return m.ConsumerGenesis
@@ -371,57 +361,55 @@ func init() {
 }
 
 var fileDescriptor_48411d9c7900d48e = []byte{
-	// 794 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0x5d, 0x6f, 0xf3, 0x34,
-	0x14, 0x6e, 0xd6, 0xd2, 0xb7, 0xf5, 0xfb, 0x6e, 0x14, 0x33, 0x55, 0x59, 0x5f, 0xd1, 0x55, 0x05,
-	0x44, 0x25, 0x46, 0xa2, 0x14, 0x21, 0xc1, 0x80, 0x8b, 0x7d, 0x48, 0xd0, 0x0b, 0xc4, 0x94, 0x7d,
-	0x5c, 0xec, 0x26, 0x72, 0x1d, 0xab, 0x35, 0x4d, 0xec, 0x28, 0x76, 0xc2, 0x26, 0x84, 0x84, 0xc4,
-	0x1f, 0xe0, 0x0f, 0x21, 0x6e, 0x77, 0xb9, 0x4b, 0xae, 0x26, 0xb4, 0xfd, 0x03, 0x7e, 0x01, 0x8a,
-	0xe3, 0x76, 0x69, 0xd5, 0x8e, 0xf6, 0x2e, 0x39, 0x8f, 0x9f, 0xe7, 0x3c, 0x3e, 0x3e, 0x3e, 0x06,
-	0x0e, 0x65, 0x92, 0xc4, 0x78, 0x8c, 0x28, 0xf3, 0x04, 0xc1, 0x49, 0x4c, 0xe5, 0xad, 0x8d, 0x71,
-	0x6a, 0x47, 0x31, 0x4f, 0xa9, 0x4f, 0x62, 0x3b, 0x75, 0xec, 0x11, 0x61, 0x44, 0x50, 0x61, 0x45,
-	0x31, 0x97, 0x1c, 0x7e, 0xb8, 0x84, 0x62, 0x61, 0x9c, 0x5a, 0x53, 0x8a, 0x95, 0x3a, 0xad, 0xdd,
-	0x11, 0x1f, 0x71, 0xb5, 0xde, 0xce, 0xbe, 0x72, 0x6a, 0xeb, 0xa3, 0x55, 0xd9, 0x52, 0xc7, 0xd6,
-	0x0a, 0x92, 0xb7, 0xfa, 0xeb, 0x78, 0x9a, 0x25, 0xfb, 0x1f, 0x0e, 0xe6, 0x4c, 0x24, 0x61, 0xce,
-	0x99, 0x7e, 0x6b, 0x8e, 0xb3, 0x0e, 0x67, 0x6e, 0xef, 0xdd, 0xbf, 0xaa, 0xe0, 0xcd, 0x77, 0x79,
-	0xe4, 0x5c, 0x22, 0x49, 0x60, 0x0f, 0x34, 0x52, 0x14, 0x08, 0x22, 0xbd, 0x24, 0xf2, 0x91, 0x24,
-	0x1e, 0xf5, 0x4d, 0xa3, 0x63, 0xf4, 0x2a, 0xee, 0x4e, 0x1e, 0xbf, 0x54, 0xe1, 0x81, 0x0f, 0x7f,
-	0x01, 0xef, 0x4e, 0x75, 0x3d, 0x91, 0x71, 0x85, 0xb9, 0xd5, 0x29, 0xf7, 0x5e, 0xf7, 0xfb, 0xd6,
-	0x1a, 0x05, 0xb5, 0x4e, 0x34, 0x57, 0xa5, 0x3d, 0x6e, 0xdf, 0x3d, 0xec, 0x97, 0xfe, 0x7d, 0xd8,
-	0x6f, 0xde, 0xa2, 0x30, 0x38, 0xec, 0x2e, 0x08, 0x77, 0xdd, 0x1d, 0x5c, 0x5c, 0x2e, 0xa0, 0x0b,
-	0xb6, 0x13, 0x36, 0xe4, 0xcc, 0xa7, 0x6c, 0xe4, 0xf1, 0x48, 0x98, 0x65, 0x95, 0xfa, 0x93, 0x95,
-	0xa9, 0x53, 0xc7, 0xba, 0x9c, 0x12, 0x7e, 0x8c, 0x8e, 0x2b, 0x59, 0x3e, 0xf7, 0x4d, 0xf2, 0x1c,
-	0x12, 0x10, 0x81, 0xdd, 0x10, 0xc9, 0x24, 0x26, 0xde, 0xbc, 0x74, 0xa5, 0x63, 0xf4, 0x5e, 0xf7,
-	0xed, 0x97, 0xa4, 0x7f, 0x50, 0x3c, 0xbf, 0x90, 0x41, 0xb8, 0x30, 0x17, 0x2b, 0xc6, 0xe0, 0xaf,
-	0xa0, 0xb5, 0x58, 0x5d, 0x4f, 0x72, 0x6f, 0x4c, 0xe8, 0x68, 0x2c, 0xcd, 0x77, 0xd4, 0x1e, 0xbe,
-	0x5e, 0xab, 0x7c, 0x57, 0x73, 0x87, 0x71, 0xc1, 0xbf, 0x57, 0x12, 0x7a, 0x5f, 0xcd, 0x74, 0x29,
-	0x0a, 0x7f, 0x37, 0xc0, 0xdb, 0x59, 0x69, 0x91, 0xef, 0x53, 0x49, 0x39, 0xf3, 0xa2, 0x98, 0x47,
-	0x5c, 0xa0, 0x40, 0x98, 0x55, 0x65, 0xe0, 0xdb, 0x8d, 0xce, 0xef, 0x48, 0xcb, 0x9c, 0x69, 0x15,
-	0x6d, 0x61, 0x0f, 0xaf, 0xc0, 0x05, 0xfc, 0xcd, 0x00, 0xad, 0x99, 0x8b, 0x98, 0x84, 0x3c, 0x45,
-	0x41, 0xc1, 0xc4, 0x2b, 0x65, 0xe2, 0x9b, 0x8d, 0x4c, 0xb8, 0xb9, 0xca, 0x82, 0x07, 0x13, 0x2f,
-	0x87, 0x05, 0x1c, 0x80, 0x6a, 0x84, 0x62, 0x14, 0x0a, 0xb3, 0xa6, 0x0e, 0xf7, 0xd3, 0xb5, 0xb2,
-	0x9d, 0x29, 0x8a, 0x16, 0xd7, 0x02, 0xdd, 0x3f, 0x2b, 0x60, 0x7b, 0xae, 0x97, 0xe1, 0x1e, 0xa8,
-	0xe5, 0x42, 0xfa, 0xea, 0xd4, 0xdd, 0x57, 0xea, 0x7f, 0xe0, 0xc3, 0x0f, 0x00, 0xc0, 0x63, 0xc4,
-	0x18, 0x09, 0x32, 0x70, 0x4b, 0x81, 0x75, 0x1d, 0x19, 0xf8, 0xf0, 0x2d, 0xa8, 0xe3, 0x80, 0x12,
-	0x26, 0x33, 0xb4, 0xac, 0xd0, 0x5a, 0x1e, 0x18, 0xf8, 0xf0, 0x63, 0xb0, 0x43, 0x19, 0x95, 0x14,
-	0x05, 0xd3, 0x7e, 0xa9, 0xa8, 0x7b, 0xb9, 0xad, 0xa3, 0xfa, 0x8c, 0xbf, 0x02, 0x7b, 0x01, 0xc7,
-	0x93, 0x62, 0x0f, 0x33, 0x4f, 0xd2, 0x90, 0xf0, 0x24, 0xeb, 0x30, 0xa3, 0x57, 0x73, 0x9b, 0xd9,
-	0x82, 0xe7, 0xbe, 0x64, 0x17, 0x39, 0x0a, 0x87, 0xa0, 0x31, 0x3b, 0x17, 0x3d, 0x26, 0xcc, 0xaa,
-	0xaa, 0x8f, 0xb3, 0xb2, 0x3e, 0xb3, 0x11, 0x94, 0x3a, 0x56, 0x71, 0x90, 0xe8, 0x2a, 0xcd, 0x46,
-	0x84, 0xc6, 0xa0, 0x04, 0xcd, 0x88, 0xe4, 0xbe, 0xf4, 0x4d, 0xc8, 0xb6, 0x3f, 0x22, 0xd3, 0x73,
-	0xff, 0xf2, 0xa5, 0x6b, 0x76, 0x85, 0x02, 0xea, 0x23, 0xc9, 0xe3, 0x73, 0x22, 0x4f, 0x14, 0xed,
-	0x0c, 0xe1, 0x09, 0x91, 0xa7, 0x48, 0x22, 0x9d, 0x70, 0x57, 0xab, 0xe7, 0xf7, 0x23, 0x5f, 0x24,
-	0xe0, 0x01, 0x80, 0x22, 0x40, 0x62, 0xec, 0xf9, 0xfc, 0x67, 0x96, 0x15, 0xc3, 0x43, 0x78, 0x62,
-	0xd6, 0x3a, 0xe5, 0x5e, 0xdd, 0x6d, 0x28, 0xe4, 0x54, 0x03, 0x47, 0x78, 0x02, 0x27, 0xe0, 0xfd,
-	0xb9, 0x09, 0xe0, 0x51, 0xe6, 0x93, 0x1b, 0xb3, 0xae, 0x0c, 0x7e, 0xb1, 0x56, 0xab, 0x14, 0x6e,
-	0xfd, 0x20, 0x23, 0x6b, 0x77, 0xef, 0x15, 0x07, 0x8e, 0x02, 0xba, 0x3f, 0x81, 0xc6, 0xe2, 0xe2,
-	0x0d, 0x86, 0xf0, 0x01, 0x80, 0x45, 0xab, 0xda, 0x69, 0x36, 0x87, 0x2b, 0x6e, 0x23, 0x59, 0xd0,
-	0xed, 0x5e, 0x83, 0xe6, 0xf2, 0xb9, 0xb1, 0x41, 0xc6, 0x26, 0xa8, 0xea, 0xf6, 0xdb, 0x52, 0xb8,
-	0xfe, 0x3b, 0xbe, 0xb8, 0x7b, 0x6c, 0x1b, 0xf7, 0x8f, 0x6d, 0xe3, 0x9f, 0xc7, 0xb6, 0xf1, 0xc7,
-	0x53, 0xbb, 0x74, 0xff, 0xd4, 0x2e, 0xfd, 0xfd, 0xd4, 0x2e, 0x5d, 0x1f, 0x8e, 0xa8, 0x1c, 0x27,
-	0x43, 0x0b, 0xf3, 0xd0, 0xc6, 0x5c, 0x84, 0x5c, 0xd8, 0xcf, 0x25, 0xfc, 0x6c, 0xf6, 0x50, 0xdd,
-	0xcc, 0x3f, 0x89, 0xf2, 0x36, 0x22, 0x62, 0x58, 0x55, 0xcf, 0xd4, 0xe7, 0xff, 0x05, 0x00, 0x00,
-	0xff, 0xff, 0xb9, 0x12, 0x17, 0x90, 0xd7, 0x07, 0x00, 0x00,
+	// 765 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0xcb, 0x6e, 0xe3, 0x36,
+	0x14, 0xb5, 0x12, 0xc7, 0xb1, 0x99, 0x47, 0x5d, 0x36, 0x30, 0x14, 0x07, 0x75, 0x02, 0xb7, 0x45,
+	0x0d, 0x34, 0x95, 0x20, 0x17, 0x05, 0x8a, 0xb4, 0x5d, 0xe4, 0x01, 0xb4, 0x5e, 0x14, 0x0d, 0x94,
+	0xc7, 0x22, 0x1b, 0x81, 0xa6, 0x08, 0x9b, 0x63, 0x49, 0x14, 0x44, 0x4a, 0x93, 0x60, 0x30, 0xc0,
+	0x60, 0xe6, 0x07, 0xe6, 0x8f, 0x66, 0x9b, 0x65, 0x96, 0xb3, 0x0a, 0x06, 0xc9, 0x1f, 0xcc, 0x17,
+	0x0c, 0x44, 0xd1, 0x8e, 0x6c, 0xd8, 0x19, 0x7b, 0x27, 0xdd, 0xc3, 0x73, 0xee, 0xb9, 0xe4, 0xbd,
+	0x24, 0xb0, 0x68, 0x20, 0x48, 0x84, 0xfb, 0x88, 0x06, 0x0e, 0x27, 0x38, 0x8e, 0xa8, 0xb8, 0x31,
+	0x31, 0x4e, 0xcc, 0x30, 0x62, 0x09, 0x75, 0x49, 0x64, 0x26, 0x96, 0xd9, 0x23, 0x01, 0xe1, 0x94,
+	0x1b, 0x61, 0xc4, 0x04, 0x83, 0x3f, 0x4c, 0xa1, 0x18, 0x18, 0x27, 0xc6, 0x90, 0x62, 0x24, 0x56,
+	0x7d, 0xab, 0xc7, 0x7a, 0x4c, 0xae, 0x37, 0xd3, 0xaf, 0x8c, 0x5a, 0xff, 0x71, 0x56, 0xb6, 0xc4,
+	0x32, 0x95, 0x82, 0x60, 0xf5, 0xf6, 0x3c, 0x9e, 0x46, 0xc9, 0xbe, 0xc2, 0xc1, 0x2c, 0xe0, 0xb1,
+	0x9f, 0x71, 0x86, 0xdf, 0x8a, 0x63, 0xcd, 0xc3, 0x19, 0xab, 0xbd, 0xf9, 0xa1, 0x04, 0xd6, 0xff,
+	0xc9, 0x22, 0x67, 0x02, 0x09, 0x02, 0x5b, 0xa0, 0x9a, 0x20, 0x8f, 0x13, 0xe1, 0xc4, 0xa1, 0x8b,
+	0x04, 0x71, 0xa8, 0xab, 0x6b, 0x7b, 0x5a, 0xab, 0x68, 0x6f, 0x66, 0xf1, 0x0b, 0x19, 0xee, 0xb8,
+	0xf0, 0x15, 0xf8, 0x66, 0xa8, 0xeb, 0xf0, 0x94, 0xcb, 0xf5, 0xa5, 0xbd, 0xe5, 0xd6, 0x5a, 0xbb,
+	0x6d, 0xcc, 0xb1, 0xa1, 0xc6, 0xb1, 0xe2, 0xca, 0xb4, 0x47, 0x8d, 0xdb, 0xfb, 0xdd, 0xc2, 0xe7,
+	0xfb, 0xdd, 0xda, 0x0d, 0xf2, 0xbd, 0x83, 0xe6, 0x84, 0x70, 0xd3, 0xde, 0xc4, 0xf9, 0xe5, 0x1c,
+	0xda, 0x60, 0x23, 0x0e, 0xba, 0x2c, 0x70, 0x69, 0xd0, 0x73, 0x58, 0xc8, 0xf5, 0x65, 0x99, 0xfa,
+	0xe7, 0x99, 0xa9, 0x13, 0xcb, 0xb8, 0x18, 0x12, 0xfe, 0x0f, 0x8f, 0x8a, 0x69, 0x3e, 0x7b, 0x3d,
+	0x7e, 0x0a, 0x71, 0x88, 0xc0, 0x96, 0x8f, 0x44, 0x1c, 0x11, 0x67, 0x5c, 0xba, 0xb8, 0xa7, 0xb5,
+	0xd6, 0xda, 0xe6, 0x73, 0xd2, 0xff, 0x49, 0x9e, 0x9b, 0xcb, 0xc0, 0x6d, 0x98, 0x89, 0xe5, 0x63,
+	0xf0, 0x35, 0xa8, 0x4f, 0xee, 0xae, 0x23, 0x98, 0xd3, 0x27, 0xb4, 0xd7, 0x17, 0xfa, 0x8a, 0xac,
+	0xe1, 0xcf, 0xb9, 0xb6, 0xef, 0x72, 0xec, 0x30, 0xce, 0xd9, 0xbf, 0x52, 0x42, 0xd5, 0x55, 0x4b,
+	0xa6, 0xa2, 0xf0, 0x9d, 0x06, 0x76, 0x46, 0x5b, 0x8b, 0x5c, 0x97, 0x0a, 0xca, 0x02, 0x27, 0x8c,
+	0x58, 0xc8, 0x38, 0xf2, 0xb8, 0x5e, 0x92, 0x06, 0xfe, 0x5e, 0xe8, 0xfc, 0x0e, 0x95, 0xcc, 0xa9,
+	0x52, 0x51, 0x16, 0xb6, 0xf1, 0x0c, 0x9c, 0xc3, 0x37, 0x1a, 0xa8, 0x8f, 0x5c, 0x44, 0xc4, 0x67,
+	0x09, 0xf2, 0x72, 0x26, 0x56, 0xa5, 0x89, 0xbf, 0x16, 0x32, 0x61, 0x67, 0x2a, 0x13, 0x1e, 0x74,
+	0x3c, 0x1d, 0xe6, 0xb0, 0x03, 0x4a, 0x21, 0x8a, 0x90, 0xcf, 0xf5, 0xb2, 0x3c, 0xdc, 0x5f, 0xe6,
+	0xca, 0x76, 0x2a, 0x29, 0x4a, 0x5c, 0x09, 0x34, 0xdf, 0x16, 0xc1, 0xc6, 0x58, 0x2f, 0xc3, 0x6d,
+	0x50, 0xce, 0x84, 0xd4, 0xe8, 0x54, 0xec, 0x55, 0xf9, 0xdf, 0x71, 0xe1, 0xf7, 0x00, 0xe0, 0x3e,
+	0x0a, 0x02, 0xe2, 0xa5, 0xe0, 0x92, 0x04, 0x2b, 0x2a, 0xd2, 0x71, 0xe1, 0x0e, 0xa8, 0x60, 0x8f,
+	0x92, 0x40, 0xa4, 0xe8, 0xb2, 0x44, 0xcb, 0x59, 0xa0, 0xe3, 0xc2, 0x9f, 0xc0, 0x26, 0x0d, 0xa8,
+	0xa0, 0xc8, 0x1b, 0xf6, 0x4b, 0x51, 0xce, 0xe5, 0x86, 0x8a, 0xaa, 0x33, 0xee, 0x82, 0xea, 0x68,
+	0x73, 0xd5, 0xac, 0xeb, 0x2b, 0xb2, 0x48, 0x6b, 0x66, 0x91, 0xa3, 0x7b, 0x24, 0xb1, 0x8c, 0xfc,
+	0x6d, 0xa0, 0x4a, 0x1d, 0xcd, 0xb9, 0xc2, 0xa0, 0x00, 0xb5, 0x90, 0x64, 0x03, 0xa2, 0xda, 0x39,
+	0xad, 0xa1, 0x47, 0x86, 0x1d, 0xf4, 0xc7, 0x73, 0xb3, 0x72, 0x89, 0x3c, 0xea, 0x22, 0xc1, 0xa2,
+	0x33, 0x22, 0x8e, 0x25, 0xed, 0x14, 0xe1, 0x01, 0x11, 0x27, 0x48, 0x20, 0x95, 0x70, 0x4b, 0xa9,
+	0x67, 0x4d, 0x9e, 0x2d, 0xe2, 0x70, 0x1f, 0x40, 0xee, 0x21, 0xde, 0x77, 0x5c, 0xf6, 0x32, 0x10,
+	0xd4, 0x27, 0x0e, 0xc2, 0x03, 0xd9, 0x2e, 0x15, 0xbb, 0x2a, 0x91, 0x13, 0x05, 0x1c, 0xe2, 0x01,
+	0x1c, 0x80, 0xef, 0xc6, 0xc6, 0xd8, 0xa1, 0x81, 0x4b, 0xae, 0xf5, 0xb2, 0x34, 0xf8, 0xfb, 0x5c,
+	0xe7, 0x9d, 0x1b, 0xdd, 0x4e, 0x4a, 0x56, 0xee, 0xbe, 0xcd, 0xdf, 0x1a, 0x12, 0x68, 0xbe, 0x00,
+	0xd5, 0xc9, 0xc5, 0x0b, 0xdc, 0xa4, 0xfb, 0x00, 0xe6, 0xad, 0x2a, 0xa7, 0xe9, 0x65, 0x5a, 0xb4,
+	0xab, 0xf1, 0x84, 0x6e, 0xf3, 0x0a, 0xd4, 0xa6, 0x0f, 0xff, 0x02, 0x19, 0x6b, 0xa0, 0xa4, 0x7a,
+	0x68, 0x49, 0xe2, 0xea, 0xef, 0xe8, 0xfc, 0xf6, 0xa1, 0xa1, 0xdd, 0x3d, 0x34, 0xb4, 0x4f, 0x0f,
+	0x0d, 0xed, 0xfd, 0x63, 0xa3, 0x70, 0xf7, 0xd8, 0x28, 0x7c, 0x7c, 0x6c, 0x14, 0xae, 0x0e, 0x7a,
+	0x54, 0xf4, 0xe3, 0xae, 0x81, 0x99, 0x6f, 0x62, 0xc6, 0x7d, 0xc6, 0xcd, 0xa7, 0x2d, 0xfc, 0x75,
+	0xf4, 0xda, 0x5c, 0x8f, 0xbf, 0x6b, 0xe2, 0x26, 0x24, 0xbc, 0x5b, 0x92, 0x6f, 0xcd, 0x6f, 0x5f,
+	0x02, 0x00, 0x00, 0xff, 0xff, 0x37, 0xc0, 0x26, 0x55, 0x9c, 0x07, 0x00, 0x00,
 }
 
 func (m *GenesisState) Marshal() (dAtA []byte, err error) {
@@ -575,7 +563,7 @@ func (m *ConsumerState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 				i = encodeVarintGenesis(dAtA, i, uint64(size))
 			}
 			i--
-			dAtA[i] = 0x4a
+			dAtA[i] = 0x42
 		}
 	}
 	if len(m.SlashDowntimeAck) > 0 {
@@ -584,7 +572,7 @@ func (m *ConsumerState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			copy(dAtA[i:], m.SlashDowntimeAck[iNdEx])
 			i = encodeVarintGenesis(dAtA, i, uint64(len(m.SlashDowntimeAck[iNdEx])))
 			i--
-			dAtA[i] = 0x42
+			dAtA[i] = 0x3a
 		}
 	}
 	if len(m.PendingValsetChanges) > 0 {
@@ -598,7 +586,7 @@ func (m *ConsumerState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 				i = encodeVarintGenesis(dAtA, i, uint64(size))
 			}
 			i--
-			dAtA[i] = 0x3a
+			dAtA[i] = 0x32
 		}
 	}
 	{
@@ -610,17 +598,7 @@ func (m *ConsumerState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i = encodeVarintGenesis(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0x32
-	if m.LockUnbondingOnTimeout {
-		i--
-		if m.LockUnbondingOnTimeout {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i--
-		dAtA[i] = 0x28
-	}
+	dAtA[i] = 0x2a
 	if m.InitialHeight != 0 {
 		i = encodeVarintGenesis(dAtA, i, uint64(m.InitialHeight))
 		i--
@@ -809,9 +787,6 @@ func (m *ConsumerState) Size() (n int) {
 	if m.InitialHeight != 0 {
 		n += 1 + sovGenesis(uint64(m.InitialHeight))
 	}
-	if m.LockUnbondingOnTimeout {
-		n += 2
-	}
 	l = m.ConsumerGenesis.Size()
 	n += 1 + l + sovGenesis(uint64(l))
 	if len(m.PendingValsetChanges) > 0 {
@@ -1328,26 +1303,6 @@ func (m *ConsumerState) Unmarshal(dAtA []byte) error {
 				}
 			}
 		case 5:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LockUnbondingOnTimeout", wireType)
-			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			m.LockUnbondingOnTimeout = bool(v != 0)
-		case 6:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field ConsumerGenesis", wireType)
 			}
@@ -1380,7 +1335,7 @@ func (m *ConsumerState) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 7:
+		case 6:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field PendingValsetChanges", wireType)
 			}
@@ -1414,7 +1369,7 @@ func (m *ConsumerState) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 8:
+		case 7:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field SlashDowntimeAck", wireType)
 			}
@@ -1446,7 +1401,7 @@ func (m *ConsumerState) Unmarshal(dAtA []byte) error {
 			}
 			m.SlashDowntimeAck = append(m.SlashDowntimeAck, string(dAtA[iNdEx:postIndex]))
 			iNdEx = postIndex
-		case 9:
+		case 8:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingOpsIndex", wireType)
 			}
diff --git a/x/ccv/provider/types/keys.go b/x/ccv/provider/types/keys.go
index 5ddee21d00..12b07611ba 100644
--- a/x/ccv/provider/types/keys.go
+++ b/x/ccv/provider/types/keys.go
@@ -92,9 +92,6 @@ const (
 	// VscSendTimestampBytePrefix is the byte prefix for storing
 	// the list of VSC sending timestamps for a given consumer chainID.
 	VscSendTimestampBytePrefix
-
-	// LockUnbondingOnTimeoutBytePrefix is the byte prefix that will store the consumer chain id which unbonding operations are locked on CCV channel timeout
-	LockUnbondingOnTimeoutBytePrefix
 )
 
 // PortKey returns the key to the port ID in the store
@@ -215,12 +212,6 @@ func ParseVscSendingTimestampKey(bz []byte) (string, uint64, error) {
 	return parseChainIdAndVscIdKey(VscSendTimestampBytePrefix, bz)
 }
 
-// LockUnbondingOnTimeoutKey returns the key that will store the consumer chain id which unbonding operations are locked
-// on CCV channel timeout
-func LockUnbondingOnTimeoutKey(chainID string) []byte {
-	return append([]byte{LockUnbondingOnTimeoutBytePrefix}, []byte(chainID)...)
-}
-
 // AppendMany appends a variable number of byte slices together
 func AppendMany(byteses ...[]byte) (out []byte) {
 	for _, bytes := range byteses {
diff --git a/x/ccv/provider/types/keys_test.go b/x/ccv/provider/types/keys_test.go
index 8152ecf01a..946ba68140 100644
--- a/x/ccv/provider/types/keys_test.go
+++ b/x/ccv/provider/types/keys_test.go
@@ -54,7 +54,6 @@ func getSingleByteKeys() [][]byte {
 	keys[i], i = []byte{InitChainHeightBytePrefix}, i+1
 	keys[i], i = []byte{PendingVSCsBytePrefix}, i+1
 	keys[i], i = []byte{VscSendTimestampBytePrefix}, i+1
-	keys[i], i = []byte{LockUnbondingOnTimeoutBytePrefix}, i+1
 
 	return keys[:i]
 }
@@ -148,7 +147,6 @@ func TestKeysWithPrefixAndId(t *testing.T) {
 		SlashAcksKey,
 		InitChainHeightKey,
 		PendingVSCsKey,
-		LockUnbondingOnTimeoutKey,
 	}
 
 	expectedBytePrefixes := []byte{
@@ -160,7 +158,6 @@ func TestKeysWithPrefixAndId(t *testing.T) {
 		SlashAcksBytePrefix,
 		InitChainHeightBytePrefix,
 		PendingVSCsBytePrefix,
-		LockUnbondingOnTimeoutBytePrefix,
 	}
 
 	tests := []struct {
diff --git a/x/ccv/provider/types/provider.pb.go b/x/ccv/provider/types/provider.pb.go
index a3fb286d40..baf9d17fe4 100644
--- a/x/ccv/provider/types/provider.pb.go
+++ b/x/ccv/provider/types/provider.pb.go
@@ -53,10 +53,6 @@ type ConsumerAdditionProposal struct {
 	// spawn time is the time on the provider chain at which the consumer chain genesis is finalized and all validators
 	// will be responsible for starting their consumer chain validator node.
 	SpawnTime time.Time `protobuf:"bytes,7,opt,name=spawn_time,json=spawnTime,proto3,stdtime" json:"spawn_time"`
-	// Indicates whether the outstanding unbonding operations should be released
-	// in case of a channel time-outs. When set to true, a governance proposal
-	// on the provider chain would be necessary to release the locked funds.
-	LockUnbondingOnTimeout bool `protobuf:"varint,8,opt,name=lock_unbonding_on_timeout,json=lockUnbondingOnTimeout,proto3" json:"lock_unbonding_on_timeout,omitempty"`
 }
 
 func (m *ConsumerAdditionProposal) Reset()      { *m = ConsumerAdditionProposal{} }
@@ -93,7 +89,7 @@ var xxx_messageInfo_ConsumerAdditionProposal proto.InternalMessageInfo
 
 // ConsumerRemovalProposal is a governance proposal on the provider chain to remove (and stop) a consumer chain.
 // If it passes, all the consumer chain's state is removed from the provider chain. The outstanding unbonding
-// operation funds are released if the LockUnbondingOnTimeout parameter is set to false for the consumer chain ID.
+// operation funds are released.
 type ConsumerRemovalProposal struct {
 	// the title of the proposal
 	Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
@@ -484,62 +480,60 @@ func init() {
 }
 
 var fileDescriptor_f22ec409a72b7b72 = []byte{
-	// 872 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xcf, 0x73, 0xdb, 0x44,
-	0x14, 0xb6, 0xb0, 0x13, 0xdb, 0xeb, 0x52, 0xe8, 0xb6, 0x13, 0xe4, 0xd0, 0xb1, 0x8d, 0xb9, 0x98,
-	0x61, 0x90, 0x26, 0xee, 0x85, 0x76, 0xe0, 0x90, 0x84, 0x29, 0xe1, 0xd0, 0xc1, 0x55, 0x02, 0xcc,
-	0x70, 0xd1, 0xac, 0x57, 0x2f, 0xd6, 0x4e, 0x24, 0xad, 0x66, 0x77, 0x25, 0x92, 0x3b, 0x07, 0x8e,
-	0x3d, 0xf6, 0xd8, 0xff, 0x80, 0x7f, 0xa3, 0xc7, 0x1e, 0x39, 0x01, 0x93, 0xfc, 0x15, 0xdc, 0x98,
-	0xdd, 0x95, 0xec, 0xc4, 0x24, 0x33, 0xc9, 0x81, 0x9b, 0xf6, 0x7d, 0xdf, 0xfb, 0xde, 0x7b, 0xfa,
-	0xf6, 0x07, 0x9a, 0xb2, 0x4c, 0x81, 0xa0, 0x31, 0x61, 0x59, 0x28, 0x81, 0x16, 0x82, 0xa9, 0x33,
-	0x9f, 0xd2, 0xd2, 0xcf, 0x05, 0x2f, 0x59, 0x04, 0xc2, 0x2f, 0x77, 0x96, 0xdf, 0x5e, 0x2e, 0xb8,
-	0xe2, 0xf8, 0xd3, 0x6b, 0x72, 0x3c, 0x4a, 0x4b, 0x6f, 0xc9, 0x2b, 0x77, 0xb6, 0x1f, 0x2d, 0xf8,
-	0x82, 0x1b, 0xbe, 0xaf, 0xbf, 0x6c, 0xea, 0xf6, 0x70, 0xc1, 0xf9, 0x22, 0x01, 0xdf, 0xac, 0xe6,
-	0xc5, 0xb1, 0xaf, 0x58, 0x0a, 0x52, 0x91, 0x34, 0xaf, 0x08, 0x83, 0x75, 0x42, 0x54, 0x08, 0xa2,
-	0x18, 0xcf, 0x6a, 0x01, 0x36, 0xa7, 0x3e, 0xe5, 0x02, 0x7c, 0x9a, 0x30, 0xc8, 0x94, 0x6e, 0xcf,
-	0x7e, 0x55, 0x04, 0x5f, 0x13, 0x12, 0xb6, 0x88, 0x95, 0x0d, 0x4b, 0x5f, 0x41, 0x16, 0x81, 0x48,
-	0x99, 0x25, 0xaf, 0x56, 0x36, 0x61, 0xfc, 0x6b, 0x13, 0xb9, 0xfb, 0x3c, 0x93, 0x45, 0x0a, 0x62,
-	0x37, 0x8a, 0x98, 0x2e, 0x36, 0x13, 0x3c, 0xe7, 0x92, 0x24, 0xf8, 0x11, 0xda, 0x50, 0x4c, 0x25,
-	0xe0, 0x3a, 0x23, 0x67, 0xd2, 0x0d, 0xec, 0x02, 0x8f, 0x50, 0x2f, 0x02, 0x49, 0x05, 0xcb, 0x35,
-	0xd9, 0x7d, 0xcf, 0x60, 0x97, 0x43, 0xb8, 0x8f, 0x3a, 0xf6, 0xff, 0xb0, 0xc8, 0x6d, 0x1a, 0xb8,
-	0x6d, 0xd6, 0xdf, 0x45, 0xf8, 0x5b, 0x74, 0x9f, 0x65, 0x4c, 0x31, 0x92, 0x84, 0x31, 0xe8, 0x3e,
-	0xdd, 0xd6, 0xc8, 0x99, 0xf4, 0xa6, 0xdb, 0x1e, 0x9b, 0x53, 0x4f, 0x8f, 0xe6, 0x55, 0x03, 0x95,
-	0x3b, 0xde, 0x81, 0x61, 0xec, 0xb5, 0xde, 0xfe, 0x39, 0x6c, 0x04, 0xef, 0x57, 0x79, 0x36, 0x88,
-	0x3f, 0x41, 0xf7, 0x16, 0x90, 0x81, 0x64, 0x32, 0x8c, 0x89, 0x8c, 0xdd, 0x8d, 0x91, 0x33, 0xb9,
-	0x17, 0xf4, 0xaa, 0xd8, 0x01, 0x91, 0x31, 0x1e, 0xa2, 0xde, 0x9c, 0x65, 0x44, 0x9c, 0x59, 0xc6,
-	0xa6, 0x61, 0x20, 0x1b, 0x32, 0x84, 0x7d, 0x84, 0x64, 0x4e, 0x7e, 0xc9, 0x42, 0xed, 0x83, 0xdb,
-	0xae, 0x1a, 0xb1, 0x1e, 0x78, 0xb5, 0x07, 0xde, 0x51, 0x6d, 0xd2, 0x5e, 0x47, 0x37, 0xf2, 0xea,
-	0xaf, 0xa1, 0x13, 0x74, 0x4d, 0x9e, 0x46, 0xf0, 0x53, 0xd4, 0x4f, 0x38, 0x3d, 0x09, 0x8b, 0x6c,
-	0xce, 0xb3, 0x88, 0x65, 0x8b, 0x90, 0x5b, 0x41, 0x5e, 0x28, 0xb7, 0x33, 0x72, 0x26, 0x9d, 0x60,
-	0x4b, 0x13, 0x7e, 0xa8, 0xf1, 0xef, 0x4d, 0x1e, 0x2f, 0xd4, 0xb3, 0xce, 0x6f, 0x6f, 0x86, 0x8d,
-	0xd7, 0x6f, 0x86, 0x8d, 0xf1, 0xef, 0x0e, 0xfa, 0xa8, 0xb6, 0x21, 0x80, 0x94, 0x97, 0x24, 0xf9,
-	0x3f, 0x5d, 0xd8, 0x45, 0x5d, 0xa9, 0x78, 0x6e, 0xe7, 0x6e, 0xdd, 0x61, 0xee, 0x8e, 0x4e, 0xd3,
-	0xc0, 0xf8, 0x9f, 0x16, 0xda, 0x9c, 0x11, 0x41, 0x52, 0x89, 0x8f, 0xd0, 0x07, 0x0a, 0xd2, 0x3c,
-	0x21, 0x0a, 0x42, 0x6b, 0x9e, 0x69, 0xb5, 0x37, 0xfd, 0xdc, 0x98, 0x7a, 0x79, 0x3b, 0x7a, 0x97,
-	0x36, 0x60, 0xb9, 0xe3, 0xed, 0x9b, 0xe8, 0xa1, 0x22, 0x0a, 0x82, 0xfb, 0xb5, 0x86, 0x0d, 0xe2,
-	0x2f, 0x91, 0xab, 0x44, 0x21, 0x95, 0xfe, 0xa3, 0x39, 0x08, 0xc6, 0xa3, 0xf0, 0x58, 0x10, 0xba,
-	0x9c, 0xb6, 0x19, 0x6c, 0xd5, 0xf8, 0xcc, 0xc0, 0xcf, 0x2b, 0x14, 0xbf, 0x44, 0x98, 0xd2, 0xb2,
-	0xf6, 0xa0, 0x4a, 0x36, 0xbf, 0xa0, 0x37, 0xed, 0xff, 0x67, 0xcc, 0x6f, 0xaa, 0x23, 0x66, 0xa7,
-	0x7c, 0xad, 0xa7, 0xfc, 0x90, 0xd2, 0xb2, 0xf2, 0xc8, 0x4a, 0xe3, 0x43, 0xf4, 0x50, 0x6f, 0xbf,
-	0x75, 0xcd, 0xd6, 0xed, 0x35, 0x1f, 0xe8, 0xfc, 0xab, 0xa2, 0x2f, 0x11, 0x2e, 0x25, 0x5d, 0xd7,
-	0xdc, 0xb8, 0x43, 0x9f, 0xa5, 0xa4, 0x57, 0x25, 0x23, 0xf4, 0x58, 0x26, 0x44, 0xc6, 0x61, 0x0a,
-	0x0a, 0x44, 0x28, 0x20, 0x4f, 0x20, 0x63, 0x32, 0xae, 0xc5, 0x37, 0x6f, 0x2f, 0xde, 0x37, 0x42,
-	0x2f, 0xb4, 0x4e, 0x50, 0xcb, 0x54, 0x55, 0xf6, 0xd1, 0xe0, 0xfa, 0x2a, 0x4b, 0x83, 0xda, 0x66,
-	0xbf, 0x7d, 0x7c, 0x8d, 0xc4, 0xd2, 0xa5, 0xa7, 0xa8, 0x9f, 0x92, 0xd3, 0x30, 0x07, 0x7b, 0x68,
-	0xac, 0x60, 0x4e, 0xe8, 0x09, 0x28, 0x69, 0xce, 0x4d, 0x33, 0xd8, 0x4a, 0xc9, 0xe9, 0xcc, 0xe2,
-	0x87, 0x1a, 0x9e, 0x59, 0x74, 0x3c, 0x47, 0x0f, 0x0e, 0x48, 0x16, 0xc9, 0x98, 0x9c, 0xc0, 0x0b,
-	0x50, 0x24, 0x22, 0x8a, 0xe0, 0x27, 0x68, 0xab, 0xbe, 0x81, 0xc3, 0x63, 0x80, 0x30, 0xe7, 0x3c,
-	0x09, 0x49, 0x14, 0x89, 0xea, 0xdc, 0x3c, 0xac, 0xd1, 0xe7, 0x00, 0x33, 0xce, 0x93, 0xdd, 0x28,
-	0x12, 0xd8, 0x45, 0xed, 0x12, 0x84, 0x5c, 0x9d, 0xa0, 0x7a, 0x39, 0xfe, 0x0c, 0x75, 0x4d, 0xcd,
-	0x5d, 0x7a, 0x22, 0xf1, 0x63, 0xd4, 0xd5, 0x4a, 0x20, 0x25, 0x48, 0xd7, 0x19, 0x35, 0x27, 0xdd,
-	0x60, 0x15, 0x18, 0x2b, 0xd4, 0xbf, 0xe9, 0x0a, 0x95, 0xf8, 0x27, 0xd4, 0xae, 0x46, 0x34, 0x89,
-	0xbd, 0xe9, 0xd7, 0xde, 0x2d, 0x1e, 0x10, 0xef, 0x26, 0xc1, 0xa0, 0x56, 0x1b, 0x8b, 0xd5, 0xc5,
-	0xbd, 0x76, 0x63, 0x48, 0xfc, 0xe3, 0x7a, 0xd1, 0xaf, 0xee, 0x54, 0x74, 0x4d, 0x6f, 0x59, 0x73,
-	0xef, 0xe8, 0xed, 0xf9, 0xc0, 0x79, 0x77, 0x3e, 0x70, 0xfe, 0x3e, 0x1f, 0x38, 0xaf, 0x2e, 0x06,
-	0x8d, 0x77, 0x17, 0x83, 0xc6, 0x1f, 0x17, 0x83, 0xc6, 0xcf, 0xcf, 0x16, 0x4c, 0xc5, 0xc5, 0xdc,
-	0xa3, 0x3c, 0xf5, 0x29, 0x97, 0x29, 0x97, 0xfe, 0xaa, 0xe2, 0x17, 0xcb, 0xb7, 0xf5, 0xf4, 0xea,
-	0xeb, 0xaa, 0xce, 0x72, 0x90, 0xf3, 0x4d, 0xb3, 0x0d, 0x9f, 0xfc, 0x1b, 0x00, 0x00, 0xff, 0xff,
-	0xf3, 0xd5, 0x5b, 0x4e, 0x8e, 0x07, 0x00, 0x00,
+	// 841 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xc1, 0x6e, 0x1b, 0x37,
+	0x10, 0xd5, 0xc6, 0xb2, 0x25, 0x51, 0x69, 0xda, 0x30, 0x41, 0xba, 0x72, 0x03, 0x49, 0x55, 0x2f,
+	0x2e, 0x8a, 0xee, 0xc2, 0xca, 0xa5, 0x0d, 0xda, 0x83, 0xed, 0x22, 0x75, 0x0f, 0x01, 0x94, 0xb5,
+	0xd0, 0x02, 0xbd, 0x2c, 0x28, 0x72, 0xac, 0x25, 0xbc, 0xbb, 0x5c, 0x90, 0xd4, 0xd6, 0xfe, 0x83,
+	0x1e, 0x73, 0xcc, 0x31, 0x7f, 0xd0, 0xdf, 0x48, 0x6f, 0x39, 0xf6, 0xd4, 0x16, 0xf6, 0x57, 0xf4,
+	0x56, 0x90, 0xdc, 0x95, 0x6c, 0xd5, 0x06, 0xec, 0x43, 0x6f, 0xe4, 0xbc, 0x37, 0x6f, 0x66, 0x38,
+	0x43, 0x12, 0x8d, 0x79, 0xae, 0x41, 0xd2, 0x84, 0xf0, 0x3c, 0x56, 0x40, 0x17, 0x92, 0xeb, 0xb3,
+	0x90, 0xd2, 0x32, 0x2c, 0xa4, 0x28, 0x39, 0x03, 0x19, 0x96, 0xbb, 0xcb, 0x75, 0x50, 0x48, 0xa1,
+	0x05, 0xfe, 0xec, 0x1a, 0x9f, 0x80, 0xd2, 0x32, 0x58, 0xf2, 0xca, 0xdd, 0xed, 0xc7, 0x73, 0x31,
+	0x17, 0x96, 0x1f, 0x9a, 0x95, 0x73, 0xdd, 0x1e, 0xcc, 0x85, 0x98, 0xa7, 0x10, 0xda, 0xdd, 0x6c,
+	0x71, 0x1c, 0x6a, 0x9e, 0x81, 0xd2, 0x24, 0x2b, 0x2a, 0x42, 0x7f, 0x9d, 0xc0, 0x16, 0x92, 0x68,
+	0x2e, 0xf2, 0x5a, 0x80, 0xcf, 0x68, 0x48, 0x85, 0x84, 0x90, 0xa6, 0x1c, 0x72, 0x6d, 0xd2, 0x73,
+	0xab, 0x8a, 0x10, 0x1a, 0x42, 0xca, 0xe7, 0x89, 0x76, 0x66, 0x15, 0x6a, 0xc8, 0x19, 0xc8, 0x8c,
+	0x3b, 0xf2, 0x6a, 0xe7, 0x1c, 0x46, 0xbf, 0xdf, 0x43, 0xfe, 0x81, 0xc8, 0xd5, 0x22, 0x03, 0xb9,
+	0xc7, 0x18, 0x37, 0xc1, 0x26, 0x52, 0x14, 0x42, 0x91, 0x14, 0x3f, 0x46, 0x9b, 0x9a, 0xeb, 0x14,
+	0x7c, 0x6f, 0xe8, 0xed, 0x74, 0x22, 0xb7, 0xc1, 0x43, 0xd4, 0x65, 0xa0, 0xa8, 0xe4, 0x85, 0x21,
+	0xfb, 0xf7, 0x2c, 0x76, 0xd9, 0x84, 0x7b, 0xa8, 0xed, 0xce, 0x87, 0x33, 0x7f, 0xc3, 0xc2, 0x2d,
+	0xbb, 0xff, 0x81, 0xe1, 0xef, 0xd1, 0x03, 0x9e, 0x73, 0xcd, 0x49, 0x1a, 0x27, 0x60, 0xf2, 0xf4,
+	0x9b, 0x43, 0x6f, 0xa7, 0x3b, 0xde, 0x0e, 0xf8, 0x8c, 0x06, 0xa6, 0xb4, 0xa0, 0x2a, 0xa8, 0xdc,
+	0x0d, 0x0e, 0x2d, 0x63, 0xbf, 0xf9, 0xee, 0xcf, 0x41, 0x23, 0xfa, 0xa0, 0xf2, 0x73, 0x46, 0xfc,
+	0x29, 0xba, 0x3f, 0x87, 0x1c, 0x14, 0x57, 0x71, 0x42, 0x54, 0xe2, 0x6f, 0x0e, 0xbd, 0x9d, 0xfb,
+	0x51, 0xb7, 0xb2, 0x1d, 0x12, 0x95, 0xe0, 0x01, 0xea, 0xce, 0x78, 0x4e, 0xe4, 0x99, 0x63, 0x6c,
+	0x59, 0x06, 0x72, 0x26, 0x4b, 0x38, 0x40, 0x48, 0x15, 0xe4, 0x97, 0x3c, 0x36, 0x7d, 0xf0, 0x5b,
+	0x55, 0x22, 0xae, 0x07, 0x41, 0xdd, 0x83, 0x60, 0x5a, 0x37, 0x69, 0xbf, 0x6d, 0x12, 0x79, 0xfd,
+	0xd7, 0xc0, 0x8b, 0x3a, 0xd6, 0xcf, 0x20, 0xcf, 0xdb, 0xbf, 0xbe, 0x1d, 0x34, 0xde, 0xbc, 0x1d,
+	0x34, 0x46, 0xbf, 0x79, 0xe8, 0xe3, 0xfa, 0x2c, 0x23, 0xc8, 0x44, 0x49, 0xd2, 0xff, 0xf3, 0x28,
+	0xf7, 0x50, 0x47, 0x69, 0x51, 0xb8, 0xe4, 0x9b, 0x77, 0x48, 0xbe, 0x6d, 0xdc, 0x0c, 0x30, 0xfa,
+	0xa7, 0x89, 0xb6, 0x26, 0x44, 0x92, 0x4c, 0xe1, 0x29, 0xfa, 0x50, 0x43, 0x56, 0xa4, 0x44, 0x43,
+	0xec, 0x3a, 0x60, 0x53, 0xed, 0x8e, 0xbf, 0xb0, 0x9d, 0xb9, 0x3c, 0x53, 0xc1, 0xa5, 0x29, 0x2a,
+	0x77, 0x83, 0x03, 0x6b, 0x3d, 0xd2, 0x44, 0x43, 0xf4, 0xa0, 0xd6, 0x70, 0x46, 0xfc, 0x15, 0xf2,
+	0xb5, 0x5c, 0x28, 0xcd, 0xf3, 0x79, 0x5c, 0x80, 0xe4, 0x82, 0xc5, 0xc7, 0x92, 0xd0, 0x65, 0xb5,
+	0x1b, 0xd1, 0x93, 0x1a, 0x9f, 0x58, 0xf8, 0x45, 0x85, 0xe2, 0x57, 0x08, 0x53, 0x5a, 0xda, 0xe2,
+	0xc4, 0x42, 0x57, 0xce, 0xf6, 0x08, 0xba, 0xe3, 0xde, 0x7f, 0xca, 0xfc, 0xae, 0xba, 0x27, 0xae,
+	0xca, 0x37, 0xa6, 0xca, 0x8f, 0x28, 0x2d, 0xa7, 0xce, 0xdb, 0x49, 0xe3, 0x23, 0xf4, 0xc8, 0xcc,
+	0xd0, 0xba, 0x66, 0xf3, 0xf6, 0x9a, 0x0f, 0x8d, 0xff, 0x55, 0xd1, 0x57, 0x08, 0x97, 0x8a, 0xae,
+	0x6b, 0x6e, 0xde, 0x21, 0xcf, 0x52, 0xd1, 0xab, 0x92, 0x0c, 0x3d, 0x55, 0x29, 0x51, 0x49, 0x9c,
+	0x81, 0x06, 0x19, 0x4b, 0x28, 0x52, 0xc8, 0xb9, 0x4a, 0x6a, 0xf1, 0xad, 0xdb, 0x8b, 0xf7, 0xac,
+	0xd0, 0x4b, 0xa3, 0x13, 0xd5, 0x32, 0x55, 0x94, 0x03, 0xd4, 0xbf, 0x3e, 0xca, 0xb2, 0x41, 0x2d,
+	0x3b, 0x6f, 0x9f, 0x5c, 0x23, 0xb1, 0xec, 0xd2, 0xd7, 0xa8, 0x97, 0x91, 0xd3, 0xb8, 0x80, 0x9c,
+	0x99, 0x16, 0x3b, 0xc1, 0x82, 0xd0, 0x13, 0xd0, 0xca, 0x6f, 0xbb, 0x06, 0x67, 0xe4, 0x74, 0xe2,
+	0xf0, 0x23, 0x03, 0x4f, 0x1c, 0x3a, 0x9a, 0xa1, 0x87, 0x87, 0x24, 0x67, 0x2a, 0x21, 0x27, 0xf0,
+	0x12, 0x34, 0x61, 0x44, 0x13, 0xfc, 0x0c, 0x3d, 0xa9, 0x9f, 0xd1, 0xf8, 0x18, 0x20, 0x2e, 0x84,
+	0x48, 0x63, 0xc2, 0x98, 0xac, 0xee, 0xcd, 0xa3, 0x1a, 0x7d, 0x01, 0x30, 0x11, 0x22, 0xdd, 0x63,
+	0x4c, 0x62, 0x1f, 0xb5, 0x4a, 0x90, 0x6a, 0x75, 0x83, 0xea, 0xed, 0xe8, 0x73, 0xd4, 0xb1, 0x31,
+	0xf7, 0xe8, 0x89, 0xc2, 0x4f, 0x51, 0xc7, 0x28, 0x81, 0x52, 0xa0, 0x7c, 0x6f, 0xb8, 0xb1, 0xd3,
+	0x89, 0x56, 0x86, 0x91, 0x46, 0xbd, 0x9b, 0xde, 0x41, 0x85, 0x7f, 0x42, 0xad, 0xaa, 0x44, 0xeb,
+	0xd8, 0x1d, 0x7f, 0x1b, 0xdc, 0xe2, 0x17, 0x08, 0x6e, 0x12, 0x8c, 0x6a, 0xb5, 0x91, 0x5c, 0xbd,
+	0xbe, 0x6b, 0x2f, 0x86, 0xc2, 0x3f, 0xae, 0x07, 0xfd, 0xe6, 0x4e, 0x41, 0xd7, 0xf4, 0x96, 0x31,
+	0xf7, 0xa7, 0xef, 0xce, 0xfb, 0xde, 0xfb, 0xf3, 0xbe, 0xf7, 0xf7, 0x79, 0xdf, 0x7b, 0x7d, 0xd1,
+	0x6f, 0xbc, 0xbf, 0xe8, 0x37, 0xfe, 0xb8, 0xe8, 0x37, 0x7e, 0x7e, 0x3e, 0xe7, 0x3a, 0x59, 0xcc,
+	0x02, 0x2a, 0xb2, 0x90, 0x0a, 0x95, 0x09, 0x15, 0xae, 0x22, 0x7e, 0xb9, 0xfc, 0x20, 0x4f, 0xaf,
+	0x7e, 0x91, 0xfa, 0xac, 0x00, 0x35, 0xdb, 0xb2, 0x63, 0xf8, 0xec, 0xdf, 0x00, 0x00, 0x00, 0xff,
+	0xff, 0x71, 0x06, 0x0a, 0x76, 0x53, 0x07, 0x00, 0x00,
 }
 
 func (m *ConsumerAdditionProposal) Marshal() (dAtA []byte, err error) {
@@ -562,16 +556,6 @@ func (m *ConsumerAdditionProposal) MarshalToSizedBuffer(dAtA []byte) (int, error
 	_ = i
 	var l int
 	_ = l
-	if m.LockUnbondingOnTimeout {
-		i--
-		if m.LockUnbondingOnTimeout {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i--
-		dAtA[i] = 0x40
-	}
 	n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.SpawnTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.SpawnTime):])
 	if err1 != nil {
 		return 0, err1
@@ -948,9 +932,6 @@ func (m *ConsumerAdditionProposal) Size() (n int) {
 	}
 	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.SpawnTime)
 	n += 1 + l + sovProvider(uint64(l))
-	if m.LockUnbondingOnTimeout {
-		n += 2
-	}
 	return n
 }
 
@@ -1335,26 +1316,6 @@ func (m *ConsumerAdditionProposal) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 8:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LockUnbondingOnTimeout", wireType)
-			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowProvider
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			m.LockUnbondingOnTimeout = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipProvider(dAtA[iNdEx:])