evm: move ChainConfig to Params (#266)

* evm: move ChainConfig to Params * fixes * fix test
2021-07-14 05:13:55 -04:00
parent 74b7eaf431
commit e09bf23bd0
26 changed files with 1185 additions and 1884 deletions
@@ -59,8 +59,6 @@ func InitGenesis(
 		k.SetLogs(ethcmn.HexToHash(txLog.Hash), txLog.EthLogs())
 	}

-	k.SetChainConfig(ctx, data.ChainConfig)
-
 	return []abci.ValidatorUpdate{}
 }

@@ -94,12 +92,9 @@ func ExportGenesis(ctx sdk.Context, k *keeper.Keeper, ak types.AccountKeeper) *t
 		return false
 	})

-	config, _ := k.GetChainConfig(ctx)
-
 	return &types.GenesisState{
-		Accounts:    ethGenAccounts,
-		TxsLogs:     k.GetAllTxLogs(ctx),
-		ChainConfig: config,
-		Params:      k.GetParams(ctx),
+		Accounts: ethGenAccounts,
+		TxsLogs:  k.GetAllTxLogs(ctx),
+		Params:   k.GetParams(ctx),
 	}
 }
@@ -298,19 +298,6 @@ func (k Keeper) Params(c context.Context, _ *types.QueryParamsRequest) (*types.Q
 	}, nil
 }

