@agoric/cosmos 0.34.2-dev-3c8aafe.0 → 0.34.2-dev-74fbe43.0.74fbe43

package/app/encoding.go

@@ -4,14 +4,17 @@ import (
 	"github.com/Agoric/agoric-sdk/golang/cosmos/app/params"
 
 	"github.com/cosmos/cosmos-sdk/std"
+	"github.com/cosmos/cosmos-sdk/types/module"
 )
 
 // MakeEncodingConfig creates an EncodingConfig for testing
-func MakeEncodingConfig() params.EncodingConfig {
+func MakeEncodingConfig(basicManager module.BasicManager) params.EncodingConfig {
 	encodingConfig := params.MakeEncodingConfig()
 	std.RegisterLegacyAminoCodec(encodingConfig.Amino)
 	std.RegisterInterfaces(encodingConfig.InterfaceRegistry)
-	ModuleBasics.RegisterLegacyAminoCodec(encodingConfig.Amino)
-	ModuleBasics.RegisterInterfaces(encodingConfig.InterfaceRegistry)
+	if basicManager != nil {
+		basicManager.RegisterLegacyAminoCodec(encodingConfig.Amino)
+		basicManager.RegisterInterfaces(encodingConfig.InterfaceRegistry)
+	}
 	return encodingConfig
 }

package/app/export.go

@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"log"
 
-	tmproto "github.com/cometbft/cometbft/proto/tendermint/types"
+	storetypes "cosmossdk.io/store/types"
 
 	servertypes "github.com/cosmos/cosmos-sdk/server/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -20,26 +20,30 @@ func (app *GaiaApp) ExportAppStateAndValidators(
 	forZeroHeight bool, jailAllowedAddrs []string, modulesToExport []string,
 ) (servertypes.ExportedApp, error) {
 	// as if they could withdraw from the start of the next block
-	ctx := app.NewContext(true, tmproto.Header{Height: app.LastBlockHeight()})
+	ctx := app.NewContext(true)
 
-	// We export at last height + 1, because that's the height at which
-	// Tendermint will start InitChain.
-	height := app.LastBlockHeight() + 1
+	height := app.LastBlockHeight()
 	if forZeroHeight {
 		return servertypes.ExportedApp{}, fmt.Errorf("forZeroHeight not supported")
 	}
 
-	genState := app.ModuleManager.ExportGenesisForModules(ctx, app.appCodec, modulesToExport)
+	ctx = ctx.WithBlockHeight(height)
+	genState, err := app.ModuleManager.ExportGenesis(ctx, app.appCodec)
+	if err != nil {
+		return servertypes.ExportedApp{}, err
+	}
+
 	appState, err := json.MarshalIndent(genState, "", "  ")
 	if err != nil {
 		return servertypes.ExportedApp{}, err
 	}
 
-	validators, err := staking.WriteValidators(ctx, &app.StakingKeeper)
+	validators, err := staking.WriteValidators(ctx, app.StakingKeeper)
+
 	return servertypes.ExportedApp{
 		AppState:        appState,
 		Validators:      validators,
-		Height:          height,
+		Height:          height + 1,
 		ConsensusParams: app.BaseApp.GetConsensusParams(ctx),
 	}, err
 }
