feat!: bootstrap comet cmd for local state sync (backport #16061)

CHANGELOG.md

@@ -41,7 +41,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 
 * (server) [#15984](https://github.com/cosmos/cosmos-sdk/pull/15984) Use `cosmossdk.io/log` package for logging instead of CometBFT logger. NOTE: v0.45 and v0.46 were not using CometBFT logger either. This keeps the same underlying logger (zerolog) as in v0.45.x+ and v0.46.x+ but now properly supporting filtered logging.
 * (gov) [#15979](https://github.com/cosmos/cosmos-sdk/pull/15979) Improve gov error message when failing to convert v1 proposal to v1beta1.
-
+* (server) [#16061](https://github.com/cosmos/cosmos-sdk/pull/16061) add comet bootstrap command
 ### Bug Fixes
 
 * (x/group) [#16017](https://github.com/cosmos/cosmos-sdk/pull/16017) Correctly apply account number in group v2 migration.

docs/docs/run-node/01-run-node.md

@@ -149,3 +149,15 @@ In config.toml:
 ```toml
 log_level: "state:info,p2p:info,consensus:info,x/staking:info,x/ibc:info,*error"
 ```
+
+## State Sync
+
+State sync is the act in which a node syncs the latest or close to the latest state of a blockchain. This is useful for users who don't want to sync all the blocks in history. You can read more here: https://docs.cometbft.com/v0.37/core/state-sync
+
+### Local State Sync
+
+Local state sync work similar to normal state sync except that it works off a local snapshot of state instead of one provided via the p2p network. The steps to start local state sync are similar to normal state sync with a few different designs. 
+
+1. As mentioned in https://docs.cometbft.com/v0.37/core/state-sync, one must set a height and hash in the config.toml along with a few rpc servers (the afromentioned link has instructions on how to do this). 
+2. Bootsrapping Comet state in order to start the node after the snapshot has been ingested. This can be done with the bootstrap command `<app> comet bootstrap-state`
+<!-- 3. TODO after https://github.com/cosmos/cosmos-sdk/pull/16060 is merged -->

server/cmt_cmds.go

@@ -0,0 +1,349 @@
+package server
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"cosmossdk.io/log"
+	"github.com/cometbft/cometbft/light"
+	"github.com/cometbft/cometbft/node"
+	"github.com/cometbft/cometbft/p2p"
+	pvm "github.com/cometbft/cometbft/privval"
+	cmtstore "github.com/cometbft/cometbft/proto/tendermint/store"
+	sm "github.com/cometbft/cometbft/state"
+	"github.com/cometbft/cometbft/statesync"
+	"github.com/cometbft/cometbft/store"
+	cmtversion "github.com/cometbft/cometbft/version"
+	"github.com/spf13/cobra"
+	"sigs.k8s.io/yaml"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	rpc "github.com/cosmos/cosmos-sdk/client/rpc"
+	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
+	servercmtlog "github.com/cosmos/cosmos-sdk/server/log"
+	"github.com/cosmos/cosmos-sdk/server/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/query"
+	"github.com/cosmos/cosmos-sdk/version"
+	auth "github.com/cosmos/cosmos-sdk/x/auth/client/cli"
+)
+
+// ShowNodeIDCmd - ported from CometBFT, dump node ID to stdout
+func ShowNodeIDCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "show-node-id",
+		Short: "Show this node's ID",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			serverCtx := GetServerContextFromCmd(cmd)
+			cfg := serverCtx.Config
+
+			nodeKey, err := p2p.LoadNodeKey(cfg.NodeKeyFile())
+			if err != nil {
+				return err
+			}
+
+			fmt.Println(nodeKey.ID())
+			return nil
+		},
+	}
+}
+
+// ShowValidatorCmd - ported from CometBFT, show this node's validator info
+func ShowValidatorCmd() *cobra.Command {
+	cmd := cobra.Command{
+		Use:   "show-validator",
+		Short: "Show this node's CometBFT validator info",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			serverCtx := GetServerContextFromCmd(cmd)
+			cfg := serverCtx.Config
+
+			privValidator := pvm.LoadFilePV(cfg.PrivValidatorKeyFile(), cfg.PrivValidatorStateFile())
+			pk, err := privValidator.GetPubKey()
+			if err != nil {
+				return err
+			}
+
+			sdkPK, err := cryptocodec.FromCmtPubKeyInterface(pk)
+			if err != nil {
+				return err
+			}
+
+			clientCtx := client.GetClientContextFromCmd(cmd)
+			bz, err := clientCtx.Codec.MarshalInterfaceJSON(sdkPK)
+			if err != nil {
+				return err
+			}
+
+			fmt.Println(string(bz))
+			return nil
+		},
+	}
+
+	return &cmd
+}
+
+// ShowAddressCmd - show this node's validator address
+func ShowAddressCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "show-address",
+		Short: "Shows this node's CometBFT validator consensus address",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			serverCtx := GetServerContextFromCmd(cmd)
+			cfg := serverCtx.Config
+
+			privValidator := pvm.LoadFilePV(cfg.PrivValidatorKeyFile(), cfg.PrivValidatorStateFile())
+
+			valConsAddr := (sdk.ConsAddress)(privValidator.GetAddress())
+			fmt.Println(valConsAddr.String())
+			return nil
+		},
+	}
+
+	return cmd
+}
+
+// VersionCmd prints CometBFT and ABCI version numbers.
+func VersionCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "version",
+		Short: "Print CometBFT libraries' version",
+		Long:  "Print protocols' and libraries' version numbers against which this app has been compiled.",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			bs, err := yaml.Marshal(&struct {
+				CometBFT      string
+				ABCI          string
+				BlockProtocol uint64
+				P2PProtocol   uint64
+			}{
+				CometBFT:      cmtversion.TMCoreSemVer,
+				ABCI:          cmtversion.ABCIVersion,
+				BlockProtocol: cmtversion.BlockProtocol,
+				P2PProtocol:   cmtversion.P2PProtocol,
+			})
+			if err != nil {
+				return err
+			}
+
+			cmd.Print(string(bs))
+			return nil
+		},
+	}
+}
+
+// QueryBlocksCmd returns a command to search through blocks by events.
+func QueryBlocksCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "blocks",
+		Short: "Query for paginated blocks that match a set of events",
+		Long: `Search for blocks that match the exact given events where results are paginated.
+The events query is directly passed to CometBFT's RPC BlockSearch method and must
+conform to CometBFT's query syntax.
+Please refer to each module's documentation for the full set of events to query
+for. Each module documents its respective events under 'xx_events.md'.
+`,
+		Example: fmt.Sprintf(
+			"$ %s query blocks --query \"message.sender='cosmos1...' AND block.height > 7\" --page 1 --limit 30 --order-by ASC",
+			version.AppName,
+		),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+			query, _ := cmd.Flags().GetString(auth.FlagQuery)
+			page, _ := cmd.Flags().GetInt(flags.FlagPage)
+			limit, _ := cmd.Flags().GetInt(flags.FlagLimit)
+			orderBy, _ := cmd.Flags().GetString(auth.FlagOrderBy)
+
+			blocks, err := rpc.QueryBlocks(clientCtx, page, limit, query, orderBy)
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(blocks)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	cmd.Flags().Int(flags.FlagPage, query.DefaultPage, "Query a specific page of paginated results")
+	cmd.Flags().Int(flags.FlagLimit, query.DefaultLimit, "Query number of transactions results per page returned")
+	cmd.Flags().String(auth.FlagQuery, "", "The blocks events query per CometBFT's query semantics")
+	cmd.Flags().String(auth.FlagOrderBy, "", "The ordering semantics (asc|dsc)")
+	_ = cmd.MarkFlagRequired(auth.FlagQuery)
+
+	return cmd
+}
+
+// QueryBlockCmd implements the default command for a Block query.
+func QueryBlockCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "block --type=[height|hash] [height|hash]",
+		Short: "Query for a committed block by height, hash, or event(s)",
+		Long:  "Query for a specific committed block using the CometBFT RPC `block` and `block_by_hash` method",
+		Example: strings.TrimSpace(fmt.Sprintf(`
+$ %s query block --%s=%s <height>
+$ %s query block --%s=%s <hash>
+`,
+			version.AppName, auth.FlagType, auth.TypeHeight,
+			version.AppName, auth.FlagType, auth.TypeHash)),
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			typ, _ := cmd.Flags().GetString(auth.FlagType)
+
+			switch typ {
+			case auth.TypeHeight:
+
+				if args[0] == "" {
+					return fmt.Errorf("argument should be a block height")
+				}
+
+				var height *int64
+
+				// optional height
+				if len(args) > 0 {
+					h, err := strconv.Atoi(args[0])
+					if err != nil {
+						return err
+					}
+					if h > 0 {
+						tmp := int64(h)
+						height = &tmp
+					}
+				}
+
+				output, err := rpc.GetBlockByHeight(clientCtx, height)
+				if err != nil {
+					return err
+				}
+
+				if output.Header.Height == 0 {
+					return fmt.Errorf("no block found with height %s", args[0])
+				}
+
+				return clientCtx.PrintProto(output)
+
+			case auth.TypeHash:
+
+				if args[0] == "" {
+					return fmt.Errorf("argument should be a tx hash")
+				}
+
+				// If hash is given, then query the tx by hash.
+				output, err := rpc.GetBlockByHash(clientCtx, args[0])
+				if err != nil {
+					return err
+				}
+
+				if output.Header.AppHash == nil {
+					return fmt.Errorf("no block found with hash %s", args[0])
+				}
+
+				return clientCtx.PrintProto(output)
+
+			default:
+				return fmt.Errorf("unknown --%s value %s", auth.FlagType, typ)
+			}
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	cmd.Flags().String(auth.FlagType, auth.TypeHash, fmt.Sprintf("The type to be used when querying tx, can be one of \"%s\", \"%s\"", auth.TypeHeight, auth.TypeHash))
+
+	return cmd
+}
+
+func BootstrapStateCmd(appCreator types.AppCreator) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "bootstrap-state",
+		Short: "Bootstrap CometBFT state at an arbitrary block height using a light client",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			serverCtx := GetServerContextFromCmd(cmd)
+			logger := log.NewLogger(cmd.OutOrStdout())
+			cfg := serverCtx.Config
+
+			height, err := cmd.Flags().GetInt64("height")
+			if err != nil {
+				return err
+			}
+			if height == 0 {
+				home := serverCtx.Viper.GetString(flags.FlagHome)
+				db, err := openDB(home, GetAppDBBackend(serverCtx.Viper))
+				if err != nil {
+					return err
+				}
+
+				app := appCreator(logger, db, nil, serverCtx.Viper)
+				height = app.CommitMultiStore().LastCommitID().Version
+			}
+
+			blockStoreDB, err := node.DefaultDBProvider(&node.DBContext{ID: "blockstore", Config: cfg})
+			if err != nil {
+				return err
+			}
+			blockStore := store.NewBlockStore(blockStoreDB)
+
+			stateDB, err := node.DefaultDBProvider(&node.DBContext{ID: "state", Config: cfg})
+			if err != nil {
+				return err
+			}
+			stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+				DiscardABCIResponses: cfg.Storage.DiscardABCIResponses,
+			})
+
+			genState, _, err := node.LoadStateFromDBOrGenesisDocProvider(stateDB, node.DefaultGenesisDocProviderFunc(cfg))
+			if err != nil {
+				return err
+			}
+
+			stateProvider, err := statesync.NewLightClientStateProvider(
+				cmd.Context(),
+				genState.ChainID, genState.Version, genState.InitialHeight,
+				cfg.StateSync.RPCServers, light.TrustOptions{
+					Period: cfg.StateSync.TrustPeriod,
+					Height: cfg.StateSync.TrustHeight,
+					Hash:   cfg.StateSync.TrustHashBytes(),
+				}, servercmtlog.CometLoggerWrapper{Logger: logger.With("module", "light")})
+			if err != nil {
+				return fmt.Errorf("failed to set up light client state provider: %w", err)
+			}
+
+			state, err := stateProvider.State(cmd.Context(), uint64(height))
+			if err != nil {
+				return fmt.Errorf("failed to get state: %w", err)
+			}
+
+			commit, err := stateProvider.Commit(cmd.Context(), uint64(height))
+			if err != nil {
+				return fmt.Errorf("failed to get commit: %w", err)
+			}
+
+			if err := stateStore.Bootstrap(state); err != nil {
+				return fmt.Errorf("failed to bootstrap state: %w", err)
+			}
+
+			if err := blockStore.SaveSeenCommit(state.LastBlockHeight, commit); err != nil {
+				return fmt.Errorf("failed to save seen commit: %w", err)
+			}
+
+			store.SaveBlockStoreState(&cmtstore.BlockStoreState{
+				// it breaks the invariant that blocks in range [Base, Height] must exists, but it do works in practice.
+				Base:   state.LastBlockHeight,
+				Height: state.LastBlockHeight,
+			}, blockStoreDB)
+
+			return nil
+		},
+	}
+
+	cmd.Flags().Int64("height", 0, "Block height to bootstrap state at, if not provided will use the latest block height in app state")
+
+	return cmd
+}

server/util.go

@@ -304,8 +304,14 @@ func AddCommands(rootCmd *cobra.Command, defaultNodeHome string, appCreator type
 		ShowValidatorCmd(),
 		ShowAddressCmd(),
 		VersionCmd(),
+<<<<<<< HEAD
 		tmcmd.ResetAllCmd,
 		tmcmd.ResetStateCmd,
+=======
+		cmtcmd.ResetAllCmd,
+		cmtcmd.ResetStateCmd,
+		BootstrapStateCmd(appCreator),
+>>>>>>> 25df90d0f (feat!: bootstrap comet cmd for local state sync  (#16061))
 	)
 
 	startCmd := StartCmd(appCreator, defaultNodeHome)