feat(connection): migrate connection params

Author: DimitrisJim

docs/migrations/v7-to-v8.md

@@ -47,13 +47,12 @@ TODO: https://github.com/cosmos/ibc-go/pull/3505 (extra parameter added to trans
 	)
 ```
 
-- You should pass the `authority` to the IBC keeper. ([#3640](https://github.com/cosmos/ibc-go/pull/3640)) See [diff](https://github.com/cosmos/ibc-go/pull/3640/files#diff-d18972debee5e64f16e40807b2ae112ddbe609504a93ea5e1c80a5d489c3a08a).
+- You should pass the `authority` to the IBC keeper. ([#3640](https://github.com/cosmos/ibc-go/pull/3640) and [#3650](https://github.com/cosmos/ibc-go/pull/3650)) See [diff](https://github.com/cosmos/ibc-go/pull/3640/files#diff-d18972debee5e64f16e40807b2ae112ddbe609504a93ea5e1c80a5d489c3a08a).
 
 ```diff
 // app.go
 
 	// IBC Keepers
-
 	app.IBCKeeper = ibckeeper.NewKeeper(
 -       appCodec, keys[ibcexported.StoreKey], app.GetSubspace(ibcexported.ModuleName), app.StakingKeeper, app.UpgradeKeeper, scopedIBCKeeper,
 +		appCodec, keys[ibcexported.StoreKey], app.GetSubspace(ibcexported.ModuleName), app.StakingKeeper, app.UpgradeKeeper, scopedIBCKeeper, authtypes.NewModuleAddress(govtypes.ModuleName).String(),

e2e/tests/core/03-connection/connection_test.go

@@ -3,11 +3,10 @@ package connection
 import (
 	"context"
 	"fmt"
-	"strconv"
-	"strings"
 	"testing"
 	"time"
 
+	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
 	paramsproposaltypes "github.com/cosmos/cosmos-sdk/x/params/types/proposal"
 	"github.com/strangelove-ventures/interchaintest/v7/ibc"
 	test "github.com/strangelove-ventures/interchaintest/v7/testutil"
@@ -30,19 +29,11 @@ type ConnectionTestSuite struct {
 
 // QueryMaxExpectedTimePerBlockParam queries the on-chain max expected time per block param for 03-connection
 func (s *ConnectionTestSuite) QueryMaxExpectedTimePerBlockParam(ctx context.Context, chain ibc.Chain) uint64 {
-	queryClient := s.GetChainGRCPClients(chain).ParamsQueryClient
-	res, err := queryClient.Params(ctx, &paramsproposaltypes.QueryParamsRequest{
-		Subspace: ibcexported.ModuleName,
-		Key:      string(connectiontypes.KeyMaxExpectedTimePerBlock),
-	})
-	s.Require().NoError(err)
-
-	// removing additional strings that are used for amino
-	delay := strings.ReplaceAll(res.Param.Value, "\"", "")
-	time, err := strconv.ParseUint(delay, 10, 64)
+	queryClient := s.GetChainGRCPClients(chain).ConnectionQueryClient
+	res, err := queryClient.ConnectionParams(ctx, &connectiontypes.QueryConnectionParamsRequest{})
 	s.Require().NoError(err)
 
-	return time
+	return res.Params.MaxExpectedTimePerBlock
 }
 
 // TestMaxExpectedTimePerBlockParam tests changing the MaxExpectedTimePerBlock param using a governance proposal
@@ -52,6 +43,7 @@ func (s *ConnectionTestSuite) TestMaxExpectedTimePerBlockParam() {
 
 	relayer, channelA := s.SetupChainsRelayerAndChannel(ctx, s.TransferChannelOptions())
 	chainA, chainB := s.GetChains()
+	chainAVersion := chainA.Config().Images[0].Version
 
 	chainBDenom := chainB.Config().Denom
 	chainAIBCToken := testsuite.GetIBCToken(chainBDenom, channelA.PortID, channelA.ChannelID)
@@ -71,13 +63,22 @@ func (s *ConnectionTestSuite) TestMaxExpectedTimePerBlockParam() {
 	})
 
 	t.Run("change the delay to 60 seconds", func(t *testing.T) {
-		delay := fmt.Sprintf(`"%d"`, 1*time.Minute)
-		changes := []paramsproposaltypes.ParamChange{
-			paramsproposaltypes.NewParamChange(ibcexported.ModuleName, string(connectiontypes.KeyMaxExpectedTimePerBlock), delay),
-		}
+		delay := uint64(1 * time.Minute)
+		if testvalues.SelfParamsFeatureReleases.IsSupported(chainAVersion) {
+			authority, err := s.QueryModuleAccountAddress(ctx, govtypes.ModuleName, chainA)
+			s.Require().NoError(err)
+			s.Require().NotNil(authority)
+
+			msg := connectiontypes.NewMsgUpdateConnectionParams(authority.String(), connectiontypes.NewParams(delay))
+			s.ExecuteGovProposalV1(ctx, msg, chainA, chainAWallet, 1)
+		} else {
+			changes := []paramsproposaltypes.ParamChange{
+				paramsproposaltypes.NewParamChange(ibcexported.ModuleName, string(connectiontypes.KeyMaxExpectedTimePerBlock), fmt.Sprintf(`"%d"`, delay)),
+			}
 
-		proposal := paramsproposaltypes.NewParameterChangeProposal(ibctesting.Title, ibctesting.Description, changes)
-		s.ExecuteGovProposal(ctx, chainA, chainAWallet, proposal)
+			proposal := paramsproposaltypes.NewParameterChangeProposal(ibctesting.Title, ibctesting.Description, changes)
+			s.ExecuteGovProposal(ctx, chainA, chainAWallet, proposal)
+		}
 	})
 
 	t.Run("validate the param was successfully changed", func(t *testing.T) {

e2e/tests/transfer/base_test.go

@@ -245,7 +245,7 @@ func (s *TransferTestSuite) TestSendEnabledParam() {
 	chainBAddress := chainBWallet.FormattedAddress()
 
 	chainAVersion := chainA.Config().Images[0].Version
-	isSelfManagingParams := testvalues.TransferSelfParamsFeatureReleases.IsSupported(chainAVersion)
+	isSelfManagingParams := testvalues.SelfParamsFeatureReleases.IsSupported(chainAVersion)
 
 	govModuleAddress, err := s.QueryModuleAccountAddress(ctx, govtypes.ModuleName, chainA)
 	s.Require().NoError(err)
@@ -308,7 +308,7 @@ func (s *TransferTestSuite) TestReceiveEnabledParam() {
 	)
 
 	chainAVersion := chainA.Config().Images[0].Version
-	isSelfManagingParams := testvalues.TransferSelfParamsFeatureReleases.IsSupported(chainAVersion)
+	isSelfManagingParams := testvalues.SelfParamsFeatureReleases.IsSupported(chainAVersion)
 
 	govModuleAddress, err := s.QueryModuleAccountAddress(ctx, govtypes.ModuleName, chainA)
 	s.Require().NoError(err)

e2e/testsuite/grpc_query.go

@@ -73,6 +73,7 @@ func (s *E2ETestSuite) InitGRPCClients(chain *cosmos.CosmosChain) {
 
 	s.grpcClients[chain.Config().ChainID] = GRPCClients{
 		ClientQueryClient:      clienttypes.NewQueryClient(grpcConn),
+		ConnectionQueryClient:  connectiontypes.NewQueryClient(grpcConn),
 		ChannelQueryClient:     channeltypes.NewQueryClient(grpcConn),
 		TransferQueryClient:    transfertypes.NewQueryClient(grpcConn),
 		FeeQueryClient:         feetypes.NewQueryClient(grpcConn),

e2e/testvalues/values.go

@@ -67,7 +67,7 @@ var IcadNewGenesisCommandsFeatureReleases = semverutil.FeatureReleases{
 }
 
 // TransferSelfParamsFeatureReleases represents the releases the transfer module started managing its own params.
-var TransferSelfParamsFeatureReleases = semverutil.FeatureReleases{
+var SelfParamsFeatureReleases = semverutil.FeatureReleases{
 	MajorVersion: "v8",
 }
 

modules/core/03-connection/genesis.go

@@ -1,6 +1,8 @@
 package connection
 
 import (
+	"fmt"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/cosmos/ibc-go/v7/modules/core/03-connection/keeper"
@@ -18,6 +20,9 @@ func InitGenesis(ctx sdk.Context, k keeper.Keeper, gs types.GenesisState) {
 		k.SetClientConnectionPaths(ctx, connPaths.ClientId, connPaths.Paths)
 	}
 	k.SetNextConnectionSequence(ctx, gs.NextConnectionSequence)
+	if err := gs.Params.Validate(); err != nil {
+		panic(fmt.Sprintf("invalid ibc connection genesis state parameters: %v", err))
+	}
 	k.SetParams(ctx, gs.Params)
 
 	k.CreateSentinelLocalhostConnection(ctx)

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

@@ -20,24 +20,24 @@ type Keeper struct {
 	// implements gRPC QueryServer interface
 	types.QueryServer
 
-	storeKey     storetypes.StoreKey
-	paramSpace   paramtypes.Subspace
-	cdc          codec.BinaryCodec
-	clientKeeper types.ClientKeeper
+	storeKey       storetypes.StoreKey
+	legacySubspace paramtypes.Subspace
+	cdc            codec.BinaryCodec
+	clientKeeper   types.ClientKeeper
 }
 
 // NewKeeper creates a new IBC connection Keeper instance
-func NewKeeper(cdc codec.BinaryCodec, key storetypes.StoreKey, paramSpace paramtypes.Subspace, ck types.ClientKeeper) Keeper {
+func NewKeeper(cdc codec.BinaryCodec, key storetypes.StoreKey, legacySubspace paramtypes.Subspace, ck types.ClientKeeper) Keeper {
 	// set KeyTable if it has not already been set
-	if !paramSpace.HasKeyTable() {
-		paramSpace = paramSpace.WithKeyTable(types.ParamKeyTable())
+	if !legacySubspace.HasKeyTable() {
+		legacySubspace = legacySubspace.WithKeyTable(types.ParamKeyTable())
 	}
 
 	return Keeper{
-		storeKey:     key,
-		cdc:          cdc,
-		paramSpace:   paramSpace,
-		clientKeeper: ck,
+		storeKey:       key,
+		cdc:            cdc,
+		legacySubspace: legacySubspace,
+		clientKeeper:   ck,
 	}
 }
 
@@ -221,3 +221,23 @@ func (k Keeper) addConnectionToClient(ctx sdk.Context, clientID, connectionID st
 	k.SetClientConnectionPaths(ctx, clientID, conns)
 	return nil
 }
+
+// GetParams returns the total set of ibc-connection parameters.
+func (k Keeper) GetParams(ctx sdk.Context) types.Params {
+	store := ctx.KVStore(k.storeKey)
+	bz := store.Get([]byte(types.ParamsKey))
+	if len(bz) == 0 {
+		return types.Params{}
+	}
+
+	var params types.Params
+	k.cdc.MustUnmarshal(bz, &params)
+	return params
+}
+
+// SetParams sets the total set of ibc-connection parameters.
+func (k Keeper) SetParams(ctx sdk.Context, params types.Params) {
+	store := ctx.KVStore(k.storeKey)
+	bz := k.cdc.MustMarshal(&params)
+	store.Set([]byte(types.ParamsKey), bz)
+}

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

@@ -176,3 +176,53 @@ func (suite *KeeperTestSuite) TestLocalhostConnectionEndCreation() {
 	expectedCounterParty := types.NewCounterparty(exported.LocalhostClientID, exported.LocalhostConnectionID, commitmenttypes.NewMerklePrefix(connectionKeeper.GetCommitmentPrefix().Bytes()))
 	suite.Require().Equal(expectedCounterParty, connectionEnd.Counterparty)
 }
+
+// TestDefaultSetParams tests the default params set are what is expected
+func (suite *KeeperTestSuite) TestDefaultSetParams() {
+	expParams := types.DefaultParams()
+
+	params := suite.chainA.App.GetIBCKeeper().ConnectionKeeper.GetParams(suite.chainA.GetContext())
+	suite.Require().Equal(expParams, params)
+}
+
+// TestParams tests that param setting and retrieval works properly
+func (suite *KeeperTestSuite) TestParams() {
+	testCases := []struct {
+		name    string
+		input   types.Params
+		expPass bool
+	}{
+		{"success: set default params", types.DefaultParams(), true},
+		{"success: valid value for MaxExpectedTimePerBlock", types.NewParams(10), true},
+		{"failure: invalid value for MaxExpectedTimePerBlock", types.NewParams(0), false},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+
+		suite.Run(tc.name, func() {
+			suite.SetupTest() // reset
+			ctx := suite.chainA.GetContext()
+			err := tc.input.Validate()
+			suite.chainA.GetSimApp().IBCKeeper.ConnectionKeeper.SetParams(ctx, tc.input)
+			if tc.expPass {
+				suite.Require().NoError(err)
+				expected := tc.input
+				p := suite.chainA.GetSimApp().IBCKeeper.ConnectionKeeper.GetParams(ctx)
+				suite.Require().Equal(expected, p)
+			} else {
+				suite.Require().Error(err)
+			}
+		})
+	}
+}
+
+// TestUnsetParams tests that trying to get params that are not set panics.
+func (suite *KeeperTestSuite) TestUnsetParams() {
+	suite.SetupTest()
+	ctx := suite.chainA.GetContext()
+	store := ctx.KVStore(suite.chainA.GetSimApp().GetKey(exported.StoreKey))
+	store.Delete([]byte(types.ParamsKey))
+
+	suite.Require().Equal(suite.chainA.GetSimApp().IBCKeeper.ConnectionKeeper.GetParams(ctx), types.Params{})
+}

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

@@ -4,6 +4,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	connectionv7 "github.com/cosmos/ibc-go/v7/modules/core/03-connection/migrations/v7"
+	"github.com/cosmos/ibc-go/v7/modules/core/03-connection/types"
 )
 
 // Migrator is a struct for handling in-place store migrations.
@@ -22,3 +23,17 @@ func (m Migrator) Migrate3to4(ctx sdk.Context) error {
 	connectionv7.MigrateLocalhostConnection(ctx, m.keeper)
 	return nil
 }
+
+// MigrateParams migrates from consensus version 4 to 5.
+// This migration takes the parameters that are currently stored and managed by x/params
+// and stores them directly in the ibc module's state.
+func (m Migrator) MigrateParams(ctx sdk.Context) error {
+	var params types.Params
+	m.keeper.legacySubspace.GetParamSet(ctx, &params)
+
+	if err := params.Validate(); err != nil {
+		return err
+	}
+	m.keeper.SetParams(ctx, params)
+	return nil
+}

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

@@ -0,0 +1,43 @@
+package keeper_test
+
+import (
+	"github.com/cosmos/ibc-go/v7/modules/core/03-connection/keeper"
+	"github.com/cosmos/ibc-go/v7/modules/core/03-connection/types"
+	ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported"
+)
+
+// TestMigrateParams tests that the params for the connection are properly migrated
+func (suite *KeeperTestSuite) TestMigrateParams() {
+	testCases := []struct {
+		name           string
+		malleate       func()
+		expectedParams types.Params
+	}{
+		{
+			"success: default params",
+			func() {
+				params := types.DefaultParams()
+				subspace := suite.chainA.GetSimApp().GetSubspace(ibcexported.ModuleName)
+				subspace.SetParamSet(suite.chainA.GetContext(), &params) // set params
+			},
+			types.DefaultParams(),
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		suite.Run(tc.name, func() {
+			suite.SetupTest() // reset
+
+			tc.malleate()
+
+			ctx := suite.chainA.GetContext()
+			migrator := keeper.NewMigrator(suite.chainA.GetSimApp().IBCKeeper.ConnectionKeeper)
+			err := migrator.MigrateParams(ctx)
+			suite.Require().NoError(err)
+
+			params := suite.chainA.GetSimApp().IBCKeeper.ConnectionKeeper.GetParams(ctx)
+			suite.Require().Equal(tc.expectedParams, params)
+		})
+	}
+}

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

@@ -369,7 +369,7 @@ func (k Keeper) VerifyNextSequenceRecv(
 func (k Keeper) getBlockDelay(ctx sdk.Context, connection exported.ConnectionI) uint64 {
 	// expectedTimePerBlock should never be zero, however if it is then return a 0 blcok delay for safety
 	// as the expectedTimePerBlock parameter was not set.
-	expectedTimePerBlock := k.GetMaxExpectedTimePerBlock(ctx)
+	expectedTimePerBlock := k.GetParams(ctx).MaxExpectedTimePerBlock
 	if expectedTimePerBlock == 0 {
 		return 0
 	}

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

@@ -33,6 +33,7 @@ func RegisterInterfaces(registry codectypes.InterfaceRegistry) {
 		&MsgConnectionOpenTry{},
 		&MsgConnectionOpenAck{},
 		&MsgConnectionOpenConfirm{},
+		&MsgUpdateConnectionParams{},
 	)
 
 	msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)

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

@@ -28,6 +28,9 @@ const (
 
 	// ConnectionPrefix is the prefix used when creating a connection identifier
 	ConnectionPrefix = "connection-"
+
+	// ParamsKey is the store key for the IBC connection parameters
+	ParamsKey = "connectionParams"
 )
 
 // FormatConnectionIdentifier returns the connection identifier with the sequence appended.

modules/core/03-connection/types/codec.go

@@ -17,6 +17,7 @@ var (
 	_ sdk.Msg = (*MsgConnectionOpenConfirm)(nil)
 	_ sdk.Msg = (*MsgConnectionOpenAck)(nil)
 	_ sdk.Msg = (*MsgConnectionOpenTry)(nil)
+	_ sdk.Msg = (*MsgUpdateConnectionParams)(nil)
 
 	_ codectypes.UnpackInterfacesMessage = (*MsgConnectionOpenTry)(nil)
 	_ codectypes.UnpackInterfacesMessage = (*MsgConnectionOpenAck)(nil)
@@ -289,3 +290,28 @@ func (msg MsgConnectionOpenConfirm) GetSigners() []sdk.AccAddress {
 	}
 	return []sdk.AccAddress{accAddr}
 }
+
+// NewMsgUpdateConnectionParams creates a new MsgUpdateConnectionParams instance
+func NewMsgUpdateConnectionParams(authority string, params Params) *MsgUpdateConnectionParams {
+	return &MsgUpdateConnectionParams{
+		Authority: authority,
+		Params:    params,
+	}
+}
+
+// GetSigners returns the expected signers for a MsgUpdateConnectionParams message.
+func (msg *MsgUpdateConnectionParams) GetSigners() []sdk.AccAddress {
+	accAddr, err := sdk.AccAddressFromBech32(msg.Authority)
+	if err != nil {
+		panic(err)
+	}
+	return []sdk.AccAddress{accAddr}
+}
+
+// ValidateBasic performs basic checks on a MsgUpdateConnectionParams.
+func (msg *MsgUpdateConnectionParams) ValidateBasic() error {
+	if _, err := sdk.AccAddressFromBech32(msg.Authority); err != nil {
+		return errorsmod.Wrapf(ibcerrors.ErrInvalidAddress, "string could not be parsed as address: %v", err)
+	}
+	return msg.Params.Validate()
+}

modules/core/03-connection/types/keys.go

@@ -231,3 +231,38 @@ func (suite *MsgTestSuite) TestNewMsgConnectionOpenConfirm() {
 		}
 	}
 }
+
+// TestMsgUpdateConnectionParams_ValidateBasic tests ValidateBasic for MsgUpdateConnectionParams
+func (suite *MsgTestSuite) TestMsgUpdateConnectionParams_ValidateBasic() {
+	authority := suite.chainA.App.GetIBCKeeper().GetAuthority()
+	testCases := []struct {
+		name    string
+		msg     *types.MsgUpdateConnectionParams
+		expPass bool
+	}{
+		{
+			"success: valid authority and params",
+			types.NewMsgUpdateConnectionParams(authority, types.DefaultParams()),
+			true,
+		},
+		{
+			"failure: invalid authority address",
+			types.NewMsgUpdateConnectionParams("invalid", types.DefaultParams()),
+			false,
+		},
+		{
+			"failure: invalid time per block",
+			types.NewMsgUpdateConnectionParams(authority, types.NewParams(0)),
+			false,
+		},
+	}
+
+	for _, tc := range testCases {
+		err := tc.msg.ValidateBasic()
+		if tc.expPass {
+			suite.Require().NoError(err, "valid case %s failed", tc.name)
+		} else {
+			suite.Require().Error(err, "invalid case %s passed", tc.name)
+		}
+	}
+}

modules/core/03-connection/types/msgs.go

@@ -3,21 +3,11 @@ package types
 import (
 	"fmt"
 	"time"
-
-	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
 )
 
 // DefaultTimePerBlock is the default value for maximum expected time per block (in nanoseconds).
 const DefaultTimePerBlock = 30 * time.Second
 
-// KeyMaxExpectedTimePerBlock is store's key for MaxExpectedTimePerBlock parameter
-var KeyMaxExpectedTimePerBlock = []byte("MaxExpectedTimePerBlock")
-
-// ParamKeyTable type declaration for parameters
-func ParamKeyTable() paramtypes.KeyTable {
-	return paramtypes.NewKeyTable().RegisterParamSet(&Params{})
-}
-
 // NewParams creates a new parameter configuration for the ibc connection module
 func NewParams(timePerBlock uint64) Params {
 	return Params{
@@ -37,18 +27,3 @@ func (p Params) Validate() error {
 	}
 	return nil
 }
-
-// ParamSetPairs implements params.ParamSet
-func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
-	return paramtypes.ParamSetPairs{
-		paramtypes.NewParamSetPair(KeyMaxExpectedTimePerBlock, p.MaxExpectedTimePerBlock, validateParams),
-	}
-}
-
-func validateParams(i interface{}) error {
-	_, ok := i.(uint64)
-	if !ok {
-		return fmt.Errorf("invalid parameter. expected %T, got type: %T", uint64(1), i)
-	}
-	return nil
-}

modules/core/03-connection/types/msgs_test.go

@@ -0,0 +1,36 @@
+/*
+NOTE: Usage of x/params to manage parameters is deprecated in favor of x/gov
+controlled execution of MsgUpdateParams messages. These types remains solely
+for migration purposes and will be removed in a future release.
+[#3621](https://github.com/cosmos/ibc-go/issues/3621)
+*/
+package types
+
+import (
+	fmt "fmt"
+
+	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
+)
+
+// KeyMaxExpectedTimePerBlock is store's key for MaxExpectedTimePerBlock parameter
+var KeyMaxExpectedTimePerBlock = []byte("MaxExpectedTimePerBlock")
+
+// ParamKeyTable type declaration for parameters
+func ParamKeyTable() paramtypes.KeyTable {
+	return paramtypes.NewKeyTable().RegisterParamSet(&Params{})
+}
+
+// ParamSetPairs implements params.ParamSet
+func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
+	return paramtypes.ParamSetPairs{
+		paramtypes.NewParamSetPair(KeyMaxExpectedTimePerBlock, &p.MaxExpectedTimePerBlock, validateParams),
+	}
+}
+
+func validateParams(i interface{}) error {
+	_, ok := i.(uint64)
+	if !ok {
+		return fmt.Errorf("invalid parameter. expected %T, got type: %T", uint64(1), i)
+	}
+	return nil
+}

modules/core/03-connection/types/params.go

@@ -95,11 +95,6 @@ func (k *Keeper) SetRouter(rtr *porttypes.Router) {
 	k.Router.Seal()
 }
 
-// GetAuthority returns the client submodule's authority.
-func (k Keeper) GetAuthority() string {
-	return k.authority
-}
-
 // isEmpty checks if the interface is an empty struct or a pointer pointing
 // to an empty struct
 func isEmpty(keeper interface{}) bool {
@@ -115,3 +110,8 @@ func isEmpty(keeper interface{}) bool {
 	}
 	return false
 }
+
+// GetAuthority returns the ibc module's authority.
+func (k Keeper) GetAuthority() string {
+	return k.authority
+}

modules/core/03-connection/types/params_legacy.go

@@ -706,3 +706,15 @@ func (k Keeper) UpdateClientParams(goCtx context.Context, msg *clienttypes.MsgUp
 
 	return &clienttypes.MsgUpdateClientParamsResponse{}, nil
 }
+
+// UpdateConnectionParams defines a rpc handler method for MsgUpdateConnectionParams.
+func (k Keeper) UpdateConnectionParams(goCtx context.Context, msg *connectiontypes.MsgUpdateConnectionParams) (*connectiontypes.MsgUpdateConnectionParamsResponse, error) {
+	if k.GetAuthority() != msg.Authority {
+		return nil, errorsmod.Wrapf(ibcerrors.ErrUnauthorized, "expected %s, got %s", k.GetAuthority(), msg.Authority)
+	}
+
+	ctx := sdk.UnwrapSDKContext(goCtx)
+	k.ConnectionKeeper.SetParams(ctx, msg.Params)
+
+	return &connectiontypes.MsgUpdateConnectionParamsResponse{}, nil
+}

modules/core/03-connection/types/tx.pb.go

@@ -5,6 +5,7 @@ import (
 	upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types"
 
 	clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types"
+	connectiontypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types"
 	channeltypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types"
 	commitmenttypes "github.com/cosmos/ibc-go/v7/modules/core/23-commitment/types"
 	host "github.com/cosmos/ibc-go/v7/modules/core/24-host"
@@ -825,3 +826,54 @@ func (suite *KeeperTestSuite) TestUpdateClientParams() {
 		})
 	}
 }
+
+// TestUpdateConnectionParams tests the UpdateConnectionParams rpc handler
+func (suite *KeeperTestSuite) TestUpdateConnectionParams() {
+	validAuthority := suite.chainA.App.GetIBCKeeper().GetAuthority()
+	testCases := []struct {
+		name    string
+		msg     *connectiontypes.MsgUpdateConnectionParams
+		expPass bool
+	}{
+		{
+			"success: valid authority and default params",
+			connectiontypes.NewMsgUpdateConnectionParams(validAuthority, connectiontypes.DefaultParams()),
+			true,
+		},
+		{
+			"failure: malformed authority address",
+			connectiontypes.NewMsgUpdateConnectionParams(ibctesting.InvalidID, connectiontypes.DefaultParams()),
+			false,
+		},
+		{
+			"failure: empty authority address",
+			connectiontypes.NewMsgUpdateConnectionParams("", connectiontypes.DefaultParams()),
+			false,
+		},
+		{
+			"failure: whitespace authority address",
+			connectiontypes.NewMsgUpdateConnectionParams("    ", connectiontypes.DefaultParams()),
+			false,
+		},
+		{
+			"failure: unauthorized authority address",
+			connectiontypes.NewMsgUpdateConnectionParams(ibctesting.TestAccAddress, connectiontypes.DefaultParams()),
+			false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		suite.Run(tc.name, func() {
+			suite.SetupTest()
+			_, err := keeper.Keeper.UpdateConnectionParams(*suite.chainA.App.GetIBCKeeper(), suite.chainA.GetContext(), tc.msg)
+			if tc.expPass {
+				suite.Require().NoError(err)
+				p := suite.chainA.App.GetIBCKeeper().ConnectionKeeper.GetParams(suite.chainA.GetContext())
+				suite.Require().Equal(tc.msg.Params, p)
+			} else {
+				suite.Require().Error(err)
+			}
+		})
+	}
+}

modules/core/keeper/keeper.go

@@ -138,7 +138,13 @@ func (am AppModule) RegisterServices(cfg module.Configurator) {
 		panic(err)
 	}
 
-	if err := cfg.RegisterMigration(exported.ModuleName, 4, clientMigrator.MigrateParams); err != nil {
+	if err := cfg.RegisterMigration(exported.ModuleName, 4, func(ctx sdk.Context) error {
+		if err := clientMigrator.MigrateParams(ctx); err != nil {
+			return err
+		}
+
+		return connectionMigrator.MigrateParams(ctx)
+	}); err != nil {
 		panic(err)
 	}
 }

modules/core/keeper/msg_server.go

@@ -4,6 +4,7 @@ package ibc.core.connection.v1;
 
 option go_package = "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types";
 
+import "cosmos/msg/v1/msg.proto";
 import "gogoproto/gogo.proto";
 import "google/protobuf/any.proto";
 import "ibc/core/client/v1/client.proto";
@@ -23,6 +24,10 @@ service Msg {
   // ConnectionOpenConfirm defines a rpc handler method for
   // MsgConnectionOpenConfirm.
   rpc ConnectionOpenConfirm(MsgConnectionOpenConfirm) returns (MsgConnectionOpenConfirmResponse);
+
+  // UpdateConnectionParams defines a rpc handler method for
+  // MsgUpdateConnectionParams.
+  rpc UpdateConnectionParams(MsgUpdateConnectionParams) returns (MsgUpdateConnectionParamsResponse);
 }
 
 // MsgConnectionOpenInit defines the msg sent by an account on Chain A to
@@ -115,3 +120,19 @@ message MsgConnectionOpenConfirm {
 // MsgConnectionOpenConfirmResponse defines the Msg/ConnectionOpenConfirm
 // response type.
 message MsgConnectionOpenConfirmResponse {}
+
+// MsgUpdateConnectionParams defines the sdk.Msg type to update the connection parameters.
+message MsgUpdateConnectionParams {
+  option (cosmos.msg.v1.signer) = "authority";
+
+  // authority is the address of the governance account.
+  string authority = 1;
+
+  // params defines the connection parameters to update.
+  //
+  // NOTE: All parameters must be supplied.
+  Params params = 2 [(gogoproto.nullable) = false];
+}
+
+// MsgUpdateConnectionParamsResponse defines the MsgUpdateConnectionParams response type.
+message MsgUpdateConnectionParamsResponse {}