@@ -70,12 +74,20 @@ func (app *GaiaApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs [
 
 	// withdraw all validator commission
 	app.StakingKeeper.IterateValidators(ctx, func(_ int64, val stakingtypes.ValidatorI) (stop bool) {
-		_, _ = app.DistrKeeper.WithdrawValidatorCommission(ctx, val.GetOperator())
+		addr, err := sdk.ValAddressFromBech32(val.GetOperator())
+		if err != nil {
+			panic(err)
+		}
+		_, _ = app.DistrKeeper.WithdrawValidatorCommission(ctx, addr)
 		return false
 	})
 
 	// withdraw all delegator rewards
-	dels := app.StakingKeeper.GetAllDelegations(ctx)
+	dels, err := app.StakingKeeper.GetAllDelegations(ctx)
+	if err != nil {
+		panic(err)
+	}
+
 	for _, delegation := range dels {
 		valAddr, err := sdk.ValAddressFromBech32(delegation.ValidatorAddress)
 		if err != nil {
@@ -102,12 +114,28 @@ func (app *GaiaApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs [
 	// reinitialize all validators
 	app.StakingKeeper.IterateValidators(ctx, func(_ int64, val stakingtypes.ValidatorI) (stop bool) {
 		// donate any unwithdrawn outstanding reward fraction tokens to the community pool
-		scraps := app.DistrKeeper.GetValidatorOutstandingRewardsCoins(ctx, val.GetOperator())
-		feePool := app.DistrKeeper.GetFeePool(ctx)
+		addr, err := sdk.ValAddressFromBech32(val.GetOperator())
+		if err != nil {
+			panic(err)
+		}
+		scraps, err := app.DistrKeeper.GetValidatorOutstandingRewardsCoins(ctx, addr)
+		if err != nil {
+			panic(err)
+		}
+
+		feePool, err := app.DistrKeeper.FeePool.Get(ctx)
+		if err != nil {
+			panic(err)
+		}
 		feePool.CommunityPool = feePool.CommunityPool.Add(scraps...)
-		app.DistrKeeper.SetFeePool(ctx, feePool)
 
-		if err := app.DistrKeeper.Hooks().AfterValidatorCreated(ctx, val.GetOperator()); err != nil {
+		var err_ error
+		err_ = app.DistrKeeper.FeePool.Set(ctx, feePool)
+		if err_ != nil {
+			panic(err_)
+		}
+
+		if err := app.DistrKeeper.Hooks().AfterValidatorCreated(ctx, addr); err != nil {
 			panic(err)
 		}
 		return false
@@ -157,13 +185,13 @@ func (app *GaiaApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs [
 	// Iterate through validators by power descending, reset bond heights, and
 	// update bond intra-tx counters.
 	store := ctx.KVStore(app.keys[stakingtypes.StoreKey])
-	iter := sdk.KVStoreReversePrefixIterator(store, stakingtypes.ValidatorsKey)
+	iter := storetypes.KVStoreReversePrefixIterator(store, stakingtypes.ValidatorsKey)
 	counter := int16(0)
 
 	for ; iter.Valid(); iter.Next() {
 		addr := sdk.ValAddress(stakingtypes.AddressFromValidatorsKey(iter.Key()))
-		validator, found := app.StakingKeeper.GetValidator(ctx, addr)
-		if !found {
+		validator, err := app.StakingKeeper.GetValidator(ctx, addr)
+		if err != nil {
 			panic("expected validator, not found")
 		}
 
@@ -178,11 +206,12 @@ func (app *GaiaApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs [
 
 	iter.Close()
 
-	_, err := app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
-	if err != nil {
-		log.Fatal(err)
-	}
+	var err_ error
 
+	_, err_ = app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
+	if err_ != nil {
+		log.Fatal(err_)
+	}
 	/* Handle slashing state. */
 
 	// reset start height on signing infos

package/app/genesis.go

@@ -2,6 +2,9 @@ package gaia
 
 import (
 	"encoding/json"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/types/module"
 )
 
 // The genesis state of the blockchain is represented here as a map of raw json
@@ -14,11 +17,10 @@ import (
 type GenesisState map[string]json.RawMessage
 
 // NewDefaultGenesisState generates the default state for the application.
-func NewDefaultGenesisState() GenesisState {
-	encCfg := MakeEncodingConfig()
-	return ModuleBasics.DefaultGenesis(encCfg.Marshaler)
+func NewDefaultGenesisState(appCodec codec.Codec, basicManager module.BasicManager) GenesisState {
+	return basicManager.DefaultGenesis(appCodec)
 }
 
-func (_app *GaiaApp) DefaultGenesis() GenesisState {
-	return NewDefaultGenesisState()
+func (app *GaiaApp) DefaultGenesis() GenesisState {
+	return NewDefaultGenesisState(app.appCodec, app.BasicModuleManager)
 }

package/app/params/encoding.go

@@ -10,7 +10,7 @@ import (
 // This is provided for compatibility between protobuf and amino implementations.
 type EncodingConfig struct {
 	InterfaceRegistry types.InterfaceRegistry
-	Marshaler         codec.Codec
+	Codec             codec.Codec
 	TxConfig          client.TxConfig
 	Amino             *codec.LegacyAmino
 }

package/app/params/proto.go

@@ -1,6 +1,7 @@
 package params
 
 import (
+	"github.com/Agoric/agoric-sdk/golang/cosmos/app/txconfig"
 	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/codec/types"
 	"github.com/cosmos/cosmos-sdk/x/auth/tx"
@@ -10,12 +11,13 @@ import (
 func MakeEncodingConfig() EncodingConfig {
 	amino := codec.NewLegacyAmino()
 	interfaceRegistry := types.NewInterfaceRegistry()
-	marshaler := codec.NewProtoCodec(interfaceRegistry)
-	txCfg := tx.NewTxConfig(marshaler, tx.DefaultSignModes)
-
+	codec := codec.NewProtoCodec(interfaceRegistry)
+	txCfg, _ := txconfig.NewTxConfigWithOptionsWithCustomEncoders(codec, tx.ConfigOptions{
+		EnabledSignModes: tx.DefaultSignModes,
+	})
 	return EncodingConfig{
 		InterfaceRegistry: interfaceRegistry,
-		Marshaler:         marshaler,
+		Codec:             codec,
 		TxConfig:          txCfg,
 		Amino:             amino,
 	}

package/app/sim_test.go

@@ -9,27 +9,24 @@ import (
 	"strings"
 	"testing"
 
-	dbm "github.com/cometbft/cometbft-db"
+	"cosmossdk.io/log"
 	abci "github.com/cometbft/cometbft/abci/types"
-	"github.com/cometbft/cometbft/libs/log"
-	tmproto "github.com/cometbft/cometbft/proto/tendermint/types"
+	dbm "github.com/cosmos/cosmos-db"
 	"github.com/stretchr/testify/require"
 
+	storetypes "cosmossdk.io/store/types"
 	"github.com/cosmos/cosmos-sdk/client/flags"
 	"github.com/cosmos/cosmos-sdk/server"
-	storetypes "github.com/cosmos/cosmos-sdk/store/types"
 
+	"cosmossdk.io/store"
+	evidencetypes "cosmossdk.io/x/evidence/types"
 	"github.com/cosmos/cosmos-sdk/baseapp"
-	"github.com/cosmos/cosmos-sdk/store"
 	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
-	sdk "github.com/cosmos/cosmos-sdk/types"
 	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	authzkeeper "github.com/cosmos/cosmos-sdk/x/authz/keeper"
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
-	capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types"
 	distrtypes "github.com/cosmos/cosmos-sdk/x/distribution/types"
-	evidencetypes "github.com/cosmos/cosmos-sdk/x/evidence/types"
 	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
 	minttypes "github.com/cosmos/cosmos-sdk/x/mint/types"
 	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
@@ -37,6 +34,7 @@ import (
 	simcli "github.com/cosmos/cosmos-sdk/x/simulation/client/cli"
 	slashingtypes "github.com/cosmos/cosmos-sdk/x/slashing/types"
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+	capabilitytypes "github.com/cosmos/ibc-go/modules/capability/types"
 )
 
 // SimAppChainID hardcoded chainID for simulation
@@ -187,8 +185,8 @@ func TestAppImportExport(t *testing.T) {
 		}
 	}()
 
-	ctxA := app.NewContext(true, tmproto.Header{Height: app.LastBlockHeight()})
-	ctxB := newApp.NewContext(true, tmproto.Header{Height: app.LastBlockHeight()})
+	ctxA := app.NewContext(true)
+	ctxB := newApp.NewContext(true)
 	newApp.ModuleManager.InitGenesis(ctxB, app.AppCodec(), genesisState)
 	newApp.StoreConsensusParams(ctxB, exported.ConsensusParams)
 
@@ -218,7 +216,7 @@ func TestAppImportExport(t *testing.T) {
 		storeA := ctxA.KVStore(skp.A)
 		storeB := ctxB.KVStore(skp.B)
 
-		failedKVAs, failedKVBs := sdk.DiffKVStores(storeA, storeB, skp.Prefixes)
+		failedKVAs, failedKVBs := simtestutil.DiffKVStores(storeA, storeB, skp.Prefixes)
 		require.Equal(t, len(failedKVAs), len(failedKVBs), "unequal sets of key-values to compare")
 
 		fmt.Printf("compared %d different key/value pairs between %s and %s\n", len(failedKVAs), skp.A, skp.B)
@@ -293,7 +291,7 @@ func TestAppSimulationAfterImport(t *testing.T) {
 	newApp := NewSimApp(log.NewNopLogger(), newDB, nil, true, appOptions, fauxMerkleModeOpt, baseapp.SetChainID(SimAppChainID))
 	require.Equal(t, "SimApp", newApp.Name())
 
-	newApp.InitChain(abci.RequestInitChain{
+	newApp.InitChain(&abci.RequestInitChain{
 		ChainId:       SimAppChainID,
 		AppStateBytes: exported.AppState,
 	})
@@ -349,7 +347,7 @@ func TestAppStateDeterminism(t *testing.T) {
 		for j := 0; j < numTimesToRunPerSeed; j++ {
 			var logger log.Logger
 			if simcli.FlagVerboseValue {
-				logger = log.TestingLogger()
+				logger = log.NewTestLogger(t)
 			} else {
 				logger = log.NewNopLogger()
 			}

package/app/txconfig/tx_config.go

@@ -0,0 +1,169 @@
+package txconfig
+
+import (
+	"fmt"
+
+	txsigning "cosmossdk.io/x/tx/signing"
+	"cosmossdk.io/x/tx/signing/aminojson"
+	"cosmossdk.io/x/tx/signing/direct"
+	"cosmossdk.io/x/tx/signing/directaux"
+	"cosmossdk.io/x/tx/signing/textual"
+	agorictypes "github.com/Agoric/agoric-sdk/golang/cosmos/types"
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	signingtypes "github.com/cosmos/cosmos-sdk/types/tx/signing"
+	"github.com/cosmos/cosmos-sdk/x/auth/tx"
+)
+
+var legacyAddress = "legacy_address"
+var nullSliceAsEmpty = "null_slice_as_empty"
+
+type configTx struct {
+	decoder     sdk.TxDecoder
+	encoder     sdk.TxEncoder
+	jsonDecoder sdk.TxDecoder
+	jsonEncoder sdk.TxEncoder
+	protoCodec  codec.Codec
+}
+
+// CustomAminoFieldEncoders is a map of custom amino field encoders for amino json
+var CustomAminoFieldEncoders = map[string]aminojson.FieldEncoder{
+	legacyAddress:    agorictypes.LegacyAddressEncoder,
+	nullSliceAsEmpty: aminojson.NullSliceAsEmptyEncoder,
+}
+
+// NewTxConfigWithOptions returns a new protobuf TxConfig using the provided ProtoCodec, ConfigOptions and
+// custom sign mode handlers. If ConfigOptions is an empty struct then default values will be used.
+func NewTxConfigWithOptionsWithCustomEncoders(protoCodec codec.Codec, configOptions tx.ConfigOptions) (client.TxConfig, error) {
+	txConfig := &configTx{
+		protoCodec:  protoCodec,
+		decoder:     configOptions.ProtoDecoder,
+		encoder:     configOptions.ProtoEncoder,
+		jsonDecoder: configOptions.JSONDecoder,
+		jsonEncoder: configOptions.JSONEncoder,
+	}
+	if configOptions.ProtoDecoder == nil {
+		txConfig.decoder = tx.DefaultTxDecoder(protoCodec)
+	}
+	if configOptions.ProtoEncoder == nil {
+		txConfig.encoder = tx.DefaultTxEncoder()
+	}
+	if configOptions.JSONDecoder == nil {
+		txConfig.jsonDecoder = tx.DefaultJSONTxDecoder(protoCodec)
+	}
+	if configOptions.JSONEncoder == nil {
+		txConfig.jsonEncoder = tx.DefaultJSONTxEncoder(protoCodec)
+	}
+
+	var err error
+	if configOptions.SigningContext == nil {
+		if configOptions.SigningOptions == nil {
+			configOptions.SigningOptions, err = tx.NewDefaultSigningOptions()
+			if err != nil {
+				return nil, err
+			}
+		}
+		if configOptions.SigningOptions.FileResolver == nil {
+			configOptions.SigningOptions.FileResolver = protoCodec.InterfaceRegistry()
+		}
+		configOptions.SigningContext, err = txsigning.NewContext(*configOptions.SigningOptions)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	configOptions.SigningHandler, err = NewSigningHandlerMap(configOptions)
+
+	if err != nil {
+		return nil, err
+	}
+	return tx.NewTxConfigWithOptions(txConfig.protoCodec, configOptions)
+
+}
+
+func NewSigningHandlerMap(configOpts tx.ConfigOptions) (*txsigning.HandlerMap, error) {
+	var err error
+	if configOpts.SigningOptions == nil {
+		configOpts.SigningOptions, err = tx.NewDefaultSigningOptions()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if configOpts.SigningContext == nil {
+		configOpts.SigningContext, err = txsigning.NewContext(*configOpts.SigningOptions)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	signingOpts := configOpts.SigningOptions
+
+	if len(configOpts.EnabledSignModes) == 0 {
+		configOpts.EnabledSignModes = tx.DefaultSignModes
+	}
+
+	lenSignModes := len(configOpts.EnabledSignModes)
+	handlers := make([]txsigning.SignModeHandler, lenSignModes+len(configOpts.CustomSignModes))
+	for i, m := range configOpts.EnabledSignModes {
+		var err error
+		switch m {
+		case signingtypes.SignMode_SIGN_MODE_DIRECT:
+			handlers[i] = &direct.SignModeHandler{}
+		case signingtypes.SignMode_SIGN_MODE_DIRECT_AUX:
+			handlers[i], err = directaux.NewSignModeHandler(directaux.SignModeHandlerOptions{
+				TypeResolver:   signingOpts.TypeResolver,
+				SignersContext: configOpts.SigningContext,
+			})
+			if err != nil {
+				return nil, err
+			}
+		case signingtypes.SignMode_SIGN_MODE_LEGACY_AMINO_JSON:
+			// AGORIC: We inject custom amino field encoders for amino json
+			//
+			aminoHandler, _, err := NewAminoHandlerWithCustomEncoders(configOpts.SigningOptions, CustomAminoFieldEncoders)
+			if err != nil {
+				return nil, err
+			}
+			// -------------------------------------------------
+			handlers[i] = aminoHandler
+		case signingtypes.SignMode_SIGN_MODE_TEXTUAL:
+			handlers[i], err = textual.NewSignModeHandler(textual.SignModeOptions{
+				CoinMetadataQuerier: configOpts.TextualCoinMetadataQueryFn,
+				FileResolver:        signingOpts.FileResolver,
+				TypeResolver:        signingOpts.TypeResolver,
+			})
+			if configOpts.TextualCoinMetadataQueryFn == nil {
+				return nil, fmt.Errorf("cannot enable SIGN_MODE_TEXTUAL without a TextualCoinMetadataQueryFn")
+			}
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+	for i, m := range configOpts.CustomSignModes {
+		handlers[i+lenSignModes] = m
+	}
+	handler := txsigning.NewHandlerMap(handlers...)
+	return handler, nil
+
+}
+
+func NewAminoHandlerWithCustomEncoders(signingOpts *txsigning.Options, fieldEncoders map[string]aminojson.FieldEncoder) (*aminojson.SignModeHandler, aminojson.Encoder, error) {
+	encoderOptions := aminojson.EncoderOptions{
+		FileResolver: signingOpts.FileResolver,
+		TypeResolver: signingOpts.TypeResolver,
+		EnumAsString: false, // ensure enum as string is disabled
+	}
+	encoder := aminojson.NewEncoder(encoderOptions)
+	for name, customFieldEncoder := range fieldEncoders {
+		encoder.DefineFieldEncoding(name, customFieldEncoder)
+	}
+	aminoHandler := aminojson.NewSignModeHandler(aminojson.SignModeHandlerOptions{
+		FileResolver: signingOpts.FileResolver,
+		TypeResolver: signingOpts.TypeResolver,
+		Encoder:      &encoder,
+	})
+	return aminoHandler, encoder, nil
+}

package/app/upgrade.go

@@ -1,28 +1,24 @@
 package gaia
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 
 	"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"
+	upgradetypes "cosmossdk.io/x/upgrade/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"
+	icahosttypes "github.com/cosmos/ibc-go/v8/modules/apps/27-interchain-accounts/host/types"
+	ibctransfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types"
+	ibcclienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types"
+	ibcconnectiontypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types"
+	ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported"
+	ibctmmigrations "github.com/cosmos/ibc-go/v8/modules/light-clients/07-tendermint/migrations"
 )
 
 var upgradeNamesOfThisVersion = []string{
@@ -82,7 +78,11 @@ func isPrimaryUpgradeName(name string) bool {
 // upgrade plan name of this version have previously been applied.
 func isFirstTimeUpgradeOfThisVersion(app *GaiaApp, ctx sdk.Context) bool {
 	for _, name := range upgradeNamesOfThisVersion {
-		if app.UpgradeKeeper.GetDoneHeight(ctx, name) != 0 {
+		height, err := app.UpgradeKeeper.GetDoneHeight(ctx, name)
+		if err != nil {
+			panic(fmt.Errorf("error getting done height: %s", err))
+		}
+		if height != 0 {
 			return false
 		}
 	}
@@ -158,26 +158,15 @@ func buildProposalStepFromScript(targetUpgrade string, builderScript string) (vm
 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
+		case ibcexported.ModuleName:
+			keyTable = ibcclienttypes.ParamKeyTable() //nolint:staticcheck
+			keyTable.RegisterParamSet(&ibcconnectiontypes.Params{})
+		case icahosttypes.SubModuleName:
+			keyTable = icahosttypes.ParamKeyTable() //nolint:staticcheck
+		case ibctransfertypes.ModuleName:
+			keyTable = ibctransfertypes.ParamKeyTable() //nolint:staticcheck
 		default:
 			continue
 		}
@@ -187,31 +176,21 @@ func (app *GaiaApp) RegisterUpgradeHandlers() {
 		}
 	}
 
-	baseAppLegacySS := app.ParamsKeeper.Subspace(baseapp.Paramspace).WithKeyTable(paramstypes.ConsensusParamsKeyTable())
-
 	for _, name := range upgradeNamesOfThisVersion {
 		app.UpgradeKeeper.SetUpgradeHandler(
 			name,
-			makeUnreleasedUpgradeHandler(app, name, baseAppLegacySS),
+			makeUnreleasedUpgradeHandler(app, name),
 		)
 	}
 }
 
 // makeUnreleasedUpgradeHandler performs standard upgrade actions plus custom actions for the unreleased upgrade.
-func makeUnreleasedUpgradeHandler(app *GaiaApp, targetUpgrade string, baseAppLegacySS paramstypes.Subspace) func(sdk.Context, upgradetypes.Plan, module.VersionMap) (module.VersionMap, error) {
+func makeUnreleasedUpgradeHandler(app *GaiaApp, targetUpgrade string) upgradetypes.UpgradeHandler {
 	_ = targetUpgrade
-	return func(ctx sdk.Context, plan upgradetypes.Plan, fromVm module.VersionMap) (module.VersionMap, error) {
+	return func(goCtx context.Context, plan upgradetypes.Plan, fromVm module.VersionMap) (module.VersionMap, error) {
+		ctx := sdk.UnwrapSDKContext(goCtx)
 		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
@@ -224,62 +203,33 @@ func makeUnreleasedUpgradeHandler(app *GaiaApp, targetUpgrade string, baseAppLeg
 				return module.VersionMap{}, fmt.Errorf("cannot run %s as first upgrade", plan.Name)
 			}
 
-			// Each CoreProposalStep runs sequentially, and can be constructed from
-			// one or more modules executing in parallel within the step.
-			CoreProposalSteps = append(CoreProposalSteps,
-				// Register a new ZCF to be used for all future contract instances and upgrades
-				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(
-					"@agoric/builders/scripts/smart-wallet/build-wallet-factory2-upgrade.js",
-				),
-			)
-
-			// 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",
-					},
-				},
-			)
+			// prune expired tendermint consensus states to save storage space.
+			_, err := ibctmmigrations.PruneExpiredConsensusStates(ctx, app.AppCodec(), app.IBCKeeper.ClientKeeper)
 			if err != nil {
-				return module.VersionMap{}, err
+				return nil, err
 			}
-			CoreProposalSteps = append(CoreProposalSteps,
-				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"}
+			switch ctx.ChainID() {
+			case "agoric-mainfork-1", "agoric-3": // MAINNET
+				terminationTargets = []string{
+					// v29 "zcf-b1-4522b-ATOM-USD_price_feed"
+					"board02963:ATOM-USD_price_feed",
+					// v68 "zcf-b1-4522b-stATOM-USD_price_feed"
+					"board012113:stATOM-USD_price_feed",
+					// v98 "zcf-b1-4522b-stOSMO-USD_price_feed"
+					"board002164:stOSMO-USD_price_feed",
+					// v104 "zcf-b1-4522b-stTIA-USD_price_feed"
+					"board043173:stTIA-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...,
+					terminationTargets,
 				)
 				if err != nil {
 					return module.VersionMap{}, err

package/cmd/agd/agvm.go

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