@agoric/cosmos 0.35.0-u19.2 → 0.35.0-u21.0

package/app/upgrade.go

@@ -3,23 +3,31 @@ package gaia
 import (
 	"encoding/json"
 	"fmt"
-	"reflect"
-	"strings"
-	"text/template"
 
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 	swingsetkeeper "github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/keeper"
+	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/module"
+
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	crisistypes "github.com/cosmos/cosmos-sdk/x/crisis/types"
+	distrtypes "github.com/cosmos/cosmos-sdk/x/distribution/types"
+	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
+	govv1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1"
+	minttypes "github.com/cosmos/cosmos-sdk/x/mint/types"
+	paramstypes "github.com/cosmos/cosmos-sdk/x/params/types"
+	slashingtypes "github.com/cosmos/cosmos-sdk/x/slashing/types"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 	upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types"
+
+	ibctmmigrations "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint/migrations"
 )
 
 var upgradeNamesOfThisVersion = []string{
-	"agoric-upgrade-19-mainnet",
-	"agoric-upgrade-19-devnet",
-	"agoric-upgrade-19-emerynet",
-	"agoric-upgrade-19-a3p",
-	"agoric-upgrade-19-basic",
+	"agoric-upgrade-21",
+	"agoric-upgrade-21-a3p",
 }
 
 // isUpgradeNameOfThisVersion returns whether the provided plan name is a
