CHANGELOG.md

@@ -40,6 +40,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 
 ### State Machine Breaking
 
+* (evm) [#1472](https://github.com/evmos/ethermint/pull/1472) Deprecate x/params usage in x/evm
 * (deps) #[1575](https://github.com/evmos/ethermint/pull/1575) bump ibc-go to [`v6.1.0`]
 * (deps) [#1361](https://github.com/evmos/ethermint/pull/1361) Bump ibc-go to [`v5.1.0`](https://github.com/cosmos/ibc-go/releases/tag/v5.1.0)
 * (evm) [\#1272](https://github.com/evmos/ethermint/pull/1272) Implement modular interface for the EVM.

app/ante/interfaces.go

@@ -50,10 +50,10 @@ type EVMKeeper interface {
 	ResetTransientGasUsed(ctx sdk.Context)
 	GetTxIndexTransient(ctx sdk.Context) uint64
 	GetChainConfig(ctx sdk.Context) evmtypes.ChainConfig
-	GetEVMDenom(ctx sdk.Context) string
-	GetEnableCreate(ctx sdk.Context) bool
-	GetEnableCall(ctx sdk.Context) bool
 	GetAllowUnprotectedTxs(ctx sdk.Context) bool
+	GetEVMDenom(ctx sdk.Context) string
+	GetEnableCall(ctx sdk.Context) bool
+	GetEnableCreate(ctx sdk.Context) bool
 }
 
 type protoTxProvider interface {

app/app.go

@@ -416,8 +416,9 @@ func NewEthermintApp(
 		appCodec, app.GetSubspace(feemarkettypes.ModuleName), keys[feemarkettypes.StoreKey], tkeys[feemarkettypes.TransientKey],
 	)
 
+	// Set authority to x/gov module account to only expect the module account to update params
 	app.EvmKeeper = evmkeeper.NewKeeper(
-		appCodec, keys[evmtypes.StoreKey], tkeys[evmtypes.TransientKey], app.GetSubspace(evmtypes.ModuleName),
+		appCodec, keys[evmtypes.StoreKey], tkeys[evmtypes.TransientKey], authtypes.NewModuleAddress(govtypes.ModuleName),
 		app.AccountKeeper, app.BankKeeper, app.StakingKeeper, app.FeeMarketKeeper,
 		nil, geth.NewEVM, tracer,
 	)
@@ -505,7 +506,7 @@ func NewEthermintApp(
 		ibc.NewAppModule(app.IBCKeeper),
 		transferModule,
 		// Ethermint app modules
-		evm.NewAppModule(app.EvmKeeper, app.AccountKeeper),
+		evm.NewAppModule(app.EvmKeeper, app.AccountKeeper, app.GetSubspace(evmtypes.ModuleName)),
 		feemarket.NewAppModule(app.FeeMarketKeeper),
 	)
 

proto/ethermint/evm/v1/evm.proto

@@ -15,7 +15,11 @@ message Params {
   // enable_call toggles state transitions that use the vm.Call function
   bool enable_call = 3 [(gogoproto.moretags) = "yaml:\"enable_call\""];
   // extra_eips defines the additional EIPs for the vm.Config
-  repeated int64 extra_eips = 4 [(gogoproto.customname) = "ExtraEIPs", (gogoproto.moretags) = "yaml:\"extra_eips\""];
+  ExtraEIPs extra_eips = 4 [
+    (gogoproto.customname) = "ExtraEIPs",
+    (gogoproto.moretags) = "yaml:\"extra_eips\"",
+    (gogoproto.nullable) = false
+  ];
   // chain_config defines the EVM chain configuration parameters
   ChainConfig chain_config = 5 [(gogoproto.moretags) = "yaml:\"chain_config\"", (gogoproto.nullable) = false];
   // allow_unprotected_txs defines if replay-protected (i.e non EIP155
@@ -23,6 +27,12 @@ message Params {
   bool allow_unprotected_txs = 6;
 }
 
+// ExtraEIPs represents extra EIPs for the vm.Config
+message ExtraEIPs {
+  // eips defines the additional EIPs for the vm.Config
+  repeated int64 eips = 1 [(gogoproto.customname) = "EIPs", (gogoproto.moretags) = "yaml:\"eips\""];
+}
+
 // ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values
 // instead of *big.Int.
 message ChainConfig {
@@ -127,7 +137,6 @@ message ChainConfig {
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
     (gogoproto.moretags) = "yaml:\"cancun_block\""
   ];
-
 }
 
 // State represents a single Storage key value pair item.

proto/ethermint/evm/v1/tx.proto

@@ -1,6 +1,7 @@
 syntax = "proto3";
 package ethermint.evm.v1;
 
+import "cosmos/msg/v1/msg.proto";
 import "cosmos_proto/cosmos.proto";
 import "ethermint/evm/v1/evm.proto";
 import "gogoproto/gogo.proto";
@@ -15,6 +16,9 @@ service Msg {
   rpc EthereumTx(MsgEthereumTx) returns (MsgEthereumTxResponse) {
     option (google.api.http).post = "/ethermint/evm/v1/ethereum_tx";
   };
+  // UpdateParams defined a governance operation for updating the x/evm module parameters.
+  // The authority is hard-coded to the Cosmos SDK x/gov module account
+  rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse);
 }
 
 // MsgEthereumTx encapsulates an Ethereum transaction as an SDK message.
@@ -158,3 +162,19 @@ message MsgEthereumTxResponse {
   // gas_used specifies how much gas was consumed by the transaction
   uint64 gas_used = 5;
 }
+
+// MsgUpdateParams defines a Msg for updating the x/evm module parameters.
+message MsgUpdateParams {
+  option (cosmos.msg.v1.signer) = "authority";
+
+  // authority is the address of the governance account.
+  string authority = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+
+  // params defines the x/evm parameters to update.
+  // NOTE: All parameters must be supplied.
+  Params params = 2 [(gogoproto.nullable) = false];
+}
+
+// MsgUpdateParamsResponse defines the response structure for executing a
+// MsgUpdateParams message.
+message MsgUpdateParamsResponse {}

rpc/backend/backend_suite_test.go

@@ -7,8 +7,6 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/evmos/ethermint/crypto/ethsecp256k1"
-
 	dbm "github.com/tendermint/tm-db"
 
 	"github.com/cosmos/cosmos-sdk/client"
@@ -21,6 +19,7 @@ import (
 	tmrpctypes "github.com/tendermint/tendermint/rpc/core/types"
 
 	"github.com/evmos/ethermint/app"
+	"github.com/evmos/ethermint/crypto/ethsecp256k1"
 	"github.com/evmos/ethermint/crypto/hd"
 	"github.com/evmos/ethermint/encoding"
 	"github.com/evmos/ethermint/indexer"

x/evm/genesis.go

@@ -39,7 +39,10 @@ func InitGenesis(
 ) []abci.ValidatorUpdate {
 	k.WithChainID(ctx)
 
-	k.SetParams(ctx, data.Params)
+	err := k.SetParams(ctx, data.Params)
+	if err != nil {
+		panic(fmt.Errorf("error setting params %s", err))
+	}
 
 	// ensure evm module account is set
 	if addr := accountKeeper.GetModuleAddress(types.ModuleName); addr == nil {

x/evm/handler.go

@@ -30,10 +30,11 @@ func NewHandler(server types.MsgServer) sdk.Handler {
 
 		switch msg := msg.(type) {
 		case *types.MsgEthereumTx:
-			// execute state transition
 			res, err := server.EthereumTx(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
-
+		case *types.MsgUpdateParams:
+			res, err := server.UpdateParams(sdk.WrapSDKContext(ctx), msg)
+			return sdk.WrapServiceResult(ctx, res, err)
 		default:
 			err := errorsmod.Wrapf(errortypes.ErrUnknownRequest, "unrecognized %s message type: %T", types.ModuleName, msg)
 			return nil, err

x/evm/keeper/grpc_query_test.go

@@ -540,7 +540,11 @@ func (suite *KeeperTestSuite) TestEstimateGas() {
 			"enough balance",
 			func() {
 				args = types.TransactionArgs{To: &common.Address{}, From: &suite.address, Value: (*hexutil.Big)(big.NewInt(100))}
-			}, false, 0, false},
+			},
+			false,
+			0,
+			false,
+		},
 		// should success, because gas limit lower than 21000 is ignored
 		{
 			"gas exceed allowance",
@@ -1261,9 +1265,7 @@ func (suite *KeeperTestSuite) TestQueryBaseFee() {
 }
 
 func (suite *KeeperTestSuite) TestEthCall() {
-	var (
+	var req *types.EthCallRequest
-		req *types.EthCallRequest
-	)
 
 	address := tests.GenerateAddress()
 	suite.Require().Equal(uint64(0), suite.app.EvmKeeper.GetNonce(suite.ctx, address))
@@ -1334,7 +1336,6 @@ func (suite *KeeperTestSuite) TestEthCall() {
 			}
 		})
 	}
-
 }
 
 func (suite *KeeperTestSuite) TestEmptyRequest() {

x/evm/keeper/keeper.go

@@ -23,7 +23,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/store/prefix"
 	storetypes "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
@@ -51,8 +50,8 @@ type Keeper struct {
 	// key to access the transient store, which is reset on every block during Commit
 	transientKey storetypes.StoreKey
 
-	// module specific parameter space that can be configured through governance
+	// the address capable of executing a MsgUpdateParams message. Typically, this should be the x/gov module account.
-	paramSpace paramtypes.Subspace
+	authority sdk.AccAddress
 	// access to account state
 	accountKeeper types.AccountKeeper
 	// update balance and accounting operations with coins
@@ -82,7 +81,7 @@ type Keeper struct {
 func NewKeeper(
 	cdc codec.BinaryCodec,
 	storeKey, transientKey storetypes.StoreKey,
-	paramSpace paramtypes.Subspace,
+	authority sdk.AccAddress,
 	ak types.AccountKeeper,
 	bankKeeper types.BankKeeper,
 	sk types.StakingKeeper,
@@ -96,15 +95,15 @@ func NewKeeper(
 		panic("the EVM module account has not been set")
 	}
 
-	// set KeyTable if it has not already been set
+	// ensure the authority account is correct
-	if !paramSpace.HasKeyTable() {
+	if err := sdk.VerifyAddressFormat(authority); err != nil {
-		paramSpace = paramSpace.WithKeyTable(types.ParamKeyTable())
+		panic(err)
 	}
 
 	// NOTE: we pass in the parameter space to the CommitStateDB in order to use custom denominations for the EVM operations
 	return &Keeper{
 		cdc:               cdc,
-		paramSpace:        paramSpace,
+		authority:         authority,
 		accountKeeper:     ak,
 		bankKeeper:        bankKeeper,
 		stakingKeeper:     sk,
@@ -156,6 +155,11 @@ func (k Keeper) EmitBlockBloomEvent(ctx sdk.Context, bloom ethtypes.Bloom) {
 	)
 }
 
+// GetAuthority returns the x/evm module authority address
+func (k Keeper) GetAuthority() sdk.AccAddress {
+	return k.authority
+}
+
 // GetBlockBloomTransient returns bloom bytes for the current block height
 func (k Keeper) GetBlockBloomTransient(ctx sdk.Context) *big.Int {
 	store := prefix.NewStore(ctx.TransientStore(k.transientKey), types.KeyPrefixTransientBloom)
@@ -312,8 +316,7 @@ func (k *Keeper) GetNonce(ctx sdk.Context, addr common.Address) uint64 {
 // GetBalance load account's balance of gas token
 func (k *Keeper) GetBalance(ctx sdk.Context, addr common.Address) *big.Int {
 	cosmosAddr := sdk.AccAddress(addr.Bytes())
-	evmDenom := ""
+	evmDenom := k.GetEVMDenom(ctx)
-	k.paramSpace.GetIfExists(ctx, types.ParamStoreKeyEVMDenom, &evmDenom)
 	// if node is pruned, params is empty. Return invalid value
 	if evmDenom == "" {
 		return big.NewInt(-1)

x/evm/keeper/keeper_test.go

@@ -489,10 +489,8 @@ func (suite *KeeperTestSuite) TestGetAccountStorage() {
 				i++
 				return false
 			})
-
 		})
 	}
-
 }
 
 func (suite *KeeperTestSuite) TestGetAccountOrEmpty() {
@@ -529,7 +527,6 @@ func (suite *KeeperTestSuite) TestGetAccountOrEmpty() {
 			} else {
 				suite.Require().NotEqual(empty, res)
 			}
-
 		})
 	}
 }

x/evm/keeper/migrations.go

@@ -15,14 +15,27 @@
 // along with the Ethermint library. If not, see https://github.com/evmos/ethermint/blob/main/LICENSE
 package keeper
 
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	v4 "github.com/evmos/ethermint/x/evm/migrations/v4"
+	"github.com/evmos/ethermint/x/evm/types"
+)
+
 // Migrator is a struct for handling in-place store migrations.
 type Migrator struct {
 	keeper         Keeper
+	legacySubspace types.Subspace
 }
 
 // NewMigrator returns a new Migrator.
-func NewMigrator(keeper Keeper) Migrator {
+func NewMigrator(keeper Keeper, legacySubspace types.Subspace) Migrator {
 	return Migrator{
 		keeper:         keeper,
+		legacySubspace: legacySubspace,
 	}
 }
+
+// Migrate3to4 migrates the store from consensus version 3 to 4
+func (m Migrator) Migrate3to4(ctx sdk.Context) error {
+	return v4.MigrateStore(ctx, m.keeper.storeKey, m.legacySubspace, m.keeper.cdc)
+}

x/evm/keeper/migrations_test.go

@@ -0,0 +1,42 @@
+package keeper_test
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	evmkeeper "github.com/evmos/ethermint/x/evm/keeper"
+	v4types "github.com/evmos/ethermint/x/evm/migrations/v4/types"
+	"github.com/evmos/ethermint/x/evm/types"
+)
+
+type mockSubspace struct {
+	ps v4types.V4Params
+}
+
+func newMockSubspace(ps v4types.V4Params) mockSubspace {
+	return mockSubspace{ps: ps}
+}
+
+func (ms mockSubspace) GetParamSetIfExists(_ sdk.Context, ps types.LegacyParams) {
+	*ps.(*v4types.V4Params) = ms.ps
+}
+
+func (suite *KeeperTestSuite) TestMigrations() {
+	legacySubspace := newMockSubspace(v4types.DefaultParams())
+	migrator := evmkeeper.NewMigrator(*suite.app.EvmKeeper, legacySubspace)
+
+	testCases := []struct {
+		name        string
+		migrateFunc func(ctx sdk.Context) error
+	}{
+		{
+			"Run Migrate3to4",
+			migrator.Migrate3to4,
+		},
+	}
+
+	for _, tc := range testCases {
+		suite.Run(tc.name, func() {
+			err := tc.migrateFunc(suite.ctx)
+			suite.Require().NoError(err)
+		})
+	}
+}

x/evm/keeper/msg_server.go

@@ -21,6 +21,8 @@ import (
 	"fmt"
 	"strconv"
 
+	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
+
 	tmbytes "github.com/tendermint/tendermint/libs/bytes"
 	tmtypes "github.com/tendermint/tendermint/types"
 
@@ -140,3 +142,20 @@ func (k *Keeper) EthereumTx(goCtx context.Context, msg *types.MsgEthereumTx) (*t
 
 	return response, nil
 }
+
+// UpdateParams implements the gRPC MsgServer interface. When an UpdateParams
+// proposal passes, it updates the module parameters. The update can only be
+// performed if the requested authority is the Cosmos SDK governance module
+// account.
+func (k *Keeper) UpdateParams(goCtx context.Context, req *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) {
+	if k.authority.String() != req.Authority {
+		return nil, errorsmod.Wrapf(govtypes.ErrInvalidSigner, "invalid authority, expected %s, got %s", k.authority.String(), req.Authority)
+	}
+
+	ctx := sdk.UnwrapSDKContext(goCtx)
+	if err := k.SetParams(ctx, req.Params); err != nil {
+		return nil, err
+	}
+
+	return &types.MsgUpdateParamsResponse{}, nil
+}

x/evm/keeper/msg_server_test.go

@@ -3,6 +3,9 @@ package keeper_test
 import (
 	"math/big"
 
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
+
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/evmos/ethermint/x/evm/statedb"
@@ -78,3 +81,37 @@ func (suite *KeeperTestSuite) TestEthereumTx() {
 		})
 	}
 }
+
+func (suite *KeeperTestSuite) TestUpdateParams() {
+	testCases := []struct {
+		name      string
+		request   *types.MsgUpdateParams
+		expectErr bool
+	}{
+		{
+			name:      "fail - invalid authority",
+			request:   &types.MsgUpdateParams{Authority: "foobar"},
+			expectErr: true,
+		},
+		{
+			name: "pass - valid Update msg",
+			request: &types.MsgUpdateParams{
+				Authority: authtypes.NewModuleAddress(govtypes.ModuleName).String(),
+				Params:    types.DefaultParams(),
+			},
+			expectErr: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		suite.Run("MsgUpdateParams", func() {
+			_, err := suite.app.EvmKeeper.UpdateParams(suite.ctx, tc.request)
+			if tc.expectErr {
+				suite.Require().Error(err)
+			} else {
+				suite.Require().NoError(err)
+			}
+		})
+	}
+}

x/evm/keeper/params.go

@@ -17,57 +17,135 @@ package keeper
 
 import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
-
 	"github.com/evmos/ethermint/x/evm/types"
 )
 
 // GetParams returns the total set of evm parameters.
 func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) {
-	// TODO: update once https://github.com/cosmos/cosmos-sdk/pull/12615 is merged
+	evmDenom := k.GetEVMDenom(ctx)
-	// and released
+	allowUnprotectedTx := k.GetAllowUnprotectedTxs(ctx)
-	for _, pair := range params.ParamSetPairs() {
+	enableCreate := k.GetEnableCreate(ctx)
-		k.paramSpace.GetIfExists(ctx, pair.Key, pair.Value)
+	enableCall := k.GetEnableCall(ctx)
-	}
+	chainCfg := k.GetChainConfig(ctx)
+	extraEIPs := k.GetExtraEIPs(ctx)
 
-	return params
+	return types.NewParams(evmDenom, allowUnprotectedTx, enableCreate, enableCall, chainCfg, extraEIPs)
 }
 
-// SetParams sets the evm parameters to the param space.
+// SetParams sets the EVM params each in their individual key for better get performance
-func (k Keeper) SetParams(ctx sdk.Context, params types.Params) {
+func (k Keeper) SetParams(ctx sdk.Context, params types.Params) error {
-	k.paramSpace.SetParamSet(ctx, &params)
+	if err := params.Validate(); err != nil {
+		return err
+	}
+
+	k.setExtraEIPs(ctx, params.ExtraEIPs)
+	k.setChainConfig(ctx, params.ChainConfig)
+	k.setEvmDenom(ctx, params.EvmDenom)
+	k.setEnableCall(ctx, params.EnableCall)
+	k.setEnableCreate(ctx, params.EnableCreate)
+	k.setAllowUnprotectedTxs(ctx, params.AllowUnprotectedTxs)
+
+	return nil
+}
+
+// GetExtraEIPs returns the extra EIPs enabled on the chain.
+func (k Keeper) GetExtraEIPs(ctx sdk.Context) types.ExtraEIPs {
+	var extraEIPs types.ExtraEIPs
+	store := ctx.KVStore(k.storeKey)
+	bz := store.Get(types.ParamStoreKeyExtraEIPs)
+	if len(bz) == 0 {
+		return extraEIPs
+	}
+	k.cdc.MustUnmarshal(bz, &extraEIPs)
+	return extraEIPs
 }
 
 // GetChainConfig returns the chain configuration parameter.
 func (k Keeper) GetChainConfig(ctx sdk.Context) types.ChainConfig {
 	var chainCfg types.ChainConfig
-	k.paramSpace.GetIfExists(ctx, types.ParamStoreKeyChainConfig, &chainCfg)
+	store := ctx.KVStore(k.storeKey)
+	bz := store.Get(types.ParamStoreKeyChainConfig)
+	if len(bz) == 0 {
+		return chainCfg
+	}
+	k.cdc.MustUnmarshal(bz, &chainCfg)
 	return chainCfg
 }
 
 // GetEVMDenom returns the EVM denom.
 func (k Keeper) GetEVMDenom(ctx sdk.Context) string {
-	var evmDenom string
+	store := ctx.KVStore(k.storeKey)
-	k.paramSpace.GetIfExists(ctx, types.ParamStoreKeyEVMDenom, &evmDenom)
+	bz := store.Get(types.ParamStoreKeyEVMDenom)
-	return evmDenom
+	if len(bz) == 0 {
+		return ""
+	}
+	return string(bz)
 }
 
 // GetEnableCall returns true if the EVM Call operation is enabled.
 func (k Keeper) GetEnableCall(ctx sdk.Context) bool {
-	var enableCall bool
+	store := ctx.KVStore(k.storeKey)
-	k.paramSpace.GetIfExists(ctx, types.ParamStoreKeyEnableCall, &enableCall)
+	return store.Has(types.ParamStoreKeyEnableCall)
-	return enableCall
 }
 
 // GetEnableCreate returns true if the EVM Create contract operation is enabled.
 func (k Keeper) GetEnableCreate(ctx sdk.Context) bool {
-	var enableCreate bool
+	store := ctx.KVStore(k.storeKey)
-	k.paramSpace.GetIfExists(ctx, types.ParamStoreKeyEnableCreate, &enableCreate)
+	return store.Has(types.ParamStoreKeyEnableCreate)
-	return enableCreate
 }
 
 // GetAllowUnprotectedTxs returns true if unprotected txs (i.e non-replay protected as per EIP-155) are supported by the chain.
 func (k Keeper) GetAllowUnprotectedTxs(ctx sdk.Context) bool {
-	var allowUnprotectedTx bool
+	store := ctx.KVStore(k.storeKey)
-	k.paramSpace.GetIfExists(ctx, types.ParamStoreKeyAllowUnprotectedTxs, &allowUnprotectedTx)
+	return store.Has(types.ParamStoreKeyAllowUnprotectedTxs)
-	return allowUnprotectedTx
+}
+
+// setChainConfig sets the ChainConfig in the store
+func (k Keeper) setChainConfig(ctx sdk.Context, chainCfg types.ChainConfig) {
+	store := ctx.KVStore(k.storeKey)
+	chainCfgBz := k.cdc.MustMarshal(&chainCfg)
+	store.Set(types.ParamStoreKeyChainConfig, chainCfgBz)
+}
+
+// setExtraEIPs sets the ExtraEIPs in the store
+func (k Keeper) setExtraEIPs(ctx sdk.Context, extraEIPs types.ExtraEIPs) {
+	extraEIPsBz := k.cdc.MustMarshal(&extraEIPs)
+	store := ctx.KVStore(k.storeKey)
+	store.Set(types.ParamStoreKeyExtraEIPs, extraEIPsBz)
+}
+
+// setEvmDenom sets the EVMDenom param in the store
+func (k Keeper) setEvmDenom(ctx sdk.Context, evmDenom string) {
+	store := ctx.KVStore(k.storeKey)
+	store.Set(types.ParamStoreKeyEVMDenom, []byte(evmDenom))
+}
+
+// setAllowUnprotectedTxs sets the AllowUnprotectedTxs param in the store
+func (k Keeper) setAllowUnprotectedTxs(ctx sdk.Context, enable bool) {
+	store := ctx.KVStore(k.storeKey)
+	if enable {
+		store.Set(types.ParamStoreKeyAllowUnprotectedTxs, []byte{0x01})
+		return
+	}
+	store.Delete(types.ParamStoreKeyAllowUnprotectedTxs)
+}
+
+// setEnableCreate sets the EnableCreate param in the store
+func (k Keeper) setEnableCreate(ctx sdk.Context, enable bool) {
+	store := ctx.KVStore(k.storeKey)
+	if enable {
+		store.Set(types.ParamStoreKeyEnableCreate, []byte{0x01})
+		return
+	}
+	store.Delete(types.ParamStoreKeyEnableCreate)
+}
+
+// setEnableCall sets the EnableCall param in the store
+func (k Keeper) setEnableCall(ctx sdk.Context, enable bool) {
+	store := ctx.KVStore(k.storeKey)
+	if enable {
+		store.Set(types.ParamStoreKeyEnableCall, []byte{0x01})
+		return
+	}
+	store.Delete(types.ParamStoreKeyEnableCall)
 }

x/evm/keeper/params_test.go

@@ -1,8 +1,9 @@
 package keeper_test
 
 import (
-	"github.com/evmos/ethermint/x/evm/types"
 	"reflect"
+
+	"github.com/evmos/ethermint/x/evm/types"
 )
 
 func (suite *KeeperTestSuite) TestParams() {
@@ -91,5 +92,4 @@ func (suite *KeeperTestSuite) TestParams() {
 			suite.Require().Equal(tc.expected, outcome)
 		})
 	}
-
 }

x/evm/keeper/state_transition_benchmark_test.go

@@ -143,7 +143,6 @@ func newNativeMessage(
 	msgSigner := ethtypes.MakeSigner(cfg, big.NewInt(blockHeight))
 
 	msg, baseFee, err := newEthMsgTx(nonce, blockHeight, address, cfg, krSigner, ethSigner, txType, data, accessList)
-
 	if err != nil {
 		return nil, err
 	}

x/evm/keeper/statedb_test.go

@@ -897,7 +897,6 @@ func (suite *KeeperTestSuite) TestSetBalance() {
 				suite.Require().NoError(err)
 				suite.Require().Equal(amount, balance)
 			}
-
 		})
 	}
 }

