diff --git a/modules/core/04-channel/v2/client/cli/cli.go b/modules/core/04-channel/v2/client/cli/cli.go
index a9d985e72a0..59d9dded017 100644
--- a/modules/core/04-channel/v2/client/cli/cli.go
+++ b/modules/core/04-channel/v2/client/cli/cli.go
@@ -21,6 +21,7 @@ func GetQueryCmd() *cobra.Command {
 	queryCmd.AddCommand(
 		getCmdQueryChannel(),
 		getCmdQueryPacketCommitment(),
+		getCmdQueryPacketCommitments(),
 		getCmdQueryPacketAcknowledgement(),
 		getCmdQueryPacketReceipt(),
 	)
diff --git a/modules/core/04-channel/v2/client/cli/query.go b/modules/core/04-channel/v2/client/cli/query.go
index a6a1d7f0762..c79d92dfd4c 100644
--- a/modules/core/04-channel/v2/client/cli/query.go
+++ b/modules/core/04-channel/v2/client/cli/query.go
@@ -96,6 +96,45 @@ func getCmdQueryPacketCommitment() *cobra.Command {
 	return cmd
 }
 
+func getCmdQueryPacketCommitments() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "packet-commitments [channel-id]",
+		Short:   "Query all packet commitments associated with a channel",
+		Long:    "Query all packet commitments associated with a channel",
+		Example: fmt.Sprintf("%s query %s %s packet-commitments [channel-id]", version.AppName, exported.ModuleName, types.SubModuleName),
+		Args:    cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			queryClient := types.NewQueryClient(clientCtx)
+			pageReq, err := client.ReadPageRequest(cmd.Flags())
+			if err != nil {
+				return err
+			}
+
+			req := &types.QueryPacketCommitmentsRequest{
+				ChannelId:  args[0],
+				Pagination: pageReq,
+			}
+
+			res, err := queryClient.PacketCommitments(cmd.Context(), req)
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	flags.AddPaginationFlagsToCmd(cmd, "packet commitments associated with a channel")
+
+	return cmd
+}
+
 func getCmdQueryPacketAcknowledgement() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "packet-acknowledgement [channel-id] [sequence]",
diff --git a/modules/core/04-channel/v2/keeper/grpc_query.go b/modules/core/04-channel/v2/keeper/grpc_query.go
index 3106bc367cc..e72a5b3bbd9 100644
--- a/modules/core/04-channel/v2/keeper/grpc_query.go
+++ b/modules/core/04-channel/v2/keeper/grpc_query.go
@@ -2,15 +2,22 @@ package keeper
 
 import (
 	"context"
+	"strings"
 
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 
 	errorsmod "cosmossdk.io/errors"
+	"cosmossdk.io/store/prefix"
+
+	"github.com/cosmos/cosmos-sdk/runtime"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/query"
 
 	clienttypes "github.com/cosmos/ibc-go/v9/modules/core/02-client/types"
 	"github.com/cosmos/ibc-go/v9/modules/core/04-channel/v2/types"
 	host "github.com/cosmos/ibc-go/v9/modules/core/24-host"
+	hostv2 "github.com/cosmos/ibc-go/v9/modules/core/24-host/v2"
 )
 
 var _ types.QueryServer = (*queryServer)(nil)
@@ -71,6 +78,47 @@ func (q *queryServer) PacketCommitment(ctx context.Context, req *types.QueryPack
 	return types.NewQueryPacketCommitmentResponse(commitment, nil, clienttypes.GetSelfHeight(ctx)), nil
 }
 