@@ -53,11 +61,8 @@ func isPrimaryUpgradeName(name string) bool {
 		return false
 	}
 	switch name {
-	case validUpgradeName("agoric-upgrade-19-mainnet"),
-		validUpgradeName("agoric-upgrade-19-devnet"),
-		validUpgradeName("agoric-upgrade-19-emerynet"),
-		validUpgradeName("agoric-upgrade-19-a3p"),
-		validUpgradeName("agoric-upgrade-19-basic"):
+	case validUpgradeName("agoric-upgrade-21"),
+		validUpgradeName("agoric-upgrade-21-a3p"):
 		return true
 	default:
 		panic(fmt.Errorf("unexpected upgrade name %s", validUpgradeName(name)))
@@ -75,75 +80,45 @@ func isFirstTimeUpgradeOfThisVersion(app *GaiaApp, ctx sdk.Context) bool {
 	return true
 }
 
-func buildProposalStepWithArgs(moduleName string, entrypoint string, extra any) (vm.CoreProposalStep, error) {
-	t := template.Must(template.New("").Parse(`{
-  "module": "{{.moduleName}}",
-  "entrypoint": "{{.entrypoint}}",
-  "args": {{.args}}
-}`))
-
-	var args []byte
-	var err error
-	if extra == nil {
-		// The specified entrypoint will be called with no extra arguments after powers.
-		args = []byte(`[]`)
-	} else if reflect.TypeOf(extra).Kind() == reflect.Map && reflect.TypeOf(extra).Key().Kind() == reflect.String {
-		// The specified entrypoint will be called with this options argument after powers.
-		args, err = json.Marshal([]any{extra})
-	} else if reflect.TypeOf(extra).Kind() == reflect.Slice {
-		// The specified entrypoint will be called with each of these arguments after powers.
-		args, err = json.Marshal(extra)
-	} else {
-		return nil, fmt.Errorf("proposal extra must be nil, array, or string map, not %v", extra)
-	}
+// buildProposalStepWithArgs returns a CoreProposal representing invocation of
+// the specified module-specific entry point with arbitrary Jsonable arguments
+// provided after core-eval powers.
+func buildProposalStepWithArgs(moduleName string, entrypoint string, args ...vm.Jsonable) (vm.CoreProposalStep, error) {
+	argsBz, err := json.Marshal(args)
 	if err != nil {
 		return nil, err
 	}
 
-	var result strings.Builder
-	err = t.Execute(&result, map[string]any{
-		"moduleName": moduleName,
-		"entrypoint": entrypoint,
-		"args":       string(args),
-	})
+	mea := struct {
+		Module     string          `json:"module"`
+		Entrypoint string          `json:"entrypoint"`
+		Args       json.RawMessage `json:"args"`
+	}{
+		Module:     moduleName,
+		Entrypoint: entrypoint,
+		Args:       argsBz,
+	}
+
+	jsonBz, err := json.Marshal(mea)
 	if err != nil {
 		return nil, err
 	}
-	jsonStr := result.String()
-	jsonBz := []byte(jsonStr)
-	if !json.Valid(jsonBz) {
-		return nil, fmt.Errorf("invalid JSON: %s", jsonStr)
-	}
+
 	proposal := vm.ArbitraryCoreProposal{Json: jsonBz}
 	return vm.CoreProposalStepForModules(proposal), nil
 }
 
 func getVariantFromUpgradeName(upgradeName string) string {
 	switch upgradeName {
-	case "agoric-upgrade-19-a3p":
+	case "agoric-upgrade-21-a3p":
 		return "A3P_INTEGRATION"
-	case "agoric-upgrade-19-mainnet":
+	case "agoric-upgrade-21":
 		return "MAINNET"
-	case "agoric-upgrade-19-devnet":
-		return "DEVNET"
-	case "agoric-upgrade-19-emerynet":
-		return "EMERYNET"
-	case "agoric-upgrade-19-basic":
-		// Noupgrade for this version.
-		return ""
 	default:
 		return ""
 	}
 }
 
-func upgradeMintHolderCoreProposal(targetUpgrade string) (vm.CoreProposalStep, error) {
-	return buildProposalStepFromScript(targetUpgrade, "@agoric/builders/scripts/vats/upgrade-mintHolder.js")
-}
-
-func restartFeeDistributorCoreProposal(targetUpgrade string) (vm.CoreProposalStep, error) {
-	return buildProposalStepFromScript(targetUpgrade, "@agoric/builders/scripts/inter-protocol/replace-feeDistributor-combo.js")
-}
-
 func buildProposalStepFromScript(targetUpgrade string, builderScript string) (vm.CoreProposalStep, error) {
 	variant := getVariantFromUpgradeName(targetUpgrade)
 
@@ -154,17 +129,73 @@ func buildProposalStepFromScript(targetUpgrade string, builderScript string) (vm
 	return buildProposalStepWithArgs(
 		builderScript,
 		"defaultProposalBuilder",
-		map[string]any{
-			"variant": variant,
+		// Map iteration is randomised; use an anonymous struct instead.
+		struct {
+			Variant string `json:"variant"`
+		}{
+			Variant: variant,
 		},
 	)
 }
 
-// upgrade19Handler performs standard upgrade actions plus custom actions for upgrade-19.
-func upgrade19Handler(app *GaiaApp, targetUpgrade string) func(sdk.Context, upgradetypes.Plan, module.VersionMap) (module.VersionMap, error) {
+// RegisterUpgradeHandlers registers the upgrade handlers for all upgradeNames.
+func (app *GaiaApp) RegisterUpgradeHandlers() {
+	// Set param key table for params module migration
+	for _, subspace := range app.ParamsKeeper.GetSubspaces() {
+		subspace := subspace
+
+		var keyTable paramstypes.KeyTable
+		switch subspace.Name() {
+		case authtypes.ModuleName:
+			keyTable = authtypes.ParamKeyTable() //nolint:staticcheck
+		case banktypes.ModuleName:
+			keyTable = banktypes.ParamKeyTable() //nolint:staticcheck
+		case stakingtypes.ModuleName:
+			keyTable = stakingtypes.ParamKeyTable() //nolint:staticcheck
+		case minttypes.ModuleName:
+			keyTable = minttypes.ParamKeyTable() //nolint:staticcheck
+		case distrtypes.ModuleName:
+			keyTable = distrtypes.ParamKeyTable() //nolint:staticcheck
+		case slashingtypes.ModuleName:
+			keyTable = slashingtypes.ParamKeyTable() //nolint:staticcheck
+		case govtypes.ModuleName:
+			keyTable = govv1.ParamKeyTable() //nolint:staticcheck
+		case crisistypes.ModuleName:
+			keyTable = crisistypes.ParamKeyTable() //nolint:staticcheck
+		default:
+			continue
+		}
+
+		if !subspace.HasKeyTable() {
+			subspace.WithKeyTable(keyTable)
+		}
+	}
+
+	baseAppLegacySS := app.ParamsKeeper.Subspace(baseapp.Paramspace).WithKeyTable(paramstypes.ConsensusParamsKeyTable())
+
+	for _, name := range upgradeNamesOfThisVersion {
+		app.UpgradeKeeper.SetUpgradeHandler(
+			name,
+			upgrade21Handler(app, name, baseAppLegacySS),
+		)
+	}
+}
+
+// upgrade21Handler performs standard upgrade actions plus custom actions for upgrade-21.
+func upgrade21Handler(app *GaiaApp, targetUpgrade string, baseAppLegacySS paramstypes.Subspace) func(sdk.Context, upgradetypes.Plan, module.VersionMap) (module.VersionMap, error) {
+	_ = targetUpgrade
 	return func(ctx sdk.Context, plan upgradetypes.Plan, fromVm module.VersionMap) (module.VersionMap, error) {
 		app.CheckControllerInited(false)
 
+		// prune expired tendermint consensus states to save storage space
+		_, err := ibctmmigrations.PruneExpiredConsensusStates(ctx, app.AppCodec(), app.IBCKeeper.ClientKeeper)
+		if err != nil {
+			return nil, err
+		}
+
+		// Migrate Tendermint consensus parameters from x/params module to a dedicated x/consensus module.
+		baseapp.MigrateParams(ctx, baseAppLegacySS, &app.ConsensusParamsKeeper)
+
 		CoreProposalSteps := []vm.CoreProposalStep{}
 
 		// These CoreProposalSteps are not idempotent and should only be executed
@@ -184,6 +215,9 @@ func upgrade19Handler(app *GaiaApp, targetUpgrade string) func(sdk.Context, upgr
 				vm.CoreProposalStepForModules(
 					"@agoric/builders/scripts/vats/upgrade-zcf.js",
 				),
+				vm.CoreProposalStepForModules(
+					"@agoric/builders/scripts/vats/upgrade-provisionPool-to-BLD.js",
+				),
 				// because of #10794, we need to do at least a null upgrade of
 				// the walletFactory on every software upgrade
 				vm.CoreProposalStepForModules(
@@ -191,39 +225,51 @@ func upgrade19Handler(app *GaiaApp, targetUpgrade string) func(sdk.Context, upgr
 				),
 			)
 
-			upgradeMintHolderStep, err := upgradeMintHolderCoreProposal(targetUpgrade)
-			if err != nil {
-				return nil, err
-			} else if upgradeMintHolderStep != nil {
-				CoreProposalSteps = append(CoreProposalSteps, upgradeMintHolderStep)
-			}
-			restartFeeDistributorStep, err := restartFeeDistributorCoreProposal(targetUpgrade)
+			// Reserve contract needs to be upgraded for IST wind-down.
+			reserveUpgradeStep, err := buildProposalStepWithArgs(
+				"@agoric/builders/scripts/vats/upgrade-vats.js",
+				"upgradeZoeContractsProposalBuilder",
+				[]struct {
+					KitLookup  []string `json:"kitLookup"`
+					BundleName string   `json:"bundleName"`
+					Entrypoint string   `json:"entrypoint"`
+				}{
+					{
+						KitLookup:  []string{"reserveKit"},
+						BundleName: "reserve",
+						Entrypoint: "@agoric/inter-protocol/src/reserve/assetReserve.js",
+					},
+				},
+			)
 			if err != nil {
-				return nil, err
-			} else if restartFeeDistributorStep != nil {
-				CoreProposalSteps = append(CoreProposalSteps, restartFeeDistributorStep)
+				return module.VersionMap{}, err
 			}
-
 			CoreProposalSteps = append(CoreProposalSteps,
-				vm.CoreProposalStepForModules(
-					"@agoric/builders/scripts/vats/upgrade-paRegistry.js",
-				),
-				vm.CoreProposalStepForModules(
-					"@agoric/builders/scripts/vats/upgrade-provisionPool.js",
-				),
-				vm.CoreProposalStepForModules(
-					"@agoric/builders/scripts/vats/upgrade-bank.js",
-				),
-				vm.CoreProposalStepForModules(
-					"@agoric/builders/scripts/vats/upgrade-agoricNames.js",
-				),
-				vm.CoreProposalStepForModules(
-					"@agoric/builders/scripts/vats/upgrade-asset-reserve.js",
-				),
-				vm.CoreProposalStepForModules(
-					"@agoric/builders/scripts/vats/upgrade-psm.js",
-				),
+				reserveUpgradeStep,
 			)
+
+			// terminationTargets is a slice of "$boardID:$instanceKitLabel" strings.
+			var terminationTargets []string
+			switch getVariantFromUpgradeName(targetUpgrade) {
+			case "MAINNET":
+				// v111 "zcf-b1-4522b-stkATOM-USD_price_feed"
+				terminationTargets = []string{"board052184:stkATOM-USD_price_feed"}
+			case "A3P_INTEGRATION":
+				terminationTargets = []string{"board04091:stATOM-USD_price_feed"}
+			}
+			if len(terminationTargets) > 0 {
+				args := []vm.Jsonable{terminationTargets}
+				terminationStep, err := buildProposalStepWithArgs(
+					"@agoric/vats/src/proposals/terminate-governed-instance.js",
+					// defaultProposalBuilder(powers, targets)
+					"defaultProposalBuilder",
+					args...,
+				)
+				if err != nil {
+					return module.VersionMap{}, err
+				}
+				CoreProposalSteps = append(CoreProposalSteps, terminationStep)
+			}
 		}
 
 		app.upgradeDetails = &upgradeDetails{
@@ -236,7 +282,7 @@ func upgrade19Handler(app *GaiaApp, targetUpgrade string) func(sdk.Context, upgr
 		}
 
 		// Always run module migrations
-		mvm, err := app.mm.RunMigrations(ctx, app.configurator, fromVm)
+		mvm, err := app.ModuleManager.RunMigrations(ctx, app.configurator, fromVm)
 		if err != nil {
 			return mvm, err
 		}

package/app/upgrade_test.go

@@ -0,0 +1,63 @@
+package gaia
+
+import (
+	"testing"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBuildProposalSteps(t *testing.T) {
+	testCases := []struct {
+		name         string
+		makeStep     func() (vm.CoreProposalStep, error)
+		expectedJson string
+	}{
+		{
+			"buildProposalStepFromScript",
+			func() (vm.CoreProposalStep, error) {
+				return buildProposalStepFromScript(
+					"agoric-upgrade-21-a3p",
+					"@agoric/builders/scripts/vats/upgrade-orchestration.js",
+				)
+			},
+			`{"module":"@agoric/builders/scripts/vats/upgrade-orchestration.js",` +
+				`"entrypoint":"defaultProposalBuilder",` +
+				`"args":[{"variant":"A3P_INTEGRATION"}]}`,
+		},
+		{
+			"buildProposalStepWithArgs",
+			func() (vm.CoreProposalStep, error) {
+				return buildProposalStepWithArgs(
+					"@agoric/builders/scripts/vats/upgrade-vats.js",
+					"upgradeVatsProposalBuilder",
+					// Map iteration is randomised; use an anonymous struct instead.
+					struct {
+						Ibc string `json:"ibc"`
+					}{
+						Ibc: "@agoric/vats/src/vat-ibc.js",
+					},
+				)
+			},
+			`{"module":"@agoric/builders/scripts/vats/upgrade-vats.js",` +
+				`"entrypoint":"upgradeVatsProposalBuilder",` +
+				`"args":[{"ibc":"@agoric/vats/src/vat-ibc.js"}]}`,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			ps, err := tc.makeStep()
+
+			assert.NoError(t, err)
+			expected := vm.CoreProposalStepForModules(*vm.NewArbitraryCoreProposal(
+				tc.expectedJson,
+			))
+
+			assert.EqualValues(t, len(expected), len(ps), "Expected length %d to be %d", len(expected), len(ps))
+			for i, prop := range ps {
+				assert.EqualValues(t, expected[i], prop, "Expected %d to be %v, got %v", i, expected[i], prop)
+			}
+		})
+	}
+}

package/cmd/agd/agvm.go

@@ -5,7 +5,7 @@ import (
 	"os"
 	"os/exec"
 
-	"github.com/tendermint/tendermint/libs/log"
+	"github.com/cometbft/cometbft/libs/log"
 )
 
 // NewVMCommand creates a new OS command to run the Agoric VM.  It sets up the

package/cmd/agd/main.go

@@ -10,8 +10,8 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/cometbft/cometbft/libs/log"
 	"github.com/spf13/cast"
-	"github.com/tendermint/tendermint/libs/log"
 
 	gaia "github.com/Agoric/agoric-sdk/golang/cosmos/app"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/daemon"

package/cmd/libdaemon/main.go

@@ -15,8 +15,9 @@ import (
 	"net/rpc"
 	"os"
 	"path/filepath"
+	"runtime/debug"
 
-	log "github.com/tendermint/tendermint/libs/log"
+	log "github.com/cometbft/cometbft/libs/log"
 
 	gaia "github.com/Agoric/agoric-sdk/golang/cosmos/app"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/daemon"
@@ -25,6 +26,11 @@ import (
 	servertypes "github.com/cosmos/cosmos-sdk/server/types"
 )
 
+// Taken from sysexits.h
+const (
+	EX_SOFTWARE = 70 /* internal software error */
+)
+
 type goReturn = struct {
 	str string
 	err error
@@ -32,6 +38,8 @@ type goReturn = struct {
 
 const SwingSetPort = 123
 
+var logger = log.NewTMLogger(log.NewSyncWriter(os.Stderr)).With("module", "cmd/libdaemon")
+
 var vmClientCodec *vm.ClientCodec
 var agdServer *vm.AgdServer
 
@@ -59,8 +67,29 @@ func ConnectVMClientCodec(ctx context.Context, nodePort int, sendFunc func(int,
 	return vmClientCodec, sendToNode
 }
 
+// handlePanic is a helper function to recover from panics, log them, and exit the process.
+func handlePanic(caller string) {
+	if r := recover(); r != nil {
+		defer func() {
+			if err := recover(); err != nil {
+				// If we panic again, we will exit the process without logging the error or stack.
+				os.Stderr.WriteString("Double panic in exported Go function: " + caller + "\n")
+				os.Exit(EX_SOFTWARE)
+			}
+		}()
+
+		// Log the panic with the caller information.
+		logger.Error("Panic in exported Go function", "caller", caller, "error", r, "stack", debug.Stack())
+
+		// Exit the process with a non-zero exit code.
+		os.Exit(EX_SOFTWARE)
+	}
+}
+
 //export RunAgCosmosDaemon
 func RunAgCosmosDaemon(nodePort C.int, toNode C.sendFunc, cosmosArgs []*C.char) C.int {
+	defer handlePanic("RunAgCosmosDaemon")
+
 	userHomeDir, err := os.UserHomeDir()
 	if err != nil {
 		panic(err)
@@ -92,6 +121,8 @@ func RunAgCosmosDaemon(nodePort C.int, toNode C.sendFunc, cosmosArgs []*C.char)
 	// fmt.Fprintln(os.Stderr, "Starting Cosmos", args)
 	os.Args = args
 	go func() {
+		defer handlePanic("daemon.RunWithController")
+
 		// We run in the background, but exit when the job is over.
 		// swingset.SendToNode("hello from Initial Go!")
 		exitCode := 0
@@ -112,6 +143,7 @@ func RunAgCosmosDaemon(nodePort C.int, toNode C.sendFunc, cosmosArgs []*C.char)
 
 //export ReplyToGo
 func ReplyToGo(replyPort C.int, isError C.int, resp C.Body) C.int {
+	defer handlePanic("ReplyToGo")
 	respStr := C.GoString(resp)
 	// fmt.Printf("Reply to Go %d %s\n", replyPort, respStr)
 	if err := vmClientCodec.Receive(int(replyPort), int(isError) != 0, respStr); err != nil {
@@ -126,6 +158,7 @@ type errorWrapper struct {
 
 //export SendToGo
 func SendToGo(port C.int, msg C.Body) C.Body {
+	defer handlePanic("SendToGo")
 	msgStr := C.GoString(msg)
 	// fmt.Fprintln(os.Stderr, "Send to Go", msgStr)
 	var respStr string

package/daemon/cmd/root.go

@@ -10,6 +10,12 @@ import (
 
 	serverconfig "github.com/cosmos/cosmos-sdk/server/config"
 
+	rosettaCmd "cosmossdk.io/tools/rosetta/cmd"
+
+	dbm "github.com/cometbft/cometbft-db"
+	tmcfg "github.com/cometbft/cometbft/config"
+	tmcli "github.com/cometbft/cometbft/libs/cli"
+	"github.com/cometbft/cometbft/libs/log"
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/config"
 	"github.com/cosmos/cosmos-sdk/client/debug"
@@ -29,10 +35,6 @@ import (
 	"github.com/spf13/cast"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	tmcfg "github.com/tendermint/tendermint/config"
-	tmcli "github.com/tendermint/tendermint/libs/cli"
-	"github.com/tendermint/tendermint/libs/log"
-	dbm "github.com/tendermint/tm-db"
 
 	gaia "github.com/Agoric/agoric-sdk/golang/cosmos/app"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/app/params"
@@ -131,7 +133,7 @@ func initAppConfig() (string, interface{}) {
 	// FIXME: We may want a non-zero min gas price.
 	// For now, we set it to zero to reduce friction (the default "" fails
 	// startup, forcing each validator to set their own value).
-	srvCfg.MinGasPrices = "0uist"
+	srvCfg.MinGasPrices = "0ubld"
 
 	customAppConfig := CustomAppConfig{
 		Config:   *srvCfg,
@@ -152,20 +154,27 @@ func initRootCmd(sender vm.Sender, rootCmd *cobra.Command, encodingConfig params
 	cfg.Seal()
 
 	ac := appCreator{
-		encCfg:    encodingConfig,
 		sender:    sender,
 		agdServer: vm.NewAgdServer(),
 	}
 
+	genesisCmd := genutilcli.GenesisCoreCommand(
+		encodingConfig.TxConfig,
+		gaia.ModuleBasics,
+		gaia.DefaultNodeHome,
+	)
+
 	rootCmd.AddCommand(
 		genutilcli.InitCmd(gaia.ModuleBasics, gaia.DefaultNodeHome),
-		genutilcli.CollectGenTxsCmd(banktypes.GenesisBalancesIterator{}, gaia.DefaultNodeHome),
-		genutilcli.MigrateGenesisCmd(),
-		genutilcli.GenTxCmd(gaia.ModuleBasics, encodingConfig.TxConfig, banktypes.GenesisBalancesIterator{}, gaia.DefaultNodeHome),
-		genutilcli.ValidateGenesisCmd(gaia.ModuleBasics),
-		AddGenesisAccountCmd(encodingConfig.Marshaler, gaia.DefaultNodeHome),
+		genesisCmd,
+	)
+	// Alias all the genesis commands to the top level as well.
+	rootCmd.AddCommand(
+		genesisCmd.Commands()...,
+	)
+	rootCmd.AddCommand(
 		tmcli.NewCompletionCmd(rootCmd, true),
-		testnetCmd(gaia.ModuleBasics, banktypes.GenesisBalancesIterator{}),
+		NewTestnetCmd(gaia.ModuleBasics, banktypes.GenesisBalancesIterator{}, AppName),
 		debug.Cmd(),
 		config.Cmd(),
 		pruning.Cmd(ac.newSnapshotsApp, gaia.DefaultNodeHome),
@@ -217,7 +226,7 @@ func initRootCmd(sender vm.Sender, rootCmd *cobra.Command, encodingConfig params
 		keys.Commands(gaia.DefaultNodeHome),
 	)
 	// add rosetta
-	rootCmd.AddCommand(server.RosettaCommand(encodingConfig.InterfaceRegistry, encodingConfig.Marshaler))
+	rootCmd.AddCommand(rosettaCmd.RosettaCommand(encodingConfig.InterfaceRegistry, encodingConfig.Marshaler))
 }
 
 const (
@@ -301,7 +310,6 @@ func txCommand() *cobra.Command {
 }
 
 type appCreator struct {
-	encCfg    params.EncodingConfig
 	sender    vm.Sender
 	agdServer *vm.AgdServer
 }
@@ -319,12 +327,6 @@ func (ac appCreator) newApp(
 	}
 
 	baseappOptions := server.DefaultBaseappOptions(appOpts)
-
-	skipUpgradeHeights := make(map[int64]bool)
-	for _, h := range cast.ToIntSlice(appOpts.Get(server.FlagUnsafeSkipUpgrades)) {
-		skipUpgradeHeights[int64(h)] = true
-	}
-
 	homePath := cast.ToString(appOpts.Get(flags.FlagHome))
 
 	// Set a default value for FlagSwingStoreExportDir based on homePath
@@ -337,10 +339,7 @@ func (ac appCreator) newApp(
 
 	return gaia.NewAgoricApp(
 		ac.sender, ac.agdServer,
-		logger, db, traceStore, true, skipUpgradeHeights,
-		homePath,
-		cast.ToUint(appOpts.Get(server.FlagInvCheckPeriod)),
-		ac.encCfg,
+		logger, db, traceStore, true,
 		appOpts,
 		baseappOptions...,
 	)
@@ -360,14 +359,9 @@ func (ac appCreator) newSnapshotsApp(
 
 	baseappOptions := server.DefaultBaseappOptions(appOpts)
 
-	homePath := cast.ToString(appOpts.Get(flags.FlagHome))
-
 	return gaia.NewAgoricApp(
 		ac.sender, ac.agdServer,
-		logger, db, traceStore, true, map[int64]bool{},
-		homePath,
-		cast.ToUint(appOpts.Get(server.FlagInvCheckPeriod)),
-		ac.encCfg,
+		logger, db, traceStore, true,
 		appOpts,
 		baseappOptions...,
 	)
@@ -479,6 +473,7 @@ func (ac appCreator) appExport(
 	forZeroHeight bool,
 	jailAllowedAddrs []string,
 	appOpts servertypes.AppOptions,
+	modulesToExport []string,
 ) (servertypes.ExportedApp, error) {
 	swingStoreExportMode, ok := appOpts.Get(gaia.FlagSwingStoreExportMode).(string)
 	if !(ok && allowedSwingSetExportModes[swingStoreExportMode]) {
@@ -508,10 +503,6 @@ func (ac appCreator) appExport(
 		db,
 		traceStore,
 		loadLatest,
-		map[int64]bool{},
-		homePath,
-		cast.ToUint(appOpts.Get(server.FlagInvCheckPeriod)),
-		ac.encCfg,
 		appOpts,
 	)
 
@@ -521,7 +512,7 @@ func (ac appCreator) appExport(
 		}
 	}
 
-	return gaiaApp.ExportAppStateAndValidators(forZeroHeight, jailAllowedAddrs)
+	return gaiaApp.ExportAppStateAndValidators(forZeroHeight, jailAllowedAddrs, modulesToExport)
 }
 
 // replaceCosmosSnapshotExportCommand monkey-patches the "snapshots export" command