x/evm/migrations/v4/migrate.go

@@ -0,0 +1,51 @@
+package v4
+
+import (
+	"github.com/cosmos/cosmos-sdk/codec"
+	storetypes "github.com/cosmos/cosmos-sdk/store/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	v4types "github.com/evmos/ethermint/x/evm/migrations/v4/types"
+	"github.com/evmos/ethermint/x/evm/types"
+)
+
+// MigrateStore migrates the x/evm module state from the consensus version 3 to
+// version 4. Specifically, it takes the parameters that are currently stored
+// and managed by the Cosmos SDK params module and stores them directly into the x/evm module state.
+func MigrateStore(
+	ctx sdk.Context,
+	storeKey storetypes.StoreKey,
+	legacySubspace types.Subspace,
+	cdc codec.BinaryCodec,
+) error {
+	var (
+		store  = ctx.KVStore(storeKey)
+		params v4types.V4Params
+	)
+
+	legacySubspace.GetParamSetIfExists(ctx, &params)
+
+	if err := params.Validate(); err != nil {
+		return err
+	}
+
+	chainCfgBz := cdc.MustMarshal(&params.ChainConfig)
+	extraEIPsBz := cdc.MustMarshal(&v4types.ExtraEIPs{EIPs: v4types.AvailableExtraEIPs})
+
+	store.Set(v4types.ParamStoreKeyEVMDenom, []byte(params.EvmDenom))
+	store.Set(v4types.ParamStoreKeyExtraEIPs, extraEIPsBz)
+	store.Set(v4types.ParamStoreKeyChainConfig, chainCfgBz)
+
+	if params.AllowUnprotectedTxs {
+		store.Set(v4types.ParamStoreKeyAllowUnprotectedTxs, []byte{0x01})
+	}
+
+	if params.EnableCall {
+		store.Set(v4types.ParamStoreKeyEnableCall, []byte{0x01})
+	}
+
+	if params.EnableCreate {
+		store.Set(v4types.ParamStoreKeyEnableCreate, []byte{0x01})
+	}
+
+	return nil
+}

x/evm/migrations/v4/migrate_test.go

@@ -0,0 +1,64 @@
+package v4_test
+
+import (
+	"testing"
+
+	"github.com/evmos/ethermint/x/evm/types"
+	gogotypes "github.com/gogo/protobuf/types"
+
+	"github.com/cosmos/cosmos-sdk/testutil"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/evmos/ethermint/app"
+	"github.com/evmos/ethermint/encoding"
+	v4 "github.com/evmos/ethermint/x/evm/migrations/v4"
+	v4types "github.com/evmos/ethermint/x/evm/migrations/v4/types"
+	"github.com/stretchr/testify/require"
+)
+
+type mockSubspace struct {
+	ps v4types.V4Params
+}
+
+func newMockSubspace(ps v4types.V4Params) mockSubspace {
+	return mockSubspace{ps: ps}
+}
+
+func (ms mockSubspace) GetParamSetIfExists(ctx sdk.Context, ps types.LegacyParams) {
+	*ps.(*v4types.V4Params) = ms.ps
+}
+
+func TestMigrate(t *testing.T) {
+	encCfg := encoding.MakeConfig(app.ModuleBasics)
+	cdc := encCfg.Codec
+
+	storeKey := sdk.NewKVStoreKey(types.ModuleName)
+	tKey := sdk.NewTransientStoreKey("transient_test")
+	ctx := testutil.DefaultContext(storeKey, tKey)
+	kvStore := ctx.KVStore(storeKey)
+
+	legacySubspace := newMockSubspace(v4types.DefaultParams())
+	require.NoError(t, v4.MigrateStore(ctx, storeKey, legacySubspace, cdc))
+
+	// Get all the new parameters from the kvStore
+	var evmDenom string
+	bz := kvStore.Get(v4types.ParamStoreKeyEVMDenom)
+	evmDenom = string(bz)
+
+	var allowUnprotectedTx gogotypes.BoolValue
+	bz = kvStore.Get(v4types.ParamStoreKeyAllowUnprotectedTxs)
+	cdc.MustUnmarshal(bz, &allowUnprotectedTx)
+
+	enableCreate := kvStore.Has(v4types.ParamStoreKeyEnableCreate)
+	enableCall := kvStore.Has(v4types.ParamStoreKeyEnableCall)
+
+	var chainCfg v4types.ChainConfig
+	bz = kvStore.Get(v4types.ParamStoreKeyChainConfig)
+	cdc.MustUnmarshal(bz, &chainCfg)
+
+	var extraEIPs v4types.ExtraEIPs
+	bz = kvStore.Get(v4types.ParamStoreKeyExtraEIPs)
+	cdc.MustUnmarshal(bz, &extraEIPs)
+
+	params := v4types.NewParams(evmDenom, allowUnprotectedTx.Value, enableCreate, enableCall, chainCfg, extraEIPs)
+	require.Equal(t, legacySubspace.ps, params)
+}

x/evm/migrations/v4/types/chain_config.go

@@ -0,0 +1,175 @@
+package types
+
+import (
+	"math/big"
+	"strings"
+
+	"github.com/evmos/ethermint/x/evm/types"
+
+	sdkmath "cosmossdk.io/math"
+
+	errorsmod "cosmossdk.io/errors"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/params"
+)
+
+// EthereumConfig returns an Ethereum ChainConfig for EVM state transitions.
+// All the negative or nil values are converted to nil
+func (cc ChainConfig) EthereumConfig(chainID *big.Int) *params.ChainConfig {
+	return &params.ChainConfig{
+		ChainID:                 chainID,
+		HomesteadBlock:          getBlockValue(cc.HomesteadBlock),
+		DAOForkBlock:            getBlockValue(cc.DAOForkBlock),
+		DAOForkSupport:          cc.DAOForkSupport,
+		EIP150Block:             getBlockValue(cc.EIP150Block),
+		EIP150Hash:              common.HexToHash(cc.EIP150Hash),
+		EIP155Block:             getBlockValue(cc.EIP155Block),
+		EIP158Block:             getBlockValue(cc.EIP158Block),
+		ByzantiumBlock:          getBlockValue(cc.ByzantiumBlock),
+		ConstantinopleBlock:     getBlockValue(cc.ConstantinopleBlock),
+		PetersburgBlock:         getBlockValue(cc.PetersburgBlock),
+		IstanbulBlock:           getBlockValue(cc.IstanbulBlock),
+		MuirGlacierBlock:        getBlockValue(cc.MuirGlacierBlock),
+		BerlinBlock:             getBlockValue(cc.BerlinBlock),
+		LondonBlock:             getBlockValue(cc.LondonBlock),
+		ArrowGlacierBlock:       getBlockValue(cc.ArrowGlacierBlock),
+		GrayGlacierBlock:        getBlockValue(cc.GrayGlacierBlock),
+		MergeNetsplitBlock:      getBlockValue(cc.MergeNetsplitBlock),
+		ShanghaiBlock:           getBlockValue(cc.ShanghaiBlock),
+		CancunBlock:             getBlockValue(cc.CancunBlock),
+		TerminalTotalDifficulty: nil,
+		Ethash:                  nil,
+		Clique:                  nil,
+	}
+}
+
+// DefaultChainConfig returns default evm parameters.
+func DefaultChainConfig() ChainConfig {
+	homesteadBlock := sdk.ZeroInt()
+	daoForkBlock := sdk.ZeroInt()
+	eip150Block := sdk.ZeroInt()
+	eip155Block := sdk.ZeroInt()
+	eip158Block := sdk.ZeroInt()
+	byzantiumBlock := sdk.ZeroInt()
+	constantinopleBlock := sdk.ZeroInt()
+	petersburgBlock := sdk.ZeroInt()
+	istanbulBlock := sdk.ZeroInt()
+	muirGlacierBlock := sdk.ZeroInt()
+	berlinBlock := sdk.ZeroInt()
+	londonBlock := sdk.ZeroInt()
+	arrowGlacierBlock := sdk.ZeroInt()
+	grayGlacierBlock := sdk.ZeroInt()
+	mergeNetsplitBlock := sdk.ZeroInt()
+
+	return ChainConfig{
+		HomesteadBlock:      &homesteadBlock,
+		DAOForkBlock:        &daoForkBlock,
+		DAOForkSupport:      true,
+		EIP150Block:         &eip150Block,
+		EIP150Hash:          common.Hash{}.String(),
+		EIP155Block:         &eip155Block,
+		EIP158Block:         &eip158Block,
+		ByzantiumBlock:      &byzantiumBlock,
+		ConstantinopleBlock: &constantinopleBlock,
+		PetersburgBlock:     &petersburgBlock,
+		IstanbulBlock:       &istanbulBlock,
+		MuirGlacierBlock:    &muirGlacierBlock,
+		BerlinBlock:         &berlinBlock,
+		LondonBlock:         &londonBlock,
+		ArrowGlacierBlock:   &arrowGlacierBlock,
+		GrayGlacierBlock:    &grayGlacierBlock,
+		MergeNetsplitBlock:  &mergeNetsplitBlock,
+	}
+}
+
+func getBlockValue(block *sdkmath.Int) *big.Int {
+	if block == nil || block.IsNegative() {
+		return nil
+	}
+
+	return block.BigInt()
+}
+
+// Validate performs a basic validation of the ChainConfig params. The function will return an error
+// if any of the block values is uninitialized (i.e nil) or if the EIP150Hash is an invalid hash.
+func (cc ChainConfig) Validate() error {
+	if err := validateBlock(cc.HomesteadBlock); err != nil {
+		return errorsmod.Wrap(err, "homesteadBlock")
+	}
+	if err := validateBlock(cc.DAOForkBlock); err != nil {
+		return errorsmod.Wrap(err, "daoForkBlock")
+	}
+	if err := validateBlock(cc.EIP150Block); err != nil {
+		return errorsmod.Wrap(err, "eip150Block")
+	}
+	if err := validateHash(cc.EIP150Hash); err != nil {
+		return err
+	}
+	if err := validateBlock(cc.EIP155Block); err != nil {
+		return errorsmod.Wrap(err, "eip155Block")
+	}
+	if err := validateBlock(cc.EIP158Block); err != nil {
+		return errorsmod.Wrap(err, "eip158Block")
+	}
+	if err := validateBlock(cc.ByzantiumBlock); err != nil {
+		return errorsmod.Wrap(err, "byzantiumBlock")
+	}
+	if err := validateBlock(cc.ConstantinopleBlock); err != nil {
+		return errorsmod.Wrap(err, "constantinopleBlock")
+	}
+	if err := validateBlock(cc.PetersburgBlock); err != nil {
+		return errorsmod.Wrap(err, "petersburgBlock")
+	}
+	if err := validateBlock(cc.IstanbulBlock); err != nil {
+		return errorsmod.Wrap(err, "istanbulBlock")
+	}
+	if err := validateBlock(cc.MuirGlacierBlock); err != nil {
+		return errorsmod.Wrap(err, "muirGlacierBlock")
+	}
+	if err := validateBlock(cc.BerlinBlock); err != nil {
+		return errorsmod.Wrap(err, "berlinBlock")
+	}
+	if err := validateBlock(cc.LondonBlock); err != nil {
+		return errorsmod.Wrap(err, "londonBlock")
+	}
+	if err := validateBlock(cc.ArrowGlacierBlock); err != nil {
+		return errorsmod.Wrap(err, "arrowGlacierBlock")
+	}
+	if err := validateBlock(cc.GrayGlacierBlock); err != nil {
+		return errorsmod.Wrap(err, "GrayGlacierBlock")
+	}
+	if err := validateBlock(cc.MergeNetsplitBlock); err != nil {
+		return errorsmod.Wrap(err, "MergeNetsplitBlock")
+	}
+
+	// NOTE: chain ID is not needed to check config order
+	if err := cc.EthereumConfig(nil).CheckConfigForkOrder(); err != nil {
+		return errorsmod.Wrap(err, "invalid config fork order")
+	}
+	return nil
+}
+
+func validateHash(hex string) error {
+	if hex != "" && strings.TrimSpace(hex) == "" {
+		return errorsmod.Wrap(types.ErrInvalidChainConfig, "hash cannot be blank")
+	}
+
+	return nil
+}
+
+func validateBlock(block *sdkmath.Int) error {
+	// nil value means that the fork has not yet been applied
+	if block == nil {
+		return nil
+	}
+
+	if block.IsNegative() {
+		return errorsmod.Wrapf(
+			types.ErrInvalidChainConfig, "block value cannot be negative: %s", block,
+		)
+	}
+
+	return nil
+}

