feat: genesis custom initial for fork logic

Author: kioqq

Diff for: blocksync/reactor_test.go

@@ -72,13 +72,14 @@ func newReactor(
 	}
 
 	blockDB := dbm.NewMemDB()
-	stateDB := dbm.NewMemDB()
-	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
-		DiscardABCIResponses: false,
-	})
+	// stateDB := dbm.NewMemDB()
+	// stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+	// 	DiscardABCIResponses: false,
+	// })
 	blockStore := store.NewBlockStore(blockDB)
 
-	state, err := stateStore.LoadFromDBOrGenesisDoc(genDoc)
+	// state, err := stateStore.LoadFromDBOrGenesisDoc(genDoc)
+	state, err := sm.MakeGenesisState(genDoc)
 	if err != nil {
 		panic(fmt.Errorf("error constructing state from genesis file: %w", err))
 	}
@@ -100,7 +101,7 @@ func newReactor(
 	// pool.height is determined from the store.
 	blockSync := true
 	db := dbm.NewMemDB()
-	stateStore = sm.NewStore(db, sm.StoreOptions{
+	stateStore := sm.NewStore(db, sm.StoreOptions{
 		DiscardABCIResponses: false,
 	})
 	blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyApp.Consensus(),

Diff for: consensus/byzantine_test.go

@@ -54,7 +54,9 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 		stateStore := sm.NewStore(stateDB, sm.StoreOptions{
 			DiscardABCIResponses: false,
 		})
-		state, _ := stateStore.LoadFromDBOrGenesisDoc(genDoc)
+		state, err := sm.MakeGenesisState(genDoc)
+		require.NoError(t, err)
+		require.NoError(t, stateStore.Save(state))
 		thisConfig := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
 		defer os.RemoveAll(thisConfig.RootDir)
 		ensureDir(path.Dir(thisConfig.Consensus.WalFile()), 0o700) // dir for wal

Diff for: consensus/common_test.go

@@ -757,10 +757,11 @@ func randConsensusNet(nValidators int, testName string, tickerFunc func() Timeou
 	configRootDirs := make([]string, 0, nValidators)
 	for i := 0; i < nValidators; i++ {
 		stateDB := dbm.NewMemDB() // each state needs its own db
-		stateStore := sm.NewStore(stateDB, sm.StoreOptions{
-			DiscardABCIResponses: false,
-		})
-		state, _ := stateStore.LoadFromDBOrGenesisDoc(genDoc)
+		// stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		// 	DiscardABCIResponses: false,
+		// })
+		// state, _ := stateStore.LoadFromDBOrGenesisDoc(genDoc)
+		state, _ := sm.MakeGenesisState(genDoc)
 		thisConfig := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
 		configRootDirs = append(configRootDirs, thisConfig.RootDir)
 		for _, opt := range configOpts {
@@ -796,11 +797,12 @@ func randConsensusNetWithPeers(
 	var peer0Config *cfg.Config
 	configRootDirs := make([]string, 0, nPeers)
 	for i := 0; i < nPeers; i++ {
-		stateDB := dbm.NewMemDB() // each state needs its own db
-		stateStore := sm.NewStore(stateDB, sm.StoreOptions{
-			DiscardABCIResponses: false,
-		})
-		state, _ := stateStore.LoadFromDBOrGenesisDoc(genDoc)
+		// stateDB := dbm.NewMemDB() // each state needs its own db
+		// stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		// 	DiscardABCIResponses: false,
+		// })
+		// state, _ := stateStore.LoadFromDBOrGenesisDoc(genDoc)
+		state, _ := sm.MakeGenesisState(genDoc)
 		thisConfig := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
 		configRootDirs = append(configRootDirs, thisConfig.RootDir)
 		ensureDir(filepath.Dir(thisConfig.Consensus.WalFile()), 0o700) // dir for wal

Diff for: node/node.go

@@ -21,10 +21,11 @@ import (
 	cfg "github.com/cometbft/cometbft/config"
 	cs "github.com/cometbft/cometbft/consensus"
 	"github.com/cometbft/cometbft/crypto"
+	"github.com/cometbft/cometbft/crypto/tmhash"
 	"github.com/cometbft/cometbft/evidence"
 	"github.com/cometbft/cometbft/light"
 
-	cmtjson "github.com/cometbft/cometbft/libs/json"
+	// cmtjson "github.com/cometbft/cometbft/libs/json"
 	"github.com/cometbft/cometbft/libs/log"
 	cmtpubsub "github.com/cometbft/cometbft/libs/pubsub"
 	"github.com/cometbft/cometbft/libs/service"
@@ -247,10 +248,14 @@ func BootstrapState(ctx context.Context, config *cfg.Config, dbProvider DBProvid
 		return fmt.Errorf("state not empty, trying to initialize non empty state")
 	}
 
-	genState, _, err := LoadStateFromDBOrGenesisDocProvider(stateDB, DefaultGenesisDocProviderFunc(config))
-	if err != nil {
-		return err
-	}
+	// genState, _, err := LoadStateFromDBOrGenesisDocProvider(stateDB, DefaultGenesisDocProviderFunc(config))
+	// if err != nil {
+	// 	return err
+	// }
+
+	genDoc, _ := DefaultGenesisDocProviderFunc(config)()
+
+	genState, err := LoadStateFromDBOrGenesisDoc(stateStore, stateDB, genDoc)
 
 	stateProvider, err := statesync.NewLightClientStateProvider(
 		ctx,
@@ -873,11 +878,19 @@ func NewNodeWithContext(ctx context.Context,
 		DiscardABCIResponses: config.Storage.DiscardABCIResponses,
 	})
 
-	state, genDoc, err := LoadStateFromDBOrGenesisDocProvider(stateDB, genesisDocProvider)
+	// state, genDoc, err := LoadStateFromDBOrGenesisDocProvider(stateDB, genesisDocProvider)
+	genDoc, err := genesisDocProvider()
 	if err != nil {
 		return nil, err
 	}
 
+	err = genDoc.ValidateAndComplete()
+	if err != nil {
+		return nil, fmt.Errorf("error in genesis doc: %w", err)
+	}
+
+	state, err := LoadStateFromDBOrGenesisDoc(stateStore, stateDB, genDoc)
+
 	csMetrics, p2pMetrics, memplMetrics, smMetrics, abciMetrics := metricsProvider(genDoc.ChainID)
 
 	// Create the proxyApp and establish connections to the ABCI app (consensus, mempool, query).
@@ -1540,68 +1553,94 @@ func makeNodeInfo(
 
 //------------------------------------------------------------------------------
 
-var genesisDocKey = []byte("genesisDoc")
+var genesisDocHashKey = []byte("genesisDocHash")
 
-// LoadStateFromDBOrGenesisDocProvider attempts to load the state from the
+// LoadStateFromDBOrGenesisDoc attempts to load the state from the
 // database, or creates one using the given genesisDocProvider. On success this also
 // returns the genesis doc loaded through the given provider.
-func LoadStateFromDBOrGenesisDocProvider(
+func LoadStateFromDBOrGenesisDoc(
+	stateStore sm.Store,
 	stateDB dbm.DB,
-	genesisDocProvider GenesisDocProvider,
-) (sm.State, *types.GenesisDoc, error) {
-	// Get genesis doc
-	genDoc, err := loadGenesisDoc(stateDB)
-	if err != nil {
-		genDoc, err = genesisDocProvider()
-		if err != nil {
-			return sm.State{}, nil, err
-		}
-		// save genesis doc to prevent a certain class of user errors (e.g. when it
-		// was changed, accidentally or not). Also good for audit trail.
-		if err := saveGenesisDoc(stateDB, genDoc); err != nil {
-			return sm.State{}, nil, err
-		}
-	}
-	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
-		DiscardABCIResponses: false,
-	})
-	state, err := stateStore.LoadFromDBOrGenesisDoc(genDoc)
+	genDoc *types.GenesisDoc,
+) (sm.State, error) {
+	// 1. Verify genesisDoc hash in db if exists
+	genDocHash, err := stateDB.Get(genesisDocHashKey)
 	if err != nil {
-		return sm.State{}, nil, err
+		return sm.State{}, err
 	}
-	return state, genDoc, nil
-}
 
-// panics if failed to unmarshal bytes
-func loadGenesisDoc(db dbm.DB) (*types.GenesisDoc, error) {
-	b, err := db.Get(genesisDocKey)
-	if err != nil {
-		panic(err)
-	}
-	if len(b) == 0 {
-		return nil, errors.New("genesis doc not found")
-	}
-	var genDoc *types.GenesisDoc
-	err = cmtjson.Unmarshal(b, &genDoc)
-	if err != nil {
-		panic(fmt.Sprintf("Failed to load genesis doc due to unmarshaling error: %v (bytes: %X)", err, b))
+	validatorsHash := genDoc.ValidatorHash()
+
+	incomingGenDocHash := tmhash.Sum(validatorsHash)
+
+	fmt.Println("Loaded genesis doc", "chain_id", genDoc.ChainID, "app_hash", genDoc.AppHash)
+	fmt.Println("incomingGenDocHash: ", incomingGenDocHash)
+	fmt.Println("genDocHash: ", genDocHash)
+
+	if len(genDocHash) != 0 && !bytes.Equal(genDocHash, incomingGenDocHash) {
+		return sm.State{}, fmt.Errorf("genesis doc hash in db does not match loaded genesis doc")
 	}
-	return genDoc, nil
-}
 
-// panics if failed to marshal the given genesis document
-func saveGenesisDoc(db dbm.DB, genDoc *types.GenesisDoc) error {
-	b, err := cmtjson.Marshal(genDoc)
+	// 2. Attempt to load state form the database
+	state, err := stateStore.Load()
 	if err != nil {
-		return fmt.Errorf("failed to save genesis doc due to marshaling error: %w", err)
+		return sm.State{}, err
 	}
-	if err := db.SetSync(genesisDocKey, b); err != nil {
-		return err
+
+	if state.IsEmpty() {
+		// 3. If it's not there, derive it from the genesis doc
+		state, err = sm.MakeGenesisState(genDoc)
+		if err != nil {
+			return sm.State{}, err
+		}
+
+		// 4. save the gensis document to the state store so
+		// its fetchable by other callers.
+		if err := stateStore.Save(state); err != nil {
+			return sm.State{}, err
+		}
+
+		// 5. Save the genDoc hash in the store if it doesn't already exist for future verification
+		if len(genDocHash) == 0 {
+			if err := stateDB.SetSync(genesisDocHashKey, incomingGenDocHash); err != nil {
+				return sm.State{}, fmt.Errorf("failed to save genesis doc hash to db: %w", err)
+			}
+		}
 	}
 
-	return nil
+	return state, nil
 }
 
+// // panics if failed to unmarshal bytes
+// func loadGenesisDoc(db dbm.DB) (*types.GenesisDoc, error) {
+// 	b, err := db.Get(genesisDocKey)
+// 	if err != nil {
+// 		panic(err)
+// 	}
+// 	if len(b) == 0 {
+// 		return nil, errors.New("genesis doc not found")
+// 	}
+// 	var genDoc *types.GenesisDoc
+// 	err = cmtjson.Unmarshal(b, &genDoc)
+// 	if err != nil {
+// 		panic(fmt.Sprintf("Failed to load genesis doc due to unmarshaling error: %v (bytes: %X)", err, b))
+// 	}
+// 	return genDoc, nil
+// }
+
+// // panics if failed to marshal the given genesis document
+// func saveGenesisDoc(db dbm.DB, genDoc *types.GenesisDoc) error {
+// 	b, err := cmtjson.Marshal(genDoc)
+// 	if err != nil {
+// 		return fmt.Errorf("failed to save genesis doc due to marshaling error: %w", err)
+// 	}
+// 	if err := db.SetSync(genesisDocKey, b); err != nil {
+// 		return err
+// 	}
+
+// 	return nil
+// }
+
 func createAndStartPrivValidatorSocketClient(
 	listenAddr,
 	chainID string,

Diff for: state/state_test.go

@@ -32,7 +32,7 @@ func setupTestCase(t *testing.T) (func(t *testing.T), dbm.DB, sm.State) {
 		DiscardABCIResponses: false,
 	})
 	require.NoError(t, err)
-	state, err := stateStore.LoadFromDBOrGenesisFile(config.GenesisFile())
+	state, err := sm.MakeGenesisStateFromFile(config.GenesisFile())
 	assert.NoError(t, err, "expected no error on LoadStateFromDBOrGenesisFile")
 	err = stateStore.Save(state)
 	require.NoError(t, err)

Diff for: state/store.go

@@ -51,12 +51,12 @@ var offlineStateSyncHeight = []byte("offlineStateSyncHeightKey")
 // It is used to retrieve current state and save and load ABCI responses,
 // validators and consensus parameters
 type Store interface {
-	// LoadFromDBOrGenesisFile loads the most recent state.
-	// If the chain is new it will use the genesis file from the provided genesis file path as the current state.
-	LoadFromDBOrGenesisFile(string) (State, error)
-	// LoadFromDBOrGenesisDoc loads the most recent state.
-	// If the chain is new it will use the genesis doc as the current state.
-	LoadFromDBOrGenesisDoc(*types.GenesisDoc) (State, error)
+	// // LoadFromDBOrGenesisFile loads the most recent state.
+	// // If the chain is new it will use the genesis file from the provided genesis file path as the current state.
+	// LoadFromDBOrGenesisFile(string) (State, error)
+	// // LoadFromDBOrGenesisDoc loads the most recent state.
+	// // If the chain is new it will use the genesis doc as the current state.
+	// LoadFromDBOrGenesisDoc(*types.GenesisDoc) (State, error)
 	// Load loads the current state of the blockchain
 	Load() (State, error)
 	// LoadValidators loads the validator set at a given height

Diff for: state/store_test.go

@@ -56,7 +56,7 @@ func BenchmarkLoadValidators(b *testing.B) {
 	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
 		DiscardABCIResponses: false,
 	})
-	state, err := stateStore.LoadFromDBOrGenesisFile(config.GenesisFile())
+	state, err := sm.MakeGenesisStateFromFile(config.GenesisFile())
 	if err != nil {
 		b.Fatal(err)
 	}