fix(snapshot): capture DB latest before LoadVersion in loadAndTruncate (PLA-132) (#91)

LoadVersion(n) sets lastCommitInfo.Version=n, causing LatestVersion() to return
n regardless of what is in the DB. Reading LatestVersion() after LoadVersion
made the rollback guard permanently false, so RollbackToVersion was never called.

Fix: capture CommitMultiStore().LatestVersion() before LoadVersion, when
lastCommitInfo is nil and rootmulti falls through to GetLatestVersion(db).

Author: qj0r9j0vc2

run/prune_test.go

@@ -5,15 +5,99 @@ package run
 import (
 	"testing"
 
+	storetypes "cosmossdk.io/store/types"
+	abci "github.com/cometbft/cometbft/abci/types"
 	cmttypes "github.com/cometbft/cometbft/types"
 	dbm "github.com/cosmos/cosmos-db"
 	"github.com/cosmos/cosmos-sdk/client"
 	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
 	"github.com/stretchr/testify/require"
 
+	"github.com/altuslabsxyz/blockstm-sim/compare"
 	"github.com/altuslabsxyz/blockstm-sim/sdkhook"
 )
 
+// stubCMS is a minimal CommitMultiStore for testing loadAndTruncate in isolation.
+// It simulates the rootmulti behaviour where LatestVersion() reads from the DB
+// (dbLatest) before LoadVersion is called, and from lastCommitInfo (loaded) after.
+type stubCMS struct {
+	storetypes.CommitMultiStore
+	dbLatest   int64 // returned before loadCalled; simulates GetLatestVersion(db)
+	loaded     int64 // returned after loadCalled; simulates lastCommitInfo.Version
+	loadCalled bool
+	rolledBack int64 // last RollbackToVersion target, 0 if never called
+}
+
+func (s *stubCMS) LatestVersion() int64 {
+	if !s.loadCalled {
+		return s.dbLatest
+	}
+	return s.loaded
+}
+
+func (s *stubCMS) RollbackToVersion(version int64) error {
+	s.rolledBack = version
+	s.loaded = version
+	return nil
+}
+
+// stubApp implements sdkhook.App using stubCMS.
+// Only CommitMultiStore and LoadVersion are used by loadAndTruncate.
+type stubApp struct{ cms *stubCMS }
+
+func (a *stubApp) CommitMultiStore() storetypes.CommitMultiStore { return a.cms }
+func (a *stubApp) LoadVersion(v int64) error {
+	a.cms.loadCalled = true
+	a.cms.loaded = v
+	return nil
+}
+func (a *stubApp) FinalizeBlock(*abci.RequestFinalizeBlock) (*abci.ResponseFinalizeBlock, error) {
+	panic("not used")
+}
+func (a *stubApp) Commit() (*abci.ResponseCommit, error)           { panic("not used") }
+func (a *stubApp) SetLifecycleObserver(compare.LifecycleObserver)  {}
+func (a *stubApp) SetBlockSTMTxRunner(sdkhook.STMRunner)           {}
+func (a *stubApp) UnsetBlockSTMTxRunner()                          {}
+func (a *stubApp) SetDisableBlockGasMeter(bool)                    {}
+func (a *stubApp) GetStoreKeys() []storetypes.StoreKey             { return nil }
+
+// TestLoadAndTruncate_RollsBackWhenDBAboveTarget is the regression test for
+// the bug where LoadVersion(n) sets LatestVersion()=n, causing the
+// `LatestVersion() > n` guard to always be false and skipping RollbackToVersion.
+func TestLoadAndTruncate_RollsBackWhenDBAboveTarget(t *testing.T) {
+	// DB has version 100 (production node committed up to 100).
+	// Target is version 50 (we want to truncate to 50).
+	// Before fix: LoadVersion(50) → LatestVersion()=50 → 50>50=false → no rollback.
+	// After fix:  dbLatest=100 captured before LoadVersion → 100>50 → rollback.
+	cms := &stubCMS{dbLatest: 100}
+	app := &stubApp{cms: cms}
+
+	require.NoError(t, loadAndTruncate(app, 50))
+
+	require.Equal(t, int64(50), cms.rolledBack, "RollbackToVersion must be called with target version")
+	require.Equal(t, int64(50), cms.LatestVersion())
+}
+
+func TestLoadAndTruncate_SkipsRollbackWhenAlreadyAtTarget(t *testing.T) {
+	// DB is pre-pruned: dbLatest already equals loadVersion.
+	cms := &stubCMS{dbLatest: 50}
+	app := &stubApp{cms: cms}
+
+	require.NoError(t, loadAndTruncate(app, 50))
+
+	require.Equal(t, int64(0), cms.rolledBack, "RollbackToVersion must NOT be called when DB is already at target")
+}
+
+func TestLoadAndTruncate_SkipsRollbackForZeroVersion(t *testing.T) {
+	// loadVersion=0 (meta.Start==1 case); rootmulti rejects RollbackToVersion(0).
+	cms := &stubCMS{dbLatest: 0}
+	app := &stubApp{cms: cms}
+
+	require.NoError(t, loadAndTruncate(app, 0))
+
+	require.Equal(t, int64(0), cms.rolledBack)
+}
+
 // testPruneFactory returns an AppFactory suitable for PruneSnapshot calls in
 // tests. Full round-trip pruning behaviour (bootstrap → prune → reload) is
 // exercised by chain-side integration tests against real `blockstm-sim extract`

run/snapshot_executor.go

@@ -189,15 +189,21 @@ func (e *SnapshotExecutor) InitFromState(snapshotDir string, meta compare.RangeM
 // the latest version (which is now loadVersion, since everything above it
 // has been deleted).
 func loadAndTruncate(app sdkhook.App, loadVersion int64) error {
+	// Capture the actual DB-committed latest version BEFORE calling LoadVersion.
+	// rootmulti.Store.LatestVersion() reads lastCommitInfo.Version, but when
+	// lastCommitInfo is nil (pre-load) it falls through to GetLatestVersion(db)
+	// — the true on-disk latest. After LoadVersion(n), lastCommitInfo.Version
+	// is set to n regardless of what else is in the DB, so reading here would
+	// always return n and make the rollback guard below permanently false.
+	dbLatest := app.CommitMultiStore().LatestVersion()
+
 	if err := app.LoadVersion(loadVersion); err != nil {
 		return fmt.Errorf("LoadVersion: %w", err)
 	}
 	// rootmulti.Store.RollbackToVersion rejects target <= 0. When loadVersion
 	// is 0 (meta.Start == 1) there is nothing above to prune anyway, so skip.
-	// Also skip when the store's latest committed version already equals
-	// loadVersion — the DB has been pre-pruned (e.g. by PruneSnapshot) and
-	// RollbackToVersion would be a no-op scan.
-	if loadVersion > 0 && app.CommitMultiStore().LatestVersion() > loadVersion {
+	// Also skip when the DB was already at loadVersion (pre-pruned by PruneSnapshot).
+	if loadVersion > 0 && dbLatest > loadVersion {
 		if err := app.CommitMultiStore().RollbackToVersion(loadVersion); err != nil {
 			return fmt.Errorf("RollbackToVersion: %w", err)
 		}