x/evm/migrations/v4/types/params.go

@@ -0,0 +1,154 @@
+package types
+
+import (
+	"fmt"
+	"math/big"
+
+	evmtypes "github.com/evmos/ethermint/x/evm/types"
+
+	"github.com/ethereum/go-ethereum/params"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/evmos/ethermint/types"
+)
+
+var _ evmtypes.LegacyParams = &V4Params{}
+
+var (
+	// DefaultEVMDenom defines the default EVM denomination on Ethermint
+	DefaultEVMDenom = types.AttoPhoton
+	// DefaultAllowUnprotectedTxs rejects all unprotected txs (i.e false)
+	DefaultAllowUnprotectedTxs = false
+	DefaultEnableCreate        = true
+	DefaultEnableCall          = true
+	DefaultExtraEIPs           = ExtraEIPs{AvailableExtraEIPs}
+)
+
+// Parameter keys
+var (
+	ParamStoreKeyEVMDenom            = []byte("EVMDenom")
+	ParamStoreKeyEnableCreate        = []byte("EnableCreate")
+	ParamStoreKeyEnableCall          = []byte("EnableCall")
+	ParamStoreKeyExtraEIPs           = []byte("EnableExtraEIPs")
+	ParamStoreKeyChainConfig         = []byte("ChainConfig")
+	ParamStoreKeyAllowUnprotectedTxs = []byte("AllowUnprotectedTxs")
+
+	// AvailableExtraEIPs define the list of all EIPs that can be enabled by the
+	// EVM interpreter. These EIPs are applied in order and can override the
+	// instruction sets from the latest hard fork enabled by the ChainConfig. For
+	// more info check:
+	// https://github.com/ethereum/go-ethereum/blob/master/core/vm/interpreter.go#L97
+	AvailableExtraEIPs = []int64{1344, 1884, 2200, 2929, 3198, 3529}
+)
+
+// ParamKeyTable returns the parameter key table.
+func ParamKeyTable() paramtypes.KeyTable {
+	return paramtypes.NewKeyTable().RegisterParamSet(&V4Params{})
+}
+
+// NewParams creates a new Params instance
+func NewParams(evmDenom string, allowUnprotectedTxs, enableCreate, enableCall bool, config ChainConfig, extraEIPs ExtraEIPs) V4Params {
+	return V4Params{
+		EvmDenom:            evmDenom,
+		AllowUnprotectedTxs: allowUnprotectedTxs,
+		EnableCreate:        enableCreate,
+		EnableCall:          enableCall,
+		ExtraEIPs:           extraEIPs,
+		ChainConfig:         config,
+	}
+}
+
+// DefaultParams returns default evm parameters
+// ExtraEIPs is empty to prevent overriding the latest hard fork instruction set
+func DefaultParams() V4Params {
+	return V4Params{
+		EvmDenom:            DefaultEVMDenom,
+		EnableCreate:        DefaultEnableCreate,
+		EnableCall:          DefaultEnableCall,
+		ChainConfig:         DefaultChainConfig(),
+		ExtraEIPs:           DefaultExtraEIPs,
+		AllowUnprotectedTxs: DefaultAllowUnprotectedTxs,
+	}
+}
+
+// ParamSetPairs returns the parameter set pairs.
+func (p *V4Params) ParamSetPairs() paramtypes.ParamSetPairs {
+	return paramtypes.ParamSetPairs{
+		paramtypes.NewParamSetPair(ParamStoreKeyEVMDenom, &p.EvmDenom, validateEVMDenom),
+		paramtypes.NewParamSetPair(ParamStoreKeyEnableCreate, &p.EnableCreate, validateBool),
+		paramtypes.NewParamSetPair(ParamStoreKeyEnableCall, &p.EnableCall, validateBool),
+		paramtypes.NewParamSetPair(ParamStoreKeyExtraEIPs, &p.ExtraEIPs, validateEIPs),
+		paramtypes.NewParamSetPair(ParamStoreKeyChainConfig, &p.ChainConfig, validateChainConfig),
+		paramtypes.NewParamSetPair(ParamStoreKeyAllowUnprotectedTxs, &p.AllowUnprotectedTxs, validateBool),
+	}
+}
+
+// Validate performs basic validation on evm parameters.
+func (p V4Params) Validate() error {
+	if err := sdk.ValidateDenom(p.EvmDenom); err != nil {
+		return err
+	}
+
+	if err := validateEIPs(p.ExtraEIPs); err != nil {
+		return err
+	}
+
+	return p.ChainConfig.Validate()
+}
+
+// EIPs returns the ExtraEIPS as a int slice
+func (p V4Params) EIPs() []int {
+	eips := make([]int, len(p.ExtraEIPs.EIPs))
+	for i, eip := range p.ExtraEIPs.EIPs {
+		eips[i] = int(eip)
+	}
+	return eips
+}
+
+func validateEVMDenom(i interface{}) error {
+	denom, ok := i.(string)
+	if !ok {
+		return fmt.Errorf("invalid parameter EVM denom type: %T", i)
+	}
+
+	return sdk.ValidateDenom(denom)
+}
+
+func validateBool(i interface{}) error {
+	_, ok := i.(bool)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", i)
+	}
+	return nil
+}
+
+func validateEIPs(i interface{}) error {
+	eips, ok := i.(ExtraEIPs)
+	if !ok {
+		return fmt.Errorf("invalid EIP slice type: %T", i)
+	}
+
+	for _, eip := range eips.EIPs {
+		if !vm.ValidEip(int(eip)) {
+			return fmt.Errorf("EIP %d is not activateable, valid EIPS are: %s", eip, vm.ActivateableEips())
+		}
+	}
+
+	return nil
+}
+
+func validateChainConfig(i interface{}) error {
+	cfg, ok := i.(ChainConfig)
+	if !ok {
+		return fmt.Errorf("invalid chain config type: %T", i)
+	}
+
+	return cfg.Validate()
+}
+
+// IsLondon returns if london hardfork is enabled.
+func IsLondon(ethConfig *params.ChainConfig, height int64) bool {
+	return ethConfig.IsLondon(big.NewInt(height))
+}

x/evm/module.go

@@ -52,13 +52,14 @@ func (AppModuleBasic) Name() string {
 	return types.ModuleName
 }
 
-// RegisterLegacyAminoCodec performs a no-op as the evm module doesn't support amino.
+// RegisterLegacyAminoCodec registers the module's types with the given codec.
-func (AppModuleBasic) RegisterLegacyAminoCodec(_ *codec.LegacyAmino) {
+func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
+	types.RegisterLegacyAminoCodec(cdc)
 }
 
 // ConsensusVersion returns the consensus state-breaking version for the module.
 func (AppModuleBasic) ConsensusVersion() uint64 {
-	return 3
+	return 4
 }
 
 // DefaultGenesis returns default genesis state as raw bytes for the evm
@@ -110,14 +111,17 @@ type AppModule struct {
 	AppModuleBasic
 	keeper *keeper.Keeper
 	ak     types.AccountKeeper
+	// legacySubspace is used solely for migration of x/params managed parameters
+	legacySubspace types.Subspace
 }
 
 // NewAppModule creates a new AppModule object
-func NewAppModule(k *keeper.Keeper, ak types.AccountKeeper) AppModule {
+func NewAppModule(k *keeper.Keeper, ak types.AccountKeeper, ss types.Subspace) AppModule {
 	return AppModule{
 		AppModuleBasic: AppModuleBasic{},
 		keeper:         k,
 		ak:             ak,
+		legacySubspace: ss,
 	}
 }
 
@@ -136,6 +140,12 @@ func (am AppModule) RegisterInvariants(_ sdk.InvariantRegistry) {
 func (am AppModule) RegisterServices(cfg module.Configurator) {
 	types.RegisterMsgServer(cfg.MsgServer(), am.keeper)
 	types.RegisterQueryServer(cfg.QueryServer(), am.keeper)
+
+	m := keeper.NewMigrator(*am.keeper, am.legacySubspace)
+	err := cfg.RegisterMigration(types.ModuleName, 3, m.Migrate3to4)
+	if err != nil {
+		panic(err)
+	}
 }
 
 // Route returns the message routing key for the evm module.
@@ -167,7 +177,6 @@ func (am AppModule) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) []abci.V
 // no validator updates.
 func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) []abci.ValidatorUpdate {
 	var genesisState types.GenesisState
-
 	cdc.MustUnmarshalJSON(data, &genesisState)
 	InitGenesis(ctx, am.keeper, am.ak, genesisState)
 	return []abci.ValidatorUpdate{}

x/evm/types/codec.go

@@ -26,18 +26,38 @@ import (
 	proto "github.com/gogo/protobuf/proto"
 )
 
-var ModuleCdc = codec.NewProtoCodec(codectypes.NewInterfaceRegistry())
+var (
+	amino = codec.NewLegacyAmino()
+	// ModuleCdc references the global evm module codec. Note, the codec should
+	// ONLY be used in certain instances of tests and for JSON encoding.
+	ModuleCdc = codec.NewProtoCodec(codectypes.NewInterfaceRegistry())
+
+	// AminoCdc is a amino codec created to support amino JSON compatible msgs.
+	AminoCdc = codec.NewAminoCodec(amino)
+)
+
+const (
+	// Amino names
+	updateParamsName = "ethermint/MsgUpdateParams"
+)
+
+// NOTE: This is required for the GetSignBytes function
+func init() {
+	RegisterLegacyAminoCodec(amino)
+	amino.Seal()
+}
 
 // RegisterInterfaces registers the client interfaces to protobuf Any.
 func RegisterInterfaces(registry codectypes.InterfaceRegistry) {
-	registry.RegisterImplementations(
-		(*sdk.Msg)(nil),
-		&MsgEthereumTx{},
-	)
 	registry.RegisterImplementations(
 		(*tx.TxExtensionOptionI)(nil),
 		&ExtensionOptionsEthereumTx{},
 	)
+	registry.RegisterImplementations(
+		(*sdk.Msg)(nil),
+		&MsgEthereumTx{},
+		&MsgUpdateParams{},
+	)
 	registry.RegisterInterface(
 		"ethermint.evm.v1.TxData",
 		(*TxData)(nil),
@@ -49,7 +69,7 @@ func RegisterInterfaces(registry codectypes.InterfaceRegistry) {
 	msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)
 }
 
-// PackClientState constructs a new Any packed with the given tx data value. It returns
+// PackTxData constructs a new Any packed with the given tx data value. It returns
 // an error if the client state can't be casted to a protobuf message or if the concrete
 // implementation is not registered to the protobuf codec.
 func PackTxData(txData TxData) (*codectypes.Any, error) {
@@ -80,3 +100,8 @@ func UnpackTxData(any *codectypes.Any) (TxData, error) {
 
 	return txData, nil
 }
+
+// RegisterLegacyAminoCodec required for EIP-712
+func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
+	cdc.RegisterConcrete(&MsgUpdateParams{}, updateParamsName, nil)
+}

x/evm/types/evm.pb.go

@@ -34,7 +34,7 @@ type Params struct {
 	// enable_call toggles state transitions that use the vm.Call function
 	EnableCall bool `protobuf:"varint,3,opt,name=enable_call,json=enableCall,proto3" json:"enable_call,omitempty" yaml:"enable_call"`
 	// extra_eips defines the additional EIPs for the vm.Config
-	ExtraEIPs []int64 `protobuf:"varint,4,rep,packed,name=extra_eips,json=extraEips,proto3" json:"extra_eips,omitempty" yaml:"extra_eips"`
+	ExtraEIPs ExtraEIPs `protobuf:"bytes,4,opt,name=extra_eips,json=extraEips,proto3" json:"extra_eips" yaml:"extra_eips"`
 	// chain_config defines the EVM chain configuration parameters
 	ChainConfig ChainConfig `protobuf:"bytes,5,opt,name=chain_config,json=chainConfig,proto3" json:"chain_config" yaml:"chain_config"`
 	// allow_unprotected_txs defines if replay-protected (i.e non EIP155
@@ -96,11 +96,11 @@ func (m *Params) GetEnableCall() bool {
 	return false
 }
 
-func (m *Params) GetExtraEIPs() []int64 {
+func (m *Params) GetExtraEIPs() ExtraEIPs {
 	if m != nil {
 		return m.ExtraEIPs
 	}
-	return nil
+	return ExtraEIPs{}
 }
 
 func (m *Params) GetChainConfig() ChainConfig {
@@ -117,6 +117,52 @@ func (m *Params) GetAllowUnprotectedTxs() bool {
 	return false
 }
 
+// ExtraEIPs represents extra EIPs for the vm.Config
+type ExtraEIPs struct {
+	// eips defines the additional EIPs for the vm.Config
+	EIPs []int64 `protobuf:"varint,1,rep,packed,name=eips,proto3" json:"eips,omitempty" yaml:"eips"`
+}
+
+func (m *ExtraEIPs) Reset()         { *m = ExtraEIPs{} }
+func (m *ExtraEIPs) String() string { return proto.CompactTextString(m) }
+func (*ExtraEIPs) ProtoMessage()    {}
+func (*ExtraEIPs) Descriptor() ([]byte, []int) {
+	return fileDescriptor_d21ecc92c8c8583e, []int{1}
+}
+func (m *ExtraEIPs) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ExtraEIPs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ExtraEIPs.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *ExtraEIPs) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ExtraEIPs.Merge(m, src)
+}
+func (m *ExtraEIPs) XXX_Size() int {
+	return m.Size()
+}
+func (m *ExtraEIPs) XXX_DiscardUnknown() {
+	xxx_messageInfo_ExtraEIPs.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExtraEIPs proto.InternalMessageInfo
+
+func (m *ExtraEIPs) GetEIPs() []int64 {
+	if m != nil {
+		return m.EIPs
+	}
+	return nil
+}
+
 // ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values
 // instead of *big.Int.
 type ChainConfig struct {
@@ -165,7 +211,7 @@ func (m *ChainConfig) Reset()         { *m = ChainConfig{} }
 func (m *ChainConfig) String() string { return proto.CompactTextString(m) }
 func (*ChainConfig) ProtoMessage()    {}
 func (*ChainConfig) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d21ecc92c8c8583e, []int{1}
+	return fileDescriptor_d21ecc92c8c8583e, []int{2}
 }
 func (m *ChainConfig) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -220,7 +266,7 @@ func (m *State) Reset()         { *m = State{} }
 func (m *State) String() string { return proto.CompactTextString(m) }
 func (*State) ProtoMessage()    {}
 func (*State) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d21ecc92c8c8583e, []int{2}
+	return fileDescriptor_d21ecc92c8c8583e, []int{3}
 }
 func (m *State) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -277,7 +323,7 @@ func (m *TransactionLogs) Reset()         { *m = TransactionLogs{} }
 func (m *TransactionLogs) String() string { return proto.CompactTextString(m) }
 func (*TransactionLogs) ProtoMessage()    {}
 func (*TransactionLogs) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d21ecc92c8c8583e, []int{3}
+	return fileDescriptor_d21ecc92c8c8583e, []int{4}
 }
 func (m *TransactionLogs) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -353,7 +399,7 @@ func (m *Log) Reset()         { *m = Log{} }
 func (m *Log) String() string { return proto.CompactTextString(m) }
 func (*Log) ProtoMessage()    {}
 func (*Log) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d21ecc92c8c8583e, []int{4}
+	return fileDescriptor_d21ecc92c8c8583e, []int{5}
 }
 func (m *Log) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -468,7 +514,7 @@ func (m *TxResult) Reset()         { *m = TxResult{} }
 func (m *TxResult) String() string { return proto.CompactTextString(m) }
 func (*TxResult) ProtoMessage()    {}
 func (*TxResult) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d21ecc92c8c8583e, []int{5}
+	return fileDescriptor_d21ecc92c8c8583e, []int{6}
 }
 func (m *TxResult) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -509,7 +555,7 @@ func (m *AccessTuple) Reset()         { *m = AccessTuple{} }
 func (m *AccessTuple) String() string { return proto.CompactTextString(m) }
 func (*AccessTuple) ProtoMessage()    {}
 func (*AccessTuple) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d21ecc92c8c8583e, []int{6}
+	return fileDescriptor_d21ecc92c8c8583e, []int{7}
 }
 func (m *AccessTuple) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -569,7 +615,7 @@ func (m *TraceConfig) Reset()         { *m = TraceConfig{} }
 func (m *TraceConfig) String() string { return proto.CompactTextString(m) }
 func (*TraceConfig) ProtoMessage()    {}
 func (*TraceConfig) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d21ecc92c8c8583e, []int{7}
