Merge branch 'feat/sdk-50' into fix/slinky-state

app/upgrades/v4.0.0/upgrades.go

@@ -5,12 +5,14 @@ import (
 	"fmt"
 
 	upgradetypes "cosmossdk.io/x/upgrade/types"
-
+	comettypes "github.com/cometbft/cometbft/proto/tendermint/types"
 	adminmoduletypes "github.com/cosmos/admin-module/x/adminmodule/types"
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/module"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	consensuskeeper "github.com/cosmos/cosmos-sdk/x/consensus/keeper"
+	"github.com/cosmos/cosmos-sdk/x/consensus/types"
 	marketmapkeeper "github.com/skip-mev/slinky/x/marketmap/keeper"
 	marketmaptypes "github.com/skip-mev/slinky/x/marketmap/types"
 
@@ -34,6 +36,12 @@ func CreateUpgradeHandler(
 			return vm, err
 		}
 
+		ctx.Logger().Info("Setting consensus params...")
+		err = enableVoteExtensions(ctx, keepers.ConsensusKeeper)
+		if err != nil {
+			return nil, err
+		}
+
 		ctx.Logger().Info("Setting marketmap params...")
 		err = setMarketMapParams(ctx, keepers.MarketmapKeeper)
 		if err != nil {
@@ -79,3 +87,24 @@ func setMarketState(ctx sdk.Context, mmKeeper *marketmapkeeper.Keeper) error {
 	}
 	return nil
 }
+
+func enableVoteExtensions(ctx sdk.Context, consensusKeeper *consensuskeeper.Keeper) error {
+	oldParams, err := consensusKeeper.Params(ctx, &types.QueryParamsRequest{})
+	if err != nil {
+		return err
+	}
+
+	// we need to enable VoteExtensions for Slinky
+	oldParams.Params.Abci = &comettypes.ABCIParams{VoteExtensionsEnableHeight: ctx.BlockHeight() + 4}
+
+	updateParamsMsg := types.MsgUpdateParams{
+		Authority: authtypes.NewModuleAddress(adminmoduletypes.ModuleName).String(),
+		Block:     oldParams.Params.Block,
+		Evidence:  oldParams.Params.Evidence,
+		Validator: oldParams.Params.Validator,
+		Abci:      oldParams.Params.Abci,
+	}
+
+	_, err = consensusKeeper.UpdateParams(ctx, &updateParamsMsg)
+	return err
+}

app/upgrades/v4.0.0/upgrades_test.go

@@ -8,6 +8,8 @@ import (
 	slinkyutils "github.com/neutron-org/neutron/v4/utils/slinky"
 
 	upgradetypes "cosmossdk.io/x/upgrade/types"
+	comettypes "github.com/cometbft/cometbft/proto/tendermint/types"
+	"github.com/cosmos/cosmos-sdk/x/consensus/types"
 	"github.com/stretchr/testify/require"
 
 	"github.com/stretchr/testify/suite"
@@ -73,3 +75,30 @@ func (suite *UpgradeTestSuite) TestOracleUpgrade() {
 		suite.Require().True(market.Ticker.Enabled)
 	}
 }
+
+func (suite *UpgradeTestSuite) TestEnableVoteExtensionsUpgrade() {
+	app := suite.GetNeutronZoneApp(suite.ChainA)
+	ctx := suite.ChainA.GetContext()
+	t := suite.T()
+
+	oldParams, err := app.ConsensusParamsKeeper.Params(ctx, &types.QueryParamsRequest{})
+	suite.Require().NoError(err)
+
+	// VoteExtensionsEnableHeight must be updated after the upgrade on upgrade height
+	// but the rest of params must be the same
+	oldParams.Params.Abci = &comettypes.ABCIParams{VoteExtensionsEnableHeight: ctx.BlockHeight() + 4}
+	// it is automatically tracked in upgrade handler, we need to set it manually for tests
+	oldParams.Params.Version = &comettypes.VersionParams{App: 0}
+
+	upgrade := upgradetypes.Plan{
+		Name:   v400.UpgradeName,
+		Info:   "some text here",
+		Height: ctx.BlockHeight(),
+	}
+	require.NoError(t, app.UpgradeKeeper.ApplyUpgrade(ctx, upgrade))
+
+	newParams, err := app.ConsensusParamsKeeper.Params(ctx, &types.QueryParamsRequest{})
+	suite.Require().NoError(err)
+
+	suite.Require().Equal(oldParams, newParams)
+}

testutil/test_helpers.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	tmrand "github.com/cometbft/cometbft/libs/rand"
+
 	"github.com/neutron-org/neutron/v4/utils"
 
 	"github.com/neutron-org/neutron/v4/app/config"

testutil/tokenfactory/keeper/tokenfactory.go

@@ -0,0 +1,56 @@
+package keeper
+
+import (
+	"testing"
+
+	"cosmossdk.io/log"
+	"cosmossdk.io/store"
+	metrics2 "cosmossdk.io/store/metrics"
+	storetypes "cosmossdk.io/store/types"
+	tmproto "github.com/cometbft/cometbft/proto/tendermint/types"
+	db2 "github.com/cosmos/cosmos-db"
+	"github.com/cosmos/cosmos-sdk/codec"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/require"
+
+	"github.com/neutron-org/neutron/v4/x/tokenfactory/keeper"
+	"github.com/neutron-org/neutron/v4/x/tokenfactory/types"
+)
+
+func TokenFactoryKeeper(
+	t testing.TB,
+	accountKeeper types.AccountKeeper,
+	bankKeeper types.BankKeeper,
+	contractKeeper types.ContractKeeper,
+) (keeper.Keeper, sdk.Context) {
+	storeKey := storetypes.NewKVStoreKey(types.StoreKey)
+	memStoreKey := storetypes.NewMemoryStoreKey(types.MemStoreKey)
+
+	db := db2.NewMemDB()
+	stateStore := store.NewCommitMultiStore(db, log.NewNopLogger(), metrics2.NewNoOpMetrics())
+	stateStore.MountStoreWithDB(storeKey, storetypes.StoreTypeIAVL, db)
+	stateStore.MountStoreWithDB(memStoreKey, storetypes.StoreTypeMemory, nil)
+	require.NoError(t, stateStore.LoadLatestVersion())
+
+	registry := codectypes.NewInterfaceRegistry()
+	cdc := codec.NewProtoCodec(registry)
+
+	k := keeper.NewKeeper(
+		cdc,
+		storeKey,
+		nil,
+		accountKeeper,
+		bankKeeper,
+		contractKeeper,
+		"authority",
+	)
+
+	ctx := sdk.NewContext(stateStore, tmproto.Header{}, false, log.NewNopLogger())
+
+	// Initialize params
+	err := k.SetParams(ctx, types.DefaultParams())
+	require.NoError(t, err)
+
+	return k, ctx
+}

testutil/transfer/keeper/keeper.go

@@ -23,7 +23,13 @@ import (
 	"github.com/neutron-org/neutron/v4/x/transfer/types"
 )
 
-func TransferKeeper(t testing.TB, managerKeeper types.WasmKeeper, refunderKeeper types.FeeRefunderKeeper, channelKeeper types.ChannelKeeper, authKeeper types.AccountKeeper) (*keeper.KeeperTransferWrapper, sdk.Context, *storetypes.KVStoreKey) {
+func TransferKeeper(
+	t testing.TB,
+	managerKeeper types.WasmKeeper,
+	refunderKeeper types.FeeRefunderKeeper,
+	channelKeeper types.ChannelKeeper,
+	authKeeper types.AccountKeeper,
+) (*keeper.KeeperTransferWrapper, sdk.Context, *storetypes.KVStoreKey) {
 	storeKey := storetypes.NewKVStoreKey(transfertypes.StoreKey)
 	memStoreKey := storetypes.NewMemoryStoreKey("mem_" + transfertypes.StoreKey)
 

wasmbinding/message_plugin.go

@@ -176,12 +176,6 @@ func (m *CustomMessenger) DispatchMsg(ctx sdk.Context, contractAddr sdk.AccAddre
 }
 
 func handleDexMsg[T sdk.LegacyMsg, R proto.Message](ctx sdk.Context, msg T, handler func(ctx context.Context, msg T) (R, error)) ([][]byte, [][]*types.Any, error) {
-	// TODO: is this even legal to do?
-	validatableMsg := any(msg).(sdk.HasValidateBasic)
-	if err := validatableMsg.ValidateBasic(); err != nil {
-		return nil, nil, errors.Wrapf(err, "failed to validate %T", msg)
-	}
-
 	if len(msg.GetSigners()) != 1 {
 		// should never happen
 		panic("should be 1 signer")
@@ -271,10 +265,6 @@ func (m *CustomMessenger) dispatchDexMsg(ctx sdk.Context, contractAddr sdk.AccAd
 func (m *CustomMessenger) ibcTransfer(ctx sdk.Context, contractAddr sdk.AccAddress, ibcTransferMsg transferwrappertypes.MsgTransfer) ([]sdk.Event, [][]byte, [][]*types.Any, error) {
 	ibcTransferMsg.Sender = contractAddr.String()
 
-	if err := ibcTransferMsg.ValidateBasic(); err != nil {
-		return nil, nil, nil, errors.Wrap(err, "failed to validate ibcTransferMsg")
-	}
-
 	response, err := m.transferKeeper.Transfer(ctx, &ibcTransferMsg)
 	if err != nil {
 		ctx.Logger().Debug("transferServer.Transfer: failed to transfer",
@@ -351,10 +341,6 @@ func (m *CustomMessenger) performUpdateInterchainQuery(ctx sdk.Context, contract
 		Sender:                contractAddr.String(),
 	}
 
-	if err := msg.ValidateBasic(); err != nil {
-		return nil, errors.Wrap(err, "failed to validate incoming UpdateInterchainQuery message")
-	}
-
 	response, err := m.Icqmsgserver.UpdateInterchainQuery(ctx, &msg)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to update interchain query")
@@ -403,10 +389,6 @@ func (m *CustomMessenger) performRemoveInterchainQuery(ctx sdk.Context, contract
 		Sender:  contractAddr.String(),
 	}
 
-	if err := msg.ValidateBasic(); err != nil {
-		return nil, errors.Wrap(err, "failed to validate incoming RemoveInterchainQuery message")
-	}
-
 	response, err := m.Icqmsgserver.RemoveInterchainQuery(ctx, &msg)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to remove interchain query")
@@ -637,10 +619,6 @@ func PerformCreateDenom(f *tokenfactorykeeper.Keeper, ctx sdk.Context, contractA
 
 	msgCreateDenom := tokenfactorytypes.NewMsgCreateDenom(contractAddr.String(), createDenom.Subdenom)
 
-	if err := msgCreateDenom.ValidateBasic(); err != nil {
-		return errors.Wrap(err, "failed validating MsgCreateDenom")
-	}
-
 	// Create denom
 	_, err := msgServer.CreateDenom(
 		ctx,
@@ -667,10 +645,6 @@ func PerformForceTransfer(f *tokenfactorykeeper.Keeper, ctx sdk.Context, contrac
 
 	msgForceTransfer := tokenfactorytypes.NewMsgForceTransfer(contractAddr.String(), sdk.NewInt64Coin(forceTransfer.Denom, forceTransfer.Amount.Int64()), forceTransfer.TransferFromAddress, forceTransfer.TransferToAddress)
 
-	if err := msgForceTransfer.ValidateBasic(); err != nil {
-		return errors.Wrap(err, "failed validating MsgForceTransfer")
-	}
-
 	// Force Transfer
 	_, err := msgServer.ForceTransfer(
 		ctx,
@@ -697,10 +671,6 @@ func PerformSetDenomMetadata(f *tokenfactorykeeper.Keeper, ctx sdk.Context, cont
 
 	msgSetDenomMetadata := tokenfactorytypes.NewMsgSetDenomMetadata(contractAddr.String(), setDenomMetadata.Metadata)
 
-	if err := msgSetDenomMetadata.ValidateBasic(); err != nil {
-		return errors.Wrap(err, "failed validating MsgSetDenomMetadata")
-	}
-
 	// Set denom metadata
 	_, err := msgServer.SetDenomMetadata(
 		ctx,
@@ -739,9 +709,6 @@ func PerformMint(f *tokenfactorykeeper.Keeper, b *bankkeeper.BaseKeeper, ctx sdk
 
 	coin := sdk.Coin{Denom: mint.Denom, Amount: mint.Amount}
 	sdkMsg := tokenfactorytypes.NewMsgMint(contractAddr.String(), coin)
-	if err = sdkMsg.ValidateBasic(); err != nil {
-		return err
-	}
 
 	// Mint through token factory / message server
 	msgServer := tokenfactorykeeper.NewMsgServerImpl(*f)
@@ -760,9 +727,6 @@ func PerformMint(f *tokenfactorykeeper.Keeper, b *bankkeeper.BaseKeeper, ctx sdk
 
 func PerformSetBeforeSendHook(f *tokenfactorykeeper.Keeper, ctx sdk.Context, contractAddr sdk.AccAddress, set *bindings.SetBeforeSendHook) error {
 	sdkMsg := tokenfactorytypes.NewMsgSetBeforeSendHook(contractAddr.String(), set.Denom, set.ContractAddr)
-	if err := sdkMsg.ValidateBasic(); err != nil {
-		return err
-	}
 
 	// SetBeforeSendHook through token factory / message server
 	msgServer := tokenfactorykeeper.NewMsgServerImpl(*f)
@@ -792,9 +756,6 @@ func ChangeAdmin(f *tokenfactorykeeper.Keeper, ctx sdk.Context, contractAddr sdk
 	}
 
 	changeAdminMsg := tokenfactorytypes.NewMsgChangeAdmin(contractAddr.String(), changeAdmin.Denom, newAdminAddr.String())
-	if err := changeAdminMsg.ValidateBasic(); err != nil {
-		return err
-	}
 
 	msgServer := tokenfactorykeeper.NewMsgServerImpl(*f)
 	_, err = msgServer.ChangeAdmin(ctx, changeAdminMsg)
@@ -822,9 +783,6 @@ func PerformBurn(f *tokenfactorykeeper.Keeper, ctx sdk.Context, contractAddr sdk
 
 	coin := sdk.Coin{Denom: burn.Denom, Amount: burn.Amount}
 	sdkMsg := tokenfactorytypes.NewMsgBurn(contractAddr.String(), coin)
-	if err := sdkMsg.ValidateBasic(); err != nil {
-		return err
-	}
 
 	// Burn through token factory / message server
 	msgServer := tokenfactorykeeper.NewMsgServerImpl(*f)
@@ -882,10 +840,6 @@ func (m *CustomMessenger) performSubmitTx(ctx sdk.Context, contractAddr sdk.AccA
 		})
 	}
 
-	if err := tx.ValidateBasic(); err != nil {
-		return nil, errors.Wrap(err, "failed to validate incoming SubmitTx message")
-	}
-
 	response, err := m.Ictxmsgserver.SubmitTx(ctx, &tx)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to submit interchain transaction")
@@ -938,9 +892,6 @@ func (m *CustomMessenger) performRegisterInterchainAccount(ctx sdk.Context, cont
 		InterchainAccountId: reg.InterchainAccountId,
 		RegisterFee:         getRegisterFee(reg.RegisterFee),
 	}
-	if err := msg.ValidateBasic(); err != nil {
-		return nil, errors.Wrap(err, "failed to validate incoming RegisterInterchainAccount message")
-	}
 
 	response, err := m.Ictxmsgserver.RegisterInterchainAccount(ctx, &msg)
 	if err != nil {
@@ -1005,9 +956,6 @@ func (m *CustomMessenger) performRegisterInterchainQuery(ctx sdk.Context, contra
 		UpdatePeriod:       reg.UpdatePeriod,
 		Sender:             contractAddr.String(),
 	}
-	if err := msg.ValidateBasic(); err != nil {
-		return nil, errors.Wrap(err, "failed to validate incoming RegisterInterchainQuery message")
-	}
 
 	response, err := m.Icqmsgserver.RegisterInterchainQuery(ctx, &msg)
 	if err != nil {

x/contractmanager/keeper/msg_server.go

@@ -24,9 +24,10 @@ var _ types.MsgServer = msgServer{}
 
 // UpdateParams updates the module parameters
 func (k Keeper) UpdateParams(goCtx context.Context, req *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) {
-	if err := req.ValidateBasic(); err != nil {
-		return nil, err
+	if err := req.Validate(); err != nil {
+		return nil, errors.Wrap(err, "failed to validate MsgUpdateParams")
 	}
+
 	authority := k.GetAuthority()
 	if authority != req.Authority {
 		return nil, errors.Wrapf(sdkerrors.ErrInvalidRequest, "invalid authority; expected %s, got %s", authority, req.Authority)

x/contractmanager/keeper/msg_server_test.go

@@ -0,0 +1,44 @@
+package keeper_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/neutron-org/neutron/v4/testutil/contractmanager/keeper"
+	"github.com/neutron-org/neutron/v4/x/contractmanager/types"
+)
+
+func TestMsgUpdateParamsValidate(t *testing.T) {
+	k, ctx := keeper.ContractManagerKeeper(t, nil)
+
+	tests := []struct {
+		name        string
+		msg         types.MsgUpdateParams
+		expectedErr string
+	}{
+		{
+			"empty authority",
+			types.MsgUpdateParams{
+				Authority: "",
+			},
+			"authority is invalid",
+		},
+		{
+			"invalid authority",
+			types.MsgUpdateParams{
+				Authority: "invalid authority",
+			},
+			"authority is invalid",
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			resp, err := k.UpdateParams(ctx, &tt.msg)
+			require.ErrorContains(t, err, tt.expectedErr)
+			require.Nil(t, resp)
+		})
+	}
+}

x/contractmanager/types/tx.go

@@ -27,7 +27,7 @@ func (msg *MsgUpdateParams) GetSignBytes() []byte {
 	return ModuleCdc.MustMarshalJSON(msg)
 }
 
-func (msg *MsgUpdateParams) ValidateBasic() error {
+func (msg *MsgUpdateParams) Validate() error {
 	if _, err := sdk.AccAddressFromBech32(msg.Authority); err != nil {
 		return errorsmod.Wrap(err, "authority is invalid")
 	}