+// PacketCommitments implements the Query/PacketCommitments gRPC method
+func (q *queryServer) PacketCommitments(ctx context.Context, req *types.QueryPacketCommitmentsRequest) (*types.QueryPacketCommitmentsResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "empty request")
+	}
+
+	if err := host.ChannelIdentifierValidator(req.ChannelId); err != nil {
+		return nil, status.Error(codes.InvalidArgument, err.Error())
+	}
+
+	if !q.HasChannel(ctx, req.ChannelId) {
+		return nil, status.Error(codes.NotFound, errorsmod.Wrap(types.ErrChannelNotFound, req.ChannelId).Error())
+	}
+
+	var commitments []*types.PacketState
+	store := prefix.NewStore(runtime.KVStoreAdapter(q.storeService.OpenKVStore(ctx)), hostv2.PacketCommitmentPrefixKey(req.ChannelId))
+
+	pageRes, err := query.Paginate(store, req.Pagination, func(key, value []byte) error {
+		keySplit := strings.Split(string(key), "/")
+
+		sequence := sdk.BigEndianToUint64([]byte(keySplit[len(keySplit)-1]))
+		if sequence == 0 {
+			return types.ErrInvalidPacket
+		}
+
+		commitment := types.NewPacketState(req.ChannelId, sequence, value)
+		commitments = append(commitments, &commitment)
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	selfHeight := clienttypes.GetSelfHeight(ctx)
+	return &types.QueryPacketCommitmentsResponse{
+		Commitments: commitments,
+		Pagination:  pageRes,
+		Height:      selfHeight,
+	}, nil
+}
+
 // PacketAcknowledgement implements the Query/PacketAcknowledgement gRPC method.
 func (q *queryServer) PacketAcknowledgement(ctx context.Context, req *types.QueryPacketAcknowledgementRequest) (*types.QueryPacketAcknowledgementResponse, error) {
 	if req == nil {
diff --git a/modules/core/04-channel/v2/keeper/grpc_query_test.go b/modules/core/04-channel/v2/keeper/grpc_query_test.go
index e458128ce09..faecb9a2595 100644
--- a/modules/core/04-channel/v2/keeper/grpc_query_test.go
+++ b/modules/core/04-channel/v2/keeper/grpc_query_test.go
@@ -6,6 +6,8 @@ import (
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 
+	"github.com/cosmos/cosmos-sdk/types/query"
+
 	"github.com/cosmos/ibc-go/v9/modules/core/04-channel/v2/keeper"
 	"github.com/cosmos/ibc-go/v9/modules/core/04-channel/v2/types"
 	commitmenttypes "github.com/cosmos/ibc-go/v9/modules/core/23-commitment/types"
@@ -191,6 +193,119 @@ func (suite *KeeperTestSuite) TestQueryPacketCommitment() {
 	}
 }
 
+func (suite *KeeperTestSuite) TestQueryPacketCommitments() {
+	var (
+		req            *types.QueryPacketCommitmentsRequest
+		expCommitments = []*types.PacketState{}
+	)
+
+	testCases := []struct {
+		msg      string
+		malleate func()
+		expError error
+	}{
+		{
+			"success",
+			func() {
+				path := ibctesting.NewPath(suite.chainA, suite.chainB)
+				path.SetupV2()
+
+				expCommitments = make([]*types.PacketState, 0, 10) // reset expected commitments
+				for i := uint64(1); i <= 10; i++ {
+					pktStateCommitment := types.NewPacketState(path.EndpointA.ChannelID, i, []byte(fmt.Sprintf("hash_%d", i)))
+					suite.chainA.App.GetIBCKeeper().ChannelKeeperV2.SetPacketCommitment(suite.chainA.GetContext(), pktStateCommitment.ChannelId, pktStateCommitment.Sequence, pktStateCommitment.Data)
+					expCommitments = append(expCommitments, &pktStateCommitment)
+				}
+
+				req = &types.QueryPacketCommitmentsRequest{
+					ChannelId: path.EndpointA.ChannelID,
+					Pagination: &query.PageRequest{
+						Key:        nil,
+						Limit:      11,
+						CountTotal: true,
+					},
+				}
+			},
+			nil,
+		},
+		{
+			"success: with pagination",
+			func() {
+				path := ibctesting.NewPath(suite.chainA, suite.chainB)
+				path.SetupV2()
+
+				expCommitments = make([]*types.PacketState, 0, 10) // reset expected commitments
+				for i := uint64(1); i <= 10; i++ {
+					pktStateCommitment := types.NewPacketState(path.EndpointA.ChannelID, i, []byte(fmt.Sprintf("hash_%d", i)))
+					suite.chainA.App.GetIBCKeeper().ChannelKeeperV2.SetPacketCommitment(suite.chainA.GetContext(), pktStateCommitment.ChannelId, pktStateCommitment.Sequence, pktStateCommitment.Data)
+					expCommitments = append(expCommitments, &pktStateCommitment)
+				}
+
+				limit := uint64(5)
+				expCommitments = expCommitments[:limit]
+
+				req = &types.QueryPacketCommitmentsRequest{
+					ChannelId: path.EndpointA.ChannelID,
+					Pagination: &query.PageRequest{
+						Key:        nil,
+						Limit:      limit,
+						CountTotal: true,
+					},
+				}
+			},
+			nil,
+		},
+		{
+			"empty request",
+			func() {
+				req = nil
+			},
+			status.Error(codes.InvalidArgument, "empty request"),
+		},
+		{
+			"invalid channel ID",
+			func() {
+				req = &types.QueryPacketCommitmentsRequest{
+					ChannelId: "",
+				}
+			},
+			status.Error(codes.InvalidArgument, "identifier cannot be blank: invalid identifier"),
+		},
+		{
+			"channel not found",
+			func() {
+				req = &types.QueryPacketCommitmentsRequest{
+					ChannelId: "channel-141",
+				}
+			},
+			status.Error(codes.NotFound, fmt.Sprintf("%s: channel not found", "channel-141")),
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+
+		suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
+			suite.SetupTest() // reset
+
+			tc.malleate()
+			ctx := suite.chainA.GetContext()
+
+			queryServer := keeper.NewQueryServer(suite.chainA.GetSimApp().IBCKeeper.ChannelKeeperV2)
+			res, err := queryServer.PacketCommitments(ctx, req)
+
+			expPass := tc.expError == nil
+			if expPass {
+				suite.Require().NoError(err)
+				suite.Require().NotNil(res)
+				suite.Require().Equal(expCommitments, res.Commitments)
+			} else {
+				suite.Require().Error(err)
+			}
+		})
+	}
+}
+
 func (suite *KeeperTestSuite) TestQueryPacketAcknowledgement() {
 	var (
 		expAcknowledgement []byte
diff --git a/modules/core/04-channel/v2/types/packet.go b/modules/core/04-channel/v2/types/packet.go
index 1ba7722b925..42da61b2a15 100644
--- a/modules/core/04-channel/v2/types/packet.go
+++ b/modules/core/04-channel/v2/types/packet.go
@@ -84,3 +84,12 @@ func (p Payload) ValidateBasic() error {
 func TimeoutTimestampToNanos(seconds uint64) uint64 {
 	return uint64(time.Unix(int64(seconds), 0).UnixNano())
 }
+
+// NewPacketState creates and returns a new PacketState envelope type to encapsulate packet commitments, acks or receipts.
+func NewPacketState(channelID string, sequence uint64, data []byte) PacketState {
+	return PacketState{
+		ChannelId: channelID,
+		Sequence:  sequence,
+		Data:      data,
+	}
+}
diff --git a/modules/core/04-channel/v2/types/query.pb.go b/modules/core/04-channel/v2/types/query.pb.go
index 02e5f2a1b1b..897cd508b6d 100644
--- a/modules/core/04-channel/v2/types/query.pb.go
+++ b/modules/core/04-channel/v2/types/query.pb.go
@@ -6,6 +6,7 @@ package types
 import (
 	context "context"
 	fmt "fmt"
+	query "github.com/cosmos/cosmos-sdk/types/query"
 	_ "github.com/cosmos/gogoproto/gogoproto"
 	grpc1 "github.com/cosmos/gogoproto/grpc"
 	proto "github.com/cosmos/gogoproto/proto"
@@ -240,6 +241,125 @@ func (m *QueryPacketCommitmentResponse) GetProofHeight() types.Height {
 	return types.Height{}
 }
 
+// QueryPacketCommitmentsRequest is the request type for the Query/PacketCommitments RPC method.
+type QueryPacketCommitmentsRequest struct {
+	// channel unique identifier
+	ChannelId string `protobuf:"bytes,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
+	// pagination request
+	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (m *QueryPacketCommitmentsRequest) Reset()         { *m = QueryPacketCommitmentsRequest{} }
+func (m *QueryPacketCommitmentsRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryPacketCommitmentsRequest) ProtoMessage()    {}
+func (*QueryPacketCommitmentsRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a328cba4986edcab, []int{4}
+}
+func (m *QueryPacketCommitmentsRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryPacketCommitmentsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryPacketCommitmentsRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryPacketCommitmentsRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryPacketCommitmentsRequest.Merge(m, src)
+}
+func (m *QueryPacketCommitmentsRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryPacketCommitmentsRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryPacketCommitmentsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryPacketCommitmentsRequest proto.InternalMessageInfo
+
+func (m *QueryPacketCommitmentsRequest) GetChannelId() string {
+	if m != nil {
+		return m.ChannelId
+	}
+	return ""
+}
+
+func (m *QueryPacketCommitmentsRequest) GetPagination() *query.PageRequest {
+	if m != nil {
+		return m.Pagination
+	}
+	return nil
+}
+
+// QueryPacketCommitmentResponse is the response type for the Query/PacketCommitment RPC method.
+type QueryPacketCommitmentsResponse struct {
+	// collection of packet commitments for the requested channel identifier.
+	Commitments []*PacketState `protobuf:"bytes,1,rep,name=commitments,proto3" json:"commitments,omitempty"`
+	// pagination response.
+	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	// query block height.
+	Height types.Height `protobuf:"bytes,3,opt,name=height,proto3" json:"height"`
+}
+
+func (m *QueryPacketCommitmentsResponse) Reset()         { *m = QueryPacketCommitmentsResponse{} }
+func (m *QueryPacketCommitmentsResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryPacketCommitmentsResponse) ProtoMessage()    {}
+func (*QueryPacketCommitmentsResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a328cba4986edcab, []int{5}
+}
+func (m *QueryPacketCommitmentsResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryPacketCommitmentsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryPacketCommitmentsResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryPacketCommitmentsResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryPacketCommitmentsResponse.Merge(m, src)
+}
+func (m *QueryPacketCommitmentsResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryPacketCommitmentsResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryPacketCommitmentsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryPacketCommitmentsResponse proto.InternalMessageInfo
+
+func (m *QueryPacketCommitmentsResponse) GetCommitments() []*PacketState {
+	if m != nil {
+		return m.Commitments
+	}
+	return nil
+}
+
+func (m *QueryPacketCommitmentsResponse) GetPagination() *query.PageResponse {
+	if m != nil {
+		return m.Pagination
+	}
+	return nil
+}
+
+func (m *QueryPacketCommitmentsResponse) GetHeight() types.Height {
+	if m != nil {
+		return m.Height
+	}
+	return types.Height{}
+}
+
 // QueryPacketAcknowledgementRequest is the request type for the Query/PacketAcknowledgement RPC method.
 type QueryPacketAcknowledgementRequest struct {
 	// channel unique identifier
@@ -252,7 +372,7 @@ func (m *QueryPacketAcknowledgementRequest) Reset()         { *m = QueryPacketAc
 func (m *QueryPacketAcknowledgementRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryPacketAcknowledgementRequest) ProtoMessage()    {}
 func (*QueryPacketAcknowledgementRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_a328cba4986edcab, []int{4}
+	return fileDescriptor_a328cba4986edcab, []int{6}
 }
 func (m *QueryPacketAcknowledgementRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -309,7 +429,7 @@ func (m *QueryPacketAcknowledgementResponse) Reset()         { *m = QueryPacketA
 func (m *QueryPacketAcknowledgementResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryPacketAcknowledgementResponse) ProtoMessage()    {}
 func (*QueryPacketAcknowledgementResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_a328cba4986edcab, []int{5}
+	return fileDescriptor_a328cba4986edcab, []int{7}
 }
 func (m *QueryPacketAcknowledgementResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -373,7 +493,7 @@ func (m *QueryPacketReceiptRequest) Reset()         { *m = QueryPacketReceiptReq
 func (m *QueryPacketReceiptRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryPacketReceiptRequest) ProtoMessage()    {}
 func (*QueryPacketReceiptRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_a328cba4986edcab, []int{6}
+	return fileDescriptor_a328cba4986edcab, []int{8}
 }
 func (m *QueryPacketReceiptRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -437,7 +557,7 @@ func (m *QueryPacketReceiptResponse) Reset()         { *m = QueryPacketReceiptRe
 func (m *QueryPacketReceiptResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryPacketReceiptResponse) ProtoMessage()    {}
 func (*QueryPacketReceiptResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_a328cba4986edcab, []int{7}
+	return fileDescriptor_a328cba4986edcab, []int{9}
 }
 func (m *QueryPacketReceiptResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -492,6 +612,8 @@ func init() {
 	proto.RegisterType((*QueryChannelResponse)(nil), "ibc.core.channel.v2.QueryChannelResponse")
 	proto.RegisterType((*QueryPacketCommitmentRequest)(nil), "ibc.core.channel.v2.QueryPacketCommitmentRequest")
 	proto.RegisterType((*QueryPacketCommitmentResponse)(nil), "ibc.core.channel.v2.QueryPacketCommitmentResponse")
+	proto.RegisterType((*QueryPacketCommitmentsRequest)(nil), "ibc.core.channel.v2.QueryPacketCommitmentsRequest")
+	proto.RegisterType((*QueryPacketCommitmentsResponse)(nil), "ibc.core.channel.v2.QueryPacketCommitmentsResponse")
 	proto.RegisterType((*QueryPacketAcknowledgementRequest)(nil), "ibc.core.channel.v2.QueryPacketAcknowledgementRequest")
 	proto.RegisterType((*QueryPacketAcknowledgementResponse)(nil), "ibc.core.channel.v2.QueryPacketAcknowledgementResponse")
 	proto.RegisterType((*QueryPacketReceiptRequest)(nil), "ibc.core.channel.v2.QueryPacketReceiptRequest")
@@ -501,48 +623,58 @@ func init() {
 func init() { proto.RegisterFile("ibc/core/channel/v2/query.proto", fileDescriptor_a328cba4986edcab) }
 
 var fileDescriptor_a328cba4986edcab = []byte{
-	// 654 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xcf, 0x4f, 0xd4, 0x40,
-	0x14, 0xde, 0xe1, 0x37, 0x0f, 0x8c, 0x66, 0xc0, 0x88, 0x0d, 0x14, 0xe8, 0x69, 0x35, 0xd2, 0x91,
-	0x95, 0x68, 0x4c, 0xb8, 0xc0, 0xc6, 0x08, 0x26, 0x26, 0xd8, 0x18, 0x13, 0x3d, 0x48, 0xba, 0xb3,
-	0x63, 0xb7, 0x61, 0xdb, 0x29, 0xed, 0x6c, 0x0d, 0x21, 0x5c, 0xf8, 0x0b, 0x8c, 0xdc, 0xfc, 0x0f,
-	0xfc, 0x2b, 0xbc, 0x92, 0x78, 0x21, 0xe1, 0xe2, 0xc9, 0x18, 0xf0, 0x0f, 0x31, 0x9d, 0x0e, 0xbb,
-	0xdd, 0x4d, 0x77, 0xd9, 0x35, 0x7a, 0x9b, 0x79, 0xf3, 0xbe, 0xf7, 0xbe, 0xef, 0xa3, 0x1f, 0x0b,
-	0x8b, 0x6e, 0x85, 0x12, 0xca, 0x43, 0x46, 0x68, 0xcd, 0xf6, 0x7d, 0x56, 0x27, 0x71, 0x89, 0xec,
-	0x37, 0x58, 0x78, 0x60, 0x06, 0x21, 0x17, 0x1c, 0xcf, 0xb8, 0x15, 0x6a, 0x26, 0x0d, 0xa6, 0x6a,
-	0x30, 0xe3, 0x92, 0xb6, 0x9c, 0x87, 0xba, 0x7a, 0x97, 0x38, 0x2d, 0x33, 0xb8, 0xee, 0x32, 0x5f,
-	0x90, 0x78, 0x55, 0x9d, 0x54, 0xc3, 0xbc, 0xc3, 0xb9, 0x53, 0x67, 0xc4, 0x0e, 0x5c, 0x62, 0xfb,
-	0x3e, 0x17, 0xb6, 0x70, 0xb9, 0x1f, 0xa9, 0xd7, 0x59, 0x87, 0x3b, 0x5c, 0x1e, 0x49, 0x72, 0x4a,
-	0xab, 0xc6, 0x1a, 0xcc, 0xbc, 0x4a, 0xb8, 0x95, 0xd3, 0x55, 0x16, 0xdb, 0x6f, 0xb0, 0x48, 0xe0,
-	0x05, 0x00, 0xb5, 0x7c, 0xd7, 0xad, 0xce, 0xa1, 0x25, 0x54, 0x9c, 0xb4, 0x26, 0x55, 0x65, 0xbb,
-	0x6a, 0xbc, 0x86, 0xd9, 0x76, 0x54, 0x14, 0x70, 0x3f, 0x62, 0x78, 0x1d, 0xc6, 0x55, 0x93, 0xc4,
-	0x4c, 0x95, 0xe6, 0xcd, 0x1c, 0xb1, 0xa6, 0x82, 0x6d, 0x8e, 0x9c, 0xfe, 0x5c, 0x2c, 0x58, 0x57,
-	0x10, 0xe3, 0x2d, 0xcc, 0xcb, 0xa9, 0x3b, 0x36, 0xdd, 0x63, 0xa2, 0xcc, 0x3d, 0xcf, 0x15, 0x1e,
-	0xf3, 0x45, 0x7f, 0xa4, 0xb0, 0x06, 0x13, 0x51, 0xd2, 0xe9, 0x53, 0x36, 0x37, 0xb4, 0x84, 0x8a,
-	0x23, 0x56, 0xf3, 0x6e, 0x7c, 0x41, 0xb0, 0xd0, 0x65, 0xb6, 0xa2, 0xae, 0x03, 0xd0, 0x66, 0x55,
-	0x0e, 0x9f, 0xb6, 0x32, 0x15, 0x3c, 0x0b, 0xa3, 0x41, 0xc8, 0xf9, 0x07, 0x39, 0x7a, 0xda, 0x4a,
-	0x2f, 0xb8, 0x0c, 0xd3, 0xf2, 0xb0, 0x5b, 0x63, 0xae, 0x53, 0x13, 0x73, 0xc3, 0x52, 0xb5, 0x96,
-	0x51, 0x9d, 0xfe, 0x81, 0xe2, 0x55, 0x73, 0x4b, 0x76, 0x28, 0xcd, 0x53, 0x12, 0x95, 0x96, 0x8c,
-	0xf7, 0xb0, 0x9c, 0xe1, 0xb6, 0x41, 0xf7, 0x7c, 0xfe, 0xb1, 0xce, 0xaa, 0x0e, 0xfb, 0x47, 0xe2,
-	0xbf, 0x22, 0x30, 0x7a, 0x2d, 0x50, 0x0e, 0x14, 0xe1, 0xa6, 0xdd, 0xfe, 0xa4, 0x6c, 0xe8, 0x2c,
-	0xff, 0x4f, 0x2f, 0x38, 0xdc, 0xcd, 0x50, 0xb5, 0x18, 0x65, 0x6e, 0xd0, 0xf4, 0xe0, 0x0e, 0x8c,
-	0x07, 0x3c, 0x14, 0x2d, 0x03, 0xc6, 0x92, 0xeb, 0x76, 0xb5, 0xc3, 0x9c, 0xa1, 0x5e, 0xe6, 0x0c,
-	0x77, 0x98, 0x73, 0x82, 0x40, 0xcb, 0xdb, 0xa8, 0x4c, 0xd1, 0x60, 0x22, 0x4c, 0x4a, 0x31, 0x4b,
-	0xe7, 0x4e, 0x58, 0xcd, 0x7b, 0xcb, 0x86, 0xe1, 0x5e, 0x36, 0x8c, 0xfc, 0x85, 0x0d, 0xa5, 0xe3,
-	0x31, 0x18, 0x95, 0xac, 0xf0, 0x67, 0x04, 0xe3, 0x2a, 0x2f, 0xb8, 0x98, 0x9b, 0xa6, 0x9c, 0xfc,
-	0x6a, 0xf7, 0xfa, 0xe8, 0x4c, 0x15, 0x1a, 0xa5, 0xe3, 0xf3, 0xdf, 0x27, 0x43, 0x0f, 0xf0, 0x7d,
-	0xd2, 0xe3, 0x5f, 0x50, 0x44, 0x0e, 0x5b, 0x06, 0x1f, 0xe1, 0xef, 0x08, 0x6e, 0x75, 0x26, 0x09,
-	0xaf, 0x76, 0xdf, 0xd9, 0x25, 0xd1, 0x5a, 0x69, 0x10, 0x88, 0xe2, 0xbb, 0x23, 0xf9, 0xbe, 0xc0,
-	0x5b, 0xfd, 0xf3, 0x25, 0x81, 0x1c, 0xb6, 0xdb, 0x8a, 0x73, 0x44, 0x0e, 0xaf, 0xbe, 0x80, 0x23,
-	0x7c, 0x8e, 0xe0, 0x76, 0x6e, 0x34, 0xf0, 0xe3, 0xeb, 0xf8, 0xe5, 0x87, 0x55, 0x7b, 0x32, 0x30,
-	0x4e, 0x89, 0xdb, 0x96, 0xe2, 0xca, 0x78, 0x63, 0x70, 0x71, 0x36, 0xdd, 0x6b, 0x53, 0xf5, 0x0d,
-	0xc1, 0x8d, 0xb6, 0x6f, 0x1a, 0x9b, 0xd7, 0xb1, 0x6a, 0x8f, 0x9b, 0x46, 0xfa, 0xee, 0x57, 0xec,
-	0x5f, 0x4a, 0xf6, 0xcf, 0xf1, 0xb3, 0xc1, 0xd9, 0x87, 0xe9, 0xa8, 0xac, 0x82, 0xcd, 0x37, 0xa7,
-	0x17, 0x3a, 0x3a, 0xbb, 0xd0, 0xd1, 0xaf, 0x0b, 0x1d, 0x7d, 0xba, 0xd4, 0x0b, 0x67, 0x97, 0x7a,
-	0xe1, 0xc7, 0xa5, 0x5e, 0x78, 0xb7, 0xee, 0xb8, 0xa2, 0xd6, 0xa8, 0x98, 0x94, 0x7b, 0x84, 0xf2,
-	0xc8, 0xe3, 0x51, 0xb2, 0x71, 0xc5, 0xe1, 0x24, 0x7e, 0x4a, 0x3c, 0x5e, 0x6d, 0xd4, 0x59, 0x94,
-	0xee, 0x7f, 0xb8, 0xb6, 0x92, 0xa1, 0x20, 0x0e, 0x02, 0x16, 0x55, 0xc6, 0xe4, 0x4f, 0xdf, 0xa3,
-	0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x39, 0x9c, 0xc7, 0xa2, 0xaa, 0x07, 0x00, 0x00,
+	// 810 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x96, 0x4d, 0x4f, 0x13, 0x5d,
+	0x14, 0xc7, 0x7b, 0x29, 0x50, 0x38, 0xe5, 0xc9, 0xf3, 0x3c, 0x17, 0x8c, 0x75, 0x02, 0x43, 0x99,
+	0x85, 0x56, 0x22, 0x73, 0xed, 0x40, 0x7c, 0x49, 0x30, 0x06, 0x1a, 0x04, 0x4c, 0x4c, 0x70, 0x34,
+	0x26, 0xba, 0x90, 0x4c, 0xa7, 0xd7, 0xe9, 0x84, 0x76, 0xee, 0xd0, 0x99, 0xd6, 0x10, 0xc2, 0xc6,
+	0x85, 0x6b, 0x23, 0x3b, 0xbf, 0x81, 0x9f, 0xc2, 0x85, 0x1b, 0x12, 0x37, 0x24, 0x6c, 0x5c, 0x19,
+	0x03, 0x26, 0x7e, 0x0d, 0xd3, 0x3b, 0xb7, 0xed, 0xb4, 0x4e, 0x4b, 0xeb, 0xcb, 0xee, 0xde, 0xd3,
+	0x73, 0xce, 0xfd, 0x9d, 0xff, 0x3d, 0xf7, 0x74, 0x60, 0xd6, 0xce, 0x9b, 0xc4, 0x64, 0x15, 0x4a,
+	0xcc, 0xa2, 0xe1, 0x38, 0xb4, 0x44, 0x6a, 0x1a, 0xd9, 0xad, 0xd2, 0xca, 0x9e, 0xea, 0x56, 0x98,
+	0xcf, 0xf0, 0xa4, 0x9d, 0x37, 0xd5, 0xba, 0x83, 0x2a, 0x1c, 0xd4, 0x9a, 0x26, 0xcd, 0x9b, 0xcc,
+	0x2b, 0x33, 0x8f, 0xe4, 0x0d, 0x8f, 0x06, 0xde, 0xa4, 0x96, 0xcd, 0x53, 0xdf, 0xc8, 0x12, 0xd7,
+	0xb0, 0x6c, 0xc7, 0xf0, 0x6d, 0xe6, 0x04, 0x09, 0xa4, 0xb9, 0xa8, 0x13, 0x1a, 0xb9, 0x7a, 0xb8,
+	0x58, 0xd4, 0xa1, 0x9e, 0xed, 0x09, 0x97, 0x10, 0x67, 0xc9, 0xa6, 0x8e, 0x4f, 0x6a, 0x59, 0xb1,
+	0x12, 0x0e, 0xd3, 0x16, 0x63, 0x56, 0x89, 0x12, 0xc3, 0xb5, 0x89, 0xe1, 0x38, 0xcc, 0xe7, 0x0c,
+	0x8d, 0xf0, 0x29, 0x8b, 0x59, 0x8c, 0x2f, 0x49, 0x7d, 0x15, 0x58, 0x95, 0x25, 0x98, 0x7c, 0x58,
+	0x87, 0xcf, 0x05, 0xa7, 0xea, 0x74, 0xb7, 0x4a, 0x3d, 0x1f, 0xcf, 0x00, 0x08, 0x8e, 0x6d, 0xbb,
+	0x90, 0x42, 0x69, 0x94, 0x19, 0xd7, 0xc7, 0x85, 0x65, 0xb3, 0xa0, 0x3c, 0x86, 0xa9, 0xf6, 0x28,
+	0xcf, 0x65, 0x8e, 0x47, 0xf1, 0x32, 0x24, 0x84, 0x13, 0x8f, 0x49, 0x6a, 0xd3, 0x6a, 0x84, 0x76,
+	0xaa, 0x08, 0x5b, 0x1d, 0x3e, 0xfa, 0x32, 0x1b, 0xd3, 0x1b, 0x21, 0xca, 0x53, 0x98, 0xe6, 0x59,
+	0xb7, 0x0c, 0x73, 0x87, 0xfa, 0x39, 0x56, 0x2e, 0xdb, 0x7e, 0x99, 0x3a, 0x7e, 0x7f, 0x50, 0x58,
+	0x82, 0x31, 0xaf, 0xee, 0xe9, 0x98, 0x34, 0x35, 0x94, 0x46, 0x99, 0x61, 0xbd, 0xb9, 0x57, 0xde,
+	0x21, 0x98, 0xe9, 0x92, 0x5b, 0xa0, 0xcb, 0x00, 0x66, 0xd3, 0xca, 0x93, 0x4f, 0xe8, 0x21, 0x0b,
+	0x9e, 0x82, 0x11, 0xb7, 0xc2, 0xd8, 0x0b, 0x9e, 0x7a, 0x42, 0x0f, 0x36, 0x38, 0x07, 0x13, 0x7c,
+	0xb1, 0x5d, 0xa4, 0xb6, 0x55, 0xf4, 0x53, 0x71, 0x5e, 0xb5, 0x14, 0xaa, 0x3a, 0xb8, 0xa0, 0x5a,
+	0x56, 0xdd, 0xe0, 0x1e, 0xa2, 0xe6, 0x24, 0x8f, 0x0a, 0x4c, 0xca, 0xeb, 0x6e, 0x70, 0x5e, 0x9f,
+	0x95, 0xdf, 0x03, 0x68, 0xf5, 0x1c, 0x07, 0x4c, 0x6a, 0x97, 0xd5, 0xa0, 0x41, 0xd5, 0x7a, 0x83,
+	0xaa, 0x41, 0x3b, 0x8b, 0x06, 0x55, 0xb7, 0x0c, 0x8b, 0x8a, 0xd4, 0x7a, 0x28, 0x52, 0xf9, 0x8e,
+	0x40, 0xee, 0x06, 0x22, 0x64, 0x5a, 0x85, 0x64, 0x4b, 0x14, 0x2f, 0x85, 0xd2, 0xf1, 0x4c, 0x52,
+	0x4b, 0x47, 0xde, 0x72, 0x90, 0xe4, 0x91, 0x6f, 0xf8, 0x54, 0x0f, 0x07, 0xe1, 0xf5, 0x08, 0xdc,
+	0x2b, 0xe7, 0xe2, 0x06, 0x00, 0x61, 0x5e, 0x7c, 0x0b, 0x46, 0x07, 0xd4, 0x5d, 0xf8, 0x2b, 0xcf,
+	0x61, 0x2e, 0x54, 0xe8, 0x8a, 0xb9, 0xe3, 0xb0, 0x97, 0x25, 0x5a, 0xb0, 0xe8, 0x1f, 0xea, 0xb7,
+	0xf7, 0x08, 0x94, 0x5e, 0x07, 0x08, 0x35, 0x33, 0xf0, 0xaf, 0xd1, 0xfe, 0x93, 0xe8, 0xbc, 0x4e,
+	0xf3, 0xdf, 0x6c, 0x3f, 0x06, 0x97, 0x42, 0xa8, 0x3a, 0x35, 0xa9, 0xed, 0x36, 0x35, 0xb8, 0x08,
+	0x09, 0x97, 0x55, 0xfc, 0x96, 0x00, 0xa3, 0xf5, 0xed, 0x66, 0xa1, 0x43, 0x9c, 0xa1, 0x5e, 0xe2,
+	0xc4, 0x3b, 0xc4, 0x39, 0x44, 0x20, 0x45, 0x9d, 0x28, 0x44, 0x91, 0x60, 0xac, 0x52, 0x37, 0xd5,
+	0x68, 0x90, 0x77, 0x4c, 0x6f, 0xee, 0x5b, 0x32, 0xc4, 0x7b, 0xc9, 0x30, 0xfc, 0x0b, 0x32, 0x68,
+	0x47, 0x09, 0x18, 0xe1, 0x54, 0xf8, 0x2d, 0x82, 0x84, 0x18, 0x51, 0x38, 0x13, 0xd9, 0xda, 0x11,
+	0x23, 0x53, 0xba, 0xda, 0x87, 0x67, 0x50, 0xa1, 0xa2, 0xbd, 0x3a, 0xf9, 0x76, 0x38, 0x74, 0x0d,
+	0xcf, 0x93, 0x1e, 0x7f, 0x0c, 0x1e, 0xd9, 0x6f, 0x09, 0x7c, 0x80, 0x3f, 0x21, 0xf8, 0xaf, 0xf3,
+	0x59, 0xe2, 0x6c, 0xf7, 0x33, 0xbb, 0x0c, 0x51, 0x49, 0x1b, 0x24, 0x44, 0xf0, 0x6e, 0x71, 0xde,
+	0xfb, 0x78, 0xa3, 0x7f, 0x5e, 0xe2, 0xf2, 0x64, 0xdb, 0xa1, 0x77, 0x4f, 0xf6, 0x1b, 0x1d, 0x70,
+	0x80, 0x3f, 0x22, 0xf8, 0xff, 0xa7, 0x21, 0x83, 0x07, 0x60, 0x6b, 0x8c, 0x46, 0x69, 0x71, 0xa0,
+	0x18, 0x51, 0xd0, 0x1a, 0x2f, 0xe8, 0x2e, 0xbe, 0xf3, 0x5b, 0x05, 0xe1, 0x13, 0x04, 0x17, 0x22,
+	0x1f, 0x38, 0xbe, 0x71, 0x1e, 0x55, 0xf4, 0xc8, 0x91, 0x6e, 0x0e, 0x1c, 0x27, 0x2a, 0xda, 0xe4,
+	0x15, 0xe5, 0xf0, 0xca, 0xe0, 0x15, 0x19, 0xe6, 0x4e, 0xdb, 0xdd, 0x7c, 0x40, 0xf0, 0x4f, 0xdb,
+	0xcb, 0xc4, 0xea, 0x79, 0x54, 0xed, 0x43, 0x43, 0x22, 0x7d, 0xfb, 0x0b, 0xfa, 0x07, 0x9c, 0x7e,
+	0x1d, 0xaf, 0x0d, 0x4e, 0x5f, 0x09, 0x52, 0x85, 0x2b, 0x58, 0x7d, 0x72, 0x74, 0x2a, 0xa3, 0xe3,
+	0x53, 0x19, 0x7d, 0x3d, 0x95, 0xd1, 0x9b, 0x33, 0x39, 0x76, 0x7c, 0x26, 0xc7, 0x3e, 0x9f, 0xc9,
+	0xb1, 0x67, 0xcb, 0x96, 0xed, 0x17, 0xab, 0x79, 0xd5, 0x64, 0x65, 0x22, 0x3e, 0xe0, 0xec, 0xbc,
+	0xb9, 0x60, 0x31, 0x52, 0xbb, 0x4d, 0xca, 0xac, 0x50, 0x2d, 0x51, 0x2f, 0x38, 0xff, 0xfa, 0xd2,
+	0x42, 0x08, 0xc1, 0xdf, 0x73, 0xa9, 0x97, 0x1f, 0xe5, 0xdf, 0x4c, 0x8b, 0x3f, 0x02, 0x00, 0x00,
+	0xff, 0xff, 0x78, 0xf5, 0x4d, 0xe9, 0x32, 0x0a, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -561,6 +693,8 @@ type QueryClient interface {
 	Channel(ctx context.Context, in *QueryChannelRequest, opts ...grpc.CallOption) (*QueryChannelResponse, error)
 	// PacketCommitment queries a stored packet commitment hash.
 	PacketCommitment(ctx context.Context, in *QueryPacketCommitmentRequest, opts ...grpc.CallOption) (*QueryPacketCommitmentResponse, error)
+	// PacketCommitments queries a stored packet commitment hash.
+	PacketCommitments(ctx context.Context, in *QueryPacketCommitmentsRequest, opts ...grpc.CallOption) (*QueryPacketCommitmentsResponse, error)
 	// PacketAcknowledgement queries a stored acknowledgement commitment hash.
 	PacketAcknowledgement(ctx context.Context, in *QueryPacketAcknowledgementRequest, opts ...grpc.CallOption) (*QueryPacketAcknowledgementResponse, error)
 	// PacketReceipt queries a stored packet receipt.
@@ -593,6 +727,15 @@ func (c *queryClient) PacketCommitment(ctx context.Context, in *QueryPacketCommi
 	return out, nil
 }
 
+func (c *queryClient) PacketCommitments(ctx context.Context, in *QueryPacketCommitmentsRequest, opts ...grpc.CallOption) (*QueryPacketCommitmentsResponse, error) {
+	out := new(QueryPacketCommitmentsResponse)
+	err := c.cc.Invoke(ctx, "/ibc.core.channel.v2.Query/PacketCommitments", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *queryClient) PacketAcknowledgement(ctx context.Context, in *QueryPacketAcknowledgementRequest, opts ...grpc.CallOption) (*QueryPacketAcknowledgementResponse, error) {
 	out := new(QueryPacketAcknowledgementResponse)
 	err := c.cc.Invoke(ctx, "/ibc.core.channel.v2.Query/PacketAcknowledgement", in, out, opts...)
@@ -617,6 +760,8 @@ type QueryServer interface {
 	Channel(context.Context, *QueryChannelRequest) (*QueryChannelResponse, error)
 	// PacketCommitment queries a stored packet commitment hash.
 	PacketCommitment(context.Context, *QueryPacketCommitmentRequest) (*QueryPacketCommitmentResponse, error)
+	// PacketCommitments queries a stored packet commitment hash.
+	PacketCommitments(context.Context, *QueryPacketCommitmentsRequest) (*QueryPacketCommitmentsResponse, error)
 	// PacketAcknowledgement queries a stored acknowledgement commitment hash.
 	PacketAcknowledgement(context.Context, *QueryPacketAcknowledgementRequest) (*QueryPacketAcknowledgementResponse, error)
 	// PacketReceipt queries a stored packet receipt.
@@ -633,6 +778,9 @@ func (*UnimplementedQueryServer) Channel(ctx context.Context, req *QueryChannelR
 func (*UnimplementedQueryServer) PacketCommitment(ctx context.Context, req *QueryPacketCommitmentRequest) (*QueryPacketCommitmentResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method PacketCommitment not implemented")
 }
+func (*UnimplementedQueryServer) PacketCommitments(ctx context.Context, req *QueryPacketCommitmentsRequest) (*QueryPacketCommitmentsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method PacketCommitments not implemented")
+}
 func (*UnimplementedQueryServer) PacketAcknowledgement(ctx context.Context, req *QueryPacketAcknowledgementRequest) (*QueryPacketAcknowledgementResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method PacketAcknowledgement not implemented")
 }
@@ -680,6 +828,24 @@ func _Query_PacketCommitment_Handler(srv interface{}, ctx context.Context, dec f
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_PacketCommitments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryPacketCommitmentsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).PacketCommitments(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/ibc.core.channel.v2.Query/PacketCommitments",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).PacketCommitments(ctx, req.(*QueryPacketCommitmentsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Query_PacketAcknowledgement_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QueryPacketAcknowledgementRequest)
 	if err := dec(in); err != nil {
@@ -728,6 +894,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "PacketCommitment",
 			Handler:    _Query_PacketCommitment_Handler,
 		},
+		{
+			MethodName: "PacketCommitments",
+			Handler:    _Query_PacketCommitments_Handler,
+		},
 		{
 			MethodName: "PacketAcknowledgement",
 			Handler:    _Query_PacketAcknowledgement_Handler,
@@ -886,6 +1056,107 @@ func (m *QueryPacketCommitmentResponse) MarshalToSizedBuffer(dAtA []byte) (int,
 	return len(dAtA) - i, nil
 }
 
+func (m *QueryPacketCommitmentsRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryPacketCommitmentsRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryPacketCommitmentsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Pagination != nil {
+		{
+			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintQuery(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.ChannelId) > 0 {
+		i -= len(m.ChannelId)
+		copy(dAtA[i:], m.ChannelId)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.ChannelId)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryPacketCommitmentsResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryPacketCommitmentsResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryPacketCommitmentsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size, err := m.Height.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintQuery(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	if m.Pagination != nil {
+		{
+			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintQuery(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Commitments) > 0 {
+		for iNdEx := len(m.Commitments) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Commitments[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintQuery(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *QueryPacketAcknowledgementRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -1130,6 +1401,44 @@ func (m *QueryPacketCommitmentResponse) Size() (n int) {
 	return n
 }
 
+func (m *QueryPacketCommitmentsRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.ChannelId)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	if m.Pagination != nil {
+		l = m.Pagination.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryPacketCommitmentsResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Commitments) > 0 {
+		for _, e := range m.Commitments {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	if m.Pagination != nil {
+		l = m.Pagination.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	l = m.Height.Size()
+	n += 1 + l + sovQuery(uint64(l))
+	return n
+}
+
 func (m *QueryPacketAcknowledgementRequest) Size() (n int) {
 	if m == nil {
 		return 0
@@ -1626,6 +1935,277 @@ func (m *QueryPacketCommitmentResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *QueryPacketCommitmentsRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryPacketCommitmentsRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryPacketCommitmentsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ChannelId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageRequest{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryPacketCommitmentsResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryPacketCommitmentsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryPacketCommitmentsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Commitments", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Commitments = append(m.Commitments, &PacketState{})
+			if err := m.Commitments[len(m.Commitments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageResponse{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Height.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *QueryPacketAcknowledgementRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/modules/core/04-channel/v2/types/query.pb.gw.go b/modules/core/04-channel/v2/types/query.pb.gw.go
index 5a274f65b17..07dbf642b72 100644
--- a/modules/core/04-channel/v2/types/query.pb.gw.go
+++ b/modules/core/04-channel/v2/types/query.pb.gw.go
@@ -163,6 +163,78 @@ func local_request_Query_PacketCommitment_0(ctx context.Context, marshaler runti
 
 }
 
+var (
+	filter_Query_PacketCommitments_0 = &utilities.DoubleArray{Encoding: map[string]int{"channel_id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+)
+
+func request_Query_PacketCommitments_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryPacketCommitmentsRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["channel_id"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channel_id")
+	}
+
+	protoReq.ChannelId, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channel_id", err)
+	}
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_PacketCommitments_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.PacketCommitments(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_PacketCommitments_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryPacketCommitmentsRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["channel_id"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channel_id")
+	}
+
+	protoReq.ChannelId, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channel_id", err)
+	}
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_PacketCommitments_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.PacketCommitments(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 func request_Query_PacketAcknowledgement_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
 	var protoReq QueryPacketAcknowledgementRequest
 	var metadata runtime.ServerMetadata
@@ -385,6 +457,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 
 	})
 
+	mux.Handle("GET", pattern_Query_PacketCommitments_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_PacketCommitments_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_PacketCommitments_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Query_PacketAcknowledgement_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -512,6 +607,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 
 	})
 
+	mux.Handle("GET", pattern_Query_PacketCommitments_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_PacketCommitments_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_PacketCommitments_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Query_PacketAcknowledgement_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -560,6 +675,8 @@ var (
 
 	pattern_Query_PacketCommitment_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7}, []string{"ibc", "core", "channel", "v2", "channels", "channel_id", "packet_commitments", "sequence"}, "", runtime.AssumeColonVerbOpt(false)))
 
+	pattern_Query_PacketCommitments_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6}, []string{"ibc", "core", "channel", "v2", "channels", "channel_id", "packet_commitments"}, "", runtime.AssumeColonVerbOpt(false)))
+
 	pattern_Query_PacketAcknowledgement_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7}, []string{"ibc", "core", "channel", "v2", "channels", "channel_id", "packet_acks", "sequence"}, "", runtime.AssumeColonVerbOpt(false)))
 
 	pattern_Query_PacketReceipt_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7}, []string{"ibc", "core", "channel", "v2", "channels", "channel_id", "packet_receipts", "sequence"}, "", runtime.AssumeColonVerbOpt(false)))
@@ -570,6 +687,8 @@ var (
 
 	forward_Query_PacketCommitment_0 = runtime.ForwardResponseMessage
 
+	forward_Query_PacketCommitments_0 = runtime.ForwardResponseMessage
+
 	forward_Query_PacketAcknowledgement_0 = runtime.ForwardResponseMessage
 
 	forward_Query_PacketReceipt_0 = runtime.ForwardResponseMessage
diff --git a/modules/core/24-host/v2/packet_keys.go b/modules/core/24-host/v2/packet_keys.go
index a556df4de38..b7c540b2abd 100644
--- a/modules/core/24-host/v2/packet_keys.go
+++ b/modules/core/24-host/v2/packet_keys.go
@@ -17,6 +17,11 @@ func PacketAcknowledgementKey(channelID string, sequence uint64) []byte {
 	return []byte(fmt.Sprintf("acks/channels/%s/sequences/%s", channelID, sdk.Uint64ToBigEndian(sequence)))
 }
 
+// PacketCommitmentPrefixKey returns the store key prefix under which packet commitments for a particular channel are stored.
+func PacketCommitmentPrefixKey(channelID string) []byte {
+	return []byte(fmt.Sprintf("commitments/channels/%s", channelID))
+}
+
 // PacketCommitmentKey returns the store key of under which a packet commitment is stored.
 func PacketCommitmentKey(channelID string, sequence uint64) []byte {
 	return []byte(fmt.Sprintf("commitments/channels/%s/sequences/%s", channelID, sdk.Uint64ToBigEndian(sequence)))
diff --git a/proto/ibc/core/channel/v2/query.proto b/proto/ibc/core/channel/v2/query.proto
index 6d731385164..00b60fd6891 100644
--- a/proto/ibc/core/channel/v2/query.proto
+++ b/proto/ibc/core/channel/v2/query.proto
@@ -4,7 +4,9 @@ package ibc.core.channel.v2;
 
 option go_package = "github.com/cosmos/ibc-go/v9/modules/core/04-channel/v2/types";
 
+import "cosmos/base/query/v1beta1/pagination.proto";
 import "ibc/core/channel/v2/channel.proto";
+import "ibc/core/channel/v2/genesis.proto";
 import "ibc/core/client/v1/client.proto";
 import "google/api/annotations.proto";
 import "gogoproto/gogo.proto";
@@ -21,6 +23,11 @@ service Query {
     option (google.api.http).get = "/ibc/core/channel/v2/channels/{channel_id}/packet_commitments/{sequence}";
   }
 
+  // PacketCommitments queries a stored packet commitment hash.
+  rpc PacketCommitments(QueryPacketCommitmentsRequest) returns (QueryPacketCommitmentsResponse) {
+    option (google.api.http).get = "/ibc/core/channel/v2/channels/{channel_id}/packet_commitments";
+  }
+
   // PacketAcknowledgement queries a stored acknowledgement commitment hash.
   rpc PacketAcknowledgement(QueryPacketAcknowledgementRequest) returns (QueryPacketAcknowledgementResponse) {
     option (google.api.http).get = "/ibc/core/channel/v2/channels/{channel_id}/packet_acks/{sequence}";
@@ -61,6 +68,24 @@ message QueryPacketCommitmentResponse {
   ibc.core.client.v1.Height proof_height = 3 [(gogoproto.nullable) = false];
 }
 
+// QueryPacketCommitmentsRequest is the request type for the Query/PacketCommitments RPC method.
+message QueryPacketCommitmentsRequest {
+  // channel unique identifier
+  string channel_id = 1;
+  // pagination request
+  cosmos.base.query.v1beta1.PageRequest pagination = 2;
+}
+
+// QueryPacketCommitmentResponse is the response type for the Query/PacketCommitment RPC method.
+message QueryPacketCommitmentsResponse {
+  // collection of packet commitments for the requested channel identifier.
+  repeated ibc.core.channel.v2.PacketState commitments = 1;
+  // pagination response.
+  cosmos.base.query.v1beta1.PageResponse pagination = 2;
+  // query block height.
+  ibc.core.client.v1.Height height = 3 [(gogoproto.nullable) = false];
+}
+
 // QueryPacketAcknowledgementRequest is the request type for the Query/PacketAcknowledgement RPC method.
 message QueryPacketAcknowledgementRequest {
   // channel unique identifier