+	return fileDescriptor_d21ecc92c8c8583e, []int{8}
 }
 func (m *TraceConfig) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -677,6 +723,7 @@ func (m *TraceConfig) GetTracerJsonConfig() string {
 
 func init() {
 	proto.RegisterType((*Params)(nil), "ethermint.evm.v1.Params")
+	proto.RegisterType((*ExtraEIPs)(nil), "ethermint.evm.v1.ExtraEIPs")
 	proto.RegisterType((*ChainConfig)(nil), "ethermint.evm.v1.ChainConfig")
 	proto.RegisterType((*State)(nil), "ethermint.evm.v1.State")
 	proto.RegisterType((*TransactionLogs)(nil), "ethermint.evm.v1.TransactionLogs")
@@ -689,108 +736,110 @@ func init() {
 func init() { proto.RegisterFile("ethermint/evm/v1/evm.proto", fileDescriptor_d21ecc92c8c8583e) }
 
 var fileDescriptor_d21ecc92c8c8583e = []byte{
-	// 1608 bytes of a gzipped FileDescriptorProto
+	// 1644 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x58, 0xdd, 0x6e, 0xe3, 0xc6,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x58, 0x4f, 0x6f, 0xe3, 0xc6,
-	0x15, 0xb6, 0x2d, 0xda, 0xa6, 0x46, 0xb2, 0x44, 0x8f, 0xb5, 0x8e, 0xb2, 0x8b, 0x9a, 0x2e, 0x2f,
+	0x15, 0xb7, 0x2d, 0xda, 0xa6, 0x46, 0xb2, 0x44, 0x8f, 0xb5, 0x5e, 0x65, 0x17, 0x35, 0x5d, 0x1e,
-	0x0a, 0x17, 0x48, 0xec, 0xd8, 0x81, 0xd1, 0x45, 0x82, 0x16, 0xb5, 0x76, 0x9d, 0xc4, 0xee, 0x36,
+	0x02, 0x17, 0x4d, 0xec, 0xd8, 0x81, 0xd1, 0x45, 0x82, 0x16, 0x5d, 0xed, 0x3a, 0x89, 0xdd, 0x6d,
-	0x35, 0xc6, 0x0e, 0x0a, 0x14, 0x28, 0x88, 0x11, 0x39, 0xa1, 0x18, 0x93, 0x1c, 0x61, 0x66, 0xa8,
+	0x6a, 0x8c, 0x1d, 0x14, 0x28, 0x50, 0x10, 0x23, 0x72, 0x42, 0x31, 0x26, 0x39, 0xc2, 0xcc, 0x50,
-	0x95, 0xda, 0x3e, 0x40, 0x8b, 0xde, 0xf4, 0x09, 0x8a, 0x3c, 0x4e, 0xd0, 0xab, 0xbd, 0x2c, 0x7a,
+	0x2b, 0xb5, 0xfd, 0x00, 0x05, 0x7a, 0xe9, 0x27, 0x28, 0x72, 0xee, 0x27, 0x09, 0x7a, 0xda, 0x63,
-	0x41, 0x14, 0xde, 0x3b, 0x5f, 0xea, 0x09, 0x8a, 0xf9, 0x11, 0xf5, 0x63, 0xa3, 0xad, 0x75, 0xe5,
+	0xd1, 0x03, 0x51, 0x78, 0x6f, 0x3e, 0xea, 0x13, 0x14, 0xf3, 0x47, 0xd4, 0x1f, 0x1b, 0x6d, 0xad,
-	0xf9, 0xce, 0x39, 0xf3, 0x7d, 0x33, 0x67, 0xce, 0x68, 0x0e, 0x0d, 0x9e, 0x13, 0xd1, 0x23, 0x2c,
+	0x93, 0xe7, 0xf7, 0xde, 0x9b, 0xdf, 0x6f, 0xde, 0x9b, 0x37, 0x9e, 0xa1, 0xc0, 0x33, 0x22, 0x7a,
-	0x8d, 0x33, 0x71, 0x44, 0x06, 0xe9, 0xd1, 0xe0, 0x58, 0xfe, 0x39, 0xec, 0x33, 0x2a, 0x28, 0x74,
+	0x84, 0xa5, 0x71, 0x26, 0x8e, 0xc8, 0x20, 0x3d, 0x1a, 0x1c, 0xcb, 0x3f, 0x87, 0x7d, 0x46, 0x05,
-	0x4a, 0xdf, 0xa1, 0x34, 0x0e, 0x8e, 0x9f, 0xb7, 0x22, 0x1a, 0x51, 0xe5, 0x3c, 0x92, 0x23, 0x1d,
+	0x85, 0x4e, 0xe9, 0x3b, 0x94, 0xc6, 0xc1, 0xf1, 0xb3, 0x56, 0x44, 0x23, 0xaa, 0x9c, 0x47, 0x72,
-	0xe7, 0xfd, 0xa5, 0x02, 0x36, 0xae, 0x30, 0xc3, 0x29, 0x87, 0xc7, 0xa0, 0x4a, 0x06, 0xa9, 0x1f,
+	0xa4, 0xe3, 0xbc, 0xbf, 0x57, 0xc0, 0xc6, 0x25, 0x66, 0x38, 0xe5, 0xf0, 0x18, 0x54, 0xc9, 0x20,
-	0x92, 0x8c, 0xa6, 0xed, 0xd5, 0xfd, 0xd5, 0x83, 0x6a, 0xa7, 0x35, 0x2e, 0x5c, 0x67, 0x84, 0xd3,
+	0xf5, 0x43, 0x92, 0xd1, 0xb4, 0xbd, 0xba, 0xbf, 0x7a, 0x50, 0xed, 0xb4, 0xc6, 0x85, 0xeb, 0x8c,
-	0xe4, 0x33, 0xaf, 0x74, 0x79, 0xc8, 0x26, 0x83, 0xf4, 0xb5, 0x1c, 0xc2, 0x9f, 0x83, 0x2d, 0x92,
+	0x70, 0x9a, 0x7c, 0xe6, 0x95, 0x2e, 0x0f, 0xd9, 0x64, 0x90, 0xbe, 0x96, 0x43, 0xf8, 0x73, 0xb0,
-	0xe1, 0x6e, 0x42, 0xfc, 0x80, 0x11, 0x2c, 0x48, 0x7b, 0x6d, 0x7f, 0xf5, 0xc0, 0xee, 0xb4, 0xc7,
+	0x45, 0x32, 0xdc, 0x4d, 0x88, 0x1f, 0x30, 0x82, 0x05, 0x69, 0xaf, 0xed, 0xaf, 0x1e, 0xd8, 0x9d,
-	0x85, 0xdb, 0x32, 0xd3, 0x66, 0xdd, 0x1e, 0xaa, 0x6b, 0xfc, 0x4a, 0x41, 0xf8, 0x33, 0x50, 0x9b,
+	0xf6, 0xb8, 0x70, 0x5b, 0x66, 0xda, 0xac, 0xdb, 0x43, 0x75, 0x8d, 0x5f, 0x29, 0x08, 0x7f, 0x06,
-	0xf8, 0x71, 0x92, 0xb4, 0x2b, 0x6a, 0xf2, 0xee, 0xb8, 0x70, 0xe1, 0xfc, 0x64, 0x9c, 0x24, 0x1e,
+	0x6a, 0x13, 0x3f, 0x4e, 0x92, 0x76, 0x45, 0x4d, 0xde, 0x1d, 0x17, 0x2e, 0x9c, 0x9f, 0x8c, 0x93,
-	0x02, 0x66, 0x2a, 0x4e, 0x12, 0x78, 0x06, 0x00, 0x19, 0x0a, 0x86, 0x7d, 0x12, 0xf7, 0x79, 0xdb,
+	0xc4, 0x43, 0xc0, 0x4c, 0xc5, 0x49, 0x02, 0xbb, 0x00, 0x90, 0xa1, 0x60, 0xd8, 0x27, 0x71, 0x9f,
-	0xda, 0xaf, 0x1c, 0x54, 0x3a, 0xde, 0x5d, 0xe1, 0x56, 0xcf, 0xa5, 0xf5, 0xfc, 0xe2, 0x8a, 0x8f,
+	0xb7, 0xad, 0xfd, 0xd5, 0x83, 0xda, 0xc9, 0xf3, 0xc3, 0xc5, 0x94, 0x0f, 0xcf, 0x64, 0xcc, 0xd9,
-	0x0b, 0x77, 0xdb, 0x90, 0x94, 0x81, 0x1e, 0xaa, 0x2a, 0x70, 0x1e, 0xf7, 0x39, 0xfc, 0x3d, 0xa8,
+	0xf9, 0x25, 0xef, 0x7c, 0xf8, 0x43, 0xe1, 0xae, 0xdc, 0x16, 0x6e, 0xb5, 0x34, 0x8d, 0x0b, 0x77,
-	0x07, 0x3d, 0x1c, 0x67, 0x7e, 0x40, 0xb3, 0x6f, 0xe3, 0xa8, 0xbd, 0xbe, 0xbf, 0x7a, 0x50, 0x3b,
+	0xdb, 0xa8, 0x94, 0x4c, 0x1e, 0xaa, 0x2a, 0x70, 0x16, 0xf7, 0x39, 0xfc, 0x3d, 0xa8, 0x07, 0x3d,
-	0xf9, 0xd1, 0xe1, 0x62, 0xde, 0x0e, 0x5f, 0xc9, 0xa8, 0x57, 0x2a, 0xa8, 0xf3, 0xe2, 0x87, 0xc2,
+	0x1c, 0x67, 0x7e, 0x40, 0xb3, 0x6f, 0xe3, 0xa8, 0xbd, 0xae, 0x54, 0x7e, 0x74, 0x5f, 0xe5, 0x95,
-	0x5d, 0x19, 0x17, 0xee, 0x8e, 0xa6, 0x9e, 0x25, 0xf0, 0x50, 0x2d, 0x98, 0x46, 0xc2, 0x13, 0xf0,
+	0x8c, 0x7a, 0xa5, 0x82, 0x3a, 0xcf, 0xa5, 0xce, 0xb8, 0x70, 0x77, 0x34, 0xf5, 0x2c, 0x81, 0x87,
-	0x0c, 0x27, 0x09, 0x7d, 0xeb, 0xe7, 0x99, 0x4c, 0x34, 0x09, 0x04, 0x09, 0x7d, 0x31, 0xe4, 0xed,
+	0x6a, 0xc1, 0x34, 0x12, 0x9e, 0x80, 0x27, 0x38, 0x49, 0xe8, 0x5b, 0x3f, 0xcf, 0xe4, 0x4e, 0x90,
-	0x0d, 0xb9, 0x49, 0xb4, 0xa3, 0x9c, 0xdf, 0x4c, 0x7d, 0x37, 0x43, 0xee, 0xfd, 0x7d, 0x1b, 0xd4,
+	0x40, 0x90, 0xd0, 0x17, 0x43, 0xde, 0xde, 0x90, 0x55, 0x40, 0x3b, 0xca, 0xf9, 0xcd, 0xd4, 0x77,
-	0x66, 0xd4, 0x60, 0x0a, 0x9a, 0x3d, 0x9a, 0x12, 0x2e, 0x08, 0x0e, 0xfd, 0x6e, 0x42, 0x83, 0x5b,
+	0x3d, 0xe4, 0xde, 0x0b, 0x30, 0x5d, 0x3f, 0xfc, 0x29, 0xb0, 0x54, 0xf6, 0xab, 0xfb, 0x95, 0x83,
-	0x73, 0x2c, 0xaf, 0xff, 0x55, 0xb8, 0x3f, 0x89, 0x62, 0xd1, 0xcb, 0xbb, 0x87, 0x01, 0x4d, 0x8f,
+	0x4a, 0xe7, 0xe9, 0x6d, 0xe1, 0x5a, 0x26, 0xaf, 0x9a, 0xc9, 0x4b, 0x65, 0xa4, 0x82, 0xbc, 0xbf,
-	0x02, 0xca, 0x53, 0xca, 0xcd, 0x9f, 0x8f, 0x79, 0x78, 0x7b, 0x24, 0x46, 0x7d, 0xc2, 0x0f, 0x2f,
+	0x6d, 0x83, 0xda, 0xcc, 0x3a, 0x61, 0x0a, 0x9a, 0x3d, 0x9a, 0x12, 0x2e, 0x08, 0x0e, 0xfd, 0x6e,
-	0x32, 0x31, 0x2e, 0xdc, 0x5d, 0xbd, 0xd8, 0x05, 0x2a, 0x0f, 0x35, 0x4a, 0x4b, 0x47, 0x1a, 0xe0,
+	0x42, 0x83, 0x1b, 0xb3, 0xe3, 0xaf, 0xff, 0x55, 0xb8, 0x1f, 0x46, 0xb1, 0xe8, 0xe5, 0xdd, 0xc3,
-	0x08, 0x34, 0x42, 0x4c, 0xfd, 0x6f, 0x29, 0xbb, 0x35, 0x6a, 0x6b, 0x4a, 0xed, 0xfa, 0xff, 0x57,
+	0x80, 0xa6, 0x47, 0x01, 0xe5, 0x29, 0xe5, 0xe6, 0xcf, 0xc7, 0x3c, 0xbc, 0x39, 0x12, 0xa3, 0x3e,
-	0xbb, 0x2b, 0xdc, 0xfa, 0xeb, 0xb3, 0xdf, 0x7c, 0x41, 0xd9, 0xad, 0xe2, 0x1c, 0x17, 0xee, 0x33,
+	0xe1, 0x87, 0xe7, 0x99, 0x18, 0x17, 0xee, 0xae, 0x56, 0x5a, 0xa0, 0xf2, 0x50, 0xa3, 0xb4, 0x74,
-	0xad, 0x3e, 0xcf, 0xec, 0xa1, 0x7a, 0x88, 0x69, 0x19, 0x06, 0x7f, 0x0b, 0x9c, 0x32, 0x80, 0xe7,
+	0xa4, 0x01, 0x8e, 0x40, 0x23, 0xc4, 0xd4, 0xff, 0x96, 0xb2, 0x1b, 0xa3, 0xb6, 0xa6, 0xd4, 0xae,
-	0xfd, 0x3e, 0x65, 0xc2, 0x54, 0xc3, 0xc7, 0x77, 0x85, 0xdb, 0x30, 0x94, 0xd7, 0xda, 0x33, 0x2e,
+	0xfe, 0x7f, 0xb5, 0xdb, 0xc2, 0xad, 0xbf, 0x7e, 0xf9, 0x9b, 0x2f, 0x28, 0xbb, 0x51, 0x9c, 0xe3,
-	0xdc, 0x0f, 0x16, 0x48, 0xcd, 0x1c, 0x0f, 0x35, 0x0c, 0xad, 0x09, 0x85, 0x1c, 0xd4, 0x49, 0xdc,
+	0xc2, 0x7d, 0xa2, 0xd5, 0xe7, 0x99, 0x3d, 0x54, 0x0f, 0x31, 0x2d, 0xc3, 0xe0, 0x6f, 0x81, 0x53,
-	0x3f, 0x3e, 0xfd, 0xc4, 0xec, 0xc8, 0x52, 0x3b, 0xba, 0x7a, 0xd2, 0x8e, 0x6a, 0xe7, 0x17, 0x57,
+	0x06, 0xf0, 0xbc, 0xdf, 0xa7, 0x4c, 0x98, 0x46, 0xfb, 0xf8, 0xb6, 0x70, 0x1b, 0x86, 0xf2, 0x4a,
-	0xc7, 0xa7, 0x9f, 0x4c, 0x36, 0x64, 0xce, 0x7e, 0x96, 0xd6, 0x43, 0x35, 0x0d, 0xf5, 0x6e, 0x2e,
+	0x7b, 0xc6, 0x85, 0xfb, 0x74, 0x81, 0xd4, 0xcc, 0xf1, 0x50, 0xc3, 0xd0, 0x9a, 0x50, 0xc8, 0x41,
-	0x80, 0x81, 0x7e, 0x0f, 0xf3, 0x9e, 0xaa, 0xac, 0x6a, 0xe7, 0xe0, 0xae, 0x70, 0x81, 0x66, 0xfa,
+	0x9d, 0xc4, 0xfd, 0xe3, 0xd3, 0x4f, 0x4c, 0x46, 0x96, 0xca, 0xe8, 0xf2, 0x51, 0x19, 0xd5, 0xce,
-	0x0a, 0xf3, 0xde, 0xf4, 0x5c, 0xba, 0xa3, 0x3f, 0xe0, 0x4c, 0xc4, 0x79, 0x3a, 0xe1, 0x02, 0x7a,
+	0xce, 0x2f, 0x8f, 0x4f, 0x3f, 0x99, 0x24, 0xb4, 0x53, 0x6e, 0x5c, 0x49, 0xeb, 0xa1, 0x9a, 0x86,
-	0xb2, 0x8c, 0x2a, 0xd7, 0x7f, 0x6a, 0xd6, 0xbf, 0xb1, 0xf4, 0xfa, 0x4f, 0x1f, 0x5b, 0xff, 0xe9,
+	0x3a, 0x9b, 0x73, 0x60, 0xa0, 0xdf, 0xc3, 0xbc, 0xa7, 0x7a, 0xb2, 0xda, 0x39, 0xb8, 0x2d, 0x5c,
-	0xfc, 0xfa, 0x75, 0x4c, 0x29, 0xfa, 0xd2, 0x88, 0x6e, 0x2e, 0x2d, 0xfa, 0xf2, 0x31, 0xd1, 0x97,
+	0xa0, 0x99, 0xbe, 0xc2, 0xbc, 0x37, 0xdd, 0x97, 0xee, 0xe8, 0x0f, 0x38, 0x13, 0x71, 0x9e, 0x4e,
-	0xf3, 0xa2, 0x3a, 0x46, 0x16, 0xfb, 0x42, 0x26, 0xda, 0xf6, 0xf2, 0xc5, 0xfe, 0x20, 0xa9, 0x8d,
+	0xb8, 0x80, 0x9e, 0x2c, 0xa3, 0xca, 0xf5, 0x9f, 0x9a, 0xf5, 0x6f, 0x2c, 0xbd, 0xfe, 0xd3, 0x87,
-	0xd2, 0xa2, 0xe5, 0xfe, 0x04, 0x5a, 0x01, 0xcd, 0xb8, 0x90, 0xb6, 0x8c, 0xf6, 0x13, 0x62, 0x34,
+	0xd6, 0x7f, 0x3a, 0xbf, 0x7e, 0x1d, 0x53, 0x8a, 0xbe, 0x30, 0xa2, 0x9b, 0x4b, 0x8b, 0xbe, 0x78,
-	0xab, 0x4a, 0xf3, 0xe2, 0x49, 0x9a, 0x2f, 0xcc, 0xaf, 0xc1, 0x23, 0x7c, 0x1e, 0xda, 0x99, 0x37,
+	0x48, 0xf4, 0xc5, 0xbc, 0xa8, 0x8e, 0x91, 0xcd, 0xbe, 0x50, 0x89, 0xb6, 0xbd, 0x7c, 0xb3, 0xdf,
-	0x6b, 0xf5, 0x3e, 0x70, 0xfa, 0x44, 0x10, 0xc6, 0xbb, 0x39, 0x8b, 0x8c, 0x32, 0x50, 0xca, 0xe7,
+	0x2b, 0x6a, 0xa3, 0xb4, 0x68, 0xb9, 0x3f, 0x81, 0x56, 0x40, 0x33, 0x2e, 0xa4, 0x2d, 0xa3, 0xfd,
-	0x4f, 0x52, 0x36, 0xf7, 0x60, 0x91, 0xcb, 0x43, 0xcd, 0xa9, 0x49, 0x2b, 0x7e, 0x07, 0x1a, 0xb1,
+	0x84, 0x18, 0xcd, 0xaa, 0xd2, 0x3c, 0x7f, 0x94, 0xe6, 0x73, 0xf3, 0x7f, 0xe4, 0x01, 0x3e, 0x0f,
-	0x5c, 0x46, 0x37, 0x4f, 0x8c, 0x5e, 0x4d, 0xe9, 0xbd, 0x7a, 0x92, 0x9e, 0xb9, 0xcc, 0xf3, 0x4c,
+	0xed, 0xcc, 0x9b, 0xb5, 0x7a, 0x1f, 0x38, 0x7d, 0x22, 0x08, 0xe3, 0xdd, 0x9c, 0x45, 0x46, 0x19,
-	0x1e, 0xda, 0x9a, 0x18, 0xb4, 0x56, 0x0e, 0x60, 0x9a, 0xc7, 0xcc, 0x8f, 0x12, 0x1c, 0xc4, 0x84,
+	0x28, 0xe5, 0xb3, 0x47, 0x29, 0x9b, 0x73, 0xb0, 0xc8, 0xe5, 0xa1, 0xe6, 0xd4, 0xa4, 0x15, 0xbf,
-	0x19, 0xbd, 0xba, 0xd2, 0xfb, 0xf2, 0x49, 0x7a, 0x1f, 0x6a, 0xbd, 0x87, 0x6c, 0x1e, 0x72, 0xa4,
+	0x03, 0x8d, 0x58, 0x2e, 0xa3, 0x9b, 0x27, 0x46, 0xaf, 0xa6, 0xf4, 0x5e, 0x3d, 0x4a, 0xcf, 0x1c,
-	0xf1, 0x4b, 0x6d, 0xd3, 0xb2, 0x21, 0xa8, 0x77, 0x09, 0x4b, 0xe2, 0xcc, 0x08, 0x6e, 0x29, 0xc1,
+	0xe6, 0x79, 0x26, 0x0f, 0x6d, 0x4d, 0x0c, 0x5a, 0x2b, 0x07, 0x30, 0xcd, 0x63, 0xe6, 0x47, 0x09,
-	0xb3, 0x27, 0x09, 0x9a, 0x3a, 0x9d, 0xe5, 0xf1, 0x50, 0x4d, 0xc3, 0x52, 0x25, 0xa1, 0x59, 0x48,
+	0x0e, 0x62, 0xc2, 0x8c, 0x5e, 0x5d, 0xe9, 0x7d, 0xf9, 0x28, 0xbd, 0x0f, 0xb4, 0xde, 0x7d, 0x36,
-	0x27, 0x2a, 0xdb, 0xcb, 0xab, 0xcc, 0xf2, 0x78, 0xa8, 0xa6, 0xa1, 0x56, 0x19, 0x82, 0x1d, 0xcc,
+	0x0f, 0x39, 0xd2, 0xf8, 0xa5, 0xb6, 0x69, 0xd9, 0x10, 0xd4, 0xbb, 0x84, 0x25, 0x71, 0x66, 0x04,
-	0x18, 0x7d, 0xbb, 0x90, 0x43, 0xa8, 0xc4, 0xbe, 0x7a, 0x92, 0xd8, 0x73, 0x2d, 0xf6, 0x08, 0x9d,
+	0xb7, 0x94, 0xe0, 0xcb, 0x47, 0x09, 0x9a, 0x3e, 0x9d, 0xe5, 0xf1, 0x50, 0x4d, 0xc3, 0x52, 0x25,
-	0x87, 0xb6, 0x95, 0x75, 0x2e, 0x8b, 0x39, 0x80, 0x11, 0xc3, 0xa3, 0x05, 0xe1, 0xd6, 0xf2, 0x87,
+	0xa1, 0x59, 0x48, 0x27, 0x2a, 0xdb, 0xcb, 0xab, 0xcc, 0xf2, 0x78, 0xa8, 0xa6, 0xa1, 0x56, 0x19,
-	0xf7, 0x90, 0xcd, 0x43, 0x8e, 0x34, 0xce, 0xc9, 0xfe, 0x11, 0xb4, 0x52, 0xc2, 0x22, 0xe2, 0x67,
+	0x82, 0x1d, 0xcc, 0x18, 0x7d, 0xbb, 0x50, 0x43, 0xa8, 0xc4, 0xbe, 0x7a, 0x94, 0xd8, 0x33, 0x2d,
-	0x44, 0xf0, 0x7e, 0x12, 0x0b, 0x23, 0xfc, 0x6c, 0xf9, 0xfb, 0xf8, 0x18, 0x9f, 0x87, 0xa0, 0x32,
+	0xf6, 0x00, 0x9d, 0x87, 0xb6, 0x95, 0x75, 0xae, 0x8a, 0x39, 0x80, 0x11, 0xc3, 0xa3, 0x05, 0xe1,
-	0x7f, 0x6d, 0xac, 0xe5, 0xe5, 0xe0, 0x3d, 0x9c, 0x45, 0x3d, 0x1c, 0x1b, 0xd9, 0xdd, 0xe5, 0x2f,
+	0xd6, 0xf2, 0x9b, 0x77, 0x9f, 0xcd, 0x43, 0x8e, 0x34, 0xce, 0xc9, 0xfe, 0x11, 0xb4, 0x52, 0xc2,
-	0xc7, 0x3c, 0x93, 0x87, 0xb6, 0x26, 0x86, 0xb2, 0x7e, 0x02, 0x9c, 0x05, 0xf9, 0xa4, 0x7e, 0x3e,
+	0x22, 0xe2, 0x67, 0x44, 0xf0, 0x7e, 0x12, 0x0b, 0x23, 0xfc, 0x64, 0xf9, 0xf3, 0xf8, 0x10, 0x9f,
-	0x58, 0xbe, 0x7e, 0x66, 0x79, 0x64, 0xfb, 0xa1, 0xa0, 0x52, 0xb9, 0xb4, 0xec, 0x86, 0xd3, 0xbc,
+	0x87, 0xa0, 0x32, 0x7f, 0x6d, 0xac, 0xe5, 0xe1, 0xe0, 0x3d, 0x9c, 0x45, 0x3d, 0x1c, 0x1b, 0xd9,
-	0xb4, 0xec, 0xa6, 0xe3, 0x5c, 0x5a, 0xb6, 0xe3, 0x6c, 0x5f, 0x5a, 0xf6, 0x8e, 0xd3, 0x42, 0x5b,
+	0xdd, 0xe5, 0x0f, 0xc7, 0x3c, 0x93, 0x87, 0xb6, 0x26, 0x86, 0xb2, 0x7f, 0x02, 0x9c, 0x05, 0xf9,
-	0x23, 0x9a, 0x50, 0x7f, 0xf0, 0xa9, 0x9e, 0x84, 0x6a, 0xe4, 0x2d, 0xe6, 0xe6, 0x37, 0x12, 0x35,
+	0xa4, 0x7f, 0x9e, 0x2e, 0xdf, 0x3f, 0xb3, 0x3c, 0xf2, 0xe1, 0xa2, 0xa0, 0x52, 0xb9, 0xb0, 0xec,
-	0x02, 0x2c, 0x70, 0x32, 0xe2, 0x26, 0x55, 0xc8, 0xd1, 0x09, 0x9c, 0x79, 0xb5, 0x8f, 0xc0, 0xfa,
+	0x86, 0xd3, 0xbc, 0xb0, 0xec, 0xa6, 0xe3, 0x5c, 0x58, 0xb6, 0xe3, 0x6c, 0x5f, 0x58, 0xf6, 0x8e,
-	0xb5, 0x90, 0x8d, 0x9b, 0x03, 0x2a, 0xb7, 0x64, 0xa4, 0xbb, 0x11, 0x24, 0x87, 0xb0, 0x05, 0xd6,
+	0xd3, 0x42, 0x5b, 0x23, 0x9a, 0x50, 0x7f, 0xf0, 0xa9, 0x9e, 0x84, 0x6a, 0xe4, 0x2d, 0xe6, 0xe6,
-	0x07, 0x38, 0xc9, 0x75, 0x07, 0x58, 0x45, 0x1a, 0x78, 0x57, 0xa0, 0x79, 0xc3, 0x70, 0xc6, 0x71,
+	0x7f, 0x24, 0x6a, 0x04, 0x58, 0xe0, 0x64, 0xc4, 0x4d, 0xa9, 0x90, 0xa3, 0x0b, 0x38, 0x73, 0x6b,
-	0x20, 0x62, 0x9a, 0xbd, 0xa1, 0x11, 0x87, 0x10, 0x58, 0xea, 0x55, 0xd4, 0x73, 0xd5, 0x18, 0xfe,
+	0x1f, 0x81, 0xf5, 0x2b, 0x21, 0xdf, 0x84, 0x0e, 0xa8, 0xdc, 0x90, 0x91, 0x7e, 0x8d, 0x20, 0x39,
-	0x14, 0x58, 0x09, 0x8d, 0x78, 0x7b, 0x6d, 0xbf, 0x72, 0x50, 0x3b, 0x79, 0xf6, 0xb0, 0x07, 0x7b,
+	0x84, 0x2d, 0xb0, 0x3e, 0xc0, 0x49, 0xae, 0x1f, 0x97, 0x55, 0xa4, 0x81, 0x77, 0x09, 0x9a, 0xd7,
-	0x43, 0x23, 0xa4, 0x42, 0xbc, 0x7f, 0xac, 0x81, 0xca, 0x1b, 0x1a, 0xc1, 0x36, 0xd8, 0xc4, 0x61,
+	0x0c, 0x67, 0x1c, 0x07, 0x22, 0xa6, 0xd9, 0x1b, 0x1a, 0x71, 0x08, 0x81, 0xa5, 0x6e, 0x45, 0x3d,
-	0xc8, 0x08, 0xe7, 0x86, 0x69, 0x02, 0xe1, 0x2e, 0xd8, 0x10, 0xb4, 0x1f, 0x07, 0x9a, 0xae, 0x8a,
+	0x57, 0x8d, 0xe1, 0x4f, 0x80, 0x95, 0xd0, 0x88, 0xb7, 0xd7, 0xf6, 0x2b, 0x07, 0xb5, 0x93, 0x27,
-	0x0c, 0x92, 0xc2, 0x21, 0x16, 0x58, 0xf5, 0x15, 0x75, 0xa4, 0xc6, 0xf0, 0x04, 0xd4, 0xd5, 0xce,
+	0xf7, 0x5f, 0x6f, 0x6f, 0x68, 0x84, 0x54, 0x88, 0xf7, 0x8f, 0x35, 0x50, 0x79, 0x43, 0x23, 0xd8,
-	0xfc, 0x2c, 0x4f, 0xbb, 0x84, 0xa9, 0xf6, 0xc0, 0xea, 0x34, 0xef, 0x0b, 0xb7, 0xa6, 0xec, 0x5f,
+	0x06, 0x9b, 0x38, 0x0c, 0x19, 0xe1, 0xdc, 0x30, 0x4d, 0x20, 0xdc, 0x05, 0x1b, 0x82, 0xf6, 0xe3,
-	0x2b, 0x33, 0x9a, 0x05, 0xf0, 0x23, 0xb0, 0x29, 0x86, 0xb3, 0x2f, 0xfb, 0xce, 0x7d, 0xe1, 0x36,
+	0x40, 0xd3, 0x55, 0x91, 0x41, 0x52, 0x38, 0xc4, 0x02, 0xab, 0x77, 0x45, 0x1d, 0xa9, 0x31, 0x3c,
-	0xc5, 0x74, 0x9b, 0xf2, 0xe1, 0x46, 0x1b, 0x62, 0xa8, 0x1e, 0xf0, 0x23, 0x60, 0x8b, 0xa1, 0x1f,
+	0x01, 0x75, 0x95, 0x99, 0x9f, 0xe5, 0x69, 0x97, 0x30, 0xf5, 0x3c, 0xb0, 0x3a, 0xcd, 0xbb, 0xc2,
-	0x67, 0x21, 0x19, 0xaa, 0xc7, 0xdb, 0xea, 0xb4, 0xee, 0x0b, 0xd7, 0x99, 0x09, 0xbf, 0x90, 0x3e,
+	0xad, 0x29, 0xfb, 0xd7, 0xca, 0x8c, 0x66, 0x01, 0xfc, 0x08, 0x6c, 0x8a, 0xe1, 0xec, 0xcd, 0xbe,
-	0xb4, 0x29, 0x86, 0x6a, 0x00, 0x3f, 0x02, 0x40, 0x2f, 0x49, 0x29, 0xe8, 0xa7, 0x77, 0xeb, 0xbe,
+	0x73, 0x57, 0xb8, 0x4d, 0x31, 0x4d, 0x53, 0x5e, 0xdc, 0x68, 0x43, 0x0c, 0xd5, 0x05, 0x7e, 0x04,
-	0x70, 0xab, 0xca, 0xaa, 0xb8, 0xa7, 0x43, 0xe8, 0x81, 0x75, 0xcd, 0x6d, 0x2b, 0xee, 0xfa, 0x7d,
+	0x6c, 0x31, 0xf4, 0xe3, 0x2c, 0x24, 0x43, 0x75, 0x79, 0x5b, 0x9d, 0xd6, 0x5d, 0xe1, 0x3a, 0x33,
-	0xe1, 0xda, 0x09, 0x8d, 0x34, 0xa7, 0x76, 0xc9, 0x54, 0x31, 0x92, 0xd2, 0x01, 0x09, 0xd5, 0xeb,
+	0xe1, 0xe7, 0xd2, 0x87, 0x36, 0xc5, 0x50, 0x0d, 0xe0, 0x47, 0x00, 0xe8, 0x25, 0x29, 0x05, 0x7d,
-	0x66, 0xa3, 0x09, 0xf4, 0xfe, 0xba, 0x06, 0xec, 0x9b, 0x21, 0x22, 0x3c, 0x4f, 0x04, 0xfc, 0x02,
+	0xf5, 0x6e, 0xdd, 0x15, 0x6e, 0x55, 0x59, 0x15, 0xf7, 0x74, 0x08, 0x3d, 0xb0, 0xae, 0xb9, 0x6d,
-	0x38, 0x01, 0xcd, 0x04, 0xc3, 0x81, 0xf0, 0xe7, 0x52, 0xdb, 0x79, 0x31, 0x7d, 0x69, 0x16, 0x23,
+	0xc5, 0x5d, 0xbf, 0x2b, 0x5c, 0x3b, 0xa1, 0x91, 0xe6, 0xd4, 0x2e, 0x59, 0x2a, 0x46, 0x52, 0x3a,
-	0x3c, 0xd4, 0x9c, 0x98, 0xce, 0x4c, 0xfe, 0x5b, 0x60, 0xbd, 0x9b, 0x50, 0x9a, 0xaa, 0x4a, 0xa8,
+	0x20, 0xa1, 0xba, 0xdd, 0x6c, 0x34, 0x81, 0xde, 0x5f, 0xd6, 0x80, 0x7d, 0x3d, 0x44, 0x84, 0xe7,
-	0x23, 0x0d, 0x20, 0x52, 0x59, 0x53, 0xa7, 0x5c, 0x51, 0x9d, 0xf6, 0x8f, 0x1f, 0x9e, 0xf2, 0x42,
+	0x89, 0x80, 0x5f, 0x00, 0x27, 0xa0, 0x99, 0x60, 0x38, 0x10, 0xfe, 0x5c, 0x69, 0x3b, 0xcf, 0xa7,
-	0xa9, 0x74, 0x76, 0x4d, 0xb7, 0xdd, 0xd0, 0xda, 0x66, 0xbe, 0x27, 0x73, 0xab, 0x4a, 0xc9, 0x01,
+	0x37, 0xcd, 0x62, 0x84, 0x87, 0x9a, 0x13, 0xd3, 0x4b, 0x53, 0xff, 0x16, 0x58, 0xef, 0x26, 0x94,
-	0x15, 0x46, 0x84, 0x3a, 0xb4, 0x3a, 0x92, 0x43, 0xf8, 0x1c, 0xd8, 0x8c, 0x0c, 0x08, 0x13, 0x24,
+	0xa6, 0xaa, 0x13, 0xea, 0x48, 0x03, 0x88, 0x54, 0xd5, 0xd4, 0x2e, 0x57, 0xd4, 0x1b, 0xfd, 0xc7,
-	0x54, 0x87, 0x63, 0xa3, 0x12, 0xc3, 0x0f, 0x81, 0x1d, 0x61, 0xee, 0xe7, 0x9c, 0x84, 0xfa, 0x24,
+	0xf7, 0x77, 0x79, 0xa1, 0x55, 0x3a, 0xbb, 0xe6, 0x9d, 0xde, 0xd0, 0xda, 0x66, 0xbe, 0x27, 0x6b,
-	0xd0, 0x66, 0x84, 0xf9, 0x37, 0x9c, 0x84, 0x9f, 0x59, 0x7f, 0xfe, 0xde, 0x5d, 0xf1, 0x30, 0xa8,
+	0xab, 0x5a, 0xc9, 0x01, 0x15, 0x46, 0x84, 0xda, 0xb4, 0x3a, 0x92, 0x43, 0xf8, 0x0c, 0xd8, 0x8c,
-	0x9d, 0x05, 0x01, 0xe1, 0xfc, 0x26, 0xef, 0x27, 0xe4, 0xbf, 0x54, 0xd8, 0x09, 0xa8, 0x73, 0x41,
+	0x0c, 0x08, 0x13, 0x24, 0x54, 0x9b, 0x63, 0xa3, 0x12, 0xc3, 0x0f, 0x80, 0x1d, 0x61, 0xee, 0xe7,
-	0x19, 0x8e, 0x88, 0x7f, 0x4b, 0x46, 0xa6, 0xce, 0x74, 0xd5, 0x18, 0xfb, 0xaf, 0xc8, 0x88, 0xa3,
+	0x9c, 0x84, 0x7a, 0x27, 0xd0, 0x66, 0x84, 0xf9, 0x37, 0x9c, 0x84, 0x9f, 0x59, 0x7f, 0xfe, 0xde,
-	0x59, 0x60, 0x24, 0xbe, 0xb7, 0x40, 0xed, 0x86, 0xe1, 0x80, 0x98, 0x0e, 0x5f, 0xd6, 0xaa, 0x84,
+	0x5d, 0xf1, 0x30, 0xa8, 0xbd, 0x0c, 0x02, 0xc2, 0xf9, 0x75, 0xde, 0x4f, 0xc8, 0x7f, 0xe9, 0xb0,
-	0xcc, 0x48, 0x18, 0x24, 0xb5, 0x45, 0x9c, 0x12, 0x9a, 0x0b, 0x73, 0x9f, 0x26, 0x50, 0xce, 0x60,
+	0x13, 0x50, 0xe7, 0x82, 0x32, 0x1c, 0x11, 0xff, 0x86, 0x8c, 0x4c, 0x9f, 0xe9, 0xae, 0x31, 0xf6,
-	0x84, 0x0c, 0x49, 0xa0, 0xd2, 0x68, 0x21, 0x83, 0xe0, 0x29, 0xd8, 0x0a, 0x63, 0xae, 0x3e, 0x97,
+	0x5f, 0x91, 0x11, 0x47, 0xb3, 0xc0, 0x48, 0x7c, 0x6f, 0x81, 0xda, 0x35, 0xc3, 0x01, 0x31, 0x2f,
-	0xb8, 0xc0, 0xc1, 0xad, 0xde, 0x7e, 0xc7, 0xb9, 0x2f, 0xdc, 0xba, 0x71, 0x5c, 0x4b, 0x3b, 0x9a,
+	0x7c, 0xd9, 0xab, 0x12, 0x32, 0x23, 0x61, 0x90, 0xd4, 0x16, 0x71, 0x4a, 0x68, 0x2e, 0xcc, 0x79,
-	0x43, 0xf0, 0x73, 0xd0, 0x9c, 0x4e, 0x53, 0xab, 0xd5, 0x1f, 0x28, 0x1d, 0x78, 0x5f, 0xb8, 0x8d,
+	0x9a, 0x40, 0x39, 0x83, 0x11, 0x32, 0x24, 0x81, 0x2a, 0xa3, 0x85, 0x0c, 0x82, 0xa7, 0x60, 0x2b,
-	0x32, 0x54, 0x79, 0xd0, 0x02, 0x96, 0x27, 0x1d, 0x92, 0x6e, 0x1e, 0xa9, 0xe2, 0xb3, 0x91, 0x06,
+	0x8c, 0xb9, 0xfa, 0x12, 0xe3, 0x02, 0x07, 0x37, 0x3a, 0xfd, 0x8e, 0x73, 0x57, 0xb8, 0x75, 0xe3,
-	0xd2, 0x9a, 0xc4, 0x69, 0x2c, 0x54, 0xb1, 0xad, 0x23, 0x0d, 0xe0, 0xe7, 0xa0, 0x4a, 0x07, 0x84,
+	0xb8, 0x92, 0x76, 0x34, 0x87, 0xe0, 0xe7, 0xa0, 0x39, 0x9d, 0xa6, 0x56, 0xab, 0x3f, 0x6d, 0x3a,
-	0xb1, 0x38, 0x24, 0x5c, 0xb5, 0x3a, 0xff, 0xeb, 0x5b, 0x0b, 0x4d, 0xe3, 0xe5, 0xe6, 0xcc, 0xa7,
+	0xf0, 0xae, 0x70, 0x1b, 0x65, 0xa8, 0xf2, 0xa0, 0x05, 0x2c, 0x77, 0x3a, 0x24, 0xdd, 0x3c, 0x52,
-	0x60, 0x4a, 0x52, 0xca, 0x46, 0xaa, 0x77, 0x31, 0x9b, 0xd3, 0x8e, 0x5f, 0x2b, 0x3b, 0x9a, 0x43,
+	0xcd, 0x67, 0x23, 0x0d, 0xa4, 0x35, 0x89, 0xd3, 0x58, 0xa8, 0x66, 0x5b, 0x47, 0x1a, 0xc0, 0xcf,
-	0xb0, 0x03, 0xa0, 0x99, 0xc6, 0x88, 0xc8, 0x59, 0xe6, 0xab, 0xfb, 0x5f, 0x57, 0x73, 0xd5, 0x2d,
+	0x41, 0x95, 0x0e, 0x08, 0x63, 0x71, 0x48, 0xb8, 0x7a, 0xea, 0xfc, 0xaf, 0xaf, 0x34, 0x34, 0x8d,
-	0xd4, 0x5e, 0xa4, 0x9c, 0xaf, 0xb1, 0xc0, 0xe8, 0x81, 0x05, 0xfe, 0x02, 0x40, 0x7d, 0x26, 0xfe,
+	0x97, 0xc9, 0x99, 0xaf, 0xcc, 0x94, 0xa4, 0x94, 0x8d, 0xd4, 0xdb, 0xc5, 0x24, 0xa7, 0x1d, 0xbf,
-	0x77, 0x9c, 0x96, 0x1f, 0x8b, 0xba, 0xb5, 0x50, 0xfa, 0xda, 0x6b, 0xd6, 0xec, 0x68, 0x74, 0xc9,
+	0x56, 0x76, 0x34, 0x87, 0x60, 0x07, 0x40, 0x33, 0x8d, 0x11, 0x91, 0xb3, 0xcc, 0x57, 0xe7, 0xbf,
-	0xa9, 0xd9, 0xc5, 0xa5, 0x65, 0x5b, 0xce, 0xfa, 0xa5, 0x65, 0x6f, 0x3a, 0x76, 0x99, 0x3f, 0xb3,
+	0xae, 0xe6, 0xaa, 0x53, 0xa8, 0xbd, 0x48, 0x39, 0x5f, 0x63, 0x81, 0xd1, 0x3d, 0x0b, 0xfc, 0x05,
-	0x0b, 0xb4, 0x33, 0xc1, 0x33, 0xcb, 0xeb, 0xfc, 0xf2, 0x87, 0xbb, 0xbd, 0xd5, 0x77, 0x77, 0x7b,
+	0x80, 0x7a, 0x4f, 0xfc, 0xef, 0x38, 0x2d, 0x3f, 0x33, 0xf5, 0xd3, 0x42, 0xe9, 0x6b, 0xaf, 0x59,
-	0xab, 0xff, 0xbe, 0xdb, 0x5b, 0xfd, 0xdb, 0xfb, 0xbd, 0x95, 0x77, 0xef, 0xf7, 0x56, 0xfe, 0xf9,
+	0xb3, 0xa3, 0xd1, 0x05, 0xa7, 0x26, 0x8b, 0x0b, 0xcb, 0xb6, 0x9c, 0xf5, 0x0b, 0xcb, 0xde, 0x74,
-	0x7e, 0x6f, 0xe5, 0x77, 0xb3, 0xef, 0x03, 0x19, 0xc8, 0xe7, 0x61, 0xfa, 0xfd, 0x3f, 0x54, 0xff,
+	0xec, 0xb2, 0x7e, 0x26, 0x0b, 0xb4, 0x33, 0xc1, 0x33, 0xcb, 0xeb, 0xfc, 0xf2, 0x87, 0xdb, 0xbd,
-	0x01, 0x50, 0x6f, 0x44, 0x77, 0x43, 0x7d, 0xd9, 0x7f, 0xfa, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff,
+	0xd5, 0x77, 0xb7, 0x7b, 0xab, 0xff, 0xbe, 0xdd, 0x5b, 0xfd, 0xeb, 0xfb, 0xbd, 0x95, 0x77, 0xef,
-	0xe2, 0xe1, 0x18, 0x7a, 0x1f, 0x10, 0x00, 0x00,
+	0xf7, 0x56, 0xfe, 0xf9, 0x7e, 0x6f, 0xe5, 0x77, 0xb3, 0xf7, 0x03, 0x19, 0xc8, 0xeb, 0x61, 0xfa,
+	0xd3, 0xc2, 0x50, 0xfd, 0xb8, 0xa0, 0xee, 0x88, 0xee, 0x86, 0xfa, 0xd1, 0xe0, 0xd3, 0xff, 0x04,
+	0x00, 0x00, 0xff, 0xff, 0x68, 0xce, 0x8e, 0x23, 0x7a, 0x10, 0x00, 0x00,
 }
 
 func (m *Params) Marshal() (dAtA []byte, err error) {
@@ -833,25 +882,16 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	}
 	i--
 	dAtA[i] = 0x2a
-	if len(m.ExtraEIPs) > 0 {
+	{
-		dAtA3 := make([]byte, len(m.ExtraEIPs)*10)
+		size, err := m.ExtraEIPs.MarshalToSizedBuffer(dAtA[:i])
-		var j2 int
+		if err != nil {
-		for _, num1 := range m.ExtraEIPs {
+			return 0, err
-			num := uint64(num1)
-			for num >= 1<<7 {
-				dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80)
-				num >>= 7
-				j2++
 		}
-			dAtA3[j2] = uint8(num)
+		i -= size
-			j2++
+		i = encodeVarintEvm(dAtA, i, uint64(size))
 	}
-		i -= j2
-		copy(dAtA[i:], dAtA3[:j2])
-		i = encodeVarintEvm(dAtA, i, uint64(j2))
 	i--
 	dAtA[i] = 0x22
-	}
 	if m.EnableCall {
 		i--
 		if m.EnableCall {
@@ -882,6 +922,48 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *ExtraEIPs) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ExtraEIPs) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ExtraEIPs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.EIPs) > 0 {
+		dAtA4 := make([]byte, len(m.EIPs)*10)
+		var j3 int
+		for _, num1 := range m.EIPs {
+			num := uint64(num1)
+			for num >= 1<<7 {
+				dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
+				num >>= 7
+				j3++
+			}
+			dAtA4[j3] = uint8(num)
+			j3++
+		}
+		i -= j3
+		copy(dAtA[i:], dAtA4[:j3])
+		i = encodeVarintEvm(dAtA, i, uint64(j3))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *ChainConfig) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -1555,13 +1637,8 @@ func (m *Params) Size() (n int) {
 	if m.EnableCall {
 		n += 2
 	}
-	if len(m.ExtraEIPs) > 0 {
+	l = m.ExtraEIPs.Size()
-		l = 0
+	n += 1 + l + sovEvm(uint64(l))
-		for _, e := range m.ExtraEIPs {
-			l += sovEvm(uint64(e))
-		}
-		n += 1 + sovEvm(uint64(l)) + l
-	}
 	l = m.ChainConfig.Size()
 	n += 1 + l + sovEvm(uint64(l))
 	if m.AllowUnprotectedTxs {
@@ -1570,6 +1647,22 @@ func (m *Params) Size() (n int) {
 	return n
 }
 
+func (m *ExtraEIPs) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.EIPs) > 0 {
+		l = 0
+		for _, e := range m.EIPs {
+			l += sovEvm(uint64(e))
+		}
+		n += 1 + sovEvm(uint64(l)) + l
+	}
+	return n
+}
+
 func (m *ChainConfig) Size() (n int) {
 	if m == nil {
 		return 0
@@ -1935,8 +2028,10 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 			}
 			m.EnableCall = bool(v != 0)
 		case 4:
-			if wireType == 0 {
+			if wireType != 2 {
-				var v int64
+				return fmt.Errorf("proto: wrong wireType = %d for field ExtraEIPs", wireType)
+			}
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowEvm
@@ -1946,70 +2041,25 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-					v |= int64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-				m.ExtraEIPs = append(m.ExtraEIPs, v)
+			if msglen < 0 {
-			} else if wireType == 2 {
-				var packedLen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return ErrIntOverflowEvm
-					}
-					if iNdEx >= l {
-						return io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					packedLen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if packedLen < 0 {
 				return ErrInvalidLengthEvm
 			}
-				postIndex := iNdEx + packedLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthEvm
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-				var elementCount int
+			if err := m.ExtraEIPs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				var count int
+				return err
-				for _, integer := range dAtA[iNdEx:postIndex] {
-					if integer < 128 {
-						count++
-					}
-				}
-				elementCount = count
-				if elementCount != 0 && len(m.ExtraEIPs) == 0 {
-					m.ExtraEIPs = make([]int64, 0, elementCount)
-				}
-				for iNdEx < postIndex {
-					var v int64
-					for shift := uint(0); ; shift += 7 {
-						if shift >= 64 {
-							return ErrIntOverflowEvm
-						}
-						if iNdEx >= l {
-							return io.ErrUnexpectedEOF
-						}
-						b := dAtA[iNdEx]
-						iNdEx++
-						v |= int64(b&0x7F) << shift
-						if b < 0x80 {
-							break
-						}
-					}
-					m.ExtraEIPs = append(m.ExtraEIPs, v)
-				}
-			} else {
-				return fmt.Errorf("proto: wrong wireType = %d for field ExtraEIPs", wireType)
 			}
+			iNdEx = postIndex
 		case 5:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field ChainConfig", wireType)
@@ -2084,6 +2134,132 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *ExtraEIPs) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowEvm
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ExtraEIPs: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ExtraEIPs: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType == 0 {
+				var v int64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowEvm
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				m.EIPs = append(m.EIPs, v)
+			} else if wireType == 2 {
+				var packedLen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowEvm
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					packedLen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if packedLen < 0 {
+					return ErrInvalidLengthEvm
+				}
+				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthEvm
+				}
+				if postIndex > l {
+					return io.ErrUnexpectedEOF
+				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA[iNdEx:postIndex] {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.EIPs) == 0 {
+					m.EIPs = make([]int64, 0, elementCount)
+				}
+				for iNdEx < postIndex {
+					var v int64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowEvm
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						v |= int64(b&0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					m.EIPs = append(m.EIPs, v)
+				}
+			} else {
+				return fmt.Errorf("proto: wrong wireType = %d for field EIPs", wireType)
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipEvm(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthEvm
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *ChainConfig) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0

x/evm/types/interfaces.go

@@ -18,6 +18,8 @@ package types
 import (
 	"math/big"
 
+	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
@@ -70,3 +72,12 @@ type EvmHooks interface {
 	// Must be called after tx is processed successfully, if return an error, the whole transaction is reverted.
 	PostTxProcessing(ctx sdk.Context, msg core.Message, receipt *ethtypes.Receipt) error
 }
+
+type (
+	LegacyParams = paramtypes.ParamSet
+	// Subspace defines an interface that implements the legacy Cosmos SDK x/params Subspace type.
+	// NOTE: This is used solely for migration of the Cosmos SDK x/params managed parameters.
+	Subspace interface {
+		GetParamSetIfExists(ctx sdk.Context, ps LegacyParams)
+	}
+)

x/evm/types/msg.go

@@ -43,6 +43,7 @@ var (
 	_ sdk.Msg    = &MsgEthereumTx{}
 	_ sdk.Tx     = &MsgEthereumTx{}
 	_ ante.GasTx = &MsgEthereumTx{}
+	_ sdk.Msg    = &MsgUpdateParams{}
 
 	_ codectypes.UnpackInterfacesMessage = MsgEthereumTx{}
 )
@@ -389,3 +390,24 @@ func (msg *MsgEthereumTx) BuildTx(b client.TxBuilder, evmDenom string) (signing.
 	tx := builder.GetTx()
 	return tx, nil
 }
+
+// GetSigners returns the expected signers for a MsgUpdateParams message.
+func (m MsgUpdateParams) GetSigners() []sdk.AccAddress {
+	//#nosec G703 -- gosec raises a warning about a non-handled error which we deliberately ignore here
+	addr, _ := sdk.AccAddressFromBech32(m.Authority)
+	return []sdk.AccAddress{addr}
+}
+
+// ValidateBasic does a sanity check of the provided data
+func (m *MsgUpdateParams) ValidateBasic() error {
+	if _, err := sdk.AccAddressFromBech32(m.Authority); err != nil {
+		return errortypes.Wrap(err, "invalid authority address")
+	}
+
+	return m.Params.Validate()
+}
+
+// GetSignBytes implements the LegacyMsg interface.
+func (m MsgUpdateParams) GetSignBytes() []byte {
+	return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(&m))
+}

x/evm/types/params.go

@@ -22,20 +22,21 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/evmos/ethermint/types"
 )
 
-var _ paramtypes.ParamSet = &Params{}
-
 var (
 	// DefaultEVMDenom defines the default EVM denomination on Ethermint
 	DefaultEVMDenom = types.AttoPhoton
-	// DefaultMinGasMultiplier is 0.5 or 50%
-	DefaultMinGasMultiplier = sdk.NewDecWithPrec(50, 2)
 	// DefaultAllowUnprotectedTxs rejects all unprotected txs (i.e false)
 	DefaultAllowUnprotectedTxs = false
+	// DefaultEnableCreate enables contract creation (i.e true)
+	DefaultEnableCreate = true
+	// DefaultEnableCall enables contract calls (i.e true)
+	DefaultEnableCall = true
+	// DefaultExtraEIPs  defines the set of activateable Ethereum Improvement Proposals
+	DefaultExtraEIPs = ExtraEIPs{AvailableExtraEIPs}
 )
 
 // Parameter keys
@@ -55,15 +56,11 @@ var (
 	AvailableExtraEIPs = []int64{1344, 1884, 2200, 2929, 3198, 3529}
 )
 
-// ParamKeyTable returns the parameter key table.
-func ParamKeyTable() paramtypes.KeyTable {
-	return paramtypes.NewKeyTable().RegisterParamSet(&Params{})
-}
-
 // NewParams creates a new Params instance
-func NewParams(evmDenom string, enableCreate, enableCall bool, config ChainConfig, extraEIPs ...int64) Params {
+func NewParams(evmDenom string, allowUnprotectedTxs, enableCreate, enableCall bool, config ChainConfig, extraEIPs ExtraEIPs) Params {
 	return Params{
 		EvmDenom:            evmDenom,
+		AllowUnprotectedTxs: allowUnprotectedTxs,
 		EnableCreate:        enableCreate,
 		EnableCall:          enableCall,
 		ExtraEIPs:           extraEIPs,
@@ -76,43 +73,43 @@ func NewParams(evmDenom string, enableCreate, enableCall bool, config ChainConfi
 func DefaultParams() Params {
 	return Params{
 		EvmDenom:            DefaultEVMDenom,
-		EnableCreate:        true,
+		EnableCreate:        DefaultEnableCreate,
-		EnableCall:          true,
+		EnableCall:          DefaultEnableCall,
 		ChainConfig:         DefaultChainConfig(),
-		ExtraEIPs:           nil,
+		ExtraEIPs:           DefaultExtraEIPs,
 		AllowUnprotectedTxs: DefaultAllowUnprotectedTxs,
 	}
 }
 
-// ParamSetPairs returns the parameter set pairs.
-func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
-	return paramtypes.ParamSetPairs{
-		paramtypes.NewParamSetPair(ParamStoreKeyEVMDenom, &p.EvmDenom, validateEVMDenom),
-		paramtypes.NewParamSetPair(ParamStoreKeyEnableCreate, &p.EnableCreate, validateBool),
-		paramtypes.NewParamSetPair(ParamStoreKeyEnableCall, &p.EnableCall, validateBool),
-		paramtypes.NewParamSetPair(ParamStoreKeyExtraEIPs, &p.ExtraEIPs, validateEIPs),
-		paramtypes.NewParamSetPair(ParamStoreKeyChainConfig, &p.ChainConfig, validateChainConfig),
-		paramtypes.NewParamSetPair(ParamStoreKeyAllowUnprotectedTxs, &p.AllowUnprotectedTxs, validateBool),
-	}
-}
-
 // Validate performs basic validation on evm parameters.
 func (p Params) Validate() error {
-	if err := sdk.ValidateDenom(p.EvmDenom); err != nil {
+	if err := validateEVMDenom(p.EvmDenom); err != nil {
 		return err
 	}
 
-	if err := validateEIPs(p.ExtraEIPs); err != nil {
+	if err := validateEIPs(p.ExtraEIPs.EIPs); err != nil {
 		return err
 	}
 
-	return p.ChainConfig.Validate()
+	if err := validateBool(p.EnableCall); err != nil {
+		return err
+	}
+
+	if err := validateBool(p.EnableCreate); err != nil {
+		return err
+	}
+
+	if err := validateBool(p.AllowUnprotectedTxs); err != nil {
+		return err
+	}
+
+	return validateChainConfig(p.ChainConfig)
 }
 
-// EIPs returns the ExtraEips as a int slice
+// EIPs returns the ExtraEIPS as a int slice
 func (p Params) EIPs() []int {
-	eips := make([]int, len(p.ExtraEIPs))
+	eips := make([]int, len(p.ExtraEIPs.EIPs))
-	for i, eip := range p.ExtraEIPs {
+	for i, eip := range p.ExtraEIPs.EIPs {
 		eips[i] = int(eip)
 	}
 	return eips

x/evm/types/params_test.go

@@ -5,15 +5,11 @@ import (
 
 	"github.com/ethereum/go-ethereum/params"
 
-	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
 	"github.com/stretchr/testify/require"
 )
 
-func TestParamKeyTable(t *testing.T) {
-	require.IsType(t, paramtypes.KeyTable{}, ParamKeyTable())
-}
-
 func TestParamsValidate(t *testing.T) {
+	extraEips := ExtraEIPs{[]int64{2929, 1884, 1344}}
 	testCases := []struct {
 		name     string
 		params   Params
@@ -22,7 +18,7 @@ func TestParamsValidate(t *testing.T) {
 		{"default", DefaultParams(), false},
 		{
 			"valid",
-			NewParams("ara", true, true, DefaultChainConfig(), 2929, 1884, 1344),
+			NewParams("ara", false, true, true, DefaultChainConfig(), extraEips),
 			false,
 		},
 		{
@@ -41,7 +37,7 @@ func TestParamsValidate(t *testing.T) {
 			"invalid eip",
 			Params{
 				EvmDenom:  "stake",
-				ExtraEIPs: []int64{1},
+				ExtraEIPs: ExtraEIPs{[]int64{1}},
 			},
 			true,
 		},
@@ -59,7 +55,8 @@ func TestParamsValidate(t *testing.T) {
 }
 
 func TestParamsEIPs(t *testing.T) {
-	params := NewParams("ara", true, true, DefaultChainConfig(), 2929, 1884, 1344)
+	extraEips := ExtraEIPs{[]int64{2929, 1884, 1344}}
+	params := NewParams("ara", false, true, true, DefaultChainConfig(), extraEips)
 	actual := params.EIPs()
 
 	require.Equal(t, []int([]int{2929, 1884, 1344}), actual)

x/evm/types/tx.pb.go

@@ -10,6 +10,7 @@ import (
 	_ "github.com/cosmos/cosmos-proto"
 	types "github.com/cosmos/cosmos-sdk/codec/types"
 	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
+	_ "github.com/cosmos/cosmos-sdk/types/msgservice"
 	_ "github.com/cosmos/gogoproto/gogoproto"
 	grpc1 "github.com/gogo/protobuf/grpc"
 	proto "github.com/gogo/protobuf/proto"
@@ -345,6 +346,100 @@ func (m *MsgEthereumTxResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MsgEthereumTxResponse proto.InternalMessageInfo
 
+// MsgUpdateParams defines a Msg for updating the x/evm module parameters.
+type MsgUpdateParams struct {
+	// authority is the address of the governance account.
+	Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
+	// params defines the x/evm parameters to update.
+	// NOTE: All parameters must be supplied.
+	Params Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params"`
+}
+
+func (m *MsgUpdateParams) Reset()         { *m = MsgUpdateParams{} }
+func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) }
+func (*MsgUpdateParams) ProtoMessage()    {}
+func (*MsgUpdateParams) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f75ac0a12d075f21, []int{6}
+}
+func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgUpdateParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgUpdateParams.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgUpdateParams) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgUpdateParams.Merge(m, src)
+}
+func (m *MsgUpdateParams) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgUpdateParams) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgUpdateParams.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgUpdateParams proto.InternalMessageInfo
+
+func (m *MsgUpdateParams) GetAuthority() string {
+	if m != nil {
+		return m.Authority
+	}
+	return ""
+}
+
+func (m *MsgUpdateParams) GetParams() Params {
+	if m != nil {
+		return m.Params
+	}
+	return Params{}
+}
+
+// MsgUpdateParamsResponse defines the response structure for executing a
+// MsgUpdateParams message.
+type MsgUpdateParamsResponse struct {
+}
+
+func (m *MsgUpdateParamsResponse) Reset()         { *m = MsgUpdateParamsResponse{} }
+func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgUpdateParamsResponse) ProtoMessage()    {}
+func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f75ac0a12d075f21, []int{7}
+}
+func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgUpdateParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgUpdateParamsResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgUpdateParamsResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgUpdateParamsResponse.Merge(m, src)
+}
+func (m *MsgUpdateParamsResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgUpdateParamsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo
+
 func init() {
 	proto.RegisterType((*MsgEthereumTx)(nil), "ethermint.evm.v1.MsgEthereumTx")
 	proto.RegisterType((*LegacyTx)(nil), "ethermint.evm.v1.LegacyTx")
@@ -352,66 +447,76 @@ func init() {
 	proto.RegisterType((*DynamicFeeTx)(nil), "ethermint.evm.v1.DynamicFeeTx")
 	proto.RegisterType((*ExtensionOptionsEthereumTx)(nil), "ethermint.evm.v1.ExtensionOptionsEthereumTx")
 	proto.RegisterType((*MsgEthereumTxResponse)(nil), "ethermint.evm.v1.MsgEthereumTxResponse")
+	proto.RegisterType((*MsgUpdateParams)(nil), "ethermint.evm.v1.MsgUpdateParams")
+	proto.RegisterType((*MsgUpdateParamsResponse)(nil), "ethermint.evm.v1.MsgUpdateParamsResponse")
 }
 
 func init() { proto.RegisterFile("ethermint/evm/v1/tx.proto", fileDescriptor_f75ac0a12d075f21) }
 
 var fileDescriptor_f75ac0a12d075f21 = []byte{
-	// 853 bytes of a gzipped FileDescriptorProto
+	// 990 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x55, 0x31, 0x8f, 0xe3, 0x44,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x56, 0x4f, 0x8f, 0xdb, 0x44,
-	0x14, 0xce, 0x24, 0x4e, 0xec, 0x4c, 0xc2, 0xe9, 0x64, 0xed, 0x49, 0x4e, 0xc4, 0xc5, 0x91, 0x25,
+	0x14, 0x5f, 0x27, 0xce, 0xbf, 0x49, 0x58, 0xaa, 0xd1, 0x56, 0x75, 0x22, 0x1a, 0xa7, 0x96, 0xa0,
-	0x20, 0x20, 0xc5, 0xd6, 0x2d, 0x54, 0x5b, 0xdd, 0xe6, 0x76, 0xef, 0x74, 0xa7, 0x9c, 0x40, 0x56,
+	0x69, 0xa5, 0xd8, 0xea, 0x82, 0x7a, 0xd8, 0x53, 0x37, 0xdd, 0x6d, 0xd5, 0x6a, 0x57, 0x54, 0x26,
-	0x68, 0xb8, 0x22, 0x9a, 0x75, 0x66, 0x1d, 0x8b, 0xd8, 0x63, 0x79, 0x26, 0x96, 0x83, 0x44, 0x83,
+	0xbd, 0xd0, 0x43, 0x34, 0xeb, 0xcc, 0x4e, 0x2c, 0x62, 0x8f, 0xe5, 0x19, 0x5b, 0x09, 0x12, 0x97,
-	0x28, 0xe8, 0x40, 0xe2, 0x0f, 0x50, 0x50, 0xd1, 0xc2, 0x0f, 0xa0, 0x3c, 0x51, 0x9d, 0x44, 0x83,
+	0x4a, 0x48, 0x1c, 0x90, 0x00, 0xf1, 0x05, 0x38, 0x70, 0xe2, 0x84, 0x44, 0x3f, 0x00, 0xc7, 0x8a,
-	0x28, 0x0c, 0xca, 0x52, 0x6d, 0x07, 0xbf, 0x00, 0xcd, 0x8c, 0xb3, 0xd9, 0x10, 0x65, 0x81, 0x65,
+	0x53, 0x05, 0x17, 0xc4, 0x21, 0xa0, 0x2c, 0x12, 0xd2, 0xde, 0xe0, 0x13, 0xa0, 0x99, 0x71, 0x36,
-	0xd1, 0x55, 0x99, 0xe7, 0xf7, 0xde, 0x37, 0x6f, 0xde, 0xf7, 0xe5, 0x3d, 0xd8, 0xc2, 0x6c, 0x8a,
+	0x9b, 0x86, 0x6d, 0xa1, 0x14, 0x71, 0xf2, 0xbc, 0x79, 0x6f, 0xde, 0x7b, 0xf3, 0xfb, 0xfd, 0x66,
-	0x93, 0x30, 0x88, 0x98, 0x83, 0xd3, 0xd0, 0x49, 0xef, 0x39, 0x2c, 0xb3, 0xe3, 0x84, 0x30, 0xa2,
+	0xc6, 0xa0, 0x8e, 0xf9, 0x10, 0xc7, 0x81, 0x1f, 0x72, 0x07, 0xa7, 0x81, 0x93, 0x5e, 0x73, 0xf8,
-	0xdf, 0xbe, 0x70, 0xd9, 0x38, 0x0d, 0xed, 0xf4, 0x5e, 0xbb, 0xe5, 0x11, 0x1a, 0x12, 0x3a, 0x16,
+	0xd8, 0x8e, 0x62, 0xca, 0x29, 0x3c, 0x77, 0xe2, 0xb2, 0x71, 0x1a, 0xd8, 0xe9, 0xb5, 0xc6, 0x05,
-	0x7e, 0x47, 0x1a, 0x32, 0xb8, 0xdd, 0xde, 0xc2, 0xe1, 0x39, 0xd2, 0xb7, 0xe7, 0x13, 0x9f, 0xc8,
+	0x8f, 0xb2, 0x80, 0x32, 0x27, 0x60, 0x44, 0x44, 0x06, 0x8c, 0xa8, 0xd0, 0x46, 0x5d, 0x39, 0xfa,
-	0x1c, 0x7e, 0x2a, 0xbe, 0xbe, 0xea, 0x13, 0xe2, 0xcf, 0xb0, 0x83, 0xe2, 0xc0, 0x41, 0x51, 0x44,
+	0xd2, 0x72, 0x94, 0x91, 0xb9, 0x1a, 0x2b, 0x05, 0x44, 0x32, 0xe5, 0xdb, 0x20, 0x94, 0x50, 0xb5,
-	0x18, 0x62, 0x01, 0x89, 0x56, 0x78, 0xad, 0xc2, 0x2b, 0xac, 0x93, 0xf9, 0xa9, 0x83, 0xa2, 0x85,
+	0x46, 0x8c, 0xb2, 0xd9, 0xd7, 0x08, 0xa5, 0x64, 0x84, 0x1d, 0x14, 0xf9, 0x0e, 0x0a, 0x43, 0xca,
-	0x74, 0x59, 0x9f, 0x03, 0xf8, 0xca, 0x53, 0xea, 0x1f, 0xf3, 0x0b, 0xf1, 0x3c, 0x1c, 0x65, 0x7a,
+	0x11, 0xf7, 0x69, 0x38, 0xcf, 0x57, 0xcf, 0xbc, 0xd2, 0x3a, 0x48, 0x0e, 0x1d, 0x14, 0x4e, 0x94,
-	0x0f, 0x2a, 0x13, 0xc4, 0x90, 0x01, 0xba, 0xa0, 0xd7, 0xd8, 0xdf, 0xb3, 0x65, 0xae, 0xbd, 0xca,
+	0xcb, 0xfa, 0x44, 0x03, 0xaf, 0xec, 0x33, 0xb2, 0x2b, 0x0a, 0xe2, 0x24, 0xe8, 0x8d, 0x61, 0x1b,
-	0xb5, 0x0f, 0xa3, 0x85, 0x2b, 0x22, 0xf4, 0x16, 0x54, 0x68, 0xf0, 0x11, 0x36, 0xca, 0x5d, 0xd0,
+	0xe8, 0x03, 0xc4, 0x91, 0xa1, 0xb5, 0xb4, 0x76, 0x75, 0x73, 0xc3, 0x56, 0x6b, 0xed, 0xf9, 0x5a,
-	0x03, 0x83, 0xea, 0x79, 0x6e, 0x82, 0xbe, 0x2b, 0x3e, 0xe9, 0x26, 0x54, 0xa6, 0x88, 0x4e, 0x8d,
+	0x7b, 0x3b, 0x9c, 0xb8, 0x32, 0x02, 0xd6, 0x81, 0xce, 0xfc, 0xf7, 0xb1, 0x91, 0x6b, 0x69, 0x6d,
-	0x4a, 0x17, 0xf4, 0xea, 0x83, 0xc6, 0x1f, 0xb9, 0xa9, 0x26, 0xb3, 0xf8, 0xc0, 0xea, 0x5b, 0xae,
+	0xad, 0x5b, 0x38, 0x9e, 0x9a, 0x5a, 0xc7, 0x95, 0x53, 0xd0, 0x04, 0xfa, 0x10, 0xb1, 0xa1, 0x91,
-	0x70, 0xe8, 0x3a, 0x54, 0x4e, 0x13, 0x12, 0x1a, 0x0a, 0x0f, 0x70, 0xc5, 0xf9, 0x40, 0xf9, 0xec,
+	0x6f, 0x69, 0xed, 0x4a, 0xb7, 0xfa, 0xc7, 0xd4, 0x2c, 0xc5, 0xa3, 0x68, 0xcb, 0xea, 0x58, 0xae,
-	0x2b, 0xb3, 0x64, 0x7d, 0x5b, 0x86, 0xda, 0x10, 0xfb, 0xc8, 0x5b, 0x8c, 0x32, 0x7d, 0x0f, 0x56,
+	0x74, 0x40, 0x08, 0xf4, 0xc3, 0x98, 0x06, 0x86, 0x2e, 0x02, 0x5c, 0x39, 0xde, 0xd2, 0x3f, 0xfa,
-	0x23, 0x12, 0x79, 0x58, 0x54, 0xa3, 0xb8, 0xd2, 0xd0, 0x1f, 0xc1, 0xba, 0x8f, 0x78, 0xe7, 0x02,
+	0xc2, 0x5c, 0xb3, 0xbe, 0xc9, 0x81, 0xf2, 0x1e, 0x26, 0xc8, 0x9b, 0xf4, 0xc6, 0x70, 0x03, 0x14,
-	0x4f, 0xde, 0x5e, 0x1f, 0xbc, 0xf5, 0x73, 0x6e, 0xbe, 0xee, 0x07, 0x6c, 0x3a, 0x3f, 0xb1, 0x3d,
+	0x42, 0x1a, 0x7a, 0x58, 0x76, 0xa3, 0xbb, 0xca, 0x80, 0xb7, 0x41, 0x85, 0x20, 0x81, 0x9c, 0xef,
-	0x12, 0x16, 0xfd, 0x2c, 0x7e, 0xfa, 0x74, 0xf2, 0xa1, 0xc3, 0x16, 0x31, 0xa6, 0xf6, 0xe3, 0x88,
+	0xa9, 0xea, 0x95, 0xee, 0xd5, 0x9f, 0xa6, 0xe6, 0x1b, 0xc4, 0xe7, 0xc3, 0xe4, 0xc0, 0xf6, 0x68,
-	0xb9, 0x9a, 0x8f, 0xe8, 0x7b, 0x3c, 0x57, 0xef, 0xc0, 0x8a, 0x8f, 0xa8, 0xa8, 0x52, 0x19, 0x34,
+	0x90, 0xe1, 0x99, 0x7d, 0x3a, 0x6c, 0xf0, 0x9e, 0xc3, 0x27, 0x11, 0x66, 0xf6, 0x9d, 0x90, 0xbb,
-	0x97, 0xb9, 0xa9, 0x3d, 0x42, 0x74, 0x18, 0x84, 0x01, 0x73, 0xb9, 0x43, 0xbf, 0x05, 0xcb, 0x8c,
+	0x65, 0x82, 0xd8, 0x3d, 0xb1, 0x16, 0x36, 0x41, 0x9e, 0x20, 0x26, 0xbb, 0xd4, 0xbb, 0xb5, 0xd9,
-	0x14, 0x35, 0x96, 0x19, 0xd1, 0x9f, 0xc0, 0x6a, 0x8a, 0x66, 0x73, 0x6c, 0x54, 0xc5, 0xa5, 0xef,
+	0xd4, 0x2c, 0xdf, 0x46, 0x6c, 0xcf, 0x0f, 0x7c, 0xee, 0x0a, 0x07, 0x5c, 0x07, 0x39, 0x4e, 0xb3,
-	0xfc, 0xf3, 0x4b, 0x97, 0xb9, 0x59, 0x3b, 0x0c, 0xc9, 0x3c, 0x62, 0xae, 0x84, 0xe0, 0x1d, 0x10,
+	0x1e, 0x73, 0x9c, 0xc2, 0xbb, 0xa0, 0x90, 0xa2, 0x51, 0x82, 0x8d, 0x82, 0x2c, 0xfa, 0xd6, 0xdf,
-	0x7d, 0xae, 0x75, 0x41, 0xaf, 0x59, 0x74, 0xb4, 0x09, 0x41, 0x6a, 0xa8, 0xe2, 0x03, 0x48, 0xb9,
+	0x2f, 0x3a, 0x9b, 0x9a, 0xc5, 0xed, 0x80, 0x26, 0x21, 0x77, 0x55, 0x0a, 0x81, 0x80, 0xc4, 0xb9,
-	0x95, 0x18, 0x9a, 0xb4, 0x12, 0x6e, 0x51, 0xa3, 0x2e, 0x2d, 0x7a, 0x70, 0x8b, 0xf7, 0xea, 0x87,
+	0xd8, 0xd2, 0xda, 0xb5, 0x0c, 0xd1, 0x1a, 0xd0, 0x52, 0xa3, 0x24, 0x27, 0xb4, 0x54, 0x58, 0xb1,
-	0xef, 0xfa, 0xb5, 0x51, 0x76, 0x84, 0x18, 0xb2, 0x7e, 0xaf, 0xc0, 0xe6, 0xa1, 0xe7, 0x61, 0x4a,
+	0x51, 0x56, 0x56, 0x2c, 0x2c, 0x66, 0x54, 0x94, 0xc5, 0xb6, 0xd6, 0x05, 0x56, 0xdf, 0x3d, 0xea,
-	0x87, 0x01, 0x65, 0xa3, 0x4c, 0x7f, 0x06, 0x35, 0x6f, 0x8a, 0x82, 0x68, 0x1c, 0x4c, 0x44, 0xf3,
+	0x14, 0x7b, 0xe3, 0x1d, 0xc4, 0x91, 0xf5, 0x7b, 0x1e, 0xd4, 0xb6, 0x3d, 0x0f, 0x33, 0xb6, 0xe7,
-	0xea, 0x83, 0xfb, 0xff, 0xaa, 0x5a, 0xf5, 0x01, 0xcf, 0x7e, 0x7c, 0x74, 0x9e, 0x9b, 0xaa, 0x27,
+	0x33, 0xde, 0x1b, 0xc3, 0x07, 0xa0, 0xec, 0x0d, 0x91, 0x1f, 0xf6, 0xfd, 0x81, 0x04, 0xaf, 0xd2,
-	0x8f, 0x6e, 0x71, 0x98, 0xac, 0x69, 0x29, 0xef, 0xa4, 0xa5, 0xf2, 0xdf, 0x69, 0x51, 0xae, 0xa6,
+	0xbd, 0xf1, 0x8f, 0xba, 0x2d, 0xdd, 0x14, 0xab, 0xef, 0xec, 0x1c, 0x4f, 0xcd, 0x92, 0xa7, 0x86,
-	0xa5, 0xba, 0x4d, 0x4b, 0xed, 0xe6, 0x68, 0x51, 0x2f, 0xd1, 0xf2, 0x0c, 0x6a, 0x48, 0xf4, 0x16,
+	0x6e, 0x36, 0x18, 0x2c, 0x68, 0xc9, 0x9d, 0x49, 0x4b, 0xfe, 0xdf, 0xd3, 0xa2, 0x3f, 0x9b, 0x96,
-	0x53, 0x43, 0xeb, 0x56, 0x7a, 0x8d, 0xfd, 0xbb, 0xf6, 0x5f, 0xff, 0xcf, 0xb6, 0xec, 0xfe, 0x68,
+	0xc2, 0x2a, 0x2d, 0xc5, 0x97, 0x47, 0x4b, 0xe9, 0x14, 0x2d, 0x0f, 0x40, 0x19, 0x49, 0x6c, 0x31,
-	0x1e, 0xcf, 0xf0, 0xa0, 0xfb, 0x3c, 0x37, 0x4b, 0xe7, 0xb9, 0x09, 0xd1, 0x05, 0x25, 0xdf, 0xfc,
+	0x33, 0xca, 0xad, 0x7c, 0xbb, 0xba, 0x79, 0xd1, 0x7e, 0xfa, 0xa0, 0xdb, 0x0a, 0xfd, 0x5e, 0x12,
-	0x62, 0xc2, 0x35, 0x41, 0xee, 0x05, 0xa0, 0xe4, 0xbc, 0xbe, 0xc1, 0x39, 0xdc, 0xe0, 0xbc, 0xb1,
+	0x8d, 0x70, 0xb7, 0xf5, 0x78, 0x6a, 0xae, 0x1d, 0x4f, 0x4d, 0x80, 0x4e, 0x28, 0xf9, 0xea, 0x67,
-	0x8b, 0xf3, 0xef, 0x15, 0xd8, 0x3c, 0x5a, 0x44, 0x28, 0x0c, 0xbc, 0x87, 0x18, 0xbf, 0x1c, 0xce,
+	0x13, 0x2c, 0x08, 0x72, 0x4f, 0x12, 0x2a, 0xce, 0x2b, 0x4b, 0x9c, 0x83, 0x25, 0xce, 0xab, 0x67,
-	0x9f, 0xc0, 0x06, 0xe7, 0x9c, 0x05, 0xf1, 0xd8, 0x43, 0xf1, 0x35, 0x58, 0xe7, 0x92, 0x19, 0x05,
+	0x71, 0xfe, 0xad, 0x0e, 0x6a, 0x3b, 0x93, 0x10, 0x05, 0xbe, 0x77, 0x0b, 0xe3, 0xff, 0x87, 0xf3,
-	0xf1, 0x03, 0x14, 0xaf, 0xb0, 0x4e, 0x31, 0x16, 0x58, 0xca, 0xb5, 0xb0, 0x1e, 0x62, 0xcc, 0xb1,
+	0xbb, 0xa0, 0x2a, 0x38, 0xe7, 0x7e, 0xd4, 0xf7, 0x50, 0xf4, 0x02, 0xac, 0x0b, 0xc9, 0xf4, 0xfc,
-	0x0a, 0x09, 0x55, 0xaf, 0x96, 0x50, 0x6d, 0x5b, 0x42, 0xea, 0xcd, 0x49, 0x48, 0xdb, 0x21, 0xa1,
+	0xe8, 0x26, 0x8a, 0xe6, 0xb9, 0x0e, 0x31, 0x96, 0xb9, 0xf4, 0x17, 0xca, 0x75, 0x0b, 0x63, 0x91,
-	0xfa, 0xff, 0x22, 0x21, 0xb8, 0x21, 0xa1, 0xc6, 0x86, 0x84, 0x9a, 0xbb, 0x24, 0x64, 0xc1, 0xf6,
+	0x2b, 0x93, 0x50, 0xe1, 0xd9, 0x12, 0x2a, 0xae, 0x4a, 0xa8, 0xf4, 0xf2, 0x24, 0x54, 0x3e, 0x43,
-	0x71, 0xc6, 0x70, 0x44, 0x03, 0x12, 0xbd, 0x1b, 0x8b, 0x9d, 0xb1, 0x5e, 0x05, 0xc5, 0x40, 0xfe,
+	0x42, 0x95, 0xff, 0x44, 0x42, 0x60, 0x49, 0x42, 0xd5, 0x25, 0x09, 0xd5, 0xce, 0x92, 0x90, 0x05,
-	0x1a, 0xc0, 0x3b, 0x1b, 0x2b, 0xc2, 0xc5, 0x34, 0x26, 0x11, 0x15, 0x0f, 0x15, 0x53, 0x1e, 0xc8,
+	0x1a, 0xbb, 0x63, 0x8e, 0x43, 0xe6, 0xd3, 0xf0, 0xed, 0x48, 0xbe, 0x19, 0x8b, 0xa7, 0x20, 0xbb,
-	0x21, 0x2e, 0x06, 0xfb, 0x9b, 0x50, 0x99, 0x11, 0x9f, 0x1a, 0x65, 0xf1, 0xc8, 0x3b, 0xdb, 0x8f,
+	0x90, 0xbf, 0xd4, 0xc0, 0xf9, 0xa5, 0x27, 0xc2, 0xc5, 0x2c, 0xa2, 0x21, 0x93, 0x1b, 0x95, 0xb7,
-	0x1c, 0x12, 0xdf, 0x15, 0x21, 0xfa, 0x6d, 0x58, 0x49, 0x30, 0x13, 0x9a, 0x69, 0xba, 0xfc, 0xa8,
+	0xbc, 0xa6, 0x2e, 0x71, 0x79, 0xb1, 0x5f, 0x01, 0xfa, 0x88, 0x12, 0x66, 0xe4, 0xe4, 0x26, 0xcf,
-	0xb7, 0xa0, 0x96, 0x86, 0x63, 0x9c, 0x24, 0x24, 0x29, 0xa6, 0xae, 0x9a, 0x86, 0xc7, 0xdc, 0xe4,
+	0xaf, 0x6e, 0x72, 0x8f, 0x12, 0x57, 0x86, 0xc0, 0x73, 0x20, 0x1f, 0x63, 0x2e, 0x35, 0x53, 0x73,
-	0x2e, 0x2e, 0x8e, 0x39, 0xc5, 0x13, 0xc9, 0xaa, 0xab, 0xfa, 0x88, 0xbe, 0x4f, 0xf1, 0x44, 0x96,
+	0xc5, 0x10, 0xd6, 0x41, 0x39, 0x0d, 0xfa, 0x38, 0x8e, 0x69, 0x9c, 0xdd, 0xba, 0xa5, 0x34, 0xd8,
-	0xb9, 0xff, 0x29, 0x80, 0x95, 0xa7, 0xd4, 0xd7, 0x3f, 0x86, 0xf0, 0xd2, 0x36, 0x33, 0xb7, 0x0b,
+	0x15, 0xa6, 0x70, 0x09, 0x71, 0x24, 0x0c, 0x0f, 0x14, 0xab, 0x6e, 0x89, 0x20, 0x76, 0x9f, 0xe1,
-	0xd8, 0x78, 0x4b, 0xfb, 0x8d, 0xbf, 0x09, 0x58, 0x3d, 0xd6, 0x7a, 0xed, 0x93, 0x1f, 0x7f, 0xfb,
+	0x41, 0xd6, 0xe6, 0x67, 0x1a, 0x78, 0x75, 0x9f, 0x91, 0xfb, 0xd1, 0x00, 0x71, 0x7c, 0x0f, 0xc5,
-	0xb2, 0x6c, 0x5a, 0x77, 0x9d, 0xed, 0xed, 0x5c, 0x44, 0x8f, 0x59, 0x36, 0xb8, 0xff, 0x7c, 0xd9,
+	0x28, 0x60, 0xf0, 0x3a, 0xa8, 0xa0, 0x84, 0x0f, 0x69, 0xec, 0xf3, 0x49, 0x76, 0x22, 0x8c, 0xef,
-	0x01, 0x2f, 0x96, 0x1d, 0xf0, 0xeb, 0xb2, 0x03, 0xbe, 0x38, 0xeb, 0x94, 0x5e, 0x9c, 0x75, 0x4a,
+	0x1f, 0x75, 0x36, 0xb2, 0xd7, 0x76, 0x7b, 0x30, 0x88, 0x31, 0x63, 0xef, 0xf0, 0xd8, 0x0f, 0x89,
-	0x3f, 0x9d, 0x75, 0x4a, 0x1f, 0x5c, 0xd6, 0x13, 0x4e, 0xb9, 0x9c, 0xd6, 0x40, 0x99, 0x80, 0x12,
+	0xbb, 0x08, 0x85, 0xd7, 0x41, 0x31, 0x92, 0x19, 0xa4, 0xd8, 0xab, 0x9b, 0xc6, 0xea, 0x36, 0x54,
-	0x9a, 0x3a, 0xa9, 0x89, 0x55, 0xfb, 0xf6, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xdd, 0xce, 0x14,
+	0x85, 0xae, 0x2e, 0x68, 0x72, 0xb3, 0xe8, 0xad, 0xf5, 0x87, 0xbf, 0x7d, 0x7d, 0x75, 0x91, 0xc7,
-	0xcb, 0x4e, 0x08, 0x00, 0x00,
+	0xaa, 0x83, 0x0b, 0x4f, 0xb5, 0x34, 0xc7, 0x6e, 0xf3, 0xe3, 0x1c, 0xc8, 0xef, 0x33, 0x02, 0x3f,
+	0x00, 0xe0, 0xd4, 0xe3, 0x6b, 0xae, 0x16, 0x5a, 0x82, 0xbe, 0x71, 0xf9, 0x39, 0x01, 0xf3, 0xfc,
+	0xd6, 0xeb, 0x0f, 0x7f, 0xf8, 0xf5, 0xf3, 0x9c, 0x69, 0x5d, 0x74, 0x56, 0x7f, 0x26, 0xb2, 0xe8,
+	0x3e, 0x1f, 0xc3, 0x0f, 0x35, 0x50, 0x5b, 0x82, 0xec, 0xd2, 0x5f, 0x16, 0x38, 0x1d, 0xd2, 0xb8,
+	0xf2, 0xdc, 0x90, 0x93, 0x2e, 0x2e, 0xcb, 0x2e, 0x2e, 0x59, 0xe6, 0x6a, 0x17, 0x89, 0x8c, 0xef,
+	0x2b, 0xe4, 0xba, 0x37, 0x1e, 0xcf, 0x9a, 0xda, 0x93, 0x59, 0x53, 0xfb, 0x65, 0xd6, 0xd4, 0x3e,
+	0x3d, 0x6a, 0xae, 0x3d, 0x39, 0x6a, 0xae, 0xfd, 0x78, 0xd4, 0x5c, 0x7b, 0xf7, 0xf4, 0x31, 0xc4,
+	0xa9, 0x38, 0x85, 0x8b, 0x54, 0x63, 0x99, 0x4c, 0x1e, 0xc5, 0x83, 0xa2, 0xfc, 0x43, 0x79, 0xf3,
+	0xcf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x3c, 0x20, 0xbe, 0xf3, 0x9e, 0x09, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -428,6 +533,9 @@ const _ = grpc.SupportPackageIsVersion4
 type MsgClient interface {
 	// EthereumTx defines a method submitting Ethereum transactions.
 	EthereumTx(ctx context.Context, in *MsgEthereumTx, opts ...grpc.CallOption) (*MsgEthereumTxResponse, error)
+	// UpdateParams defined a governance operation for updating the x/evm module parameters.
+	// The authority is hard-coded to the Cosmos SDK x/gov module account
+	UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error)
 }
 
 type msgClient struct {
@@ -447,10 +555,22 @@ func (c *msgClient) EthereumTx(ctx context.Context, in *MsgEthereumTx, opts ...g
 	return out, nil
 }
 
+func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) {
+	out := new(MsgUpdateParamsResponse)
+	err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Msg/UpdateParams", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // MsgServer is the server API for Msg service.
 type MsgServer interface {
 	// EthereumTx defines a method submitting Ethereum transactions.
 	EthereumTx(context.Context, *MsgEthereumTx) (*MsgEthereumTxResponse, error)
+	// UpdateParams defined a governance operation for updating the x/evm module parameters.
+	// The authority is hard-coded to the Cosmos SDK x/gov module account
+	UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
 }
 
 // UnimplementedMsgServer can be embedded to have forward compatible implementations.
@@ -460,6 +580,9 @@ type UnimplementedMsgServer struct {
 func (*UnimplementedMsgServer) EthereumTx(ctx context.Context, req *MsgEthereumTx) (*MsgEthereumTxResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method EthereumTx not implemented")
 }
+func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
+}
 
 func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
 	s.RegisterService(&_Msg_serviceDesc, srv)
@@ -483,6 +606,24 @@ func _Msg_EthereumTx_Handler(srv interface{}, ctx context.Context, dec func(inte
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgUpdateParams)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).UpdateParams(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/ethermint.evm.v1.Msg/UpdateParams",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Msg_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "ethermint.evm.v1.Msg",
 	HandlerType: (*MsgServer)(nil),
@@ -491,6 +632,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 			MethodName: "EthereumTx",
 			Handler:    _Msg_EthereumTx_Handler,
 		},
+		{
+			MethodName: "UpdateParams",
+			Handler:    _Msg_UpdateParams_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "ethermint/evm/v1/tx.proto",
@@ -977,6 +1122,69 @@ func (m *MsgEthereumTxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *MsgUpdateParams) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgUpdateParams) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintTx(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	if len(m.Authority) > 0 {
+		i -= len(m.Authority)
+		copy(dAtA[i:], m.Authority)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Authority)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgUpdateParamsResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgUpdateParamsResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
 	offset -= sovTx(v)
 	base := offset
@@ -1204,6 +1412,30 @@ func (m *MsgEthereumTxResponse) Size() (n int) {
 	return n
 }
 
+func (m *MsgUpdateParams) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Authority)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	l = m.Params.Size()
+	n += 1 + l + sovTx(uint64(l))
+	return n
+}
+
+func (m *MsgUpdateParamsResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
 func sovTx(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -2782,6 +3014,171 @@ func (m *MsgEthereumTxResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgUpdateParams: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Authority = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipTx(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0

x/evm/types/tx.pb.gw.go

@@ -69,6 +69,42 @@ func local_request_Msg_EthereumTx_0(ctx context.Context, marshaler runtime.Marsh
 
 }
 
+var (
+	filter_Msg_UpdateParams_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+)
+
+func request_Msg_UpdateParams_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq MsgUpdateParams
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_UpdateParams_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.UpdateParams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Msg_UpdateParams_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq MsgUpdateParams
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_UpdateParams_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.UpdateParams(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 // RegisterMsgHandlerServer registers the http handlers for service Msg to "mux".
 // UnaryRPC     :call MsgServer directly.
 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
@@ -98,6 +134,29 @@ func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server
 
 	})
 
+	mux.Handle("POST", pattern_Msg_UpdateParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Msg_UpdateParams_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Msg_UpdateParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -159,13 +218,37 @@ func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client
 
 	})
 
+	mux.Handle("POST", pattern_Msg_UpdateParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Msg_UpdateParams_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Msg_UpdateParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
 var (
 	pattern_Msg_EthereumTx_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"ethermint", "evm", "v1", "ethereum_tx"}, "", runtime.AssumeColonVerbOpt(false)))
+
+	pattern_Msg_UpdateParams_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"ethermint", "evm", "v1", "update_params"}, "", runtime.AssumeColonVerbOpt(false)))
 )
 
 var (
 	forward_Msg_EthereumTx_0 = runtime.ForwardResponseMessage
+
+	forward_Msg_UpdateParams_0 = runtime.ForwardResponseMessage
 )