testnet forr onomy

baseapp/options.go

@@ -88,6 +88,11 @@ func SetSnapshotStore(snapshotStore *snapshots.Store) func(*BaseApp) {
  return func(app *BaseApp) { app.SetSnapshotStore(snapshotStore) }
 }
 
+// SetStoreLoader allows us to customize the rootMultiStore initialization.
+func SetStoreLoader(loader StoreLoader) func(*BaseApp) {
+ return func(app *BaseApp) { app.SetStoreLoader(loader) }
+}
+
 func (app *BaseApp) SetName(name string) {
  if app.sealed {
  panic("SetName() on sealed BaseApp")

server/start.go

@@ -3,10 +3,13 @@ package server
 // DONTCOVER
 
 import (
+ "bufio"
  "fmt"
+ "io"
  "net/http"
  "os"
  "runtime/pprof"
+ "strings"
  "time"
 
  "github.com/spf13/cobra"
@@ -20,6 +23,16 @@ import (
  "github.com/tendermint/tendermint/rpc/client/local"
  "google.golang.org/grpc"
 
+ "github.com/cosmos/cosmos-sdk/x/genutil"
+ // cmtcfg "github.com/tendermint/tendermint/config"
+ cmtjson "github.com/tendermint/tendermint/libs/json"
+ cmtstate "github.com/tendermint/tendermint/proto/tendermint/state"
+ cmtproto "github.com/tendermint/tendermint/proto/tendermint/types"
+ sm "github.com/tendermint/tendermint/state"
+ "github.com/tendermint/tendermint/store"
+ cmttypes "github.com/tendermint/tendermint/types"
+ db "github.com/tendermint/tm-db"
+
  "github.com/cosmos/cosmos-sdk/client"
  "github.com/cosmos/cosmos-sdk/client/flags"
  "github.com/cosmos/cosmos-sdk/codec"
@@ -66,6 +79,17 @@ const (
  flagGRPCAddress = "grpc.address"
  flagGRPCWebEnable = "grpc-web.enable"
  flagGRPCWebAddress = "grpc-web.address"
+
+ FlagIAVLLazyLoading = "iavl-lazy-loading"
+ FlagIAVLFastNodeModuleWhitelist = "iavl-fastnode-module-whitelist"
+
+ // testnet keys
+ KeyIsTestnet = "is-testnet"
+ KeyNewChainID = "new-chain-ID"
+ KeyNewOpAddr = "new-operator-addr"
+ KeyNewValAddr = "new-validator-addr"
+ KeyUserPubKey = "user-pub-key"
+ KeyTriggerTestnetUpgrade = "trigger-testnet-upgrade"
 )
 
 // StartCmd runs the service passed in, either stand-alone or in-process with
@@ -135,7 +159,13 @@ is performed. Note, when enabled, gRPC will also be automatically enabled.
  return nil
  },
  }
+ addStartNodeFlags(cmd, defaultNodeHome)
+ // add support for all Tendermint-specific command line options
+ tcmd.AddNodeFlags(cmd)
+ return cmd
+}
 
+func addStartNodeFlags(cmd *cobra.Command, defaultNodeHome string) {
  cmd.Flags().String(flags.FlagHome, defaultNodeHome, "The application home directory")
  cmd.Flags().Bool(flagWithTendermint, true, "Run abci app embedded in-process with tendermint")
  cmd.Flags().String(flagAddress, "tcp://0.0.0.0:26658", "Listen address")
@@ -166,10 +196,6 @@ is performed. Note, when enabled, gRPC will also be automatically enabled.
  cmd.Flags().Uint32(FlagStateSyncSnapshotKeepRecent, 2, "State sync snapshot to keep")
 
  cmd.Flags().Bool(FlagDisableIAVLFastNode, true, "Disable fast node for IAVL tree")
-
- // add support for all Tendermint-specific command line options
- tcmd.AddNodeFlags(cmd)
- return cmd
 }
 
 func startStandAlone(ctx *Context, appCreator types.AppCreator) error {
@@ -257,7 +283,16 @@ func startInProcess(ctx *Context, clientCtx client.Context, appCreator types.App
  "(SDK v0.45). Please explicitly put the desired minimum-gas-prices in your app.toml.")
  }
 
- app := appCreator(ctx.Logger, db, traceWriter, ctx.Viper)
+ var app types.Application
+
+ if isTestnet, ok := ctx.Viper.Get(KeyIsTestnet).(bool); ok && isTestnet {
+ app, err = testnetify(ctx, appCreator, db, traceWriter)
+ if err != nil {
+ return err
+ }
+ } else {
+ app = appCreator(ctx.Logger, db, traceWriter, ctx.Viper)
+ }
 
  nodeKey, err := p2p.LoadOrGenNodeKey(cfg.NodeKeyFile())
  if err != nil {
@@ -433,3 +468,290 @@ func startInProcess(ctx *Context, clientCtx client.Context, appCreator types.App
  // wait for signal capture and gracefully return
  return WaitForQuitSignals()
 }
+
+// InPlaceTestnetCreator utilizes the provided chainID and operatorAddress as well as the local private validator key to
+// control the network represented in the data folder. This is useful to create testnets nearly identical to your
+// mainnet environment.
+func InPlaceTestnetCreator(testnetAppCreator types.AppCreator, defaultNodeHome string) *cobra.Command {
+ cmd := &cobra.Command{
+ Use: "in-place-testnet [newChainID] [newOperatorAddress]",
+ Short: "Create and start a testnet from current local state",
+ Long: `Create and start a testnet from current local state.
+After utilizing this command the network will start. If the network is stopped,
+the normal "start" command should be used. Re-using this command on state that
+has already been modified by this command could result in unexpected behavior.
+Additionally, the first block may take up to one minute to be committed, depending
+on how old the block is. For instance, if a snapshot was taken weeks ago and we want
+to turn this into a testnet, it is possible lots of pending state needs to be committed
+(expiring locks, etc.). It is recommended that you should wait for this block to be committed
+before stopping the daemon.
+If the --trigger-testnet-upgrade flag is set, the upgrade handler specified by the flag will be run
+on the first block of the testnet.
+Regardless of whether the flag is set or not, if any new stores are introduced in the daemon being run,
+those stores will be registered in order to prevent panics. Therefore, you only need to set the flag if
+you want to test the upgrade handler itself.
+`,
+ Example: "in-place-testnet localosmosis osmo12smx2wdlyttvyzvzg54y2vnqwq2qjateuf7thj",
+ Args: cobra.ExactArgs(2),
+ PreRunE: func(cmd *cobra.Command, _ []string) error {
+ serverCtx := GetServerContextFromCmd(cmd)
+
+ if err := serverCtx.Viper.BindPFlags(cmd.Flags()); err != nil {
+ return err
+ }
+
+ _, err := GetPruningOptionsFromFlags(serverCtx.Viper)
+ return err
+ },
+ RunE: func(cmd *cobra.Command, args []string) error {
+ serverCtx := GetServerContextFromCmd(cmd)
+ clientCtx, err := client.GetClientQueryContext(cmd)
+ if err != nil {
+ return err
+ }
+
+ newChainID := args[0]
+ newOperatorAddress := args[1]
+
+ skipConfirmation, _ := cmd.Flags().GetBool("skip-confirmation")
+
+ if !skipConfirmation {
+ // Confirmation prompt to prevent accidental modification of state.
+ reader := bufio.NewReader(os.Stdin)
+ fmt.Println("This operation will modify state in your data folder and cannot be undone. Do you want to continue? (y/n)")
+ text, _ := reader.ReadString('\n')
+ response := strings.TrimSpace(strings.ToLower(text))
+ if response != "y" && response != "yes" {
+ fmt.Println("Operation canceled.")
+ return nil
+ }
+ }
+
+ serverCtx.Viper.Set(KeyIsTestnet, true)
+ serverCtx.Viper.Set(KeyNewChainID, newChainID)
+ serverCtx.Viper.Set(KeyNewOpAddr, newOperatorAddress)
+
+ return startInProcess(serverCtx, clientCtx, testnetAppCreator)
+ },
+ }
+
+ addStartNodeFlags(cmd, defaultNodeHome)
+ cmd.Flags().String(KeyTriggerTestnetUpgrade, "", "If set (example: \"v21\"), triggers the v21 upgrade handler to run on the first block of the testnet")
+ cmd.Flags().Bool("skip-confirmation", false, "Skip the confirmation prompt")
+ return cmd
+}
+
+// testnetify modifies both state and blockStore, allowing the provided operator address and local validator key to control the network
+// that the state in the data folder represents. The chainID of the local genesis file is modified to match the provided chainID.
+func testnetify(ctx *Context, testnetAppCreator types.AppCreator, db db.DB, traceWriter io.Writer) (types.Application, error) {
+ config := ctx.Config
+
+ newChainID, ok := ctx.Viper.Get(KeyNewChainID).(string)
+ if !ok {
+ return nil, fmt.Errorf("expected string for key %s", KeyNewChainID)
+ }
+
+ genDocProvider := node.DefaultGenesisDocProviderFunc(config)
+
+ // Initialize blockStore and stateDB.
+ blockStoreDB, err := node.DefaultDBProvider(&node.DBContext{ID: "blockstore", Config: config})
+ if err != nil {
+ return nil, err
+ }
+ blockStore := store.NewBlockStore(blockStoreDB)
+
+ stateDB, err := node.DefaultDBProvider(&node.DBContext{ID: "state", Config: config})
+ if err != nil {
+ return nil, err
+ }
+
+ defer blockStore.Close()
+ defer stateDB.Close()
+
+ privValidator := pvm.LoadOrGenFilePV(config.PrivValidatorKeyFile(), config.PrivValidatorStateFile())
+ userPubKey, err := privValidator.GetPubKey()
+ if err != nil {
+ return nil, err
+ }
+ validatorAddress := userPubKey.Address()
+ if err != nil {
+ return nil, err
+ }
+
+ stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+ DiscardABCIResponses: config.Storage.DiscardABCIResponses,
+ })
+
+ state, genDoc, err := node.LoadStateFromDBOrGenesisDocProvider(stateDB, genDocProvider)
+ if err != nil {
+ return nil, err
+ }
+
+ genDoc.ChainID = newChainID
+ genFilePath := config.GenesisFile()
+ if err = genutil.ExportGenesisFile(genDoc, genFilePath); err != nil {
+ return nil, err
+ }
+
+ ctx.Viper.Set(KeyNewValAddr, validatorAddress)
+ ctx.Viper.Set(KeyUserPubKey, userPubKey)
+ testnetApp := testnetAppCreator(ctx.Logger, db, traceWriter, ctx.Viper)
+
+ // We need to create a temporary proxyApp to get the initial state of the application.
+ // Depending on how the node was stopped, the application height can differ from the blockStore height.
+ // This height difference changes how we go about modifying the state.
+ clientCreator := proxy.NewLocalClientCreator(testnetApp)
+ // metrics := node.DefaultMetricsProvider(cmtcfg.DefaultConfig().Instrumentation)
+ // _, _, _, _, proxyMetrics := metrics(genDoc.ChainID) //nolint:dogsled
+ proxyApp := proxy.NewAppConns(clientCreator)
+ if err := proxyApp.Start(); err != nil {
+ return nil, fmt.Errorf("error starting proxy app connections: %v", err)
+ }
+ res, err := proxyApp.Query().InfoSync(proxy.RequestInfo)
+ if err != nil {
+ return nil, fmt.Errorf("error calling Info: %v", err)
+ }
+ err = proxyApp.Stop()
+ if err != nil {
+ return nil, err
+ }
+ appHash := res.LastBlockAppHash
+ appHeight := res.LastBlockHeight
+
+ var block *cmttypes.Block
+ switch {
+ case appHeight == blockStore.Height():
+ block = blockStore.LoadBlock(blockStore.Height())
+ // If the state's last blockstore height does not match the app and blockstore height, we likely stopped with the halt height flag.
+ if state.LastBlockHeight != appHeight {
+ state.LastBlockHeight = appHeight
+ block.AppHash = appHash
+ state.AppHash = appHash
+ } else {
+ // Node was likely stopped via SIGTERM, delete the next block's seen commit
+ err := blockStoreDB.Delete([]byte(fmt.Sprintf("SC:%v", blockStore.Height()+1)))
+ if err != nil {
+ return nil, err
+ }
+ }
+ case blockStore.Height() > state.LastBlockHeight:
+ // This state usually occurs when we gracefully stop the node.
+ _, err = blockStore.PruneBlocks(blockStore.Height() - 1)
+ if err != nil {
+ return nil, err
+ }
+ block = blockStore.LoadBlock(blockStore.Height())
+ default:
+ // If there is any other state, we just load the block
+ block = blockStore.LoadBlock(blockStore.Height())
+ }
+
+ block.ChainID = newChainID
+ state.ChainID = newChainID
+
+ block.LastBlockID = state.LastBlockID
+ block.LastCommit.BlockID = state.LastBlockID
+
+ // Create a vote from our validator
+ vote := cmttypes.Vote{
+ Type: cmtproto.PrecommitType,
+ Height: state.LastBlockHeight,
+ Round: 0,
+ BlockID: state.LastBlockID,
+ Timestamp: time.Now(),
+ ValidatorAddress: validatorAddress,
+ ValidatorIndex: 0,
+ Signature: []byte{},
+ }
+
+ // Sign the vote, and copy the proto changes from the act of signing to the vote itself
+ voteProto := vote.ToProto()
+ err = privValidator.SignVote(newChainID, voteProto)
+ if err != nil {
+ return nil, err
+ }
+ vote.Signature = voteProto.Signature
+ vote.Timestamp = voteProto.Timestamp
+
+ // Modify the block's lastCommit to be signed only by our validator
+ block.LastCommit.Signatures[0].ValidatorAddress = validatorAddress
+ block.LastCommit.Signatures[0].Signature = vote.Signature
+ block.LastCommit.Signatures = []cmttypes.CommitSig{block.LastCommit.Signatures[0]}
+
+ // Load the seenCommit of the lastBlockHeight and modify it to be signed from our validator
+ seenCommit := blockStore.LoadSeenCommit(state.LastBlockHeight)
+ seenCommit.BlockID = state.LastBlockID
+ seenCommit.Round = vote.Round
+ seenCommit.Signatures[0].Signature = vote.Signature
+ seenCommit.Signatures[0].ValidatorAddress = validatorAddress
+ seenCommit.Signatures[0].Timestamp = vote.Timestamp
+ seenCommit.Signatures = []cmttypes.CommitSig{seenCommit.Signatures[0]}
+ err = blockStore.SaveSeenCommit(state.LastBlockHeight, seenCommit)
+ if err != nil {
+ return nil, err
+ }
+
+ // Create ValidatorSet struct containing just our valdiator.
+ newVal := &cmttypes.Validator{
+ Address: validatorAddress,
+ PubKey: userPubKey,
+ VotingPower: 900000000000000,
+ }
+ newValSet := &cmttypes.ValidatorSet{
+ Validators: []*cmttypes.Validator{newVal},
+ Proposer: newVal,
+ }
+
+ // Replace all valSets in state to be the valSet with just our validator.
+ state.Validators = newValSet
+ state.LastValidators = newValSet
+ state.NextValidators = newValSet
+ state.LastHeightValidatorsChanged = blockStore.Height()
+
+ err = stateStore.Save(state)
+ if err != nil {
+ return nil, err
+ }
+
+ // Create a ValidatorsInfo struct to store in stateDB.
+ valSet, err := state.Validators.ToProto()
+ if err != nil {
+ return nil, err
+ }
+ valInfo := &cmtstate.ValidatorsInfo{
+ ValidatorSet: valSet,
+ LastHeightChanged: state.LastBlockHeight,
+ }
+ buf, err := valInfo.Marshal()
+ if err != nil {
+ return nil, err
+ }
+
+ // Modfiy Validators stateDB entry.
+ err = stateDB.Set([]byte(fmt.Sprintf("validatorsKey:%v", blockStore.Height())), buf)
+ if err != nil {
+ return nil, err
+ }
+
+ // Modify LastValidators stateDB entry.
+ err = stateDB.Set([]byte(fmt.Sprintf("validatorsKey:%v", blockStore.Height()-1)), buf)
+ if err != nil {
+ return nil, err
+ }
+
+ // Modify NextValidators stateDB entry.
+ err = stateDB.Set([]byte(fmt.Sprintf("validatorsKey:%v", blockStore.Height()+1)), buf)
+ if err != nil {
+ return nil, err
+ }
+
+ b, err := cmtjson.Marshal(genDoc)
+ if err != nil {
+ return nil, err
+ }
+ if err := stateDB.SetSync([]byte("genesisDoc"), b); err != nil {
+ return nil, err
+ }
+
+ return testnetApp, err
+}