@agoric/cosmos 0.35.0-u21.0 → 0.35.0-u22.0

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
+}