diff --git a/store/v2/commitment/iavl/exporter.go b/store/v2/commitment/iavl/exporter.go
index 20f00d1a1722..7d7c1a5b75fc 100644
--- a/store/v2/commitment/iavl/exporter.go
+++ b/store/v2/commitment/iavl/exporter.go
@@ -38,3 +38,16 @@ func (e *Exporter) Close() error {
 
 	return nil
 }
+
+// EmptyExporter is a Exporter for an empty tree.
+type EmptyExporter struct{}
+
+// Next returns ExportDone.
+func (e *EmptyExporter) Next() (*snapshotstypes.SnapshotIAVLItem, error) {
+	return nil, commitment.ErrorExportDone
+}
+
+// Close does nothing.
+func (e *EmptyExporter) Close() error {
+	return nil
+}
diff --git a/store/v2/commitment/iavl/tree.go b/store/v2/commitment/iavl/tree.go
index 62e6d4a5e62c..76f028f1d6db 100644
--- a/store/v2/commitment/iavl/tree.go
+++ b/store/v2/commitment/iavl/tree.go
@@ -21,6 +21,8 @@ var (
 // IavlTree is a wrapper around iavl.MutableTree.
 type IavlTree struct {
 	tree *iavl.MutableTree
+	// it is only used for new store key during the migration process.
+	initialVersion uint64
 }
 
 // NewIavlTree creates a new IavlTree instance.
@@ -58,6 +60,17 @@ func (t *IavlTree) WorkingHash() []byte {
 
 // LoadVersion loads the state at the given version.
 func (t *IavlTree) LoadVersion(version uint64) error {
+	if t.initialVersion > 0 {
+		// If the initial version is set and the tree is empty,
+		// we don't need to load the version.
+		latestVersion, err := t.tree.GetLatestVersion()
+		if err != nil {
+			return err
+		}
+		if latestVersion == 0 {
+			return nil
+		}
+	}
 	return t.tree.LoadVersionForOverwriting(int64(version))
 }
 
@@ -106,6 +119,7 @@ func (t *IavlTree) GetLatestVersion() (uint64, error) {
 // SetInitialVersion sets the initial version of the database.
 func (t *IavlTree) SetInitialVersion(version uint64) error {
 	t.tree.SetInitialVersion(version)
+	t.initialVersion = version
 	return nil
 }
 
@@ -125,6 +139,9 @@ func (t *IavlTree) PausePruning(pause bool) {
 
 // Export exports the tree exporter at the given version.
 func (t *IavlTree) Export(version uint64) (commitment.Exporter, error) {
+	if version < t.initialVersion {
+		return &EmptyExporter{}, nil
+	}
 	tree, err := t.tree.GetImmutable(int64(version))
 	if err != nil {
 		return nil, err
diff --git a/store/v2/commitment/metadata.go b/store/v2/commitment/metadata.go
index a054acf26e89..aafdcf9b4c83 100644
--- a/store/v2/commitment/metadata.go
+++ b/store/v2/commitment/metadata.go
@@ -11,9 +11,9 @@ import (
 )
 
 const (
-	commitInfoKeyFmt      = "c/%d" // c/<version>
-	latestVersionKey      = "c/latest"
-	removedStoreKeyPrefix = "c/removed/" // c/removed/<version>/<store-name>
+	commitInfoKeyFmt      = "s/%d" // c/<version>
+	latestVersionKey      = "s/latest"
+	removedStoreKeyPrefix = "s/removed/" // c/removed/<version>/<store-name>
 )
 
 // MetadataStore is a store for metadata related to the commitment store.
@@ -69,7 +69,10 @@ func (m *MetadataStore) GetCommitInfo(version uint64) (*proof.CommitInfo, error)
 
 	cInfo := &proof.CommitInfo{}
 	if err := cInfo.Unmarshal(value); err != nil {
-		return nil, err
+		cInfo, err = proof.ConvertV1CommitInfo(value)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	return cInfo, nil
diff --git a/store/v2/go.mod b/store/v2/go.mod
index f906dfb1c4b2..f582a2c56f0c 100644
--- a/store/v2/go.mod
+++ b/store/v2/go.mod
@@ -21,6 +21,7 @@ require (
 	github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d
 	go.uber.org/mock v0.5.0
 	golang.org/x/sync v0.8.0
+	google.golang.org/protobuf v1.35.1
 )
 
 require (
@@ -61,6 +62,5 @@ require (
 	golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect
 	golang.org/x/sys v0.26.0 // indirect
 	golang.org/x/text v0.19.0 // indirect
-	google.golang.org/protobuf v1.35.1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/store/v2/migration/manager.go b/store/v2/migration/manager.go
index 237dbd1e3606..754b0929f442 100644
--- a/store/v2/migration/manager.go
+++ b/store/v2/migration/manager.go
@@ -265,11 +265,8 @@ func (m *Manager) Sync() error {
 }
 
 // Close closes the manager. It should be called after the migration is done.
-// It will close the db and notify the snapshotsManager that the migration is done.
+// It will notify the snapshotsManager that the migration is done.
 func (m *Manager) Close() error {
-	if err := m.db.Close(); err != nil {
-		return fmt.Errorf("failed to close db: %w", err)
-	}
 	if m.stateCommitment != nil {
 		m.snapshotsManager.EndMigration(m.stateCommitment)
 	}
diff --git a/store/v2/proof/proof.go b/store/v2/proof/proof.go
index 01a31227b7b5..ce0bcb695e2d 100644
--- a/store/v2/proof/proof.go
+++ b/store/v2/proof/proof.go
@@ -7,6 +7,7 @@ import (
 
 	errors "cosmossdk.io/errors/v2"
 	storeerrors "cosmossdk.io/store/v2/errors"
+	v1types "cosmossdk.io/store/v2/proof/v1/types"
 )
 
 // Proof operation types
@@ -228,3 +229,30 @@ func InnerHash(left, right []byte) []byte {
 	h := sha256.Sum256(data)
 	return h[:]
 }
+
+func ConvertV1CommitInfo(value []byte) (*CommitInfo, error) {
+	v1CommitInfo := &v1types.CommitInfo{}
+	if err := v1CommitInfo.Unmarshal(value); err != nil {
+		return nil, err
+	}
+	cInfo := &CommitInfo{
+		Version:    uint64(v1CommitInfo.Version),
+		StoreInfos: make([]StoreInfo, len(v1CommitInfo.StoreInfos)),
+		Timestamp:  v1CommitInfo.Timestamp,
+	}
+	for i, v1StoreInfo := range v1CommitInfo.StoreInfos {
+		cInfo.StoreInfos[i] = StoreInfo{
+			Name: []byte(v1StoreInfo.Name),
+			CommitID: CommitID{
+				Version: uint64(v1StoreInfo.CommitId.Version),
+				Hash:    v1StoreInfo.CommitId.Hash,
+			},
+			Structure: "iavl",
+		}
+	}
+
+	var err error
+	cInfo.CommitHash, _, err = cInfo.GetStoreProof([]byte{})
+
+	return cInfo, err
+}
diff --git a/store/v2/proof/v1/types/commit_info.pb.go b/store/v2/proof/v1/types/commit_info.pb.go
new file mode 100644
index 000000000000..47cb9f3678f6
--- /dev/null
+++ b/store/v2/proof/v1/types/commit_info.pb.go
@@ -0,0 +1,867 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: cosmos/store/v1beta1/commit_info.proto
+
+package types
+
+import (
+	fmt "fmt"
+	_ "github.com/cosmos/gogoproto/gogoproto"
+	proto "github.com/cosmos/gogoproto/proto"
+	github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types"
+	_ "google.golang.org/protobuf/types/known/timestamppb"
+	io "io"
+	math "math"
+	math_bits "math/bits"
+	time "time"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+var _ = time.Kitchen
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// CommitInfo defines commit information used by the multi-store when committing
+// a version/height.
+type CommitInfo struct {
+	Version    int64       `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
+	StoreInfos []StoreInfo `protobuf:"bytes,2,rep,name=store_infos,json=storeInfos,proto3" json:"store_infos"`
+	Timestamp  time.Time   `protobuf:"bytes,3,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
+}
+
+func (m *CommitInfo) Reset()         { *m = CommitInfo{} }
+func (m *CommitInfo) String() string { return proto.CompactTextString(m) }
+func (*CommitInfo) ProtoMessage()    {}
+func (*CommitInfo) Descriptor() ([]byte, []int) {
+	return fileDescriptor_5f8c656cdef8c524, []int{0}
+}
+func (m *CommitInfo) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *CommitInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_CommitInfo.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 *CommitInfo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CommitInfo.Merge(m, src)
+}
+func (m *CommitInfo) XXX_Size() int {
+	return m.Size()
+}
+func (m *CommitInfo) XXX_DiscardUnknown() {
+	xxx_messageInfo_CommitInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CommitInfo proto.InternalMessageInfo
+
+func (m *CommitInfo) GetVersion() int64 {
+	if m != nil {
+		return m.Version
+	}
+	return 0
+}
+
+func (m *CommitInfo) GetStoreInfos() []StoreInfo {
+	if m != nil {
+		return m.StoreInfos
+	}
+	return nil
+}
+
+func (m *CommitInfo) GetTimestamp() time.Time {
+	if m != nil {
+		return m.Timestamp
+	}
+	return time.Time{}
+}
+
+// StoreInfo defines store-specific commit information. It contains a reference
+// between a store name and the commit ID.
+type StoreInfo struct {
+	Name     string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	CommitId CommitID `protobuf:"bytes,2,opt,name=commit_id,json=commitId,proto3" json:"commit_id"`
+}
+
+func (m *StoreInfo) Reset()         { *m = StoreInfo{} }
+func (m *StoreInfo) String() string { return proto.CompactTextString(m) }
+func (*StoreInfo) ProtoMessage()    {}
+func (*StoreInfo) Descriptor() ([]byte, []int) {
+	return fileDescriptor_5f8c656cdef8c524, []int{1}
+}
+func (m *StoreInfo) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *StoreInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_StoreInfo.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 *StoreInfo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_StoreInfo.Merge(m, src)
+}
+func (m *StoreInfo) XXX_Size() int {
+	return m.Size()
+}
+func (m *StoreInfo) XXX_DiscardUnknown() {
+	xxx_messageInfo_StoreInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StoreInfo proto.InternalMessageInfo
+
+func (m *StoreInfo) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *StoreInfo) GetCommitId() CommitID {
+	if m != nil {
+		return m.CommitId
+	}
+	return CommitID{}
+}
+
+// CommitID defines the commitment information when a specific store is
+// committed.
+type CommitID struct {
+	Version int64  `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
+	Hash    []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
+}
+
+func (m *CommitID) Reset()      { *m = CommitID{} }
+func (*CommitID) ProtoMessage() {}
+func (m *CommitID) String() string {
+	return fmt.Sprintf("CommitID{%v:%X}", m.Hash, m.Version)
+}
+func (*CommitID) Descriptor() ([]byte, []int) {
+	return fileDescriptor_5f8c656cdef8c524, []int{2}
+}
+func (m *CommitID) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *CommitID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_CommitID.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 *CommitID) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CommitID.Merge(m, src)
+}
+func (m *CommitID) XXX_Size() int {
+	return m.Size()
+}
+func (m *CommitID) XXX_DiscardUnknown() {
+	xxx_messageInfo_CommitID.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CommitID proto.InternalMessageInfo
+
+func (m *CommitID) GetVersion() int64 {
+	if m != nil {
+		return m.Version
+	}
+	return 0
+}
+
+func (m *CommitID) GetHash() []byte {
+	if m != nil {
+		return m.Hash
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*CommitInfo)(nil), "cosmos.store.v1beta1.CommitInfo")
+	proto.RegisterType((*StoreInfo)(nil), "cosmos.store.v1beta1.StoreInfo")
+	proto.RegisterType((*CommitID)(nil), "cosmos.store.v1beta1.CommitID")
+}
+
+func init() {
+	proto.RegisterFile("cosmos/store/v1beta1/commit_info.proto", fileDescriptor_5f8c656cdef8c524)
+}
+
+var fileDescriptor_5f8c656cdef8c524 = []byte{
+	// 336 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x91, 0xb1, 0x4e, 0xf2, 0x50,
+	0x14, 0xc7, 0x7b, 0xa1, 0xf9, 0x3e, 0x7a, 0x70, 0xba, 0x61, 0x68, 0x18, 0x6e, 0x09, 0x83, 0x61,
+	0xba, 0x0d, 0xb8, 0x39, 0x98, 0x58, 0x8d, 0x09, 0x6b, 0x75, 0x72, 0x31, 0x2d, 0x5c, 0x4a, 0xa3,
+	0xed, 0x21, 0xdc, 0x2b, 0x89, 0x6f, 0xc1, 0xe8, 0xe8, 0x33, 0xf8, 0x14, 0x8c, 0x8c, 0x4e, 0x6a,
+	0xe0, 0x45, 0x4c, 0x4f, 0x5b, 0x5c, 0x88, 0xdb, 0x39, 0xed, 0xef, 0x9c, 0xff, 0xaf, 0xa7, 0x70,
+	0x3a, 0x41, 0x9d, 0xa1, 0xf6, 0xb5, 0xc1, 0xa5, 0xf2, 0x57, 0xc3, 0x58, 0x99, 0x68, 0xe8, 0x4f,
+	0x30, 0xcb, 0x52, 0xf3, 0x90, 0xe6, 0x33, 0x94, 0x8b, 0x25, 0x1a, 0xe4, 0x9d, 0x92, 0x93, 0xc4,
+	0xc9, 0x8a, 0xeb, 0x76, 0x12, 0x4c, 0x90, 0x00, 0xbf, 0xa8, 0x4a, 0xb6, 0xeb, 0x25, 0x88, 0xc9,
+	0x93, 0xf2, 0xa9, 0x8b, 0x9f, 0x67, 0xbe, 0x49, 0x33, 0xa5, 0x4d, 0x94, 0x2d, 0x4a, 0xa0, 0xff,
+	0xce, 0x00, 0xae, 0x28, 0x62, 0x9c, 0xcf, 0x90, 0xbb, 0xf0, 0x7f, 0xa5, 0x96, 0x3a, 0xc5, 0xdc,
+	0x65, 0x3d, 0x36, 0x68, 0x86, 0x75, 0xcb, 0x6f, 0xa0, 0x4d, 0x81, 0x64, 0xa2, 0xdd, 0x46, 0xaf,
+	0x39, 0x68, 0x8f, 0x3c, 0x79, 0xcc, 0x45, 0xde, 0x16, 0x5d, 0xb1, 0x2f, 0xb0, 0x37, 0x9f, 0x9e,
+	0x15, 0x82, 0xae, 0x1f, 0x68, 0x1e, 0x80, 0x73, 0x70, 0x70, 0x9b, 0x3d, 0x36, 0x68, 0x8f, 0xba,
+	0xb2, 0xb4, 0x94, 0xb5, 0xa5, 0xbc, 0xab, 0x89, 0xa0, 0x55, 0x2c, 0x58, 0x7f, 0x79, 0x2c, 0xfc,
+	0x1d, 0xeb, 0xc7, 0xe0, 0x1c, 0x22, 0x38, 0x07, 0x3b, 0x8f, 0x32, 0x45, 0xbe, 0x4e, 0x48, 0x35,
+	0xbf, 0x04, 0xa7, 0xbe, 0xdb, 0xd4, 0x6d, 0x50, 0x88, 0x38, 0xae, 0x5a, 0x7d, 0xfb, 0x75, 0x65,
+	0xda, 0x2a, 0xc7, 0xc6, 0xd3, 0xfe, 0x05, 0xb4, 0xea, 0x77, 0x7f, 0x5c, 0x85, 0x83, 0x3d, 0x8f,
+	0xf4, 0x9c, 0x32, 0x4e, 0x42, 0xaa, 0xcf, 0xed, 0xd7, 0x37, 0xcf, 0x0a, 0x46, 0x9b, 0x9d, 0x60,
+	0xdb, 0x9d, 0x60, 0xdf, 0x3b, 0xc1, 0xd6, 0x7b, 0x61, 0x6d, 0xf7, 0xc2, 0xfa, 0xd8, 0x0b, 0xeb,
+	0xde, 0x2d, 0x45, 0xf4, 0xf4, 0x51, 0xa6, 0x58, 0xfd, 0x6d, 0xf3, 0xb2, 0x50, 0x3a, 0xfe, 0x47,
+	0x07, 0x38, 0xfb, 0x09, 0x00, 0x00, 0xff, 0xff, 0x67, 0xb7, 0x0d, 0x59, 0x0a, 0x02, 0x00, 0x00,
+}
+
+func (m *CommitInfo) 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 *CommitInfo) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CommitInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	n1, err1 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):])
+	if err1 != nil {
+		return 0, err1
+	}
+	i -= n1
+	i = encodeVarintCommitInfo(dAtA, i, uint64(n1))
+	i--
+	dAtA[i] = 0x1a
+	if len(m.StoreInfos) > 0 {
+		for iNdEx := len(m.StoreInfos) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.StoreInfos[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintCommitInfo(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+		}
+	}
+	if m.Version != 0 {
+		i = encodeVarintCommitInfo(dAtA, i, uint64(m.Version))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *StoreInfo) 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 *StoreInfo) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *StoreInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size, err := m.CommitId.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintCommitInfo(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = encodeVarintCommitInfo(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *CommitID) 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 *CommitID) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CommitID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Hash) > 0 {
+		i -= len(m.Hash)
+		copy(dAtA[i:], m.Hash)
+		i = encodeVarintCommitInfo(dAtA, i, uint64(len(m.Hash)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.Version != 0 {
+		i = encodeVarintCommitInfo(dAtA, i, uint64(m.Version))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintCommitInfo(dAtA []byte, offset int, v uint64) int {
+	offset -= sovCommitInfo(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *CommitInfo) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Version != 0 {
+		n += 1 + sovCommitInfo(uint64(m.Version))
+	}
+	if len(m.StoreInfos) > 0 {
+		for _, e := range m.StoreInfos {
+			l = e.Size()
+			n += 1 + l + sovCommitInfo(uint64(l))
+		}
+	}
+	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp)
+	n += 1 + l + sovCommitInfo(uint64(l))
+	return n
+}
+
+func (m *StoreInfo) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovCommitInfo(uint64(l))
+	}
+	l = m.CommitId.Size()
+	n += 1 + l + sovCommitInfo(uint64(l))
+	return n
+}
+
+func (m *CommitID) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Version != 0 {
+		n += 1 + sovCommitInfo(uint64(m.Version))
+	}
+	l = len(m.Hash)
+	if l > 0 {
+		n += 1 + l + sovCommitInfo(uint64(l))
+	}
+	return n
+}
+
+func sovCommitInfo(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozCommitInfo(x uint64) (n int) {
+	return sovCommitInfo(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *CommitInfo) 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 ErrIntOverflowCommitInfo
+			}
+			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: CommitInfo: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: CommitInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
+			}
+			m.Version = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowCommitInfo
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Version |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StoreInfos", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowCommitInfo
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthCommitInfo
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthCommitInfo
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.StoreInfos = append(m.StoreInfos, StoreInfo{})
+			if err := m.StoreInfos[len(m.StoreInfos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowCommitInfo
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthCommitInfo
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthCommitInfo
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipCommitInfo(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthCommitInfo
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *StoreInfo) 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 ErrIntOverflowCommitInfo
+			}
+			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: StoreInfo: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: StoreInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowCommitInfo
+				}
+				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 ErrInvalidLengthCommitInfo
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthCommitInfo
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CommitId", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowCommitInfo
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthCommitInfo
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthCommitInfo
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.CommitId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipCommitInfo(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthCommitInfo
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *CommitID) 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 ErrIntOverflowCommitInfo
+			}
+			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: CommitID: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: CommitID: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
+			}
+			m.Version = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowCommitInfo
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Version |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowCommitInfo
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthCommitInfo
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthCommitInfo
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...)
+			if m.Hash == nil {
+				m.Hash = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipCommitInfo(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthCommitInfo
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipCommitInfo(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowCommitInfo
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowCommitInfo
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowCommitInfo
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthCommitInfo
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupCommitInfo
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthCommitInfo
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthCommitInfo        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowCommitInfo          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupCommitInfo = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/store/v2/root/factory.go b/store/v2/root/factory.go
index 2511a53b434e..7c95d020fd42 100644
--- a/store/v2/root/factory.go
+++ b/store/v2/root/factory.go
@@ -13,7 +13,9 @@ import (
 	"cosmossdk.io/store/v2/commitment/mem"
 	"cosmossdk.io/store/v2/db"
 	"cosmossdk.io/store/v2/internal"
+	"cosmossdk.io/store/v2/migration"
 	"cosmossdk.io/store/v2/pruning"
+	"cosmossdk.io/store/v2/snapshots"
 	"cosmossdk.io/store/v2/storage"
 	"cosmossdk.io/store/v2/storage/pebbledb"
 	"cosmossdk.io/store/v2/storage/rocksdb"
@@ -33,6 +35,8 @@ const (
 	SCTypeIavlV2 SCType = "iavl-v2"
 )
 
+const storePrefixTpl = "s/k:%s/" // s/k:<storeKey>
+
 // Options are the options for creating a root store.
 type Options struct {
 	SSType          SSType               `mapstructure:"ss-type" toml:"ss-type" comment:"State storage database type. Currently we support: \"sqlite\", \"pebble\" and \"rocksdb\""`
@@ -139,13 +143,13 @@ func CreateRootStore(opts *FactoryOptions) (store.RootStore, error) {
 		return nil, err
 	}
 
-	newTreeFn := func(key string) (commitment.Tree, error) {
+	newTreeFn := func(key string, scType SCType) (commitment.Tree, error) {
 		if internal.IsMemoryStoreKey(key) {
 			return mem.New(), nil
 		} else {
-			switch storeOpts.SCType {
+			switch scType {
 			case SCTypeIavl:
-				return iavl.NewIavlTree(db.NewPrefixDB(opts.SCRawDB, []byte(key)), opts.Logger, storeOpts.IavlConfig), nil
+				return iavl.NewIavlTree(db.NewPrefixDB(opts.SCRawDB, []byte(fmt.Sprintf(storePrefixTpl, key))), opts.Logger, storeOpts.IavlConfig), nil
 			case SCTypeIavlV2:
 				return nil, errors.New("iavl v2 not supported")
 			default:
@@ -154,17 +158,42 @@ func CreateRootStore(opts *FactoryOptions) (store.RootStore, error) {
 		}
 	}
 
+	// check if we need to migrate the store
+	isMigrating := false
+	scType := storeOpts.SCType
+	ssLatestVersion, err := ss.GetLatestVersion()
+	if err != nil {
+		return nil, err
+	}
+	if ssLatestVersion != latestVersion {
+		isMigrating = true // need to migrate
+		if scType != SCTypeIavl {
+			scType = SCTypeIavl // only support iavl v1 for migration
+		}
+	}
+
 	trees := make(map[string]commitment.Tree, len(opts.StoreKeys))
 	for _, key := range opts.StoreKeys {
-		tree, err := newTreeFn(key)
+		tree, err := newTreeFn(key, scType)
 		if err != nil {
 			return nil, err
 		}
+		if isMigrating {
+			v, err := tree.GetLatestVersion()
+			if err != nil {
+				return nil, err
+			}
+			if v == 0 && latestVersion > 0 {
+				if err := tree.SetInitialVersion(latestVersion + 1); err != nil {
+					return nil, err
+				}
+			}
+		}
 		trees[key] = tree
 	}
 	oldTrees := make(map[string]commitment.Tree, len(opts.StoreKeys))
 	for _, key := range removedStoreKeys {
-		tree, err := newTreeFn(string(key))
+		tree, err := newTreeFn(string(key), scType)
 		if err != nil {
 			return nil, err
 		}
@@ -176,6 +205,31 @@ func CreateRootStore(opts *FactoryOptions) (store.RootStore, error) {
 		return nil, err
 	}
 
+	var mm *migration.Manager
+	if isMigrating {
+		snapshotDB, err := snapshots.NewStore(fmt.Sprintf("%s/data/snapshots/store.db", opts.RootDir))
+		if err != nil {
+			return nil, err
+		}
+		snapshotMgr := snapshots.NewManager(snapshotDB, snapshots.SnapshotOptions{}, sc, nil, nil, opts.Logger)
+		var newSC *commitment.CommitStore
+		if scType != storeOpts.SCType {
+			newTrees := make(map[string]commitment.Tree, len(opts.StoreKeys))
+			for _, key := range opts.StoreKeys {
+				tree, err := newTreeFn(key, storeOpts.SCType)
+				if err != nil {
+					return nil, err
+				}
+				newTrees[key] = tree
+			}
+			newSC, err = commitment.NewCommitStore(newTrees, nil, opts.SCRawDB, opts.Logger)
+			if err != nil {
+				return nil, err
+			}
+		}
+		mm = migration.NewManager(opts.SCRawDB, snapshotMgr, ss, newSC, opts.Logger)
+	}
+
 	pm := pruning.NewManager(sc, ss, storeOpts.SCPruningOption, storeOpts.SSPruningOption)
-	return New(opts.SCRawDB, opts.Logger, ss, sc, pm, nil, nil)
+	return New(opts.SCRawDB, opts.Logger, ss, sc, pm, mm, nil)
 }
diff --git a/store/v2/root/factory_test.go b/store/v2/root/factory_test.go
index 45fd34699bf7..f00f970881d4 100644
--- a/store/v2/root/factory_test.go
+++ b/store/v2/root/factory_test.go
@@ -1,12 +1,15 @@
 package root
 
 import (
+	"bytes"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 
+	corestore "cosmossdk.io/core/store"
 	coretesting "cosmossdk.io/core/testing"
 	"cosmossdk.io/store/v2/db"
+	"cosmossdk.io/store/v2/internal/encoding"
 )
 
 func TestFactory(t *testing.T) {
@@ -26,4 +29,20 @@ func TestFactory(t *testing.T) {
 	f, err = CreateRootStore(&fop)
 	require.Error(t, err)
 	require.Nil(t, f)
+
+	require.NoError(t, setLatestVersion(fop.SCRawDB, 1))
+	fop.Options.SCType = SCTypeIavl
+	f, err = CreateRootStore(&fop)
+	require.NoError(t, err)
+	require.NotNil(t, f)
+	require.True(t, f.(*Store).isMigrating)
+}
+
+func setLatestVersion(db corestore.KVStoreWithBatch, version uint64) error {
+	var buf bytes.Buffer
+	buf.Grow(encoding.EncodeUvarintSize(version))
+	if err := encoding.EncodeUvarint(&buf, version); err != nil {
+		return err
+	}
+	return db.Set([]byte("s/latest"), buf.Bytes())
 }
diff --git a/store/v2/root/store.go b/store/v2/root/store.go
index 378cfafa3fdf..a0a38351829f 100644
--- a/store/v2/root/store.go
+++ b/store/v2/root/store.go
@@ -488,12 +488,12 @@ func (s *Store) writeSC(cs *corestore.Changeset) error {
 			close(s.chDone)
 			close(s.chChangeset)
 			s.isMigrating = false
-			// close the old state commitment and replace it with the new one
-			if err := s.stateCommitment.Close(); err != nil {
-				return fmt.Errorf("failed to close the old SC store: %w", err)
-			}
 			newStateCommitment := s.migrationManager.GetStateCommitment()
 			if newStateCommitment != nil {
+				// close the old state commitment and replace it with the new one
+				if err := s.stateCommitment.Close(); err != nil {
+					return fmt.Errorf("failed to close the old SC store: %w", err)
+				}
 				s.stateCommitment = newStateCommitment
 			}
 			if err := s.migrationManager.Close(); err != nil {