-// ChainConfig implements the Query/ChainConfig gRPC method
-func (k Keeper) ChainConfig(c context.Context, _ *types.QueryChainConfigRequest) (*types.QueryChainConfigResponse, error) {
-	ctx := sdk.UnwrapSDKContext(c)
-	cfg, found := k.GetChainConfig(ctx)
-	if !found {
-		return nil, status.Error(codes.NotFound, types.ErrChainConfigNotFound.Error())
-	}
-
-	return &types.QueryChainConfigResponse{
-		Config: cfg,
-	}, nil
-}
-
 // StaticCall implements Query/StaticCall gRPCP method
 func (k Keeper) StaticCall(c context.Context, req *types.QueryStaticCallRequest) (*types.QueryStaticCallResponse, error) {
 	if req == nil {
@@ -389,12 +376,10 @@ func (k Keeper) EthCall(c context.Context, req *types.EthCallRequest) (*types.Ms

 	msg := args.ToMessage(uint64(ethermint.DefaultRPCGasLimit))

-	cfg, found := k.GetChainConfig(ctx)
-	if !found {
-		return nil, status.Error(codes.Internal, types.ErrChainConfigNotFound.Error())
-	}
-	ethCfg := cfg.EthereumConfig(k.eip155ChainID)
-	evm := k.NewEVM(msg, ethCfg)
+	params := k.GetParams(ctx)
+	ethCfg := params.ChainConfig.EthereumConfig(k.eip155ChainID)
+
+	evm := k.NewEVM(msg, ethCfg, params)
 	res, err := k.ApplyMessage(evm, msg, ethCfg)
 	if err != nil {
 		return nil, status.Error(codes.Internal, err.Error())
@@ -608,15 +608,6 @@ func (suite *KeeperTestSuite) TestQueryParams() {
 	suite.Require().Equal(expParams, res.Params)
 }

-func (suite *KeeperTestSuite) TestQueryChainConfig() {
-	ctx := sdk.WrapSDKContext(suite.ctx)
-	expChainConfig := types.DefaultChainConfig()
-
-	res, err := suite.queryClient.ChainConfig(ctx, &types.QueryChainConfigRequest{})
-	suite.Require().NoError(err)
-	suite.Require().Equal(expChainConfig, res.Config)
-}
-
 func (suite *KeeperTestSuite) TestQueryValidatorAccount() {
 	var (
 		req        *types.QueryValidatorAccountRequest
@@ -83,15 +83,3 @@ func (suite *KeeperTestSuite) SetupTest() {
 func TestKeeperTestSuite(t *testing.T) {
 	suite.Run(t, new(KeeperTestSuite))
 }
-
-func (suite *KeeperTestSuite) TestChainConfig() {
-	config, found := suite.app.EvmKeeper.GetChainConfig(suite.ctx)
-	suite.Require().True(found)
-	suite.Require().Equal(types.DefaultChainConfig(), config)
-
-	config.EIP150Block = sdk.NewInt(100)
-	suite.app.EvmKeeper.SetChainConfig(suite.ctx, config)
-	newConfig, found := suite.app.EvmKeeper.GetChainConfig(suite.ctx)
-	suite.Require().True(found)
-	suite.Require().Equal(config, newConfig)
-}
@@ -16,23 +16,3 @@ func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) {
 func (k Keeper) SetParams(ctx sdk.Context, params types.Params) {
 	k.paramSpace.SetParamSet(ctx, &params)
 }
-
-// GetChainConfig gets block height from block consensus hash
-func (k Keeper) GetChainConfig(ctx sdk.Context) (types.ChainConfig, bool) {
-	store := ctx.KVStore(k.storeKey)
-	bz := store.Get(types.KeyPrefixChainConfig)
-	if len(bz) == 0 {
-		return types.ChainConfig{}, false
-	}
-
-	var config types.ChainConfig
-	k.cdc.MustUnmarshal(bz, &config)
-	return config, true
-}
-
-// SetChainConfig sets the mapping from block consensus hash to block height
-func (k Keeper) SetChainConfig(ctx sdk.Context, config types.ChainConfig) {
-	store := ctx.KVStore(k.storeKey)
-	bz := k.cdc.MustMarshal(&config)
-	store.Set(types.KeyPrefixChainConfig, bz)
-}
@@ -25,7 +25,7 @@ import (
 )

 // NewEVM generates an ethereum VM from the provided Message fields and the ChainConfig.
-func (k *Keeper) NewEVM(msg core.Message, config *params.ChainConfig) *vm.EVM {
+func (k *Keeper) NewEVM(msg core.Message, config *params.ChainConfig, params types.Params) *vm.EVM {
 	blockCtx := vm.BlockContext{
 		CanTransfer: core.CanTransfer,
 		Transfer:    core.Transfer,
@@ -38,16 +38,14 @@ func (k *Keeper) NewEVM(msg core.Message, config *params.ChainConfig) *vm.EVM {
 	}

 	txCtx := core.NewEVMTxContext(msg)
-	vmConfig := k.VMConfig()
+	vmConfig := k.VMConfig(params)

 	return vm.NewEVM(blockCtx, txCtx, k, config, vmConfig)
 }

 // VMConfig creates an EVM configuration from the module parameters and the debug setting.
 // The config generated uses the default JumpTable from the EVM.
-func (k Keeper) VMConfig() vm.Config {
-	params := k.GetParams(k.ctx)
-
+func (k Keeper) VMConfig(params types.Params) vm.Config {
 	return vm.Config{
 		Debug:       k.debug,
 		Tracer:      vm.NewJSONLogger(&vm.LogConfig{Debug: k.debug}, os.Stderr), // TODO: consider using the Struct Logger too
@@ -112,11 +110,8 @@ func (k Keeper) GetHashFn() vm.GetHashFunc {
 func (k *Keeper) ApplyTransaction(tx *ethtypes.Transaction) (*types.MsgEthereumTxResponse, error) {
 	defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), types.MetricKeyTransitionDB)

-	cfg, found := k.GetChainConfig(k.ctx)
-	if !found {
-		return nil, stacktrace.Propagate(types.ErrChainConfigNotFound, "configuration not found")
-	}
-	ethCfg := cfg.EthereumConfig(k.eip155ChainID)
+	params := k.GetParams(k.ctx)
+	ethCfg := params.ChainConfig.EthereumConfig(k.eip155ChainID)

 	// get the latest signer according to the chain rules from the config
 	signer := ethtypes.MakeSigner(ethCfg, big.NewInt(k.ctx.BlockHeight()))
@@ -132,7 +127,7 @@ func (k *Keeper) ApplyTransaction(tx *ethtypes.Transaction) (*types.MsgEthereumT
 	cacheCtx, commit := k.ctx.CacheContext()
 	k.ctx = cacheCtx

-	evm := k.NewEVM(msg, ethCfg)
+	evm := k.NewEVM(msg, ethCfg, params)

 	k.SetTxHashTransient(tx.Hash())
 	k.IncreaseTxIndexTransient()
@@ -29,37 +29,49 @@ func (cc ChainConfig) EthereumConfig(chainID *big.Int) *params.ChainConfig {
 		IstanbulBlock:       getBlockValue(cc.IstanbulBlock),
 		MuirGlacierBlock:    getBlockValue(cc.MuirGlacierBlock),
 		BerlinBlock:         getBlockValue(cc.BerlinBlock),
-		// TODO(xlab): after upgrading ethereum to newer version, this should be set to YoloV2Block
-		YoloV3Block:   getBlockValue(cc.YoloV3Block),
-		EWASMBlock:    getBlockValue(cc.EWASMBlock),
-		CatalystBlock: getBlockValue(cc.CatalystBlock),
+		YoloV3Block:         getBlockValue(cc.YoloV3Block),
+		EWASMBlock:          getBlockValue(cc.EWASMBlock),
+		CatalystBlock:       getBlockValue(cc.CatalystBlock),
 	}
 }

 // 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()
+	yoloV3Block := sdk.ZeroInt()
+
 	return ChainConfig{
-		HomesteadBlock:      sdk.ZeroInt(),
-		DAOForkBlock:        sdk.ZeroInt(),
+		HomesteadBlock:      &homesteadBlock,
+		DAOForkBlock:        &daoForkBlock,
 		DAOForkSupport:      true,
-		EIP150Block:         sdk.ZeroInt(),
+		EIP150Block:         &eip150Block,
 		EIP150Hash:          common.Hash{}.String(),
-		EIP155Block:         sdk.ZeroInt(),
-		EIP158Block:         sdk.ZeroInt(),
-		ByzantiumBlock:      sdk.ZeroInt(),
-		ConstantinopleBlock: sdk.ZeroInt(),
-		PetersburgBlock:     sdk.ZeroInt(),
-		IstanbulBlock:       sdk.ZeroInt(),
-		MuirGlacierBlock:    sdk.ZeroInt(),
-		BerlinBlock:         sdk.ZeroInt(),
-		YoloV3Block:         sdk.ZeroInt(),
-		EWASMBlock:          sdk.NewInt(-1),
-		CatalystBlock:       sdk.NewInt(-1),
+		EIP155Block:         &eip155Block,
+		EIP158Block:         &eip158Block,
+		ByzantiumBlock:      &byzantiumBlock,
+		ConstantinopleBlock: &constantinopleBlock,
+		PetersburgBlock:     &petersburgBlock,
+		IstanbulBlock:       &istanbulBlock,
+		MuirGlacierBlock:    &muirGlacierBlock,
+		BerlinBlock:         &berlinBlock,
+		YoloV3Block:         &yoloV3Block,
+		EWASMBlock:          nil,
+		CatalystBlock:       nil,
 	}
 }

-func getBlockValue(block sdk.Int) *big.Int {
-	if block.IsNegative() {
+func getBlockValue(block *sdk.Int) *big.Int {
+	if block == nil || block.IsNegative() {
 		return nil
 	}

@@ -102,6 +114,9 @@ func (cc ChainConfig) Validate() error {
 	if err := validateBlock(cc.MuirGlacierBlock); err != nil {
 		return sdkerrors.Wrap(err, "muirGlacierBlock")
 	}
+	if err := validateBlock(cc.BerlinBlock); err != nil {
+		return sdkerrors.Wrap(err, "berlinBlock")
+	}
 	if err := validateBlock(cc.YoloV3Block); err != nil {
 		return sdkerrors.Wrap(err, "yoloV3Block")
 	}
@@ -123,11 +138,15 @@ func validateHash(hex string) error {
 	return nil
 }

-func validateBlock(block sdk.Int) error {
-	if block == (sdk.Int{}) || block.BigInt() == nil {
+func validateBlock(block *sdk.Int) error {
+	// nil value means that the fork has not yet been applied
+	if block == nil {
+		return nil
+	}
+
+	if block.IsNegative() {
 		return sdkerrors.Wrapf(
-			ErrInvalidChainConfig,
-			"cannot use uninitialized or nil values for Int, set a negative Int value if you want to define a nil Ethereum block",
+			ErrInvalidChainConfig, "block value cannot be negative: %s", block,
 		)
 	}

@@ -12,6 +12,11 @@ import (

 var defaultEIP150Hash = common.Hash{}.String()

+func newIntPtr(i int64) *sdk.Int {
+	v := sdk.NewInt(i)
+	return &v
+}
+
 func TestChainConfigValidate(t *testing.T) {
 	testCases := []struct {
 		name     string
@@ -22,58 +27,80 @@ func TestChainConfigValidate(t *testing.T) {
 		{
 			"valid",
 			ChainConfig{
-				HomesteadBlock:      sdk.OneInt(),
-				DAOForkBlock:        sdk.OneInt(),
-				EIP150Block:         sdk.OneInt(),
+				HomesteadBlock:      newIntPtr(0),
+				DAOForkBlock:        newIntPtr(0),
+				EIP150Block:         newIntPtr(0),
 				EIP150Hash:          defaultEIP150Hash,
-				EIP155Block:         sdk.OneInt(),
-				EIP158Block:         sdk.OneInt(),
-				ByzantiumBlock:      sdk.OneInt(),
-				ConstantinopleBlock: sdk.OneInt(),
-				PetersburgBlock:     sdk.OneInt(),
-				IstanbulBlock:       sdk.OneInt(),
-				MuirGlacierBlock:    sdk.OneInt(),
-				YoloV3Block:         sdk.OneInt(),
-				EWASMBlock:          sdk.OneInt(),
-				CatalystBlock:       sdk.OneInt(),
+				EIP155Block:         newIntPtr(0),
+				EIP158Block:         newIntPtr(0),
+				ByzantiumBlock:      newIntPtr(0),
+				ConstantinopleBlock: newIntPtr(0),
+				PetersburgBlock:     newIntPtr(0),
+				IstanbulBlock:       newIntPtr(0),
+				MuirGlacierBlock:    newIntPtr(0),
+				BerlinBlock:         newIntPtr(0),
+				YoloV3Block:         newIntPtr(0),
+				EWASMBlock:          newIntPtr(0),
+				CatalystBlock:       newIntPtr(0),
+			},
+			false,
+		},
+		{
+			"valid with nil values",
+			ChainConfig{
+				HomesteadBlock:      nil,
+				DAOForkBlock:        nil,
+				EIP150Block:         nil,
+				EIP150Hash:          defaultEIP150Hash,
+				EIP155Block:         nil,
+				EIP158Block:         nil,
+				ByzantiumBlock:      nil,
+				ConstantinopleBlock: nil,
+				PetersburgBlock:     nil,
+				IstanbulBlock:       nil,
+				MuirGlacierBlock:    nil,
+				BerlinBlock:         nil,
+				YoloV3Block:         nil,
+				EWASMBlock:          nil,
+				CatalystBlock:       nil,
 			},
 			false,
 		},
 		{
 			"empty",
 			ChainConfig{},
-			true,
+			false,
 		},
 		{
 			"invalid HomesteadBlock",
 			ChainConfig{
-				HomesteadBlock: sdk.Int{},
+				HomesteadBlock: newIntPtr(-1),
 			},
 			true,
 		},
 		{
 			"invalid DAOForkBlock",
 			ChainConfig{
-				HomesteadBlock: sdk.OneInt(),
-				DAOForkBlock:   sdk.Int{},
+				HomesteadBlock: newIntPtr(0),
+				DAOForkBlock:   newIntPtr(-1),
 			},
 			true,
 		},
 		{
 			"invalid EIP150Block",
 			ChainConfig{
-				HomesteadBlock: sdk.OneInt(),
-				DAOForkBlock:   sdk.OneInt(),
-				EIP150Block:    sdk.Int{},
+				HomesteadBlock: newIntPtr(0),
+				DAOForkBlock:   newIntPtr(0),
+				EIP150Block:    newIntPtr(-1),
 			},
 			true,
 		},
 		{
 			"invalid EIP150Hash",
 			ChainConfig{
-				HomesteadBlock: sdk.OneInt(),
-				DAOForkBlock:   sdk.OneInt(),
-				EIP150Block:    sdk.OneInt(),
+				HomesteadBlock: newIntPtr(0),
+				DAOForkBlock:   newIntPtr(0),
+				EIP150Block:    newIntPtr(0),
 				EIP150Hash:     "  ",
 			},
 			true,
@@ -81,155 +108,176 @@ func TestChainConfigValidate(t *testing.T) {
 		{
 			"invalid EIP155Block",
 			ChainConfig{
-				HomesteadBlock: sdk.OneInt(),
-				DAOForkBlock:   sdk.OneInt(),
-				EIP150Block:    sdk.OneInt(),
+				HomesteadBlock: newIntPtr(0),
+				DAOForkBlock:   newIntPtr(0),
+				EIP150Block:    newIntPtr(0),
 				EIP150Hash:     defaultEIP150Hash,
-				EIP155Block:    sdk.Int{},
+				EIP155Block:    newIntPtr(-1),
 			},
 			true,
 		},
 		{
 			"invalid EIP158Block",
 			ChainConfig{
-				HomesteadBlock: sdk.OneInt(),
-				DAOForkBlock:   sdk.OneInt(),
-				EIP150Block:    sdk.OneInt(),
+				HomesteadBlock: newIntPtr(0),
+				DAOForkBlock:   newIntPtr(0),
+				EIP150Block:    newIntPtr(0),
 				EIP150Hash:     defaultEIP150Hash,
-				EIP155Block:    sdk.OneInt(),
-				EIP158Block:    sdk.Int{},
+				EIP155Block:    newIntPtr(0),
+				EIP158Block:    newIntPtr(-1),
 			},
 			true,
 		},
 		{
 			"invalid ByzantiumBlock",
 			ChainConfig{
-				HomesteadBlock: sdk.OneInt(),
-				DAOForkBlock:   sdk.OneInt(),
-				EIP150Block:    sdk.OneInt(),
+				HomesteadBlock: newIntPtr(0),
+				DAOForkBlock:   newIntPtr(0),
+				EIP150Block:    newIntPtr(0),
 				EIP150Hash:     defaultEIP150Hash,
-				EIP155Block:    sdk.OneInt(),
-				EIP158Block:    sdk.OneInt(),
-				ByzantiumBlock: sdk.Int{},
+				EIP155Block:    newIntPtr(0),
+				EIP158Block:    newIntPtr(0),
+				ByzantiumBlock: newIntPtr(-1),
 			},
 			true,
 		},
 		{
 			"invalid ConstantinopleBlock",
 			ChainConfig{
-				HomesteadBlock:      sdk.OneInt(),
-				DAOForkBlock:        sdk.OneInt(),
-				EIP150Block:         sdk.OneInt(),
+				HomesteadBlock:      newIntPtr(0),
+				DAOForkBlock:        newIntPtr(0),
+				EIP150Block:         newIntPtr(0),
 				EIP150Hash:          defaultEIP150Hash,
-				EIP155Block:         sdk.OneInt(),
-				EIP158Block:         sdk.OneInt(),
-				ByzantiumBlock:      sdk.OneInt(),
-				ConstantinopleBlock: sdk.Int{},
+				EIP155Block:         newIntPtr(0),
+				EIP158Block:         newIntPtr(0),
+				ByzantiumBlock:      newIntPtr(0),
+				ConstantinopleBlock: newIntPtr(-1),
 			},
 			true,
 		},
 		{
 			"invalid PetersburgBlock",
 			ChainConfig{
-				HomesteadBlock:      sdk.OneInt(),
-				DAOForkBlock:        sdk.OneInt(),
-				EIP150Block:         sdk.OneInt(),
+				HomesteadBlock:      newIntPtr(0),
+				DAOForkBlock:        newIntPtr(0),
+				EIP150Block:         newIntPtr(0),
 				EIP150Hash:          defaultEIP150Hash,
-				EIP155Block:         sdk.OneInt(),
-				EIP158Block:         sdk.OneInt(),
-				ByzantiumBlock:      sdk.OneInt(),
-				ConstantinopleBlock: sdk.OneInt(),
-				PetersburgBlock:     sdk.Int{},
+				EIP155Block:         newIntPtr(0),
+				EIP158Block:         newIntPtr(0),
+				ByzantiumBlock:      newIntPtr(0),
+				ConstantinopleBlock: newIntPtr(0),
+				PetersburgBlock:     newIntPtr(-1),
 			},
 			true,
 		},
 		{
 			"invalid IstanbulBlock",
 			ChainConfig{
-				HomesteadBlock:      sdk.OneInt(),
-				DAOForkBlock:        sdk.OneInt(),
-				EIP150Block:         sdk.OneInt(),
+				HomesteadBlock:      newIntPtr(0),
+				DAOForkBlock:        newIntPtr(0),
+				EIP150Block:         newIntPtr(0),
 				EIP150Hash:          defaultEIP150Hash,
-				EIP155Block:         sdk.OneInt(),
-				EIP158Block:         sdk.OneInt(),
-				ByzantiumBlock:      sdk.OneInt(),
-				ConstantinopleBlock: sdk.OneInt(),
-				PetersburgBlock:     sdk.OneInt(),
-				IstanbulBlock:       sdk.Int{},
+				EIP155Block:         newIntPtr(0),
+				EIP158Block:         newIntPtr(0),
+				ByzantiumBlock:      newIntPtr(0),
+				ConstantinopleBlock: newIntPtr(0),
+				PetersburgBlock:     newIntPtr(0),
+				IstanbulBlock:       newIntPtr(-1),
 			},
 			true,
 		},
 		{
 			"invalid MuirGlacierBlock",
 			ChainConfig{
-				HomesteadBlock:      sdk.OneInt(),
-				DAOForkBlock:        sdk.OneInt(),
-				EIP150Block:         sdk.OneInt(),
+				HomesteadBlock:      newIntPtr(0),
+				DAOForkBlock:        newIntPtr(0),
+				EIP150Block:         newIntPtr(0),
 				EIP150Hash:          defaultEIP150Hash,
-				EIP155Block:         sdk.OneInt(),
-				EIP158Block:         sdk.OneInt(),
-				ByzantiumBlock:      sdk.OneInt(),
-				ConstantinopleBlock: sdk.OneInt(),
-				PetersburgBlock:     sdk.OneInt(),
-				IstanbulBlock:       sdk.OneInt(),
-				MuirGlacierBlock:    sdk.Int{},
+				EIP155Block:         newIntPtr(0),
+				EIP158Block:         newIntPtr(0),
+				ByzantiumBlock:      newIntPtr(0),
+				ConstantinopleBlock: newIntPtr(0),
+				PetersburgBlock:     newIntPtr(0),
+				IstanbulBlock:       newIntPtr(0),
+				MuirGlacierBlock:    newIntPtr(-1),
 			},
 			true,
 		},
 		{
-			"invalid YoloV2Block",
+			"invalid BerlinBlock",
 			ChainConfig{
-				HomesteadBlock:      sdk.OneInt(),
-				DAOForkBlock:        sdk.OneInt(),
-				EIP150Block:         sdk.OneInt(),
+				HomesteadBlock:      newIntPtr(0),
+				DAOForkBlock:        newIntPtr(0),
+				EIP150Block:         newIntPtr(0),
 				EIP150Hash:          defaultEIP150Hash,
-				EIP155Block:         sdk.OneInt(),
-				EIP158Block:         sdk.OneInt(),
-				ByzantiumBlock:      sdk.OneInt(),
-				ConstantinopleBlock: sdk.OneInt(),
-				PetersburgBlock:     sdk.OneInt(),
-				IstanbulBlock:       sdk.OneInt(),
-				MuirGlacierBlock:    sdk.OneInt(),
-				YoloV3Block:         sdk.Int{},
+				EIP155Block:         newIntPtr(0),
+				EIP158Block:         newIntPtr(0),
+				ByzantiumBlock:      newIntPtr(0),
+				ConstantinopleBlock: newIntPtr(0),
+				PetersburgBlock:     newIntPtr(0),
+				IstanbulBlock:       newIntPtr(0),
+				MuirGlacierBlock:    newIntPtr(0),
+				BerlinBlock:         newIntPtr(-1),
+			},
+			true,
+		},
+		{
+			"invalid YoloV3Block",
+			ChainConfig{
+				HomesteadBlock:      newIntPtr(0),
+				DAOForkBlock:        newIntPtr(0),
+				EIP150Block:         newIntPtr(0),
+				EIP150Hash:          defaultEIP150Hash,
+				EIP155Block:         newIntPtr(0),
+				EIP158Block:         newIntPtr(0),
+				ByzantiumBlock:      newIntPtr(0),
+				ConstantinopleBlock: newIntPtr(0),
+				PetersburgBlock:     newIntPtr(0),
+				IstanbulBlock:       newIntPtr(0),
+				MuirGlacierBlock:    newIntPtr(0),
+				BerlinBlock:         newIntPtr(0),
+				YoloV3Block:         newIntPtr(-1),
 			},
 			true,
 		},
 		{
 			"invalid EWASMBlock",
 			ChainConfig{
-				HomesteadBlock:      sdk.OneInt(),
-				DAOForkBlock:        sdk.OneInt(),
-				EIP150Block:         sdk.OneInt(),
+				HomesteadBlock:      newIntPtr(0),
+				DAOForkBlock:        newIntPtr(0),
+				EIP150Block:         newIntPtr(0),
 				EIP150Hash:          defaultEIP150Hash,
-				EIP155Block:         sdk.OneInt(),
-				EIP158Block:         sdk.OneInt(),
-				ByzantiumBlock:      sdk.OneInt(),
-				ConstantinopleBlock: sdk.OneInt(),
-				PetersburgBlock:     sdk.OneInt(),
-				IstanbulBlock:       sdk.OneInt(),
-				MuirGlacierBlock:    sdk.OneInt(),
-				YoloV3Block:         sdk.OneInt(),
-				EWASMBlock:          sdk.Int{},
+				EIP155Block:         newIntPtr(0),
+				EIP158Block:         newIntPtr(0),
+				ByzantiumBlock:      newIntPtr(0),
+				ConstantinopleBlock: newIntPtr(0),
+				PetersburgBlock:     newIntPtr(0),
+				IstanbulBlock:       newIntPtr(0),
+				MuirGlacierBlock:    newIntPtr(0),
+				BerlinBlock:         newIntPtr(0),
+				YoloV3Block:         newIntPtr(0),
+				EWASMBlock:          newIntPtr(-1),
 			},
 			true,
 		},
 		{
 			"invalid CatalystBlock",
 			ChainConfig{
-				HomesteadBlock:      sdk.OneInt(),
-				DAOForkBlock:        sdk.OneInt(),
-				EIP150Block:         sdk.OneInt(),
+				HomesteadBlock:      newIntPtr(0),
+				DAOForkBlock:        newIntPtr(0),
+				EIP150Block:         newIntPtr(0),
 				EIP150Hash:          defaultEIP150Hash,
-				EIP155Block:         sdk.OneInt(),
-				EIP158Block:         sdk.OneInt(),
-				ByzantiumBlock:      sdk.OneInt(),
-				ConstantinopleBlock: sdk.OneInt(),
-				PetersburgBlock:     sdk.OneInt(),
-				IstanbulBlock:       sdk.OneInt(),
-				MuirGlacierBlock:    sdk.OneInt(),
-				YoloV3Block:         sdk.OneInt(),
-				EWASMBlock:          sdk.OneInt(),
-				CatalystBlock:       sdk.Int{},
+				EIP155Block:         newIntPtr(0),
+				EIP158Block:         newIntPtr(0),
+				ByzantiumBlock:      newIntPtr(0),
+				ConstantinopleBlock: newIntPtr(0),
+				PetersburgBlock:     newIntPtr(0),
+				IstanbulBlock:       newIntPtr(0),
+				MuirGlacierBlock:    newIntPtr(0),
+				YoloV3Block:         newIntPtr(0),
+
+				EWASMBlock:    newIntPtr(0),
+				CatalystBlock: newIntPtr(-1),
 			},
 			true,
 		},
@@ -26,15 +26,17 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

 // Params defines the EVM module parameters
 type Params struct {
-	// evm_denom represents the token denomination used to run the EVM state
+	// evm denom represents the token denomination used to run the EVM state
 	// transitions.
 	EvmDenom string `protobuf:"bytes,1,opt,name=evm_denom,json=evmDenom,proto3" json:"evm_denom,omitempty" yaml:"evm_denom"`
-	// enable_create toggles state transitions that use the vm.Create function
+	// enable create toggles state transitions that use the vm.Create function
 	EnableCreate bool `protobuf:"varint,2,opt,name=enable_create,json=enableCreate,proto3" json:"enable_create,omitempty" yaml:"enable_create"`
-	// enable_call toggles state transitions that use the vm.Call function
+	// 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
+	// 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"`
+	// 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"`
 }

 func (m *Params) Reset()      { *m = Params{} }
@@ -97,51 +99,49 @@ func (m *Params) GetExtraEIPs() []int64 {
 	return nil
 }

-// ChainConfig defines the Ethereum ChainConfig parameters using sdk.Int values
-// instead of big.Int.
-//
-// NOTE 1: Since empty/uninitialized Ints (i.e with a nil big.Int value) are
-// parsed to zero, we need to manually specify that negative Int values will be
-// considered as nil. See getBlockValue for reference.
-//
-// NOTE 2: This type is not a configurable Param since the SDK does not allow
-// for validation against a previous stored parameter values or the current
-// block height (retrieved from context). If you want to update the config
-// values, use an software upgrade procedure.
+func (m *Params) GetChainConfig() ChainConfig {
+	if m != nil {
+		return m.ChainConfig
+	}
+	return ChainConfig{}
+}
+
+// ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values
+// instead of *big.Int.
 type ChainConfig struct {
-	// Homestead switch block (< 0 no fork, 0 = already homestead)
-	HomesteadBlock github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=homestead_block,json=homesteadBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"homestead_block" yaml:"homestead_block"`
-	// TheDAO hard-fork switch block (< 0 no fork)
-	DAOForkBlock github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=dao_fork_block,json=daoForkBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"dao_fork_block" yaml:"dao_fork_block"`
+	// Homestead switch block (nil no fork, 0 = already homestead)
+	HomesteadBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=homestead_block,json=homesteadBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"homestead_block,omitempty" yaml:"homestead_block"`
+	// TheDAO hard-fork switch block (nil no fork)
+	DAOForkBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=dao_fork_block,json=daoForkBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"dao_fork_block,omitempty" yaml:"dao_fork_block"`
 	// Whether the nodes supports or opposes the DAO hard-fork
 	DAOForkSupport bool `protobuf:"varint,3,opt,name=dao_fork_support,json=daoForkSupport,proto3" json:"dao_fork_support,omitempty" yaml:"dao_fork_support"`
 	// EIP150 implements the Gas price changes
-	// (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (< 0 no fork)
-	EIP150Block github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=eip150_block,json=eip150Block,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"eip150_block" yaml:"eip150_block"`
+	// (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (nil no fork)
+	EIP150Block *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=eip150_block,json=eip150Block,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"eip150_block,omitempty" yaml:"eip150_block"`
 	// EIP150 HF hash (needed for header only clients as only gas pricing changed)
 	EIP150Hash string `protobuf:"bytes,5,opt,name=eip150_hash,json=eip150Hash,proto3" json:"eip150_hash,omitempty" yaml:"byzantium_block"`
 	// EIP155Block HF block
-	EIP155Block github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,6,opt,name=eip155_block,json=eip155Block,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"eip155_block" yaml:"eip155_block"`
+	EIP155Block *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,6,opt,name=eip155_block,json=eip155Block,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"eip155_block,omitempty" yaml:"eip155_block"`
 	// EIP158 HF block
-	EIP158Block github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,7,opt,name=eip158_block,json=eip158Block,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"eip158_block" yaml:"eip158_block"`
-	// Byzantium switch block (< 0 no fork, 0 = already on byzantium)
-	ByzantiumBlock github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,8,opt,name=byzantium_block,json=byzantiumBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"byzantium_block" yaml:"byzantium_block"`
-	// Constantinople switch block (< 0 no fork, 0 = already activated)
-	ConstantinopleBlock github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,9,opt,name=constantinople_block,json=constantinopleBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"constantinople_block" yaml:"constantinople_block"`
-	// Petersburg switch block (< 0 same as Constantinople)
-	PetersburgBlock github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,10,opt,name=petersburg_block,json=petersburgBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"petersburg_block" yaml:"petersburg_block"`
-	// Istanbul switch block (< 0 no fork, 0 = already on istanbul)
-	IstanbulBlock github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,11,opt,name=istanbul_block,json=istanbulBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"istanbul_block" yaml:"istanbul_block"`
-	// Eip-2384 (bomb delay) switch block (< 0 no fork, 0 = already activated)
-	MuirGlacierBlock github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,12,opt,name=muir_glacier_block,json=muirGlacierBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"muir_glacier_block" yaml:"muir_glacier_block"`
-	// Berlin switch block (< 0 = no fork, 0 = already on berlin)
-	BerlinBlock github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,13,opt,name=berlin_block,json=berlinBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"berlin_block" yaml:"berlin_block"`
+	EIP158Block *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,7,opt,name=eip158_block,json=eip158Block,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"eip158_block,omitempty" yaml:"eip158_block"`
+	// Byzantium switch block (nil no fork, 0 = already on byzantium)
+	ByzantiumBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,8,opt,name=byzantium_block,json=byzantiumBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"byzantium_block,omitempty" yaml:"byzantium_block"`
+	// Constantinople switch block (nil no fork, 0 = already activated)
+	ConstantinopleBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,9,opt,name=constantinople_block,json=constantinopleBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"constantinople_block,omitempty" yaml:"constantinople_block"`
+	// Petersburg switch block (nil same as Constantinople)
+	PetersburgBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,10,opt,name=petersburg_block,json=petersburgBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"petersburg_block,omitempty" yaml:"petersburg_block"`
+	// Istanbul switch block (nil no fork, 0 = already on istanbul)
+	IstanbulBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,11,opt,name=istanbul_block,json=istanbulBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"istanbul_block,omitempty" yaml:"istanbul_block"`
+	// Eip-2384 (bomb delay) switch block (nil no fork, 0 = already activated)
+	MuirGlacierBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,12,opt,name=muir_glacier_block,json=muirGlacierBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"muir_glacier_block,omitempty" yaml:"muir_glacier_block"`
+	// Berlin switch block (nil = no fork, 0 = already on berlin)
+	BerlinBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,13,opt,name=berlin_block,json=berlinBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"berlin_block,omitempty" yaml:"berlin_block"`
 	// YOLO v3: Gas repricings
-	YoloV3Block github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,14,opt,name=yolo_v3_block,json=yoloV3Block,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"yolo_v3_block" yaml:"yolo_v3_block"`
-	// EWASM switch block (< 0 no fork, 0 = already activated)
-	EWASMBlock github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,15,opt,name=ewasm_block,json=ewasmBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"ewasm_block" yaml:"ewasm_block"`
-	// Catalyst switch block (< 0 = no fork, 0 = already on catalyst)
-	CatalystBlock github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,16,opt,name=catalyst_block,json=catalystBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"catalyst_block" yaml:"catalyst_block"`
+	YoloV3Block *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,14,opt,name=yolo_v3_block,json=yoloV3Block,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"yolo_v3_block,omitempty" yaml:"yolo_v3_block"`
+	// EWASM switch block (nil no fork, 0 = already activated)
+	EWASMBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,15,opt,name=ewasm_block,json=ewasmBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"ewasm_block,omitempty" yaml:"ewasm_block"`
+	// Catalyst switch block (nil = no fork, 0 = already on catalyst)
+	CatalystBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,16,opt,name=catalyst_block,json=catalystBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"catalyst_block,omitempty" yaml:"catalyst_block"`
 }

 func (m *ChainConfig) Reset()         { *m = ChainConfig{} }
@@ -527,85 +527,87 @@ func init() {
 func init() { proto.RegisterFile("ethermint/evm/v1alpha1/evm.proto", fileDescriptor_98f00fcca8b6b943) }

 var fileDescriptor_98f00fcca8b6b943 = []byte{
-	// 1239 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x96, 0xbd, 0x6f, 0xdb, 0xc6,
-	0x1b, 0xc7, 0x2d, 0x4b, 0xb6, 0xa5, 0x93, 0x2c, 0xe9, 0x77, 0xd1, 0xcf, 0x55, 0x12, 0xc0, 0x34,
-	0x6e, 0x68, 0x3d, 0x24, 0x56, 0xec, 0xc0, 0x68, 0x10, 0xa0, 0x83, 0x95, 0x38, 0x89, 0x91, 0xa4,
-	0x0d, 0x2e, 0x6e, 0x52, 0x74, 0x21, 0x4e, 0xe4, 0x85, 0x62, 0x4d, 0xf2, 0x58, 0xde, 0x49, 0x91,
-	0x0a, 0x14, 0xe8, 0xd8, 0xb1, 0xdd, 0x3a, 0xe6, 0xcf, 0x09, 0x3a, 0x65, 0x2c, 0x3a, 0x10, 0x85,
-	0xbc, 0x79, 0xd4, 0xdc, 0xa1, 0xb8, 0x17, 0xea, 0x2d, 0x6e, 0x01, 0xc1, 0x13, 0xef, 0x79, 0xee,
-	0xb9, 0xef, 0x87, 0xcf, 0xdd, 0x73, 0x7c, 0x08, 0x76, 0xa8, 0xe8, 0xd2, 0x24, 0xf4, 0x23, 0xd1,
-	0xa2, 0xfd, 0xb0, 0xd5, 0xdf, 0x27, 0x41, 0xdc, 0x25, 0xfb, 0xd2, 0xd8, 0x8b, 0x13, 0x26, 0x18,
-	0xdc, 0x9a, 0x44, 0xec, 0x49, 0x67, 0x16, 0x71, 0xa3, 0xe1, 0x31, 0x8f, 0xa9, 0x90, 0x96, 0x1c,
-	0xe9, 0x68, 0xf4, 0x77, 0x0e, 0xac, 0xbf, 0x20, 0x09, 0x09, 0x39, 0xdc, 0x07, 0x25, 0xda, 0x0f,
-	0x6d, 0x97, 0x46, 0x2c, 0x6c, 0xe6, 0x76, 0x72, 0xbb, 0xa5, 0x76, 0x63, 0x9c, 0x5a, 0xf5, 0x21,
-	0x09, 0x83, 0xfb, 0x68, 0x32, 0x85, 0x70, 0x91, 0xf6, 0xc3, 0x87, 0x72, 0x08, 0xbf, 0x00, 0x9b,
-	0x34, 0x22, 0x9d, 0x80, 0xda, 0x4e, 0x42, 0x89, 0xa0, 0xcd, 0xd5, 0x9d, 0xdc, 0x6e, 0xb1, 0xdd,
-	0x1c, 0xa7, 0x56, 0xc3, 0x2c, 0x9b, 0x9d, 0x46, 0xb8, 0xa2, 0xed, 0x07, 0xca, 0x84, 0x9f, 0x83,
-	0x72, 0x36, 0x4f, 0x82, 0xa0, 0x99, 0x57, 0x8b, 0xb7, 0xc6, 0xa9, 0x05, 0xe7, 0x17, 0x93, 0x20,
-	0x40, 0x18, 0x98, 0xa5, 0x24, 0x08, 0xe0, 0x11, 0x00, 0x74, 0x20, 0x12, 0x62, 0x53, 0x3f, 0xe6,
-	0xcd, 0xc2, 0x4e, 0x7e, 0x37, 0xdf, 0x46, 0xa3, 0xd4, 0x2a, 0x1d, 0x4b, 0xef, 0xf1, 0xc9, 0x0b,
-	0x3e, 0x4e, 0xad, 0xff, 0x19, 0x91, 0x49, 0x20, 0xc2, 0x25, 0x65, 0x1c, 0xfb, 0x31, 0xbf, 0x5f,
-	0xf8, 0xed, 0x9d, 0xb5, 0x82, 0xde, 0x55, 0x41, 0xf9, 0x41, 0x97, 0xf8, 0xd1, 0x03, 0x16, 0xbd,
-	0xf1, 0x3d, 0xf8, 0x3d, 0xa8, 0x75, 0x59, 0x48, 0xb9, 0xa0, 0xc4, 0xb5, 0x3b, 0x01, 0x73, 0xce,
-	0xcc, 0x4e, 0x3c, 0x79, 0x9f, 0x5a, 0x2b, 0x7f, 0xa6, 0xd6, 0xa7, 0x9e, 0x2f, 0xba, 0xbd, 0xce,
-	0x9e, 0xc3, 0xc2, 0x96, 0xc3, 0x78, 0xc8, 0xb8, 0x79, 0xdc, 0xe6, 0xee, 0x59, 0x4b, 0x0c, 0x63,
-	0xca, 0xf7, 0x4e, 0x22, 0x31, 0x4e, 0xad, 0x2d, 0x8d, 0x5f, 0x90, 0x43, 0xb8, 0x3a, 0xf1, 0xb4,
-	0xa5, 0x03, 0xfe, 0x08, 0xaa, 0x2e, 0x61, 0xf6, 0x1b, 0x96, 0x9c, 0x19, 0xe2, 0xaa, 0x22, 0xbe,
-	0x5e, 0x8e, 0x38, 0x4a, 0xad, 0xca, 0xc3, 0xa3, 0xaf, 0x1e, 0xb1, 0xe4, 0x4c, 0xe9, 0x8e, 0x53,
-	0xeb, 0xff, 0xfa, 0x0d, 0xe6, 0xd5, 0x11, 0xae, 0xb8, 0x84, 0x4d, 0xc2, 0xe0, 0x6b, 0x50, 0x9f,
-	0x04, 0xf0, 0x5e, 0x1c, 0xb3, 0x44, 0x98, 0x83, 0xb8, 0x3d, 0x4a, 0xad, 0xaa, 0x91, 0x7c, 0xa9,
-	0x67, 0xc6, 0xa9, 0xf5, 0xc9, 0x82, 0xa8, 0x59, 0x83, 0x70, 0xd5, 0xc8, 0x9a, 0x50, 0xf8, 0x16,
-	0x54, 0xa8, 0x1f, 0xef, 0x1f, 0xde, 0x31, 0x59, 0x15, 0x54, 0x56, 0xa7, 0x4b, 0x67, 0x55, 0x3e,
-	0x3e, 0x79, 0xb1, 0x7f, 0x78, 0x27, 0x4b, 0xea, 0x9a, 0x39, 0xd5, 0x19, 0x69, 0x84, 0xcb, 0xda,
-	0xd4, 0x19, 0x9d, 0x00, 0x63, 0xda, 0x5d, 0xc2, 0xbb, 0xcd, 0x35, 0xc5, 0xdd, 0x1d, 0xa5, 0x16,
-	0xd0, 0x4a, 0x4f, 0x08, 0xef, 0x4e, 0xcf, 0xa7, 0x33, 0xfc, 0x81, 0x44, 0xc2, 0xef, 0x85, 0x99,
-	0x16, 0xd0, 0x8b, 0x65, 0xd4, 0x24, 0x87, 0x43, 0x93, 0xc3, 0xfa, 0x95, 0x72, 0x38, 0xbc, 0x2c,
-	0x87, 0xc3, 0xf9, 0x1c, 0x74, 0xcc, 0x04, 0x7c, 0xcf, 0x80, 0x37, 0xae, 0x04, 0xbe, 0x77, 0x19,
-	0xf8, 0xde, 0x3c, 0x58, 0xc7, 0xc8, 0x0b, 0xb0, 0xb0, 0x23, 0xcd, 0xe2, 0xd5, 0x2e, 0xc0, 0x47,
-	0x1b, 0x5c, 0x9d, 0x78, 0x34, 0xf2, 0xa7, 0x1c, 0x68, 0x38, 0x2c, 0xe2, 0x42, 0x3a, 0x23, 0x16,
-	0x07, 0xd4, 0x80, 0x4b, 0x0a, 0xfc, 0x7c, 0x69, 0xf0, 0x4d, 0x0d, 0xbe, 0x4c, 0x13, 0xe1, 0x6b,
-	0xf3, 0x6e, 0xfd, 0x0a, 0x02, 0xd4, 0x63, 0x2a, 0x68, 0xc2, 0x3b, 0xbd, 0xc4, 0x33, 0x74, 0xa0,
-	0xe8, 0x27, 0x4b, 0xd3, 0xcd, 0x05, 0x59, 0xd4, 0x43, 0xb8, 0x36, 0x75, 0x69, 0x6a, 0x04, 0xaa,
-	0xbe, 0x7c, 0x95, 0x4e, 0x2f, 0x30, 0xcc, 0xb2, 0x62, 0x3e, 0x5e, 0x9a, 0x69, 0x6e, 0xfa, 0xbc,
-	0x1a, 0xc2, 0x9b, 0x99, 0x43, 0xf3, 0x86, 0x00, 0x86, 0x3d, 0x3f, 0xb1, 0xbd, 0x80, 0x38, 0x3e,
-	0x4d, 0x0c, 0xb3, 0xa2, 0x98, 0x4f, 0x97, 0x66, 0x5e, 0xd7, 0xcc, 0x8f, 0x15, 0x11, 0xae, 0x4b,
-	0xe7, 0x63, 0xed, 0xd3, 0xe8, 0x2e, 0xa8, 0x74, 0x68, 0x12, 0xf8, 0x91, 0x81, 0x6e, 0x2a, 0xe8,
-	0xf1, 0xd2, 0x50, 0x53, 0xc0, 0xb3, 0x5a, 0x08, 0x97, 0xb5, 0xa9, 0x49, 0xdf, 0x81, 0xcd, 0x21,
-	0x0b, 0x98, 0xdd, 0xbf, 0x6b, 0x50, 0x55, 0x85, 0x7a, 0xb4, 0x34, 0xca, 0x34, 0xb0, 0x39, 0x31,
-	0x84, 0xcb, 0xd2, 0x7e, 0x75, 0x57, 0xb3, 0x38, 0x28, 0xd3, 0xb7, 0x84, 0x67, 0x17, 0xa5, 0xa6,
-	0x48, 0x78, 0xe9, 0x4b, 0x0a, 0x8e, 0x5f, 0x1f, 0xbd, 0x7c, 0x9e, 0xdd, 0xd1, 0xac, 0xf7, 0x4d,
-	0x85, 0xe5, 0x37, 0x49, 0x5a, 0x93, 0xaa, 0x71, 0x88, 0x20, 0xc1, 0x90, 0x0b, 0xc3, 0xad, 0x5f,
-	0xad, 0x6a, 0xe6, 0xd5, 0x10, 0xde, 0xcc, 0x1c, 0x8a, 0x87, 0x5a, 0x60, 0xed, 0xa5, 0x90, 0xdd,
-	0xba, 0x0e, 0xf2, 0x67, 0x74, 0xa8, 0xfb, 0x21, 0x96, 0x43, 0xd8, 0x00, 0x6b, 0x7d, 0x12, 0xf4,
-	0x74, 0xdb, 0x2f, 0x61, 0x6d, 0xa0, 0x57, 0xa0, 0x76, 0x9a, 0x90, 0x88, 0x13, 0x47, 0xf8, 0x2c,
-	0x7a, 0xc6, 0x3c, 0x0e, 0x21, 0x28, 0xa8, 0x6f, 0xb1, 0x5e, 0xab, 0xc6, 0xb0, 0x05, 0x0a, 0x01,
-	0xf3, 0x78, 0x73, 0x75, 0x27, 0xbf, 0x5b, 0x3e, 0xb8, 0xb9, 0x77, 0xf9, 0x6f, 0xcb, 0xde, 0x33,
-	0xe6, 0x61, 0x15, 0x88, 0x7e, 0x5f, 0x05, 0xf9, 0x67, 0xcc, 0x83, 0x4d, 0xb0, 0x41, 0x5c, 0x37,
-	0xa1, 0x9c, 0x1b, 0xbd, 0xcc, 0x84, 0x5b, 0x60, 0x5d, 0xb0, 0xd8, 0x77, 0xb4, 0x68, 0x09, 0x1b,
-	0x4b, 0xe2, 0x5d, 0x22, 0x88, 0xea, 0x6b, 0x15, 0xac, 0xc6, 0xf0, 0x00, 0x54, 0x54, 0xbe, 0x76,
-	0xd4, 0x0b, 0x3b, 0x34, 0x51, 0xed, 0xa9, 0xd0, 0xae, 0x5d, 0xa4, 0x56, 0x59, 0xf9, 0xbf, 0x54,
-	0x6e, 0x3c, 0x6b, 0xc0, 0x5b, 0x60, 0x43, 0x0c, 0x66, 0xbb, 0xca, 0xb5, 0x8b, 0xd4, 0xaa, 0x89,
-	0x69, 0xb2, 0xb2, 0x69, 0xe0, 0x75, 0x31, 0x78, 0xa2, 0x13, 0x2c, 0x8a, 0x81, 0xed, 0x47, 0x2e,
-	0x1d, 0xa8, 0xc6, 0x51, 0x68, 0x37, 0x2e, 0x52, 0xab, 0x3e, 0x13, 0x7e, 0x22, 0xe7, 0xf0, 0x86,
-	0x18, 0xa8, 0x01, 0xbc, 0x05, 0x80, 0x7e, 0x25, 0x45, 0xd0, 0x9f, 0xfc, 0xcd, 0x8b, 0xd4, 0x2a,
-	0x29, 0xaf, 0xd2, 0x9e, 0x0e, 0x21, 0x02, 0x6b, 0x5a, 0xbb, 0xa8, 0xb4, 0x2b, 0x17, 0xa9, 0x55,
-	0x0c, 0x98, 0xa7, 0x35, 0xf5, 0x94, 0xdc, 0xaa, 0x84, 0x86, 0xac, 0x4f, 0x5d, 0xf5, 0x31, 0x2d,
-	0xe2, 0xcc, 0x44, 0xbf, 0xae, 0x82, 0xe2, 0xe9, 0x00, 0x53, 0xde, 0x0b, 0x04, 0x7c, 0x04, 0xea,
-	0x0e, 0x8b, 0x44, 0x42, 0x1c, 0x61, 0xcf, 0x6d, 0x6d, 0xfb, 0xe6, 0xf4, 0x83, 0xb6, 0x18, 0x81,
-	0x70, 0x2d, 0x73, 0x1d, 0x99, 0xfd, 0x6f, 0x80, 0xb5, 0x4e, 0xc0, 0x58, 0xa8, 0xea, 0xa1, 0x82,
-	0xb5, 0x01, 0xbf, 0x51, 0xbb, 0xa6, 0xce, 0x5a, 0x1e, 0x40, 0xf9, 0xe0, 0xb3, 0x7f, 0x3b, 0xeb,
-	0x85, 0xb2, 0x69, 0x6f, 0xc9, 0x92, 0x1e, 0xa7, 0x56, 0x55, 0xbf, 0x81, 0x51, 0x41, 0x72, 0x87,
-	0x55, 0x59, 0xd5, 0x41, 0x3e, 0xa1, 0x42, 0x1d, 0x5d, 0x05, 0xcb, 0x21, 0xbc, 0x01, 0x8a, 0x09,
-	0xed, 0xd3, 0x44, 0x50, 0x57, 0x1d, 0x51, 0x11, 0x4f, 0x6c, 0x78, 0x1d, 0x14, 0x3d, 0xc2, 0xed,
-	0x1e, 0xa7, 0xae, 0x3e, 0x0f, 0xbc, 0xe1, 0x11, 0xfe, 0x35, 0xa7, 0xee, 0xfd, 0xc2, 0xcf, 0xf2,
-	0x67, 0x90, 0x80, 0xf2, 0x91, 0xe3, 0x50, 0xce, 0x4f, 0x7b, 0x71, 0x40, 0xff, 0xa3, 0xce, 0x0e,
-	0x40, 0x85, 0x0b, 0x96, 0x10, 0x8f, 0xda, 0x67, 0x74, 0x68, 0xaa, 0x4d, 0xd7, 0x8e, 0xf1, 0x3f,
-	0xa5, 0x43, 0x8e, 0x67, 0x0d, 0x8d, 0x68, 0xb7, 0xdf, 0x8f, 0xb6, 0x73, 0x1f, 0x46, 0xdb, 0xb9,
-	0xbf, 0x46, 0xdb, 0xb9, 0x5f, 0xce, 0xb7, 0x57, 0x3e, 0x9c, 0x6f, 0xaf, 0xfc, 0x71, 0xbe, 0xbd,
-	0xf2, 0xed, 0xee, 0xcc, 0xb5, 0x15, 0x5d, 0x92, 0x70, 0x9f, 0xb7, 0xa6, 0xff, 0xfa, 0x03, 0xf5,
-	0xb7, 0xaf, 0x2e, 0x6f, 0x67, 0x5d, 0xfd, 0xb9, 0xdf, 0xfd, 0x27, 0x00, 0x00, 0xff, 0xff, 0x17,
-	0xd8, 0xae, 0xb6, 0x0b, 0x0c, 0x00, 0x00,
+	// 1268 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x97, 0x4d, 0x6f, 0xdb, 0x36,
+	0x18, 0xc7, 0xe3, 0xd8, 0x49, 0x6c, 0x5a, 0x7e, 0x19, 0xeb, 0x65, 0x6e, 0x03, 0x44, 0x01, 0x07,
+	0x6c, 0x3e, 0xb4, 0x71, 0x93, 0x22, 0x58, 0x51, 0x60, 0x87, 0x28, 0x4d, 0xdb, 0x60, 0x5d, 0x17,
+	0x30, 0x5d, 0x3b, 0xec, 0x22, 0xd0, 0x12, 0x2b, 0x6b, 0x91, 0x44, 0x41, 0xa4, 0x3d, 0x7b, 0xd8,
+	0x07, 0xd8, 0x71, 0xbb, 0xed, 0xb8, 0x8f, 0x53, 0xec, 0xd4, 0xe3, 0xb0, 0x83, 0xb0, 0xb9, 0x87,
+	0x01, 0x39, 0xfa, 0x13, 0x0c, 0x22, 0xe9, 0xb7, 0x34, 0x1d, 0xe6, 0x9c, 0xcc, 0xe7, 0xe1, 0xc3,
+	0xff, 0x8f, 0x2f, 0x0f, 0xf5, 0xd0, 0x60, 0x87, 0x8a, 0x2e, 0x4d, 0x42, 0x3f, 0x12, 0x6d, 0xda,
+	0x0f, 0xdb, 0xfd, 0x3d, 0x12, 0xc4, 0x5d, 0xb2, 0x97, 0x19, 0xbb, 0x71, 0xc2, 0x04, 0x83, 0x9b,
+	0xd3, 0x88, 0xdd, 0xcc, 0x39, 0x89, 0xb8, 0xd5, 0xf0, 0x98, 0xc7, 0x64, 0x48, 0x3b, 0x6b, 0xa9,
+	0x68, 0xf4, 0xf7, 0x2a, 0x58, 0x3f, 0x25, 0x09, 0x09, 0x39, 0xdc, 0x03, 0x25, 0xda, 0x0f, 0x6d,
+	0x97, 0x46, 0x2c, 0x6c, 0xe6, 0x76, 0x72, 0xad, 0x92, 0xd5, 0x18, 0xa7, 0x66, 0x7d, 0x48, 0xc2,
+	0xe0, 0x01, 0x9a, 0x76, 0x21, 0x5c, 0xa4, 0xfd, 0xf0, 0x61, 0xd6, 0x84, 0x9f, 0x83, 0x0a, 0x8d,
+	0x48, 0x27, 0xa0, 0xb6, 0x93, 0x50, 0x22, 0x68, 0x73, 0x75, 0x27, 0xd7, 0x2a, 0x5a, 0xcd, 0x71,
+	0x6a, 0x36, 0xf4, 0xb0, 0xf9, 0x6e, 0x84, 0x0d, 0x65, 0x1f, 0x49, 0x13, 0x7e, 0x06, 0xca, 0x93,
+	0x7e, 0x12, 0x04, 0xcd, 0xbc, 0x1c, 0xbc, 0x39, 0x4e, 0x4d, 0xb8, 0x38, 0x98, 0x04, 0x01, 0xc2,
+	0x40, 0x0f, 0x25, 0x41, 0x00, 0x0f, 0x01, 0xa0, 0x03, 0x91, 0x10, 0x9b, 0xfa, 0x31, 0x6f, 0x16,
+	0x76, 0xf2, 0xad, 0xbc, 0x85, 0x46, 0xa9, 0x59, 0x3a, 0xce, 0xbc, 0xc7, 0x27, 0xa7, 0x7c, 0x9c,
+	0x9a, 0x1f, 0x68, 0x91, 0x69, 0x20, 0xc2, 0x25, 0x69, 0x1c, 0xfb, 0x31, 0x87, 0x0e, 0x30, 0x9c,
+	0x2e, 0xf1, 0x23, 0xdb, 0x61, 0xd1, 0x2b, 0xdf, 0x6b, 0xae, 0xed, 0xe4, 0x5a, 0xe5, 0xfd, 0x8f,
+	0x77, 0xaf, 0xde, 0xbd, 0xdd, 0xa3, 0x2c, 0xf6, 0x48, 0x86, 0x5a, 0x5b, 0xaf, 0x53, 0x73, 0x65,
+	0x9c, 0x9a, 0x37, 0x14, 0x60, 0x5e, 0x06, 0xe1, 0xb2, 0x33, 0x8b, 0x7c, 0x50, 0xf8, 0xf5, 0x37,
+	0x73, 0x05, 0xfd, 0x53, 0x01, 0xe5, 0xb9, 0xf1, 0x30, 0x04, 0xb5, 0x2e, 0x0b, 0x29, 0x17, 0x94,
+	0xb8, 0x76, 0x27, 0x60, 0xce, 0xb9, 0xde, 0xee, 0x87, 0x7f, 0xa6, 0xe6, 0x27, 0x9e, 0x2f, 0xba,
+	0xbd, 0xce, 0xae, 0xc3, 0xc2, 0xb6, 0xc3, 0x78, 0xc8, 0xb8, 0xfe, 0xb9, 0xc3, 0xdd, 0xf3, 0xb6,
+	0x18, 0xc6, 0x94, 0xef, 0x9e, 0x44, 0x62, 0x9c, 0x9a, 0x9b, 0x0a, 0x7f, 0x49, 0x0a, 0xe1, 0xea,
+	0xd4, 0x63, 0x65, 0x0e, 0x38, 0x04, 0x55, 0x97, 0x30, 0xfb, 0x15, 0x4b, 0xce, 0x35, 0x6d, 0x55,
+	0xd2, 0xce, 0xfe, 0x3f, 0x6d, 0x94, 0x9a, 0xc6, 0xc3, 0xc3, 0xaf, 0x1e, 0xb1, 0xe4, 0x5c, 0x6a,
+	0x8e, 0x53, 0xf3, 0x43, 0x45, 0x5f, 0x54, 0x46, 0xd8, 0x70, 0x09, 0x9b, 0x86, 0xc1, 0x97, 0xa0,
+	0x3e, 0x0d, 0xe0, 0xbd, 0x38, 0x66, 0x89, 0xd0, 0xa7, 0x7c, 0x67, 0x94, 0x9a, 0x55, 0x2d, 0x79,
+	0xa6, 0x7a, 0xc6, 0xa9, 0xf9, 0xd1, 0x25, 0x51, 0x3d, 0x06, 0xe1, 0xaa, 0x96, 0xd5, 0xa1, 0x90,
+	0x03, 0x83, 0xfa, 0xf1, 0xde, 0xc1, 0x5d, 0xbd, 0xa2, 0x82, 0x5c, 0xd1, 0xe9, 0x52, 0x2b, 0x2a,
+	0x1f, 0x9f, 0x9c, 0xee, 0x1d, 0xdc, 0x9d, 0x2c, 0x48, 0x9f, 0xe6, 0xbc, 0x2c, 0xc2, 0x65, 0x65,
+	0xaa, 0xd5, 0x9c, 0x00, 0x6d, 0xda, 0x5d, 0xc2, 0xbb, 0x32, 0x63, 0x4a, 0x56, 0x6b, 0x94, 0x9a,
+	0x40, 0x29, 0x3d, 0x21, 0xbc, 0x3b, 0x3b, 0x97, 0xce, 0xf0, 0x07, 0x12, 0x09, 0xbf, 0x17, 0x4e,
+	0xb4, 0x80, 0x1a, 0x9c, 0x45, 0x4d, 0xe7, 0x7f, 0xa0, 0xe7, 0xbf, 0x7e, 0xed, 0xf9, 0x1f, 0x5c,
+	0x35, 0xff, 0x83, 0xc5, 0xf9, 0xab, 0x98, 0x29, 0xf4, 0xbe, 0x86, 0x6e, 0x5c, 0x1b, 0x7a, 0xff,
+	0x2a, 0xe8, 0xfd, 0x45, 0xa8, 0x8a, 0xc9, 0x92, 0xfd, 0xd2, 0x4e, 0x34, 0x8b, 0xd7, 0x4f, 0xf6,
+	0x77, 0x36, 0xb5, 0x3a, 0xf5, 0x28, 0xdc, 0x8f, 0xa0, 0xe1, 0xb0, 0x88, 0x8b, 0xcc, 0x17, 0xb1,
+	0x38, 0xa0, 0x9a, 0x59, 0x92, 0xcc, 0x93, 0xa5, 0x98, 0x5b, 0xfa, 0x7e, 0x5f, 0xa1, 0x87, 0xf0,
+	0x8d, 0x45, 0xb7, 0xa2, 0xc7, 0xa0, 0x1e, 0x53, 0x41, 0x13, 0xde, 0xe9, 0x25, 0x9e, 0x26, 0x03,
+	0x49, 0x3e, 0x5e, 0x8a, 0xac, 0xef, 0xc1, 0x65, 0x2d, 0x84, 0x6b, 0x33, 0x97, 0x22, 0x7e, 0x07,
+	0xaa, 0x7e, 0x36, 0x8d, 0x4e, 0x2f, 0xd0, 0xbc, 0xb2, 0xe4, 0x1d, 0x2d, 0xc5, 0xd3, 0x97, 0x79,
+	0x51, 0x09, 0xe1, 0xca, 0xc4, 0xa1, 0x58, 0x3d, 0x00, 0xc3, 0x9e, 0x9f, 0xd8, 0x5e, 0x40, 0x1c,
+	0x9f, 0x26, 0x9a, 0x67, 0x48, 0xde, 0xe3, 0xa5, 0x78, 0x37, 0x15, 0xef, 0x5d, 0x35, 0x84, 0xeb,
+	0x99, 0xf3, 0xb1, 0xf2, 0x29, 0xac, 0x0b, 0x8c, 0x0e, 0x4d, 0x02, 0x3f, 0xd2, 0xc0, 0x8a, 0x04,
+	0x1e, 0x2e, 0x05, 0xd4, 0x79, 0x3a, 0xaf, 0x83, 0x70, 0x59, 0x99, 0x8a, 0xf2, 0x0a, 0x54, 0x86,
+	0x2c, 0x60, 0x76, 0xff, 0x9e, 0xc6, 0x54, 0x25, 0xc6, 0x5a, 0x0a, 0xa3, 0x8b, 0xde, 0x82, 0x10,
+	0xc2, 0xe5, 0xcc, 0x7e, 0x71, 0x4f, 0x71, 0x18, 0x28, 0xd3, 0xef, 0x09, 0x9f, 0xdc, 0x85, 0x9a,
+	0xa4, 0x3c, 0x5b, 0xea, 0x0e, 0x82, 0xe3, 0x97, 0x87, 0x67, 0x5f, 0x4e, 0xae, 0xe0, 0xa4, 0x56,
+	0xce, 0x44, 0xb3, 0x4f, 0x4d, 0x66, 0x4d, 0x33, 0xc4, 0x21, 0x82, 0x04, 0x43, 0x2e, 0x34, 0xb3,
+	0x7e, 0xfd, 0x0c, 0x59, 0x54, 0x42, 0xb8, 0x32, 0x71, 0x48, 0x16, 0x6a, 0x83, 0xb5, 0x33, 0x91,
+	0x55, 0xf6, 0x3a, 0xc8, 0x9f, 0xd3, 0xa1, 0x2a, 0x6b, 0x38, 0x6b, 0xc2, 0x06, 0x58, 0xeb, 0x93,
+	0xa0, 0xa7, 0x9e, 0x08, 0x25, 0xac, 0x0c, 0xf4, 0x02, 0xd4, 0x9e, 0x27, 0x24, 0xe2, 0xc4, 0x11,
+	0x3e, 0x8b, 0x9e, 0x32, 0x8f, 0x43, 0x08, 0x0a, 0xf2, 0xf3, 0xaa, 0xc6, 0xca, 0x36, 0x6c, 0x83,
+	0x42, 0xc0, 0x3c, 0xde, 0x5c, 0xdd, 0xc9, 0xb7, 0xca, 0xfb, 0x5b, 0xef, 0x2b, 0xd2, 0x4f, 0x99,
+	0x87, 0x65, 0x20, 0xfa, 0x7d, 0x15, 0xe4, 0x9f, 0x32, 0x0f, 0x36, 0xc1, 0x06, 0x71, 0xdd, 0x84,
+	0x72, 0xae, 0xf5, 0x26, 0x26, 0xdc, 0x04, 0xeb, 0x82, 0xc5, 0xbe, 0xa3, 0x44, 0x4b, 0x58, 0x5b,
+	0x19, 0xde, 0x25, 0x82, 0xc8, 0x32, 0x65, 0x60, 0xd9, 0x86, 0xfb, 0xc0, 0x90, 0xeb, 0xb5, 0xa3,
+	0x5e, 0xd8, 0xa1, 0x89, 0xac, 0x36, 0x05, 0xab, 0x76, 0x91, 0x9a, 0x65, 0xe9, 0x7f, 0x26, 0xdd,
+	0x78, 0xde, 0x80, 0xb7, 0xc1, 0x86, 0x18, 0xcc, 0x17, 0x8a, 0x1b, 0x17, 0xa9, 0x59, 0x13, 0xb3,
+	0xc5, 0x66, 0x75, 0x00, 0xaf, 0x8b, 0xc1, 0x13, 0xb5, 0xc0, 0xa2, 0x18, 0xd8, 0x7e, 0xe4, 0xd2,
+	0x81, 0xac, 0x05, 0x05, 0xab, 0x71, 0x91, 0x9a, 0xf5, 0xb9, 0xf0, 0x93, 0xac, 0x0f, 0x6f, 0x88,
+	0x81, 0x6c, 0xc0, 0xdb, 0x00, 0xa8, 0x29, 0x49, 0x82, 0xfa, 0x92, 0x57, 0x2e, 0x52, 0xb3, 0x24,
+	0xbd, 0x52, 0x7b, 0xd6, 0x84, 0x08, 0xac, 0x29, 0xed, 0xa2, 0xd4, 0x36, 0x2e, 0x52, 0xb3, 0x18,
+	0x30, 0x4f, 0x69, 0xaa, 0xae, 0x6c, 0xab, 0x12, 0x1a, 0xb2, 0x3e, 0x75, 0xe5, 0xc7, 0xb2, 0x88,
+	0x27, 0x26, 0xfa, 0x65, 0x15, 0x14, 0x9f, 0x0f, 0x30, 0xe5, 0xbd, 0x40, 0xc0, 0x47, 0xa0, 0xee,
+	0xb0, 0x48, 0x24, 0xc4, 0x11, 0xf6, 0xc2, 0xd6, 0x5a, 0x5b, 0xb3, 0x0f, 0xd7, 0xe5, 0x08, 0x84,
+	0x6b, 0x13, 0xd7, 0xa1, 0xde, 0xff, 0x06, 0x58, 0xeb, 0x04, 0x8c, 0x85, 0x32, 0x1f, 0x0c, 0xac,
+	0x0c, 0xf8, 0x8d, 0xdc, 0x35, 0x79, 0xd6, 0x79, 0xf9, 0x20, 0xfb, 0xf4, 0x7d, 0x67, 0x7d, 0x29,
+	0x6d, 0xac, 0x4d, 0xfd, 0x28, 0xab, 0xaa, 0x19, 0x68, 0x15, 0x94, 0xed, 0xb0, 0x4c, 0xab, 0x3a,
+	0xc8, 0x27, 0x54, 0xc8, 0xa3, 0x33, 0x70, 0xd6, 0x84, 0xb7, 0x40, 0x31, 0xa1, 0x7d, 0x9a, 0x08,
+	0xea, 0xca, 0x23, 0x2a, 0xe2, 0xa9, 0x0d, 0x6f, 0x82, 0xa2, 0x47, 0xb8, 0xdd, 0xe3, 0xd4, 0x55,
+	0xe7, 0x81, 0x37, 0x3c, 0xc2, 0xbf, 0xe6, 0xd4, 0x7d, 0x50, 0xf8, 0x29, 0x7b, 0xd3, 0x11, 0x50,
+	0x3e, 0x74, 0x1c, 0xca, 0xf9, 0xf3, 0x5e, 0x1c, 0xd0, 0xff, 0xc8, 0xb3, 0x7d, 0x60, 0x70, 0xc1,
+	0x12, 0xe2, 0x51, 0xfb, 0x9c, 0x0e, 0x75, 0xb6, 0xa9, 0xdc, 0xd1, 0xfe, 0x2f, 0xe8, 0x90, 0xe3,
+	0x79, 0x43, 0x21, 0x2c, 0xeb, 0xf5, 0x68, 0x3b, 0xf7, 0x66, 0xb4, 0x9d, 0xfb, 0x6b, 0xb4, 0x9d,
+	0xfb, 0xf9, 0xed, 0xf6, 0xca, 0x9b, 0xb7, 0xdb, 0x2b, 0x7f, 0xbc, 0xdd, 0x5e, 0xf9, 0xb6, 0x35,
+	0x77, 0x6d, 0x45, 0x97, 0x24, 0xdc, 0xe7, 0xed, 0xd9, 0xff, 0x82, 0x81, 0xfc, 0x67, 0x20, 0x2f,
+	0x6f, 0x67, 0x5d, 0xbe, 0xf2, 0xef, 0xfd, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x21, 0x0d, 0xbd, 0x5b,
+	0x37, 0x0c, 0x00, 0x00,
 }

 func (m *Params) Marshal() (dAtA []byte, err error) {
@@ -628,22 +630,32 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	{
+		size, err := m.ChainConfig.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintEvm(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x2a
 	if len(m.ExtraEIPs) > 0 {
-		dAtA2 := make([]byte, len(m.ExtraEIPs)*10)
-		var j1 int
+		dAtA3 := make([]byte, len(m.ExtraEIPs)*10)
+		var j2 int
 		for _, num1 := range m.ExtraEIPs {
 			num := uint64(num1)
 			for num >= 1<<7 {
-				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j1++
+				j2++
 			}
-			dAtA2[j1] = uint8(num)
-			j1++
+			dAtA3[j2] = uint8(num)
+			j2++
 		}
-		i -= j1
-		copy(dAtA[i:], dAtA2[:j1])
-		i = encodeVarintEvm(dAtA, i, uint64(j1))
+		i -= j2
+		copy(dAtA[i:], dAtA3[:j2])
+		i = encodeVarintEvm(dAtA, i, uint64(j2))
 		i--
 		dAtA[i] = 0x22
 	}
@@ -697,118 +709,140 @@ func (m *ChainConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	{
-		size := m.CatalystBlock.Size()
-		i -= size
-		if _, err := m.CatalystBlock.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
+	if m.CatalystBlock != nil {
+		{
+			size := m.CatalystBlock.Size()
+			i -= size
+			if _, err := m.CatalystBlock.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+			i = encodeVarintEvm(dAtA, i, uint64(size))
 		}
-		i = encodeVarintEvm(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x82
 	}
-	i--
-	dAtA[i] = 0x1
-	i--
-	dAtA[i] = 0x82
-	{
-		size := m.EWASMBlock.Size()
-		i -= size
-		if _, err := m.EWASMBlock.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
+	if m.EWASMBlock != nil {
+		{
+			size := m.EWASMBlock.Size()
+			i -= size
+			if _, err := m.EWASMBlock.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+			i = encodeVarintEvm(dAtA, i, uint64(size))
 		}
-		i = encodeVarintEvm(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x7a
 	}
-	i--
-	dAtA[i] = 0x7a
-	{
-		size := m.YoloV3Block.Size()
-		i -= size
-		if _, err := m.YoloV3Block.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
+	if m.YoloV3Block != nil {
+		{
+			size := m.YoloV3Block.Size()
+			i -= size
+			if _, err := m.YoloV3Block.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+			i = encodeVarintEvm(dAtA, i, uint64(size))
 		}
-		i = encodeVarintEvm(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x72
 	}
-	i--
-	dAtA[i] = 0x72
-	{
-		size := m.BerlinBlock.Size()
-		i -= size
-		if _, err := m.BerlinBlock.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
+	if m.BerlinBlock != nil {
+		{
+			size := m.BerlinBlock.Size()
+			i -= size
+			if _, err := m.BerlinBlock.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+			i = encodeVarintEvm(dAtA, i, uint64(size))
 		}
-		i = encodeVarintEvm(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x6a
 	}
-	i--
-	dAtA[i] = 0x6a
-	{
-		size := m.MuirGlacierBlock.Size()
-		i -= size
-		if _, err := m.MuirGlacierBlock.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
+	if m.MuirGlacierBlock != nil {
+		{
+			size := m.MuirGlacierBlock.Size()
+			i -= size
+			if _, err := m.MuirGlacierBlock.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+			i = encodeVarintEvm(dAtA, i, uint64(size))
 		}
-		i = encodeVarintEvm(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x62
 	}
-	i--
-	dAtA[i] = 0x62
-	{
-		size := m.IstanbulBlock.Size()
-		i -= size
-		if _, err := m.IstanbulBlock.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
+	if m.IstanbulBlock != nil {
+		{
+			size := m.IstanbulBlock.Size()
+			i -= size
+			if _, err := m.IstanbulBlock.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+			i = encodeVarintEvm(dAtA, i, uint64(size))
 		}
-		i = encodeVarintEvm(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x5a
 	}
-	i--
-	dAtA[i] = 0x5a
-	{
-		size := m.PetersburgBlock.Size()
-		i -= size
-		if _, err := m.PetersburgBlock.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
+	if m.PetersburgBlock != nil {
+		{
+			size := m.PetersburgBlock.Size()
+			i -= size
+			if _, err := m.PetersburgBlock.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+			i = encodeVarintEvm(dAtA, i, uint64(size))
 		}
-		i = encodeVarintEvm(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x52
 	}
-	i--
-	dAtA[i] = 0x52
-	{
-		size := m.ConstantinopleBlock.Size()
-		i -= size
-		if _, err := m.ConstantinopleBlock.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
+	if m.ConstantinopleBlock != nil {
+		{
+			size := m.ConstantinopleBlock.Size()
+			i -= size
+			if _, err := m.ConstantinopleBlock.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+			i = encodeVarintEvm(dAtA, i, uint64(size))
 		}
-		i = encodeVarintEvm(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x4a
 	}
-	i--
-	dAtA[i] = 0x4a
-	{
-		size := m.ByzantiumBlock.Size()
-		i -= size
-		if _, err := m.ByzantiumBlock.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
+	if m.ByzantiumBlock != nil {
+		{
+			size := m.ByzantiumBlock.Size()
+			i -= size
+			if _, err := m.ByzantiumBlock.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+			i = encodeVarintEvm(dAtA, i, uint64(size))
 		}
-		i = encodeVarintEvm(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x42
 	}
-	i--
-	dAtA[i] = 0x42
-	{
-		size := m.EIP158Block.Size()
-		i -= size
-		if _, err := m.EIP158Block.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
+	if m.EIP158Block != nil {
+		{
+			size := m.EIP158Block.Size()
+			i -= size
+			if _, err := m.EIP158Block.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+			i = encodeVarintEvm(dAtA, i, uint64(size))
 		}
-		i = encodeVarintEvm(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x3a
 	}
-	i--
-	dAtA[i] = 0x3a
-	{
-		size := m.EIP155Block.Size()
-		i -= size
-		if _, err := m.EIP155Block.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
+	if m.EIP155Block != nil {
+		{
+			size := m.EIP155Block.Size()
+			i -= size
+			if _, err := m.EIP155Block.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+			i = encodeVarintEvm(dAtA, i, uint64(size))
 		}
-		i = encodeVarintEvm(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x32
 	}
-	i--
-	dAtA[i] = 0x32
 	if len(m.EIP150Hash) > 0 {
 		i -= len(m.EIP150Hash)
 		copy(dAtA[i:], m.EIP150Hash)
@@ -816,16 +850,18 @@ func (m *ChainConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x2a
 	}
-	{
-		size := m.EIP150Block.Size()
-		i -= size
-		if _, err := m.EIP150Block.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
+	if m.EIP150Block != nil {
+		{
+			size := m.EIP150Block.Size()
+			i -= size
+			if _, err := m.EIP150Block.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+			i = encodeVarintEvm(dAtA, i, uint64(size))
 		}
-		i = encodeVarintEvm(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x22
 	}
-	i--
-	dAtA[i] = 0x22
 	if m.DAOForkSupport {
 		i--
 		if m.DAOForkSupport {
@@ -836,26 +872,30 @@ func (m *ChainConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x18
 	}
-	{
-		size := m.DAOForkBlock.Size()
-		i -= size
-		if _, err := m.DAOForkBlock.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
+	if m.DAOForkBlock != nil {
+		{
+			size := m.DAOForkBlock.Size()
+			i -= size
+			if _, err := m.DAOForkBlock.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+			i = encodeVarintEvm(dAtA, i, uint64(size))
 		}
-		i = encodeVarintEvm(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x12
 	}
-	i--
-	dAtA[i] = 0x12
-	{
-		size := m.HomesteadBlock.Size()
-		i -= size
-		if _, err := m.HomesteadBlock.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
+	if m.HomesteadBlock != nil {
+		{
+			size := m.HomesteadBlock.Size()
+			i -= size
+			if _, err := m.HomesteadBlock.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+			i = encodeVarintEvm(dAtA, i, uint64(size))
 		}
-		i = encodeVarintEvm(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0xa
 	}
-	i--
-	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }

@@ -1167,6 +1207,8 @@ func (m *Params) Size() (n int) {
 		}
 		n += 1 + sovEvm(uint64(l)) + l
 	}
+	l = m.ChainConfig.Size()
+	n += 1 + l + sovEvm(uint64(l))
 	return n
 }

@@ -1176,41 +1218,69 @@ func (m *ChainConfig) Size() (n int) {
 	}
 	var l int
 	_ = l
-	l = m.HomesteadBlock.Size()
-	n += 1 + l + sovEvm(uint64(l))
-	l = m.DAOForkBlock.Size()
-	n += 1 + l + sovEvm(uint64(l))
+	if m.HomesteadBlock != nil {
+		l = m.HomesteadBlock.Size()
+		n += 1 + l + sovEvm(uint64(l))
+	}
+	if m.DAOForkBlock != nil {
+		l = m.DAOForkBlock.Size()
+		n += 1 + l + sovEvm(uint64(l))
+	}
 	if m.DAOForkSupport {
 		n += 2
 	}
-	l = m.EIP150Block.Size()
-	n += 1 + l + sovEvm(uint64(l))
+	if m.EIP150Block != nil {
+		l = m.EIP150Block.Size()
+		n += 1 + l + sovEvm(uint64(l))
+	}
 	l = len(m.EIP150Hash)
 	if l > 0 {
 		n += 1 + l + sovEvm(uint64(l))
 	}
-	l = m.EIP155Block.Size()
-	n += 1 + l + sovEvm(uint64(l))
-	l = m.EIP158Block.Size()
-	n += 1 + l + sovEvm(uint64(l))
-	l = m.ByzantiumBlock.Size()
-	n += 1 + l + sovEvm(uint64(l))
-	l = m.ConstantinopleBlock.Size()
-	n += 1 + l + sovEvm(uint64(l))
-	l = m.PetersburgBlock.Size()
-	n += 1 + l + sovEvm(uint64(l))
-	l = m.IstanbulBlock.Size()
-	n += 1 + l + sovEvm(uint64(l))
-	l = m.MuirGlacierBlock.Size()
-	n += 1 + l + sovEvm(uint64(l))
-	l = m.BerlinBlock.Size()
-	n += 1 + l + sovEvm(uint64(l))
-	l = m.YoloV3Block.Size()
-	n += 1 + l + sovEvm(uint64(l))
-	l = m.EWASMBlock.Size()
-	n += 1 + l + sovEvm(uint64(l))
-	l = m.CatalystBlock.Size()
-	n += 2 + l + sovEvm(uint64(l))
+	if m.EIP155Block != nil {
+		l = m.EIP155Block.Size()
+		n += 1 + l + sovEvm(uint64(l))
+	}
+	if m.EIP158Block != nil {
+		l = m.EIP158Block.Size()
+		n += 1 + l + sovEvm(uint64(l))
+	}
+	if m.ByzantiumBlock != nil {
+		l = m.ByzantiumBlock.Size()
+		n += 1 + l + sovEvm(uint64(l))
+	}
+	if m.ConstantinopleBlock != nil {
+		l = m.ConstantinopleBlock.Size()
+		n += 1 + l + sovEvm(uint64(l))
+	}
+	if m.PetersburgBlock != nil {
+		l = m.PetersburgBlock.Size()
+		n += 1 + l + sovEvm(uint64(l))
+	}
+	if m.IstanbulBlock != nil {
+		l = m.IstanbulBlock.Size()
+		n += 1 + l + sovEvm(uint64(l))
+	}
+	if m.MuirGlacierBlock != nil {
+		l = m.MuirGlacierBlock.Size()
+		n += 1 + l + sovEvm(uint64(l))
+	}
+	if m.BerlinBlock != nil {
+		l = m.BerlinBlock.Size()
+		n += 1 + l + sovEvm(uint64(l))
+	}
+	if m.YoloV3Block != nil {
+		l = m.YoloV3Block.Size()
+		n += 1 + l + sovEvm(uint64(l))
+	}
+	if m.EWASMBlock != nil {
+		l = m.EWASMBlock.Size()
+		n += 1 + l + sovEvm(uint64(l))
+	}
+	if m.CatalystBlock != nil {
+		l = m.CatalystBlock.Size()
+		n += 2 + l + sovEvm(uint64(l))
+	}
 	return n
 }

@@ -1524,6 +1594,39 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 			} else {
 				return fmt.Errorf("proto: wrong wireType = %d for field ExtraEIPs", wireType)
 			}
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ChainConfig", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEvm
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthEvm
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthEvm
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.ChainConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipEvm(dAtA[iNdEx:])
@@ -1604,6 +1707,8 @@ func (m *ChainConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			var v github_com_cosmos_cosmos_sdk_types.Int
+			m.HomesteadBlock = &v
 			if err := m.HomesteadBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -1638,6 +1743,8 @@ func (m *ChainConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			var v github_com_cosmos_cosmos_sdk_types.Int
+			m.DAOForkBlock = &v
 			if err := m.DAOForkBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -1692,6 +1799,8 @@ func (m *ChainConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			var v github_com_cosmos_cosmos_sdk_types.Int
+			m.EIP150Block = &v
 			if err := m.EIP150Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -1758,6 +1867,8 @@ func (m *ChainConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			var v github_com_cosmos_cosmos_sdk_types.Int
+			m.EIP155Block = &v
 			if err := m.EIP155Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -1792,6 +1903,8 @@ func (m *ChainConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			var v github_com_cosmos_cosmos_sdk_types.Int
+			m.EIP158Block = &v
 			if err := m.EIP158Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -1826,6 +1939,8 @@ func (m *ChainConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			var v github_com_cosmos_cosmos_sdk_types.Int
+			m.ByzantiumBlock = &v
 			if err := m.ByzantiumBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -1860,6 +1975,8 @@ func (m *ChainConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			var v github_com_cosmos_cosmos_sdk_types.Int
+			m.ConstantinopleBlock = &v
 			if err := m.ConstantinopleBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -1894,6 +2011,8 @@ func (m *ChainConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			var v github_com_cosmos_cosmos_sdk_types.Int
+			m.PetersburgBlock = &v
 			if err := m.PetersburgBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -1928,6 +2047,8 @@ func (m *ChainConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			var v github_com_cosmos_cosmos_sdk_types.Int
+			m.IstanbulBlock = &v
 			if err := m.IstanbulBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -1962,6 +2083,8 @@ func (m *ChainConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			var v github_com_cosmos_cosmos_sdk_types.Int
+			m.MuirGlacierBlock = &v
 			if err := m.MuirGlacierBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -1996,6 +2119,8 @@ func (m *ChainConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			var v github_com_cosmos_cosmos_sdk_types.Int
+			m.BerlinBlock = &v
 			if err := m.BerlinBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -2030,6 +2155,8 @@ func (m *ChainConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			var v github_com_cosmos_cosmos_sdk_types.Int
+			m.YoloV3Block = &v
 			if err := m.YoloV3Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -2064,6 +2191,8 @@ func (m *ChainConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			var v github_com_cosmos_cosmos_sdk_types.Int
+			m.EWASMBlock = &v
 			if err := m.EWASMBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -2098,6 +2227,8 @@ func (m *ChainConfig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			var v github_com_cosmos_cosmos_sdk_types.Int
+			m.CatalystBlock = &v
 			if err := m.CatalystBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -24,10 +24,9 @@ func (ga GenesisAccount) Validate() error {
 // chain config values.
 func DefaultGenesisState() *GenesisState {
 	return &GenesisState{
-		Accounts:    []GenesisAccount{},
-		TxsLogs:     []TransactionLogs{},
-		ChainConfig: DefaultChainConfig(),
-		Params:      DefaultParams(),
+		Accounts: []GenesisAccount{},
+		TxsLogs:  []TransactionLogs{},
+		Params:   DefaultParams(),
 	}
 }

@@ -58,9 +57,5 @@ func (gs GenesisState) Validate() error {
 		seenTxs[tx.Hash] = true
 	}

-	if err := gs.ChainConfig.Validate(); err != nil {
-		return err
-	}
-
 	return gs.Params.Validate()
 }
@@ -27,8 +27,6 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 type GenesisState struct {
 	// accounts is an array containing the ethereum genesis accounts.
 	Accounts []GenesisAccount `protobuf:"bytes,1,rep,name=accounts,proto3" json:"accounts"`
-	// chain_config defines the Ethereum chain configuration.
-	ChainConfig ChainConfig `protobuf:"bytes,2,opt,name=chain_config,json=chainConfig,proto3" json:"chain_config" yaml:"chain_config"`
 	// params defines all the paramaters of the module.
 	Params  Params            `protobuf:"bytes,3,opt,name=params,proto3" json:"params"`
 	TxsLogs []TransactionLogs `protobuf:"bytes,4,rep,name=txs_logs,json=txsLogs,proto3" json:"txs_logs" yaml:"txs_logs"`
@@ -74,13 +72,6 @@ func (m *GenesisState) GetAccounts() []GenesisAccount {
 	return nil
 }

-func (m *GenesisState) GetChainConfig() ChainConfig {
-	if m != nil {
-		return m.ChainConfig
-	}
-	return ChainConfig{}
-}
-
 func (m *GenesisState) GetParams() Params {
 	if m != nil {
 		return m.Params
@@ -171,33 +162,30 @@ func init() {
 }

 var fileDescriptor_8205a12b97b89a87 = []byte{
-	// 406 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0xb1, 0x8e, 0xda, 0x30,
-	0x18, 0xc7, 0x13, 0x40, 0x04, 0x0c, 0x2a, 0x92, 0x5b, 0xb5, 0x11, 0x55, 0x03, 0x4a, 0xab, 0x36,
-	0x53, 0x22, 0xe8, 0x56, 0x75, 0x69, 0x18, 0xca, 0xd0, 0xa1, 0x0a, 0x9d, 0x7a, 0x03, 0x32, 0xc6,
-	0xe7, 0x44, 0x22, 0x71, 0x14, 0x1b, 0x04, 0x6f, 0x70, 0xe3, 0x3d, 0xc7, 0x3d, 0x09, 0x23, 0x23,
-	0x13, 0x77, 0x82, 0x37, 0xb8, 0x27, 0x38, 0xc5, 0x49, 0xe0, 0x4e, 0xba, 0x6c, 0x8e, 0xf4, 0xfb,
-	0xff, 0xfc, 0xcf, 0xe7, 0x0f, 0x7c, 0x21, 0xc2, 0x27, 0x49, 0x18, 0x44, 0xc2, 0x21, 0xab, 0xd0,
-	0x59, 0x0d, 0xd0, 0x22, 0xf6, 0xd1, 0xc0, 0xa1, 0x24, 0x22, 0x3c, 0xe0, 0x76, 0x9c, 0x30, 0xc1,
-	0xe0, 0xfb, 0x33, 0x65, 0x93, 0x55, 0x68, 0x17, 0x54, 0xf7, 0x1d, 0x65, 0x94, 0x49, 0xc4, 0x49,
-	0x4f, 0x19, 0xdd, 0xed, 0x97, 0x38, 0xd3, 0xa8, 0x24, 0xcc, 0x7d, 0x05, 0xb4, 0x7f, 0x67, 0x37,
-	0x4c, 0x04, 0x12, 0x04, 0x8e, 0x41, 0x03, 0x61, 0xcc, 0x96, 0x91, 0xe0, 0xba, 0xda, 0xaf, 0x5a,
-	0xad, 0xe1, 0x57, 0xfb, 0xf5, 0x3b, 0xed, 0x3c, 0xf7, 0x2b, 0xc3, 0xdd, 0xda, 0xf6, 0xd0, 0x53,
-	0xbc, 0x73, 0x1a, 0x62, 0xd0, 0xc6, 0x3e, 0x0a, 0xa2, 0x29, 0x66, 0xd1, 0x75, 0x40, 0xf5, 0x4a,
-	0x5f, 0xb5, 0x5a, 0xc3, 0xcf, 0x65, 0xb6, 0x51, 0xca, 0x8e, 0x24, 0xea, 0x7e, 0x4c, 0x55, 0x8f,
-	0x87, 0xde, 0xdb, 0x0d, 0x0a, 0x17, 0x3f, 0xcc, 0xe7, 0x1a, 0xd3, 0x6b, 0xe1, 0x0b, 0x09, 0x7f,
-	0x82, 0x7a, 0x8c, 0x12, 0x14, 0x72, 0xbd, 0x2a, 0xf5, 0x46, 0x99, 0xfe, 0xaf, 0xa4, 0xf2, 0x92,
-	0x79, 0x06, 0x5e, 0x81, 0x86, 0x58, 0xf3, 0xe9, 0x82, 0x51, 0xae, 0xd7, 0xe4, 0xcf, 0x7e, 0x2b,
-	0xcb, 0xff, 0x4b, 0x50, 0xc4, 0x11, 0x16, 0x01, 0x8b, 0xfe, 0x30, 0xca, 0xdd, 0x0f, 0x79, 0xc5,
-	0x4e, 0x56, 0xb1, 0xd0, 0x98, 0x9e, 0x26, 0xd6, 0x3c, 0x25, 0xcc, 0x1b, 0x15, 0xbc, 0x79, 0x39,
-	0x22, 0xa8, 0x03, 0x0d, 0xcd, 0xe7, 0x09, 0xe1, 0xe9, 0x6c, 0x55, 0xab, 0xe9, 0x15, 0x9f, 0x10,
-	0x82, 0x1a, 0x66, 0x73, 0x22, 0x87, 0xd4, 0xf4, 0xe4, 0x19, 0x8e, 0x81, 0xc6, 0x05, 0x4b, 0x10,
-	0x25, 0x7a, 0x55, 0x96, 0xfb, 0x54, 0x56, 0x4e, 0x3e, 0x9d, 0xdb, 0x49, 0x2b, 0xdd, 0xdd, 0xf7,
-	0xb4, 0x49, 0x96, 0xf2, 0x8a, 0xb8, 0xeb, 0x6e, 0x8f, 0x86, 0xba, 0x3b, 0x1a, 0xea, 0xc3, 0xd1,
-	0x50, 0x6f, 0x4f, 0x86, 0xb2, 0x3b, 0x19, 0xca, 0xfe, 0x64, 0x28, 0xff, 0x2d, 0x1a, 0x08, 0x7f,
-	0x39, 0xb3, 0x31, 0x0b, 0x1d, 0xe1, 0xa3, 0x84, 0x07, 0xdc, 0xb9, 0x2c, 0xcd, 0x5a, 0xae, 0x8d,
-	0xd8, 0xc4, 0x84, 0xcf, 0xea, 0x72, 0x61, 0xbe, 0x3f, 0x05, 0x00, 0x00, 0xff, 0xff, 0x92, 0xea,
-	0xec, 0x05, 0xa8, 0x02, 0x00, 0x00,
+	// 362 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x91, 0xb1, 0x4e, 0xc2, 0x40,
+	0x18, 0xc7, 0x7b, 0x42, 0x28, 0x1e, 0x46, 0x92, 0x8b, 0xd1, 0x86, 0xc4, 0x42, 0x1a, 0xa3, 0x9d,
+	0xda, 0x80, 0x9b, 0x71, 0xb1, 0x8b, 0x0c, 0x0e, 0xa6, 0x38, 0xe9, 0x60, 0x8e, 0x72, 0x69, 0x9b,
+	0xd0, 0x5e, 0xd3, 0xef, 0x20, 0xf0, 0x06, 0x8e, 0x3e, 0x87, 0x4f, 0xc2, 0xc8, 0xe8, 0x84, 0x06,
+	0xde, 0x40, 0x5f, 0xc0, 0xf4, 0x4a, 0x31, 0x26, 0x76, 0xfb, 0xda, 0xfc, 0x7e, 0xff, 0xef, 0xdf,
+	0x7e, 0xf8, 0x8c, 0x89, 0x80, 0xa5, 0x51, 0x18, 0x0b, 0x9b, 0x4d, 0x23, 0x7b, 0xda, 0xa5, 0xe3,
+	0x24, 0xa0, 0x5d, 0xdb, 0x67, 0x31, 0x83, 0x10, 0xac, 0x24, 0xe5, 0x82, 0x93, 0xe3, 0x1d, 0x65,
+	0xb1, 0x69, 0x64, 0x15, 0x54, 0xeb, 0xc8, 0xe7, 0x3e, 0x97, 0x88, 0x9d, 0x4d, 0x39, 0xdd, 0xea,
+	0x94, 0x64, 0x66, 0xaa, 0x24, 0x8c, 0x6f, 0x84, 0x0f, 0x6e, 0xf3, 0x0d, 0x03, 0x41, 0x05, 0x23,
+	0x7d, 0x5c, 0xa7, 0x9e, 0xc7, 0x27, 0xb1, 0x00, 0x0d, 0x75, 0x2a, 0x66, 0xa3, 0x77, 0x6e, 0xfd,
+	0xbf, 0xd3, 0xda, 0x7a, 0x37, 0x39, 0xee, 0x54, 0x17, 0xab, 0xb6, 0xe2, 0xee, 0x6c, 0x72, 0x8d,
+	0x6b, 0x09, 0x4d, 0x69, 0x04, 0x5a, 0xa5, 0x83, 0xcc, 0x46, 0x4f, 0x2f, 0xcb, 0xb9, 0x97, 0xd4,
+	0xd6, 0xdf, 0x3a, 0xe4, 0x09, 0xd7, 0xc5, 0x0c, 0x9e, 0xc7, 0xdc, 0x07, 0xad, 0x2a, 0x7b, 0x5c,
+	0x94, 0xf9, 0x0f, 0x29, 0x8d, 0x81, 0x7a, 0x22, 0xe4, 0xf1, 0x1d, 0xf7, 0xc1, 0x39, 0xc9, 0x82,
+	0xbe, 0x56, 0xed, 0xe6, 0x9c, 0x46, 0xe3, 0x2b, 0xa3, 0x88, 0x31, 0x5c, 0x55, 0xcc, 0x20, 0x23,
+	0x8c, 0x17, 0x84, 0x0f, 0xff, 0xb6, 0x27, 0x1a, 0x56, 0xe9, 0x68, 0x94, 0x32, 0xc8, 0x3e, 0x1b,
+	0x99, 0xfb, 0x6e, 0xf1, 0x48, 0x08, 0xae, 0x7a, 0x7c, 0xc4, 0xb4, 0x3d, 0xf9, 0x5a, 0xce, 0xa4,
+	0x8f, 0x55, 0x10, 0x3c, 0xa5, 0x3e, 0xd3, 0x2a, 0xb2, 0xdc, 0x69, 0x59, 0x39, 0xf9, 0x57, 0x9d,
+	0x66, 0x56, 0xe9, 0xed, 0xa3, 0xad, 0x0e, 0x72, 0xcb, 0x2d, 0x74, 0xc7, 0x59, 0xac, 0x75, 0xb4,
+	0x5c, 0xeb, 0xe8, 0x73, 0xad, 0xa3, 0xd7, 0x8d, 0xae, 0x2c, 0x37, 0xba, 0xf2, 0xbe, 0xd1, 0x95,
+	0x47, 0xd3, 0x0f, 0x45, 0x30, 0x19, 0x5a, 0x1e, 0x8f, 0x6c, 0x11, 0xd0, 0x14, 0x42, 0xb0, 0x7f,
+	0xef, 0x39, 0x93, 0x17, 0x15, 0xf3, 0x84, 0xc1, 0xb0, 0x26, 0x6f, 0x79, 0xf9, 0x13, 0x00, 0x00,
+	0xff, 0xff, 0x0d, 0x4a, 0x1d, 0x9e, 0x43, 0x02, 0x00, 0x00,
 }

 func (m *GenesisState) Marshal() (dAtA []byte, err error) {
@@ -244,16 +232,6 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	}
 	i--
 	dAtA[i] = 0x1a
-	{
-		size, err := m.ChainConfig.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenesis(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x12
 	if len(m.Accounts) > 0 {
 		for iNdEx := len(m.Accounts) - 1; iNdEx >= 0; iNdEx-- {
 			{
@@ -345,8 +323,6 @@ func (m *GenesisState) Size() (n int) {
 			n += 1 + l + sovGenesis(uint64(l))
 		}
 	}
-	l = m.ChainConfig.Size()
-	n += 1 + l + sovGenesis(uint64(l))
 	l = m.Params.Size()
 	n += 1 + l + sovGenesis(uint64(l))
 	if len(m.TxsLogs) > 0 {
@@ -450,39 +426,6 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ChainConfig", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.ChainConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
@@ -120,8 +120,7 @@ func (suite *GenesisTestSuite) TestValidateGenesis() {
 						},
 					},
 				},
-				ChainConfig: DefaultChainConfig(),
-				Params:      DefaultParams(),
+				Params: DefaultParams(),
 			},
 			expPass: true,
 		},
@@ -235,16 +234,7 @@ func (suite *GenesisTestSuite) TestValidateGenesis() {
 		{
 			name: "invalid params",
 			genState: &GenesisState{
-				ChainConfig: DefaultChainConfig(),
-				Params:      Params{},
-			},
-			expPass: false,
-		},
-		{
-			name: "invalid chain config",
-			genState: &GenesisState{
-				ChainConfig: ChainConfig{},
-				Params:      DefaultParams(),
+				Params: Params{},
 			},
 			expPass: false,
 		},
@@ -23,6 +23,7 @@ var (
 	ParamStoreKeyEnableCreate = []byte("EnableCreate")
 	ParamStoreKeyEnableCall   = []byte("EnableCall")
 	ParamStoreKeyExtraEIPs    = []byte("EnableExtraEIPs")
+	ParamStoreKeyChainConfig  = []byte("ChainConfig")
 )

 // ParamKeyTable returns the parameter key table.
@@ -31,12 +32,13 @@ func ParamKeyTable() paramtypes.KeyTable {
 }

 // NewParams creates a new Params instance
-func NewParams(evmDenom string, enableCreate, enableCall bool, extraEIPs ...int64) Params {
+func NewParams(evmDenom string, enableCreate, enableCall bool, config ChainConfig, extraEIPs ...int64) Params {
 	return Params{
 		EvmDenom:     evmDenom,
 		EnableCreate: enableCreate,
 		EnableCall:   enableCall,
 		ExtraEIPs:    extraEIPs,
+		ChainConfig:  config,
 	}
 }

@@ -47,6 +49,7 @@ func DefaultParams() Params {
 		EnableCreate: true,
 		EnableCall:   true,
 		ExtraEIPs:    []int64{2929, 2200, 1884, 1344},
+		ChainConfig:  DefaultChainConfig(),
 	}
 }

@@ -63,6 +66,7 @@ func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
 		paramtypes.NewParamSetPair(ParamStoreKeyEnableCreate, &p.EnableCreate, validateBool),
 		paramtypes.NewParamSetPair(ParamStoreKeyEnableCall, &p.EnableCall, validateBool),
 		paramtypes.NewParamSetPair(ParamStoreKeyExtraEIPs, &p.ExtraEIPs, validateEIPs),
+		paramtypes.NewParamSetPair(ParamStoreKeyChainConfig, &p.ChainConfig, validateChainConfig),
 	}
 }

@@ -72,7 +76,11 @@ func (p Params) Validate() error {
 		return err
 	}

-	return validateEIPs(p.ExtraEIPs)
+	if err := validateEIPs(p.ExtraEIPs); err != nil {
+		return err
+	}
+
+	return p.ChainConfig.Validate()
 }

 // EIPs returns the ExtraEips as a int slice
@@ -115,3 +123,12 @@ func validateEIPs(i interface{}) error {

 	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()
+}
@@ -15,7 +15,7 @@ func TestParamsValidate(t *testing.T) {
 		{"default", DefaultParams(), false},
 		{
 			"valid",
-			NewParams("ara", true, true, 2929, 1884, 1344),
+			NewParams("ara", true, true, DefaultChainConfig(), 2929, 1884, 1344),
 			false,
 		},
 		{
@@ -38,6 +38,11 @@ func TestParamsValidate(t *testing.T) {
 			},
 			true,
 		},
+		{
+			"invalid chain config",
+			NewParams("ara", true, true, ChainConfig{}, 2929, 1884, 1344),
+			false,
+		},
 	}

 	for _, tc := range testCases {
@@ -947,89 +947,6 @@ func (m *QueryParamsResponse) GetParams() Params {
 	return Params{}
 }

-// QueryChainConfigRequest defines the request type for querying x/evm chain configuration.
-type QueryChainConfigRequest struct {
-}
-
-func (m *QueryChainConfigRequest) Reset()         { *m = QueryChainConfigRequest{} }
-func (m *QueryChainConfigRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryChainConfigRequest) ProtoMessage()    {}
-func (*QueryChainConfigRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{20}
-}
-func (m *QueryChainConfigRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryChainConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryChainConfigRequest.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 *QueryChainConfigRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryChainConfigRequest.Merge(m, src)
-}
-func (m *QueryChainConfigRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryChainConfigRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryChainConfigRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryChainConfigRequest proto.InternalMessageInfo
-
-// QueryChainConfigResponse defines the response type for querying x/evm chain configuration.
-type QueryChainConfigResponse struct {
-	// ChainConfig define the evm chain configuration.
-	Config ChainConfig `protobuf:"bytes,1,opt,name=config,proto3" json:"config"`
-}
-
-func (m *QueryChainConfigResponse) Reset()         { *m = QueryChainConfigResponse{} }
-func (m *QueryChainConfigResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryChainConfigResponse) ProtoMessage()    {}
-func (*QueryChainConfigResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{21}
-}
-func (m *QueryChainConfigResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryChainConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryChainConfigResponse.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 *QueryChainConfigResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryChainConfigResponse.Merge(m, src)
-}
-func (m *QueryChainConfigResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryChainConfigResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryChainConfigResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryChainConfigResponse proto.InternalMessageInfo
-
-func (m *QueryChainConfigResponse) GetConfig() ChainConfig {
-	if m != nil {
-		return m.Config
-	}
-	return ChainConfig{}
-}
-
 // QueryStaticCallRequest defines static call request
 type QueryStaticCallRequest struct {
 	// address is the ethereum contract hex address to for static call.
@@ -1042,7 +959,7 @@ func (m *QueryStaticCallRequest) Reset()         { *m = QueryStaticCallRequest{}
 func (m *QueryStaticCallRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryStaticCallRequest) ProtoMessage()    {}
 func (*QueryStaticCallRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{22}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{20}
 }
 func (m *QueryStaticCallRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1094,7 +1011,7 @@ func (m *QueryStaticCallResponse) Reset()         { *m = QueryStaticCallResponse
 func (m *QueryStaticCallResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryStaticCallResponse) ProtoMessage()    {}
 func (*QueryStaticCallResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{23}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{21}
 }
 func (m *QueryStaticCallResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1140,7 +1057,7 @@ func (m *EthCallRequest) Reset()         { *m = EthCallRequest{} }
 func (m *EthCallRequest) String() string { return proto.CompactTextString(m) }
 func (*EthCallRequest) ProtoMessage()    {}
 func (*EthCallRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{24}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{22}
 }
 func (m *EthCallRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1197,8 +1114,6 @@ func init() {
 	proto.RegisterType((*QueryBlockBloomResponse)(nil), "ethermint.evm.v1alpha1.QueryBlockBloomResponse")
 	proto.RegisterType((*QueryParamsRequest)(nil), "ethermint.evm.v1alpha1.QueryParamsRequest")
 	proto.RegisterType((*QueryParamsResponse)(nil), "ethermint.evm.v1alpha1.QueryParamsResponse")
-	proto.RegisterType((*QueryChainConfigRequest)(nil), "ethermint.evm.v1alpha1.QueryChainConfigRequest")
-	proto.RegisterType((*QueryChainConfigResponse)(nil), "ethermint.evm.v1alpha1.QueryChainConfigResponse")
 	proto.RegisterType((*QueryStaticCallRequest)(nil), "ethermint.evm.v1alpha1.QueryStaticCallRequest")
 	proto.RegisterType((*QueryStaticCallResponse)(nil), "ethermint.evm.v1alpha1.QueryStaticCallResponse")
 	proto.RegisterType((*EthCallRequest)(nil), "ethermint.evm.v1alpha1.EthCallRequest")
@@ -1209,85 +1124,81 @@ func init() {
 }

 var fileDescriptor_8bbc79ec2b6c5cb2 = []byte{
-	// 1247 bytes of a gzipped FileDescriptorProto
+	// 1179 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x97, 0x4d, 0x6f, 0x1b, 0x45,
-	0x18, 0xc7, 0xbd, 0xad, 0x63, 0x27, 0x4f, 0x92, 0x12, 0x06, 0x53, 0xd2, 0x6d, 0x71, 0xc2, 0xb4,
-	0x4d, 0x9c, 0x97, 0xee, 0xc6, 0xe6, 0xad, 0x54, 0x48, 0x90, 0x44, 0x0d, 0x95, 0x5a, 0x50, 0x71,
-	0x22, 0x0e, 0x48, 0xc8, 0x1a, 0xaf, 0x97, 0xb5, 0x15, 0x7b, 0xc7, 0xdd, 0x59, 0x5b, 0x89, 0xa2,
-	0x5c, 0x38, 0x20, 0x28, 0x1c, 0x40, 0x1c, 0x40, 0x48, 0xa0, 0x5e, 0xb9, 0xf1, 0x15, 0xb8, 0xf5,
-	0x58, 0x89, 0x0b, 0x27, 0x84, 0x12, 0x0e, 0x7c, 0x0c, 0x34, 0x2f, 0x6b, 0xef, 0xda, 0x59, 0xaf,
-	0x83, 0xb8, 0xed, 0xcc, 0x3c, 0x2f, 0xbf, 0x67, 0x9e, 0x99, 0xf9, 0xdb, 0x80, 0x6d, 0xbf, 0x6e,
-	0x7b, 0xad, 0x86, 0xeb, 0x9b, 0x76, 0xb7, 0x65, 0x76, 0x8b, 0xa4, 0xd9, 0xae, 0x93, 0xa2, 0xf9,
-	0xa8, 0x63, 0x7b, 0x87, 0x46, 0xdb, 0xa3, 0x3e, 0x45, 0x97, 0x7b, 0x36, 0x86, 0xdd, 0x6d, 0x19,
-	0x81, 0x8d, 0x9e, 0x73, 0xa8, 0x43, 0x85, 0x89, 0xc9, 0xbf, 0xa4, 0xb5, 0xbe, 0x6a, 0x51, 0xd6,
-	0xa2, 0xcc, 0xac, 0x12, 0x66, 0xcb, 0x30, 0x66, 0xb7, 0x58, 0xb5, 0x7d, 0x52, 0x34, 0xdb, 0xc4,
-	0x69, 0xb8, 0xc4, 0x6f, 0x50, 0x57, 0xd9, 0x5e, 0x73, 0x28, 0x75, 0x9a, 0xb6, 0x49, 0xda, 0x0d,
-	0x93, 0xb8, 0x2e, 0xf5, 0xc5, 0x22, 0x53, 0xab, 0x8b, 0x31, 0x6c, 0x1c, 0x42, 0x5a, 0x2c, 0xc4,
-	0x58, 0xf8, 0x07, 0xd2, 0x00, 0xbf, 0x05, 0x2f, 0x7c, 0xc8, 0x11, 0x36, 0x2d, 0x8b, 0x76, 0x5c,
-	0xbf, 0x6c, 0x3f, 0xea, 0xd8, 0xcc, 0x47, 0xf3, 0x90, 0x25, 0xb5, 0x9a, 0x67, 0x33, 0x36, 0xaf,
-	0x2d, 0x6a, 0x85, 0xa9, 0x72, 0x30, 0xbc, 0x33, 0xf9, 0xc5, 0x93, 0x85, 0xd4, 0x3f, 0x4f, 0x16,
-	0x52, 0xd8, 0x82, 0x5c, 0xd4, 0x95, 0xb5, 0xa9, 0xcb, 0x6c, 0xee, 0x5b, 0x25, 0x4d, 0xe2, 0x5a,
-	0x76, 0xe0, 0xab, 0x86, 0xe8, 0x2a, 0x4c, 0x59, 0xb4, 0x66, 0x57, 0xea, 0x84, 0xd5, 0xe7, 0x2f,
-	0x88, 0xb5, 0x49, 0x3e, 0x71, 0x8f, 0xb0, 0x3a, 0xca, 0xc1, 0x84, 0x4b, 0xb9, 0xd3, 0xc5, 0x45,
-	0xad, 0x90, 0x2e, 0xcb, 0x01, 0x7e, 0x07, 0xae, 0x88, 0x24, 0xdb, 0x62, 0xcf, 0xfe, 0x03, 0xe5,
-	0xe7, 0x1a, 0xe8, 0x67, 0x45, 0x50, 0xb0, 0x37, 0xe1, 0x92, 0x6c, 0x47, 0x25, 0x1a, 0x69, 0x56,
-	0xce, 0x6e, 0xca, 0x49, 0xa4, 0xc3, 0x24, 0xe3, 0x49, 0x39, 0xdf, 0x05, 0xc1, 0xd7, 0x1b, 0xf3,
-	0x10, 0x44, 0x46, 0xad, 0xb8, 0x9d, 0x56, 0xd5, 0xf6, 0x54, 0x05, 0xb3, 0x6a, 0xf6, 0x03, 0x31,
-	0x89, 0xef, 0xc3, 0x35, 0xc1, 0xf1, 0x11, 0x69, 0x36, 0x6a, 0xc4, 0xa7, 0xde, 0x40, 0x31, 0xaf,
-	0xc0, 0x8c, 0x45, 0xdd, 0x41, 0x8e, 0x69, 0x3e, 0xb7, 0x39, 0x54, 0xd5, 0x57, 0x1a, 0xbc, 0x1c,
-	0x13, 0x4d, 0x15, 0xb6, 0x0c, 0xcf, 0x05, 0x54, 0xd1, 0x88, 0x01, 0xec, 0xff, 0x58, 0x5a, 0x70,
-	0x88, 0xb6, 0x64, 0x9f, 0xcf, 0xd3, 0x9e, 0x0d, 0x75, 0x88, 0x7a, 0xae, 0x49, 0x87, 0x08, 0xdf,
-	0x57, 0xc9, 0x76, 0x7d, 0xea, 0x11, 0x27, 0x39, 0x19, 0x9a, 0x83, 0x8b, 0xfb, 0xf6, 0xa1, 0x3a,
-	0x6f, 0xfc, 0x33, 0x94, 0x7e, 0x5d, 0xa5, 0xef, 0x05, 0x53, 0xe9, 0x73, 0x30, 0xd1, 0x25, 0xcd,
-	0x4e, 0x90, 0x5c, 0x0e, 0xf0, 0x1b, 0x30, 0xa7, 0x8e, 0x52, 0xed, 0x5c, 0x45, 0x2e, 0xc3, 0xf3,
-	0x21, 0x3f, 0x95, 0x02, 0x41, 0x9a, 0x9f, 0x7d, 0xe1, 0x35, 0x53, 0x16, 0xdf, 0xb8, 0x04, 0x48,
-	0x18, 0xee, 0x1d, 0x3c, 0xa0, 0x0e, 0x0b, 0x52, 0x20, 0x48, 0x8b, 0x1b, 0x23, 0xe3, 0x8b, 0xef,
-	0x50, 0xf0, 0x1d, 0xb5, 0x1f, 0x81, 0x8f, 0x0a, 0x6f, 0x42, 0xba, 0x49, 0x1d, 0x0e, 0x75, 0xb1,
-	0x30, 0x5d, 0xba, 0x6a, 0x9c, 0xfd, 0x44, 0x19, 0x0f, 0xa8, 0x53, 0x16, 0x86, 0xf8, 0x18, 0x5e,
-	0x94, 0x9d, 0x68, 0x52, 0x6b, 0x3f, 0x21, 0x3d, 0xda, 0x01, 0xe8, 0xbf, 0x55, 0x62, 0x6b, 0xa7,
-	0x4b, 0x4b, 0x86, 0xbc, 0x33, 0x06, 0x7f, 0xd8, 0x0c, 0xf9, 0x3e, 0xaa, 0x87, 0xcd, 0x78, 0xd8,
-	0xef, 0x54, 0x39, 0xe4, 0x19, 0x2a, 0xe3, 0x17, 0x0d, 0x2e, 0x0f, 0xe6, 0x57, 0xa5, 0xec, 0x40,
-	0xd6, 0x3f, 0xa8, 0x84, 0xaa, 0x59, 0x8e, 0xab, 0x66, 0xcf, 0x23, 0x2e, 0x23, 0x16, 0x0f, 0xcd,
-	0x23, 0x6c, 0xa5, 0x9f, 0xfe, 0xb9, 0x90, 0x2a, 0x67, 0x7c, 0xb1, 0x35, 0xe8, 0xbd, 0x33, 0xa0,
-	0x97, 0x13, 0xa1, 0x25, 0x44, 0x98, 0x1a, 0xcf, 0x87, 0x51, 0xb7, 0x9a, 0x94, 0xb6, 0x54, 0x6d,
-	0xd8, 0x84, 0x97, 0x86, 0x56, 0xfa, 0x47, 0xaa, 0xca, 0x27, 0x54, 0xc3, 0xe5, 0x00, 0xe7, 0x54,
-	0xc7, 0x1f, 0x12, 0x8f, 0xb4, 0x82, 0x2d, 0xc7, 0xbb, 0xaa, 0xa7, 0xc1, 0xac, 0x0a, 0xf1, 0x36,
-	0x64, 0xda, 0x62, 0x46, 0xc4, 0x98, 0x2e, 0xe5, 0xe3, 0xf6, 0x41, 0xfa, 0x05, 0xe5, 0x4b, 0x1f,
-	0x7c, 0x45, 0xb1, 0x6d, 0xd7, 0x49, 0xc3, 0xdd, 0xa6, 0xee, 0xa7, 0x0d, 0x27, 0xc8, 0xf7, 0x09,
-	0xcc, 0x0f, 0x2f, 0xa9, 0xa4, 0x9b, 0x90, 0xb1, 0xc4, 0x8c, 0x4a, 0x7a, 0x3d, 0x2e, 0x69, 0xc8,
-	0x39, 0xc8, 0x2c, 0x1d, 0xf1, 0x3d, 0xb5, 0x5f, 0xbb, 0x5c, 0xbe, 0xac, 0x6d, 0xd2, 0x6c, 0x26,
-	0xdf, 0xda, 0x1c, 0x4c, 0x34, 0xdc, 0x76, 0xc7, 0x17, 0x7d, 0x9a, 0x29, 0xcb, 0x01, 0xbe, 0xa5,
-	0x6a, 0x08, 0x47, 0xea, 0xdf, 0xa7, 0x1a, 0xf1, 0x49, 0x70, 0x9f, 0xf8, 0x37, 0xbe, 0x01, 0x97,
-	0xee, 0xfa, 0xf5, 0x70, 0x42, 0x04, 0x69, 0xe2, 0x39, 0x2c, 0xb0, 0xe2, 0xdf, 0xa5, 0xc7, 0x73,
-	0x30, 0x21, 0xa2, 0xa2, 0xef, 0x35, 0xc8, 0xaa, 0x87, 0x14, 0xad, 0xc5, 0xd5, 0x79, 0x86, 0x5e,
-	0xea, 0xeb, 0xe3, 0x19, 0x4b, 0x54, 0x5c, 0xfc, 0xec, 0xf7, 0xbf, 0xbf, 0xbb, 0xb0, 0x86, 0x56,
-	0xcc, 0x18, 0x79, 0x56, 0xcf, 0xab, 0x79, 0xa4, 0x76, 0xe3, 0x18, 0xfd, 0xaa, 0xc1, 0x6c, 0x44,
-	0xc1, 0x50, 0x71, 0x64, 0xca, 0xb3, 0xf4, 0x52, 0x2f, 0x9d, 0xc7, 0x45, 0xb1, 0xde, 0x16, 0xac,
-	0x25, 0xb4, 0x11, 0xc7, 0x1a, 0xc8, 0xe7, 0x10, 0xf2, 0x6f, 0x1a, 0xcc, 0x0d, 0xca, 0x13, 0x7a,
-	0x6d, 0x24, 0x42, 0x8c, 0x36, 0xea, 0xaf, 0x9f, 0xd3, 0x4b, 0xb1, 0xbf, 0x2b, 0xd8, 0xef, 0xa0,
-	0xdb, 0x71, 0xec, 0xdd, 0xc0, 0xb3, 0x8f, 0x1f, 0xd6, 0xe0, 0x63, 0xf4, 0x83, 0x06, 0x59, 0x25,
-	0x4d, 0x09, 0x07, 0x22, 0xaa, 0x7d, 0x09, 0x07, 0x62, 0x40, 0xed, 0x70, 0x49, 0x80, 0xae, 0xa3,
-	0xd5, 0x38, 0x50, 0x25, 0x7e, 0x2c, 0xb4, 0xbd, 0x3f, 0x69, 0x90, 0x55, 0xb2, 0x95, 0x80, 0x16,
-	0x55, 0xca, 0x04, 0xb4, 0x01, 0x25, 0xc4, 0x6f, 0x0a, 0xb4, 0x22, 0x32, 0xe3, 0xd0, 0x98, 0x74,
-	0xe8, 0x93, 0x99, 0x47, 0xfb, 0xf6, 0xe1, 0x31, 0xfa, 0x5a, 0x83, 0x34, 0x17, 0x3c, 0x54, 0x48,
-	0x38, 0x75, 0x3d, 0x2d, 0xd5, 0x57, 0xc6, 0xb0, 0x54, 0x58, 0xa6, 0xc0, 0x5a, 0x41, 0xcb, 0xf1,
-	0xc7, 0xb2, 0x16, 0xd9, 0xae, 0x6f, 0x35, 0xc8, 0x48, 0x89, 0x44, 0xab, 0x23, 0xd3, 0x44, 0xb4,
-	0x57, 0x5f, 0x1b, 0xcb, 0x56, 0x41, 0x19, 0x02, 0xaa, 0x80, 0x96, 0xcc, 0xd8, 0x9f, 0xdd, 0x42,
-	0xc6, 0xcc, 0x23, 0x2e, 0xa2, 0xa2, 0x85, 0x53, 0x3d, 0xb9, 0x43, 0xb7, 0x46, 0x1f, 0x99, 0x01,
-	0x59, 0xd6, 0x8d, 0x71, 0xcd, 0xc7, 0x7d, 0x74, 0xaa, 0xdc, 0x25, 0xc2, 0xf7, 0xa3, 0x06, 0xd0,
-	0x57, 0x32, 0x34, 0x46, 0xc6, 0xb0, 0x18, 0xea, 0xe6, 0xd8, 0xf6, 0x0a, 0x71, 0x4d, 0x20, 0xde,
-	0x44, 0xd7, 0x47, 0x23, 0x0a, 0xe5, 0x44, 0x5f, 0x6a, 0x90, 0x91, 0x3a, 0x97, 0xd0, 0xd0, 0x88,
-	0xb4, 0x26, 0x34, 0x34, 0x2a, 0xb8, 0x78, 0x49, 0x00, 0x2d, 0xa2, 0x7c, 0x1c, 0x90, 0x94, 0x56,
-	0xf4, 0xb3, 0x06, 0xd3, 0x21, 0xf9, 0x43, 0xa3, 0x2b, 0x1f, 0x16, 0x60, 0x7d, 0x63, 0x7c, 0x07,
-	0x85, 0xb6, 0x2e, 0xd0, 0x96, 0xd0, 0x8d, 0xd8, 0x0b, 0xc0, 0x9d, 0x2a, 0x52, 0x81, 0x45, 0x27,
-	0xfb, 0x9a, 0x99, 0xd0, 0xc9, 0x21, 0x99, 0x4e, 0xe8, 0xe4, 0xb0, 0x18, 0x27, 0x77, 0x92, 0x09,
-	0x9f, 0x8a, 0xc5, 0x69, 0x1e, 0x6b, 0x90, 0x55, 0x32, 0x8d, 0x96, 0xe2, 0x32, 0x45, 0x75, 0x5c,
-	0x8f, 0xbd, 0x2c, 0xef, 0x33, 0xe7, 0x2e, 0x5f, 0xb1, 0x3b, 0xad, 0xbd, 0x83, 0x1e, 0x4f, 0x41,
-	0xf0, 0x60, 0xb4, 0x18, 0xc7, 0x63, 0xfb, 0x75, 0x01, 0xb3, 0xb5, 0xf5, 0xf4, 0x24, 0xaf, 0x3d,
-	0x3b, 0xc9, 0x6b, 0x7f, 0x9d, 0xe4, 0xb5, 0x6f, 0x4e, 0xf3, 0xa9, 0x67, 0xa7, 0xf9, 0xd4, 0x1f,
-	0xa7, 0xf9, 0xd4, 0xc7, 0x05, 0xa7, 0xe1, 0xd7, 0x3b, 0x55, 0xc3, 0xa2, 0x2d, 0xd3, 0xaf, 0x13,
-	0x8f, 0x35, 0x58, 0x28, 0xda, 0x81, 0x88, 0xe7, 0x1f, 0xb6, 0x6d, 0x56, 0xcd, 0x88, 0xff, 0xd6,
-	0xaf, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x31, 0x90, 0x2b, 0x28, 0x3c, 0x10, 0x00, 0x00,
+	0x18, 0xc7, 0xbd, 0x89, 0x13, 0x27, 0x4f, 0x5e, 0x08, 0x83, 0x29, 0x61, 0x5b, 0x9c, 0x30, 0xd0,
+	0xc4, 0x79, 0xe9, 0x6e, 0x6d, 0xde, 0x4a, 0x85, 0x04, 0x49, 0xd5, 0x50, 0xa9, 0x05, 0x15, 0x27,
+	0xe2, 0xc0, 0x25, 0x1a, 0xaf, 0x57, 0x6b, 0x2b, 0xf6, 0x8e, 0xbb, 0x33, 0xb6, 0x12, 0x45, 0xb9,
+	0x70, 0x40, 0xbc, 0x1d, 0x40, 0x1c, 0x40, 0x48, 0x48, 0xbd, 0x72, 0xe3, 0x2b, 0x70, 0xeb, 0xb1,
+	0x12, 0x17, 0x4e, 0x08, 0x25, 0x1c, 0xe0, 0x5b, 0xa0, 0x79, 0x59, 0x7b, 0xd7, 0xc9, 0x7a, 0x1d,
+	0xc4, 0x6d, 0x66, 0xf6, 0x79, 0xf9, 0x3d, 0xcf, 0x3c, 0x9e, 0x7f, 0x02, 0xd8, 0xe5, 0x75, 0x37,
+	0x68, 0x35, 0x7c, 0x6e, 0xbb, 0xdd, 0x96, 0xdd, 0x2d, 0x91, 0x66, 0xbb, 0x4e, 0x4a, 0xf6, 0xa3,
+	0x8e, 0x1b, 0x1c, 0x59, 0xed, 0x80, 0x72, 0x8a, 0xae, 0xf4, 0x6c, 0x2c, 0xb7, 0xdb, 0xb2, 0x42,
+	0x1b, 0x33, 0xef, 0x51, 0x8f, 0x4a, 0x13, 0x5b, 0xac, 0x94, 0xb5, 0xb9, 0xee, 0x50, 0xd6, 0xa2,
+	0xcc, 0xae, 0x12, 0xe6, 0xaa, 0x30, 0x76, 0xb7, 0x54, 0x75, 0x39, 0x29, 0xd9, 0x6d, 0xe2, 0x35,
+	0x7c, 0xc2, 0x1b, 0xd4, 0xd7, 0xb6, 0xd7, 0x3c, 0x4a, 0xbd, 0xa6, 0x6b, 0x93, 0x76, 0xc3, 0x26,
+	0xbe, 0x4f, 0xb9, 0xfc, 0xc8, 0xf4, 0xd7, 0xe5, 0x04, 0x36, 0x01, 0xa1, 0x2c, 0x96, 0x12, 0x2c,
+	0xf8, 0xa1, 0x32, 0xc0, 0x6f, 0xc3, 0x73, 0x1f, 0x09, 0x84, 0x2d, 0xc7, 0xa1, 0x1d, 0x9f, 0x57,
+	0xdc, 0x47, 0x1d, 0x97, 0x71, 0xb4, 0x08, 0x39, 0x52, 0xab, 0x05, 0x2e, 0x63, 0x8b, 0xc6, 0xb2,
+	0x51, 0x9c, 0xae, 0x84, 0xdb, 0xdb, 0x53, 0x9f, 0x3f, 0x5e, 0xca, 0xfc, 0xfd, 0x78, 0x29, 0x83,
+	0x1d, 0xc8, 0xc7, 0x5d, 0x59, 0x9b, 0xfa, 0xcc, 0x15, 0xbe, 0x55, 0xd2, 0x24, 0xbe, 0xe3, 0x86,
+	0xbe, 0x7a, 0x8b, 0xae, 0xc2, 0xb4, 0x43, 0x6b, 0xee, 0x7e, 0x9d, 0xb0, 0xfa, 0xe2, 0x98, 0xfc,
+	0x36, 0x25, 0x0e, 0xee, 0x11, 0x56, 0x47, 0x79, 0x98, 0xf0, 0xa9, 0x70, 0x1a, 0x5f, 0x36, 0x8a,
+	0xd9, 0x8a, 0xda, 0xe0, 0x77, 0xe1, 0x45, 0x99, 0xe4, 0x8e, 0xec, 0xd9, 0x7f, 0xa0, 0xfc, 0xcc,
+	0x00, 0xf3, 0xa2, 0x08, 0x1a, 0xf6, 0x3a, 0xcc, 0xab, 0xeb, 0xd8, 0x8f, 0x47, 0x9a, 0x53, 0xa7,
+	0x5b, 0xea, 0x10, 0x99, 0x30, 0xc5, 0x44, 0x52, 0xc1, 0x37, 0x26, 0xf9, 0x7a, 0x7b, 0x11, 0x82,
+	0xa8, 0xa8, 0xfb, 0x7e, 0xa7, 0x55, 0x75, 0x03, 0x5d, 0xc1, 0x9c, 0x3e, 0xfd, 0x50, 0x1e, 0xe2,
+	0xfb, 0x70, 0x4d, 0x72, 0x7c, 0x4c, 0x9a, 0x8d, 0x1a, 0xe1, 0x34, 0x18, 0x28, 0xe6, 0x65, 0x98,
+	0x75, 0xa8, 0x3f, 0xc8, 0x31, 0x23, 0xce, 0xb6, 0xce, 0x55, 0xf5, 0x95, 0x01, 0x2f, 0x25, 0x44,
+	0xd3, 0x85, 0xad, 0xc2, 0x33, 0x21, 0x55, 0x3c, 0x62, 0x08, 0xfb, 0x3f, 0x96, 0x16, 0x0e, 0xd1,
+	0xb6, 0xba, 0xe7, 0xcb, 0x5c, 0xcf, 0x4d, 0x3d, 0x44, 0x3d, 0xd7, 0xb4, 0x21, 0xc2, 0xf7, 0x75,
+	0xb2, 0x5d, 0x4e, 0x03, 0xe2, 0xa5, 0x27, 0x43, 0x0b, 0x30, 0x7e, 0xe0, 0x1e, 0xe9, 0x79, 0x13,
+	0xcb, 0x48, 0xfa, 0x4d, 0x9d, 0xbe, 0x17, 0x4c, 0xa7, 0xcf, 0xc3, 0x44, 0x97, 0x34, 0x3b, 0x61,
+	0x72, 0xb5, 0xc1, 0x6f, 0xc2, 0x82, 0x1e, 0xa5, 0xda, 0xa5, 0x8a, 0x5c, 0x85, 0x67, 0x23, 0x7e,
+	0x3a, 0x05, 0x82, 0xac, 0x98, 0x7d, 0xe9, 0x35, 0x5b, 0x91, 0x6b, 0x5c, 0x06, 0x24, 0x0d, 0xf7,
+	0x0e, 0x1f, 0x50, 0x8f, 0x85, 0x29, 0x10, 0x64, 0xe5, 0x2f, 0x46, 0xc5, 0x97, 0xeb, 0x48, 0xf0,
+	0x1d, 0xdd, 0x8f, 0xd0, 0x47, 0x87, 0xb7, 0x21, 0xdb, 0xa4, 0x9e, 0x80, 0x1a, 0x2f, 0xce, 0x94,
+	0xaf, 0x5a, 0x17, 0x3f, 0x51, 0xd6, 0x03, 0xea, 0x55, 0xa4, 0x21, 0x3e, 0x81, 0xe7, 0xd5, 0x4d,
+	0x34, 0xa9, 0x73, 0x90, 0x92, 0x1e, 0xed, 0x00, 0xf4, 0xdf, 0x2a, 0xd9, 0xda, 0x99, 0xf2, 0x8a,
+	0xa5, 0x7e, 0x33, 0x96, 0x78, 0xd8, 0x2c, 0xf5, 0x3e, 0xea, 0x87, 0xcd, 0x7a, 0xd8, 0xbf, 0xa9,
+	0x4a, 0xc4, 0x33, 0x52, 0xc6, 0xcf, 0x06, 0x5c, 0x19, 0xcc, 0xaf, 0x4b, 0xd9, 0x81, 0x1c, 0x3f,
+	0xdc, 0x8f, 0x54, 0xb3, 0x9a, 0x54, 0xcd, 0x5e, 0x40, 0x7c, 0x46, 0x1c, 0x11, 0x5a, 0x44, 0xd8,
+	0xce, 0x3e, 0xf9, 0x63, 0x29, 0x53, 0x99, 0xe4, 0xb2, 0x35, 0xe8, 0xfd, 0x0b, 0xa0, 0x57, 0x53,
+	0xa1, 0x15, 0x44, 0x94, 0x1a, 0x2f, 0x46, 0x51, 0xb7, 0x9b, 0x94, 0xb6, 0x74, 0x6d, 0xd8, 0x86,
+	0x17, 0xce, 0x7d, 0xe9, 0x8f, 0x54, 0x55, 0x1c, 0xe8, 0x0b, 0x57, 0x1b, 0x9c, 0xd7, 0x37, 0xfe,
+	0x90, 0x04, 0xa4, 0x15, 0xb6, 0x1c, 0xef, 0xea, 0x3b, 0x0d, 0x4f, 0x75, 0x88, 0x77, 0x60, 0xb2,
+	0x2d, 0x4f, 0x64, 0x8c, 0x99, 0x72, 0x21, 0xa9, 0x0f, 0xca, 0x2f, 0x2c, 0x5f, 0xf9, 0xe0, 0x7b,
+	0x9a, 0x7a, 0x57, 0x88, 0x88, 0x73, 0x87, 0x34, 0x9b, 0xe9, 0xbf, 0x9d, 0x3c, 0x4c, 0x34, 0xfc,
+	0x76, 0x87, 0xcb, 0x6e, 0xcd, 0x56, 0xd4, 0x06, 0xdf, 0xd0, 0x55, 0x46, 0x23, 0xf5, 0xa7, 0xba,
+	0x46, 0x38, 0x09, 0xa7, 0x5a, 0xac, 0xf1, 0xab, 0x30, 0x7f, 0x97, 0xd7, 0xa3, 0x09, 0x11, 0x64,
+	0x49, 0xe0, 0xb1, 0xd0, 0x4a, 0xac, 0xcb, 0xff, 0xcc, 0xc3, 0x84, 0x8c, 0x8a, 0xbe, 0x37, 0x20,
+	0xa7, 0x9f, 0x33, 0xb4, 0x91, 0x54, 0xe2, 0x05, 0xaa, 0x65, 0x6e, 0x8e, 0x66, 0xac, 0x50, 0x71,
+	0xe9, 0xd3, 0xdf, 0xfe, 0xfa, 0x6e, 0x6c, 0x03, 0xad, 0xd9, 0x09, 0x22, 0xa9, 0x1f, 0x39, 0xfb,
+	0x58, 0x77, 0xe3, 0x04, 0xfd, 0x62, 0xc0, 0x5c, 0x4c, 0x47, 0x50, 0x69, 0x68, 0xca, 0x8b, 0x54,
+	0xcb, 0x2c, 0x5f, 0xc6, 0x45, 0xb3, 0xde, 0x92, 0xac, 0x65, 0x74, 0x33, 0x89, 0x35, 0x14, 0xb1,
+	0x73, 0xc8, 0xbf, 0x1a, 0xb0, 0x30, 0x28, 0x12, 0xe8, 0xf5, 0xa1, 0x08, 0x09, 0x0a, 0x65, 0xbe,
+	0x71, 0x49, 0x2f, 0xcd, 0xfe, 0x9e, 0x64, 0xbf, 0x8d, 0x6e, 0x25, 0xb1, 0x77, 0x43, 0xcf, 0x3e,
+	0x7e, 0x54, 0x09, 0x4f, 0xd0, 0x0f, 0x06, 0xe4, 0xb4, 0x40, 0xa4, 0x0c, 0x44, 0x5c, 0x81, 0x52,
+	0x06, 0x62, 0x40, 0x73, 0x70, 0x59, 0x82, 0x6e, 0xa2, 0xf5, 0x24, 0x50, 0x2d, 0x41, 0x2c, 0xd2,
+	0xde, 0x9f, 0x0c, 0xc8, 0x69, 0xf1, 0x48, 0x41, 0x8b, 0xeb, 0x55, 0x0a, 0xda, 0x80, 0x1e, 0xe1,
+	0xb7, 0x24, 0x5a, 0x09, 0xd9, 0x49, 0x68, 0x4c, 0x39, 0xf4, 0xc9, 0xec, 0xe3, 0x03, 0xf7, 0xe8,
+	0x04, 0x7d, 0x6d, 0x40, 0x56, 0xc8, 0x0e, 0x2a, 0xa6, 0x4c, 0x5d, 0x4f, 0xd1, 0xcc, 0xb5, 0x11,
+	0x2c, 0x35, 0x96, 0x2d, 0xb1, 0xd6, 0xd0, 0x6a, 0xf2, 0x58, 0xd6, 0x62, 0xed, 0xfa, 0xd6, 0x80,
+	0x49, 0x25, 0x54, 0x68, 0x7d, 0x68, 0x9a, 0x98, 0x02, 0x9a, 0x1b, 0x23, 0xd9, 0x6a, 0x28, 0x4b,
+	0x42, 0x15, 0xd1, 0x8a, 0x9d, 0xf8, 0xc7, 0xaf, 0x14, 0x13, 0xfb, 0x58, 0x48, 0x99, 0xbc, 0xc2,
+	0xe9, 0x9e, 0xe8, 0xa0, 0x1b, 0xc3, 0x47, 0x66, 0x40, 0x1c, 0x4d, 0x6b, 0x54, 0xf3, 0x51, 0x1f,
+	0x9d, 0xaa, 0x70, 0x89, 0xf1, 0xfd, 0x68, 0x00, 0xf4, 0xf5, 0x04, 0x8d, 0x90, 0x31, 0x2a, 0x49,
+	0xa6, 0x3d, 0xb2, 0xbd, 0x46, 0xdc, 0x90, 0x88, 0xd7, 0xd1, 0x2b, 0xc3, 0x11, 0xa5, 0x7e, 0xa1,
+	0x2f, 0x0c, 0x98, 0x54, 0x6a, 0x93, 0x72, 0xa1, 0x31, 0x81, 0x4b, 0xb9, 0xd0, 0xb8, 0xec, 0xe1,
+	0x15, 0x09, 0xb4, 0x8c, 0x0a, 0x49, 0x40, 0x4a, 0xe0, 0x64, 0xa3, 0xfa, 0x92, 0x94, 0xd2, 0xa8,
+	0x73, 0x2a, 0x98, 0xd2, 0xa8, 0xf3, 0x5a, 0x97, 0xde, 0x28, 0x26, 0x7d, 0xf6, 0x1d, 0x41, 0xf3,
+	0xa5, 0x01, 0x39, 0xad, 0x82, 0x68, 0x25, 0x29, 0x53, 0x5c, 0x26, 0xcd, 0xc4, 0x59, 0xfc, 0x80,
+	0x79, 0x77, 0xc5, 0x17, 0xb7, 0xd3, 0xda, 0x3b, 0xec, 0xf1, 0x14, 0x25, 0x0f, 0x46, 0xcb, 0x49,
+	0x3c, 0x2e, 0xaf, 0x4b, 0x98, 0xed, 0xed, 0x27, 0xa7, 0x05, 0xe3, 0xe9, 0x69, 0xc1, 0xf8, 0xf3,
+	0xb4, 0x60, 0x7c, 0x73, 0x56, 0xc8, 0x3c, 0x3d, 0x2b, 0x64, 0x7e, 0x3f, 0x2b, 0x64, 0x3e, 0x29,
+	0x7a, 0x0d, 0x5e, 0xef, 0x54, 0x2d, 0x87, 0xb6, 0x6c, 0x5e, 0x27, 0x01, 0x6b, 0xb0, 0x48, 0xb4,
+	0x43, 0x19, 0x8f, 0x1f, 0xb5, 0x5d, 0x56, 0x9d, 0x94, 0xff, 0x40, 0xbe, 0xf6, 0x6f, 0x00, 0x00,
+	0x00, 0xff, 0xff, 0xb7, 0x54, 0x23, 0x90, 0x21, 0x0f, 0x00, 0x00,
 }

 // Reference imports to suppress errors if they are not otherwise used.
@@ -1323,8 +1234,6 @@ type QueryClient interface {
 	BlockBloom(ctx context.Context, in *QueryBlockBloomRequest, opts ...grpc.CallOption) (*QueryBlockBloomResponse, error)
 	// Params queries the parameters of x/evm module.
 	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
-	// ChainConfig queries the chain configuration values of EVM.
-	ChainConfig(ctx context.Context, in *QueryChainConfigRequest, opts ...grpc.CallOption) (*QueryChainConfigResponse, error)
 	// StaticCall queries the static call value of x/evm module.
 	StaticCall(ctx context.Context, in *QueryStaticCallRequest, opts ...grpc.CallOption) (*QueryStaticCallResponse, error)
 	// EthCall implements the `eth_call` rpc api
@@ -1429,15 +1338,6 @@ func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts .
 	return out, nil
 }

-func (c *queryClient) ChainConfig(ctx context.Context, in *QueryChainConfigRequest, opts ...grpc.CallOption) (*QueryChainConfigResponse, error) {
-	out := new(QueryChainConfigResponse)
-	err := c.cc.Invoke(ctx, "/ethermint.evm.v1alpha1.Query/ChainConfig", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
 func (c *queryClient) StaticCall(ctx context.Context, in *QueryStaticCallRequest, opts ...grpc.CallOption) (*QueryStaticCallResponse, error) {
 	out := new(QueryStaticCallResponse)
 	err := c.cc.Invoke(ctx, "/ethermint.evm.v1alpha1.Query/StaticCall", in, out, opts...)
@@ -1479,8 +1379,6 @@ type QueryServer interface {
 	BlockBloom(context.Context, *QueryBlockBloomRequest) (*QueryBlockBloomResponse, error)
 	// Params queries the parameters of x/evm module.
 	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
-	// ChainConfig queries the chain configuration values of EVM.
-	ChainConfig(context.Context, *QueryChainConfigRequest) (*QueryChainConfigResponse, error)
 	// StaticCall queries the static call value of x/evm module.
 	StaticCall(context.Context, *QueryStaticCallRequest) (*QueryStaticCallResponse, error)
 	// EthCall implements the `eth_call` rpc api
@@ -1521,9 +1419,6 @@ func (*UnimplementedQueryServer) BlockBloom(ctx context.Context, req *QueryBlock
 func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
 }
-func (*UnimplementedQueryServer) ChainConfig(ctx context.Context, req *QueryChainConfigRequest) (*QueryChainConfigResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ChainConfig not implemented")
-}
 func (*UnimplementedQueryServer) StaticCall(ctx context.Context, req *QueryStaticCallRequest) (*QueryStaticCallResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method StaticCall not implemented")
 }
@@ -1715,24 +1610,6 @@ func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interf
 	return interceptor(ctx, in, info, handler)
 }

-func _Query_ChainConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryChainConfigRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).ChainConfig(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/ethermint.evm.v1alpha1.Query/ChainConfig",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).ChainConfig(ctx, req.(*QueryChainConfigRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
 func _Query_StaticCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QueryStaticCallRequest)
 	if err := dec(in); err != nil {
@@ -1813,10 +1690,6 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "Params",
 			Handler:    _Query_Params_Handler,
 		},
-		{
-			MethodName: "ChainConfig",
-			Handler:    _Query_ChainConfig_Handler,
-		},
 		{
 			MethodName: "StaticCall",
 			Handler:    _Query_StaticCall_Handler,
@@ -2496,62 +2369,6 @@ func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }

-func (m *QueryChainConfigRequest) 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 *QueryChainConfigRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryChainConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	return len(dAtA) - i, nil
-}
-
-func (m *QueryChainConfigResponse) 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 *QueryChainConfigResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryChainConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintQuery(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
 func (m *QueryStaticCallRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -2945,26 +2762,6 @@ func (m *QueryParamsResponse) Size() (n int) {
 	return n
 }

-func (m *QueryChainConfigRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	return n
-}
-
-func (m *QueryChainConfigResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.Config.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
-}
-
 func (m *QueryStaticCallRequest) Size() (n int) {
 	if m == nil {
 		return 0
@@ -4830,139 +4627,6 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryChainConfigRequest) 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 ErrIntOverflowQuery
-			}
-			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: QueryChainConfigRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryChainConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		default:
-			iNdEx = preIndex
-			skippy, err := skipQuery(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *QueryChainConfigResponse) 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 ErrIntOverflowQuery
-			}
-			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: QueryChainConfigResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryChainConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipQuery(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
 func (m *QueryStaticCallRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -539,24 +539,6 @@ func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshal

 }

-func request_Query_ChainConfig_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq QueryChainConfigRequest
-	var metadata runtime.ServerMetadata
-
-	msg, err := client.ChainConfig(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
-	return msg, metadata, err
-
-}
-
-func local_request_Query_ChainConfig_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq QueryChainConfigRequest
-	var metadata runtime.ServerMetadata
-
-	msg, err := server.ChainConfig(ctx, &protoReq)
-	return msg, metadata, err
-
-}
-
 var (
 	filter_Query_StaticCall_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
 )
@@ -835,26 +817,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv

 	})

-	mux.Handle("GET", pattern_Query_ChainConfig_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.AnnotateIncomingContext(ctx, mux, req)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := local_request_Query_ChainConfig_0(rctx, inboundMarshaler, server, req, pathParams)
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_Query_ChainConfig_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
 	mux.Handle("GET", pattern_Query_StaticCall_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -1136,26 +1098,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie

 	})

-	mux.Handle("GET", pattern_Query_ChainConfig_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_Query_ChainConfig_0(rctx, inboundMarshaler, client, req, pathParams)
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_Query_ChainConfig_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
 	mux.Handle("GET", pattern_Query_StaticCall_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -1220,8 +1162,6 @@ var (

 	pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"ethermint", "evm", "v1alpha1", "params"}, "", runtime.AssumeColonVerbOpt(true)))

-	pattern_Query_ChainConfig_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"ethermint", "evm", "v1alpha1", "chain_config"}, "", runtime.AssumeColonVerbOpt(true)))
-
 	pattern_Query_StaticCall_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"ethermint", "evm", "v1alpha1", "static_call"}, "", runtime.AssumeColonVerbOpt(true)))

 	pattern_Query_EthCall_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"ethermint", "evm", "v1alpha1", "eth_call"}, "", runtime.AssumeColonVerbOpt(true)))
@@ -1248,8 +1188,6 @@ var (

 	forward_Query_Params_0 = runtime.ForwardResponseMessage

-	forward_Query_ChainConfig_0 = runtime.ForwardResponseMessage
-
 	forward_Query_StaticCall_0 = runtime.ForwardResponseMessage

 	forward_Query_EthCall_0 = runtime.ForwardResponseMessage