feat(store/v2): add WorkingHash

store/v2/commitment/store.go

@@ -113,19 +113,6 @@ func (c *CommitStore) GetLatestVersion() (uint64, error) {
 	return version, nil
 }
 
-// IsEmpty returns true if the CommitStore is empty.
-func (c *CommitStore) IsEmpty() (bool, error) {
-	value, err := c.db.Get([]byte(latestVersionKey))
-	if err != nil {
-		return false, err
-	}
-	if value == nil {
-		return true, nil
-	} else {
-		return false, nil
-	}
-}
-
 func (c *CommitStore) LoadVersion(targetVersion uint64) error {
 	// Rollback the metadata to the target version.
 	latestVersion, err := c.GetLatestVersion()
@@ -219,18 +206,18 @@ func (c *CommitStore) Commit(version uint64) (*proof.CommitInfo, error) {
 		// If a commit event execution is interrupted, a new iavl store's version
 		// will be larger than the RMS's metadata, when the block is replayed, we
 		// should avoid committing that iavl store again.
-		var (
-			commitID      proof.CommitID
-			latestVersion = tree.GetLatestVersion()
-		)
-		if latestVersion != 0 && latestVersion >= version {
+		var commitID proof.CommitID
+		if tree.GetLatestVersion() >= version {
 			commitID.Version = version
 			commitID.Hash = tree.Hash()
 		} else {
-			hash, version, err := tree.Commit()
+			hash, cversion, err := tree.Commit()
 			if err != nil {
 				return nil, err
 			}
+			if cversion != version {
+				return nil, fmt.Errorf("commit version %d does not match the target version %d", cversion, version)
+			}
 			commitID = proof.CommitID{
 				Version: version,
 				Hash:    hash,

store/v2/database.go

@@ -57,9 +57,6 @@ type Committer interface {
 	// GetCommitInfo returns the CommitInfo for the given version.
 	GetCommitInfo(version uint64) (*proof.CommitInfo, error)
 
-	// IsEmpty returns true if the database is empty.
-	IsEmpty() (bool, error)
-
 	// Close releases associated resources. It should NOT be idempotent. It must
 	// only be called once and any call after may panic.
 	io.Closer

store/v2/root/store.go

@@ -35,7 +35,8 @@
 	// stateCommitment reflects the state commitment (SC) backend
 	stateCommitment store.Committer
 
-	// commitHeader reflects the header used when committing state (note, this isn't required and only used for query purposes)
+	// commitHeader reflects the header used when committing state
+	// note, this isn't required and only used for query purposes)
 	commitHeader *coreheader.Info
 
 	// lastCommitInfo reflects the last version/hash that has been committed
@@ -257,6 +258,40 @@
 	s.commitHeader = h
 }
 
+// WorkingHash writes the changeset to SC and SS and returns the workingHash
+// of the CommitInfo.
+func (s *Store) WorkingHash(cs *corestore.Changeset) ([]byte, error) {
+	if s.telemetry != nil {
+		now := time.Now()
+		defer s.telemetry.MeasureSince(now, "root_store", "working_hash")
+	}
+
+	// write the changeset to the SC and SS backends
+	eg := new(errgroup.Group)
+	eg.Go(func() error {
+		if err := s.writeSC(cs); err != nil {
+			return fmt.Errorf("failed to write SC: %w", err)
+		}
+
+		return nil
+	})
+	eg.Go(func() error {
+		if err := s.stateStorage.ApplyChangeset(s.initialVersion, cs); err != nil {
+			return fmt.Errorf("failed to commit SS: %w", err)
+		}
+
+		return nil
+	})
+	if err := eg.Wait(); err != nil {
+		return nil, err
+	}
+
+	workingHash := s.lastCommitInfo.Hash()
+	s.lastCommitInfo.Version -= 1 // reset lastCommitInfo to allow Commit() to work correctly
+
+	return workingHash, nil
+}
+
 // Commit commits all state changes to the underlying SS and SC backends. It
 // writes a batch of the changeset to the SC tree, and retrieves the CommitInfo
 // from the SC tree. Finally, it commits the SC tree and returns the hash of the
@@ -388,13 +423,8 @@
 		return fmt.Errorf("failed to write batch to SC store: %w", err)
 	}
 
-	isEmpty, err := s.stateCommitment.IsEmpty()
-	if err != nil {
-		return fmt.Errorf("failed to check if SC store is empty: %w", err)
-	}
-
 	var previousHeight, version uint64
-	if isEmpty {
+	if s.lastCommitInfo.GetVersion() == 0 && s.initialVersion > 1 {
 		// This case means that no commit has been made in the store, we
 		// start from initialVersion.
 		version = s.initialVersion

store/v2/root/store_test.go

@@ -74,7 +74,38 @@ func (s *RootStoreTestSuite) TestGetStateStorage() {
 }
 
 func (s *RootStoreTestSuite) TestSetInitialVersion() {
-	s.Require().NoError(s.rootStore.SetInitialVersion(100))
+	initialVersion := uint64(5)
+	s.Require().NoError(s.rootStore.SetInitialVersion(initialVersion))
+
+	// perform the initial commit
+	cs := corestore.NewChangeset()
+	cs.Add(testStoreKeyBytes, []byte("foo"), []byte("bar"), false)
+
+	wHash, err := s.rootStore.WorkingHash(cs)
+	s.Require().NoError(err)
+	cHash, err := s.rootStore.Commit(corestore.NewChangeset())
+	s.Require().NoError(err)
+	s.Require().Equal(wHash, cHash)
+
+	// check the latest version
+	lVersion, err := s.rootStore.GetLatestVersion()
+	s.Require().NoError(err)
+	s.Require().Equal(initialVersion, lVersion)
+
+	// set the initial version again
+	rInitialVersion := uint64(100)
+	s.Require().NoError(s.rootStore.SetInitialVersion(rInitialVersion))
+
+	// perform the commit
+	cs = corestore.NewChangeset()
+	cs.Add(testStoreKey2Bytes, []byte("foo"), []byte("bar"), false)
+	_, err = s.rootStore.Commit(cs)
+	s.Require().NoError(err)
+	lVersion, err = s.rootStore.GetLatestVersion()
+	s.Require().NoError(err)
+	// SetInitialVersion only works once
+	s.Require().NotEqual(rInitialVersion, lVersion)
+	s.Require().Equal(initialVersion+1, lVersion)
 }
 
 func (s *RootStoreTestSuite) TestSetCommitHeader() {
@@ -309,3 +340,26 @@ func (s *RootStoreTestSuite) TestStateAt() {
 		}
 	}
 }
+
+func (s *RootStoreTestSuite) TestWorkingHash() {
+	// write keys over multiple versions
+	for v := uint64(1); v <= 5; v++ {
+		// perform changes
+		cs := corestore.NewChangeset()
+		for _, storeKeyBytes := range [][]byte{testStoreKeyBytes, testStoreKey2Bytes, testStoreKey3Bytes} {
+			for i := 0; i < 100; i++ {
+				key := fmt.Sprintf("key_%x_%03d", i, storeKeyBytes) // key000, key001, ..., key099
+				val := fmt.Sprintf("val%03d_%03d", i, v)            // val000_1, val001_1, ..., val099_1
+
+				cs.Add(storeKeyBytes, []byte(key), []byte(val), false)
+			}
+		}
+
+		wHash, err := s.rootStore.WorkingHash(cs)
+		s.Require().NoError(err)
+		// execute Commit with empty changeset
+		cHash, err := s.rootStore.Commit(corestore.NewChangeset())
+		s.Require().NoError(err)
+		s.Require().Equal(wHash, cHash)
+	}
+}

store/v2/store.go

@@ -49,11 +49,16 @@ type RootStore interface {
 	// queries based on block time need to be supported.
 	SetCommitHeader(h *coreheader.Info)
 
+	// WorkingHash returns the current WIP commitment hash by applying the Changeset
+	// to the SC backend. It is only used to get the hash of the intermediate state
+	// before committing, the typical use case is for the genesis block.
+	// NOTE: It also writes the changeset to the SS backend.
+	WorkingHash(cs *corestore.Changeset) ([]byte, error)
+
 	// Commit should be responsible for taking the provided changeset and flushing
-	// it to disk. Note, depending on the implementation, the changeset, at this
-	// point, may already be written to the SC backends. Commit() should ensure
-	// the changeset is committed to all SC and SC backends and flushed to disk.
-	// It must return a hash of the merkle-ized committed state.
+	// it to disk. Note, it will overwrite the changeset if WorkingHash() was called.
+	// Commit() should ensure the changeset is committed to all SC and SS backends
+	// and flushed to disk. It must return a hash of the merkle-ized committed state.
 	Commit(cs *corestore.Changeset) ([]byte, error)
 
 	// LastCommitID returns a CommitID pertaining to the last commitment.