feemarket: global MinGasPrice parameter (#1104)

* Add min_gas_price to feemarket params

* Add MinGasPriceDecorators

* feemarket integration tests for MinGasPrice

* Restructure integration tests

* Simplify integration tests context

We use DeliverTx context to set up the app, otherwise not all settings are initialized.
We test CheckTx with `s.app.BaseApp.CheckTx(req)`, which uses the `CheckTx` mode and context.

* Update MinGasPrice spec in feemarket module

* reorder ethermint module order for initializing genesis

* feemarket migrations for adding MinGasPrice param

* update changelog

* Additional unit tests for MinGasPrice = 0, tx gas price > 0 (PR review)

https://github.com/tharsis/ethermint/pull/1104#discussion_r884991661

* Use 0 MinGasPrice for transaction simulations

* Fix duplicate registration of feemarket GenesisState and Params (PR review)

https://github.com/tharsis/ethermint/pull/1104#issuecomment-1141893712

x/feemarket/keeper/integration_test.go

@@ -0,0 +1,655 @@
+package keeper_test
+
+import (
+	"encoding/json"
+	"math/big"
+	"strings"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/client/tx"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/tx/signing"
+	authsigning "github.com/cosmos/cosmos-sdk/x/auth/signing"
+	authtx "github.com/cosmos/cosmos-sdk/x/auth/tx"
+	"github.com/ethereum/go-ethereum/common"
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/tharsis/ethermint/app"
+	"github.com/tharsis/ethermint/crypto/ethsecp256k1"
+	"github.com/tharsis/ethermint/encoding"
+	"github.com/tharsis/ethermint/tests"
+	"github.com/tharsis/ethermint/testutil"
+	"github.com/tharsis/ethermint/x/feemarket/types"
+
+	"github.com/cosmos/cosmos-sdk/simapp"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	abci "github.com/tendermint/tendermint/abci/types"
+	"github.com/tendermint/tendermint/libs/log"
+	dbm "github.com/tendermint/tm-db"
+	evmtypes "github.com/tharsis/ethermint/x/evm/types"
+)
+
+var _ = Describe("Ethermint App min gas prices settings: ", func() {
+	var (
+		privKey *ethsecp256k1.PrivKey
+		address sdk.AccAddress
+		msg     banktypes.MsgSend
+	)
+
+	var setupChain = func(cliMinGasPricesStr string) {
+		// Initialize the app, so we can use SetMinGasPrices to set the
+		// validator-specific min-gas-prices setting
+		db := dbm.NewMemDB()
+		newapp := app.NewEthermintApp(
+			log.NewNopLogger(),
+			db,
+			nil,
+			true,
+			map[int64]bool{},
+			app.DefaultNodeHome,
+			5,
+			encoding.MakeConfig(app.ModuleBasics),
+			simapp.EmptyAppOptions{},
+			baseapp.SetMinGasPrices(cliMinGasPricesStr),
+		)
+
+		genesisState := app.NewDefaultGenesisState()
+		genesisState[types.ModuleName] = newapp.AppCodec().MustMarshalJSON(types.DefaultGenesisState())
+
+		stateBytes, err := json.MarshalIndent(genesisState, "", "  ")
+		s.Require().NoError(err)
+
+		// Initialize the chain
+		newapp.InitChain(
+			abci.RequestInitChain{
+				ChainId:         "ethermint_9000-1",
+				Validators:      []abci.ValidatorUpdate{},
+				AppStateBytes:   stateBytes,
+				ConsensusParams: simapp.DefaultConsensusParams,
+			},
+		)
+
+		s.app = newapp
+		s.SetupApp(false)
+	}
+
+	var setupTest = func(cliMinGasPrices string) {
+		setupChain(cliMinGasPrices)
+
+		privKey, address = generateKey()
+		amount, ok := sdk.NewIntFromString("10000000000000000000")
+		s.Require().True(ok)
+		initBalance := sdk.Coins{sdk.Coin{
+			Denom:  s.denom,
+			Amount: amount,
+		}}
+		testutil.FundAccount(s.app.BankKeeper, s.ctx, address, initBalance)
+
+		msg = banktypes.MsgSend{
+			FromAddress: address.String(),
+			ToAddress:   address.String(),
+			Amount: sdk.Coins{sdk.Coin{
+				Denom:  s.denom,
+				Amount: sdk.NewInt(10000),
+			}},
+		}
+		s.Commit()
+	}
+
+	var setupContext = func(cliMinGasPrice string, minGasPrice sdk.Dec) {
+		setupTest(cliMinGasPrice + s.denom)
+		params := types.DefaultParams()
+		params.MinGasPrice = minGasPrice
+		s.app.FeeMarketKeeper.SetParams(s.ctx, params)
+		s.Commit()
+	}
+
+	Context("with Cosmos transactions", func() {
+		Context("min-gas-prices (local) < MinGasPrices (feemarket param)", func() {
+			cliMinGasPrice := "1"
+			minGasPrice := sdk.NewDecWithPrec(3, 0)
+			BeforeEach(func() {
+				setupContext(cliMinGasPrice, minGasPrice)
+			})
+
+			Context("during CheckTx", func() {
+				It("should reject transactions with gasPrice < MinGasPrices", func() {
+					gasPrice := sdk.NewInt(2)
+					res := checkTx(privKey, &gasPrice, &msg)
+					Expect(res.IsOK()).To(Equal(false), "transaction should have failed")
+					Expect(
+						strings.Contains(res.GetLog(),
+							"provided fee < minimum global fee"),
+					).To(BeTrue(), res.GetLog())
+				})
+
+				It("should accept transactions with gasPrice >= MinGasPrices", func() {
+					gasPrice := sdk.NewInt(3)
+					res := checkTx(privKey, &gasPrice, &msg)
+					Expect(res.IsOK()).To(Equal(true), "transaction should have succeeded", res.GetLog())
+				})
+			})
+
+			Context("during DeliverTx", func() {
+				It("should reject transactions with gasPrice < MinGasPrices", func() {
+					gasPrice := sdk.NewInt(2)
+					res := deliverTx(privKey, &gasPrice, &msg)
+					Expect(res.IsOK()).To(Equal(false), "transaction should have failed")
+					Expect(
+						strings.Contains(res.GetLog(),
+							"provided fee < minimum global fee"),
+					).To(BeTrue(), res.GetLog())
+				})
+
+				It("should accept transactions with gasPrice >= MinGasPrices", func() {
+					gasPrice := sdk.NewInt(3)
+					res := deliverTx(privKey, &gasPrice, &msg)
+					Expect(res.IsOK()).To(Equal(true), "transaction should have succeeded", res.GetLog())
+				})
+			})
+		})
+
+		Context("with min-gas-prices (local) == MinGasPrices (feemarket param)", func() {
+			cliMinGasPrice := "3"
+			minGasPrice := sdk.NewDecWithPrec(3, 0)
+			BeforeEach(func() {
+				setupContext(cliMinGasPrice, minGasPrice)
+			})
+
+			Context("during CheckTx", func() {
+				It("should reject transactions with gasPrice < min-gas-prices", func() {
+					gasPrice := sdk.NewInt(2)
+					res := checkTx(privKey, &gasPrice, &msg)
+					Expect(res.IsOK()).To(Equal(false), "transaction should have failed")
+					Expect(
+						strings.Contains(res.GetLog(),
+							"insufficient fee"),
+					).To(BeTrue(), res.GetLog())
+				})
+
+				It("should accept transactions with gasPrice >= MinGasPrices", func() {
+					gasPrice := sdk.NewInt(3)
+					res := checkTx(privKey, &gasPrice, &msg)
+					Expect(res.IsOK()).To(Equal(true), "transaction should have succeeded", res.GetLog())
+				})
+			})
+
+			Context("during DeliverTx", func() {
+				It("should reject transactions with gasPrice < MinGasPrices", func() {
+					gasPrice := sdk.NewInt(2)
+					res := deliverTx(privKey, &gasPrice, &msg)
+					Expect(res.IsOK()).To(Equal(false), "transaction should have failed")
+					Expect(
+						strings.Contains(res.GetLog(),
+							"provided fee < minimum global fee"),
+					).To(BeTrue(), res.GetLog())
+				})
+
+				It("should accept transactions with gasPrice >= MinGasPrices", func() {
+					gasPrice := sdk.NewInt(3)
+					res := deliverTx(privKey, &gasPrice, &msg)
+					Expect(res.IsOK()).To(Equal(true), "transaction should have succeeded", res.GetLog())
+				})
+			})
+		})
+
+		Context("with MinGasPrices (feemarket param) < min-gas-prices (local)", func() {
+			cliMinGasPrice := "5"
+			minGasPrice := sdk.NewDecWithPrec(3, 0)
+			BeforeEach(func() {
+				setupContext(cliMinGasPrice, minGasPrice)
+			})
+			Context("during CheckTx", func() {
+				It("should reject transactions with gasPrice < MinGasPrices", func() {
+					gasPrice := sdk.NewInt(2)
+					res := checkTx(privKey, &gasPrice, &msg)
+					Expect(res.IsOK()).To(Equal(false), "transaction should have failed")
+					Expect(
+						strings.Contains(res.GetLog(),
+							"insufficient fee"),
+					).To(BeTrue(), res.GetLog())
+				})
+
+				It("should reject transactions with MinGasPrices < gasPrice < min-gas-prices", func() {
+					gasPrice := sdk.NewInt(4)
+					res := checkTx(privKey, &gasPrice, &msg)
+					Expect(res.IsOK()).To(Equal(false), "transaction should have failed")
+					Expect(
+						strings.Contains(res.GetLog(),
+							"insufficient fee"),
+					).To(BeTrue(), res.GetLog())
+				})
+
+				It("should accept transactions with gasPrice > min-gas-prices", func() {
+					gasPrice := sdk.NewInt(5)
+					res := checkTx(privKey, &gasPrice, &msg)
+					Expect(res.IsOK()).To(Equal(true), "transaction should have succeeded", res.GetLog())
+				})
+			})
+
+			Context("during DeliverTx", func() {
+				It("should reject transactions with gasPrice < MinGasPrices", func() {
+					gasPrice := sdk.NewInt(2)
+					res := deliverTx(privKey, &gasPrice, &msg)
+					Expect(res.IsOK()).To(Equal(false), "transaction should have failed")
+					Expect(
+						strings.Contains(res.GetLog(),
+							"provided fee < minimum global fee"),
+					).To(BeTrue(), res.GetLog())
+				})
+
+				It("should accept transactions with MinGasPrices < gasPrice < than min-gas-prices", func() {
+					gasPrice := sdk.NewInt(4)
+					res := deliverTx(privKey, &gasPrice, &msg)
+					Expect(res.IsOK()).To(Equal(true), "transaction should have succeeded", res.GetLog())
+				})
+
+				It("should accept transactions with gasPrice >= min-gas-prices", func() {
+					gasPrice := sdk.NewInt(5)
+					res := deliverTx(privKey, &gasPrice, &msg)
+					Expect(res.IsOK()).To(Equal(true), "transaction should have succeeded", res.GetLog())
+				})
+			})
+		})
+	})
+
+	Context("with EVM transactions", func() {
+		type txParams struct {
+			gasPrice  *big.Int
+			gasFeeCap *big.Int
+			gasTipCap *big.Int
+			accesses  *ethtypes.AccessList
+		}
+		type getprices func() txParams
+
+		getBaseFee := func() int64 {
+			paramsEvm := s.app.EvmKeeper.GetParams(s.ctx)
+			ethCfg := paramsEvm.ChainConfig.EthereumConfig(s.app.EvmKeeper.ChainID())
+			return s.app.EvmKeeper.GetBaseFee(s.ctx, ethCfg).Int64()
+		}
+		Context("with BaseFee (feemarket) < MinGasPrices (feemarket param)", func() {
+			var baseFee int64
+			BeforeEach(func() {
+				baseFee = getBaseFee()
+				setupContext("1", sdk.NewDecWithPrec(baseFee+30000000000, 0))
+			})
+
+			Context("during CheckTx", func() {
+				DescribeTable("should reject transactions with EffectivePrice < MinGasPrices",
+					func(malleate getprices) {
+						p := malleate()
+						to := tests.GenerateAddress()
+						msgEthereumTx := buildEthTx(privKey, &to, p.gasPrice, p.gasFeeCap, p.gasTipCap, p.accesses)
+						res := checkEthTx(privKey, msgEthereumTx)
+						Expect(res.IsOK()).To(Equal(false), "transaction should have failed")
+						Expect(
+							strings.Contains(res.GetLog(),
+								"provided fee < minimum global fee"),
+						).To(BeTrue(), res.GetLog())
+					},
+					Entry("legacy tx", func() txParams {
+						return txParams{big.NewInt(baseFee + 20000000000), nil, nil, nil}
+					}),
+					Entry("dynamic tx", func() txParams {
+						return txParams{nil, big.NewInt(baseFee + 20000000000), big.NewInt(0), &ethtypes.AccessList{}}
+					}),
+					Entry("dynamic tx with GasFeeCap < MinGasPrices", func() txParams {
+						return txParams{nil, big.NewInt(baseFee + 29000000000), big.NewInt(29000000000), &ethtypes.AccessList{}}
+					}),
+					Entry("dynamic tx with GasFeeCap > MinGasPrices, EffectivePrice < MinGasPrices", func() txParams {
+						return txParams{nil, big.NewInt(baseFee + 40000000000), big.NewInt(0), &ethtypes.AccessList{}}
+					}),
+				)
+
+				DescribeTable("should accept transactions with gasPrice >= MinGasPrices",
+					func(malleate getprices) {
+						p := malleate()
+						to := tests.GenerateAddress()
+						msgEthereumTx := buildEthTx(privKey, &to, p.gasPrice, p.gasFeeCap, p.gasTipCap, p.accesses)
+						res := checkEthTx(privKey, msgEthereumTx)
+						Expect(res.IsOK()).To(Equal(true), "transaction should have succeeded", res.GetLog())
+					},
+					Entry("legacy tx", func() txParams {
+						return txParams{big.NewInt(baseFee + 31000000000), nil, nil, nil}
+					}),
+					Entry("dynamic tx", func() txParams {
+						return txParams{nil, big.NewInt(baseFee + 31000000000), big.NewInt(31000000000), &ethtypes.AccessList{}}
+					}),
+				)
+			})
+
+			Context("during DeliverTx", func() {
+				DescribeTable("should reject transactions with gasPrice < MinGasPrices",
+					func(malleate getprices) {
+						p := malleate()
+						to := tests.GenerateAddress()
+						msgEthereumTx := buildEthTx(privKey, &to, p.gasPrice, p.gasFeeCap, p.gasTipCap, p.accesses)
+						res := deliverEthTx(privKey, msgEthereumTx)
+						Expect(res.IsOK()).To(Equal(false), "transaction should have failed")
+						Expect(
+							strings.Contains(res.GetLog(),
+								"provided fee < minimum global fee"),
+						).To(BeTrue(), res.GetLog())
+					},
+					Entry("legacy tx", func() txParams {
+						return txParams{big.NewInt(baseFee + 20000000000), nil, nil, nil}
+					}),
+					Entry("dynamic tx", func() txParams {
+						return txParams{nil, big.NewInt(baseFee + 20000000000), big.NewInt(0), &ethtypes.AccessList{}}
+					}),
+					Entry("dynamic tx with GasFeeCap < MinGasPrices", func() txParams {
+						return txParams{nil, big.NewInt(baseFee + 29000000000), big.NewInt(29000000000), &ethtypes.AccessList{}}
+					}),
+					Entry("dynamic tx with GasFeeCap > MinGasPrices, EffectivePrice < MinGasPrices", func() txParams {
+						return txParams{nil, big.NewInt(baseFee + 40000000000), big.NewInt(0), &ethtypes.AccessList{}}
+					}),
+				)
+
+				DescribeTable("should accept transactions with gasPrice >= MinGasPrices",
+					func(malleate getprices) {
+						p := malleate()
+						to := tests.GenerateAddress()
+						msgEthereumTx := buildEthTx(privKey, &to, p.gasPrice, p.gasFeeCap, p.gasTipCap, p.accesses)
+						res := deliverEthTx(privKey, msgEthereumTx)
+						Expect(res.IsOK()).To(Equal(true), "transaction should have succeeded", res.GetLog())
+					},
+					Entry("legacy tx", func() txParams {
+						return txParams{big.NewInt(baseFee + 30000000001), nil, nil, nil}
+					}),
+					// the base fee decreases in this test, so we use a large gas tip
+					// to maintain an EffectivePrice > MinGasPrices
+					Entry("dynamic tx, EffectivePrice > MinGasPrices", func() txParams {
+						return txParams{nil, big.NewInt(baseFee + 30000000001), big.NewInt(30000000001), &ethtypes.AccessList{}}
+					}),
+				)
+			})
+		})
+
+		Context("with MinGasPrices (feemarket param) < BaseFee (feemarket)", func() {
+			var baseFee int64
+			BeforeEach(func() {
+				baseFee = getBaseFee()
+				s.Require().Greater(baseFee, int64(10))
+				setupContext("5", sdk.NewDecWithPrec(10, 0))
+			})
+
+			Context("during CheckTx", func() {
+				DescribeTable("should reject transactions with gasPrice < MinGasPrices",
+					func(malleate getprices) {
+						p := malleate()
+						to := tests.GenerateAddress()
+						msgEthereumTx := buildEthTx(privKey, &to, p.gasPrice, p.gasFeeCap, p.gasTipCap, p.accesses)
+						res := checkEthTx(privKey, msgEthereumTx)
+						Expect(res.IsOK()).To(Equal(false), "transaction should have failed")
+						Expect(
+							strings.Contains(res.GetLog(),
+								"provided fee < minimum global fee"),
+						).To(BeTrue(), res.GetLog())
+					},
+					Entry("legacy tx", func() txParams {
+						return txParams{big.NewInt(2), nil, nil, nil}
+					}),
+					Entry("dynamic tx", func() txParams {
+						return txParams{nil, big.NewInt(2), big.NewInt(2), &ethtypes.AccessList{}}
+					}),
+				)
+
+				DescribeTable("should reject transactions with MinGasPrices < tx gasPrice < EffectivePrice",
+					func(malleate getprices) {
+						p := malleate()
+						to := tests.GenerateAddress()
+						msgEthereumTx := buildEthTx(privKey, &to, p.gasPrice, p.gasFeeCap, p.gasTipCap, p.accesses)
+						res := checkEthTx(privKey, msgEthereumTx)
+						Expect(res.IsOK()).To(Equal(false), "transaction should have failed")
+						Expect(
+							strings.Contains(res.GetLog(),
+								"insufficient fee"),
+						).To(BeTrue(), res.GetLog())
+					},
+					Entry("legacy tx", func() txParams {
+						return txParams{big.NewInt(20), nil, nil, nil}
+					}),
+					Entry("dynamic tx", func() txParams {
+						return txParams{nil, big.NewInt(baseFee - 1), big.NewInt(20), &ethtypes.AccessList{}}
+					}),
+				)
+
+				DescribeTable("should accept transactions with gasPrice > EffectivePrice",
+					func(malleate getprices) {
+						p := malleate()
+						to := tests.GenerateAddress()
+						msgEthereumTx := buildEthTx(privKey, &to, p.gasPrice, p.gasFeeCap, p.gasTipCap, p.accesses)
+						res := checkEthTx(privKey, msgEthereumTx)
+						Expect(res.IsOK()).To(Equal(true), "transaction should have succeeded", res.GetLog())
+					},
+					Entry("legacy tx", func() txParams {
+						return txParams{big.NewInt(baseFee + 1000000000), nil, nil, nil}
+					}),
+					Entry("dynamic tx", func() txParams {
+						return txParams{nil, big.NewInt(baseFee + 1000000000), big.NewInt(10), &ethtypes.AccessList{}}
+					}),
+				)
+			})
+
+			Context("during DeliverTx", func() {
+				DescribeTable("should reject transactions with gasPrice < MinGasPrices",
+					func(malleate getprices) {
+						p := malleate()
+						to := tests.GenerateAddress()
+						msgEthereumTx := buildEthTx(privKey, &to, p.gasPrice, p.gasFeeCap, p.gasTipCap, p.accesses)
+						res := deliverEthTx(privKey, msgEthereumTx)
+						Expect(res.IsOK()).To(Equal(false), "transaction should have failed")
+						Expect(
+							strings.Contains(res.GetLog(),
+								"provided fee < minimum global fee"),
+						).To(BeTrue(), res.GetLog())
+					},
+					Entry("legacy tx", func() txParams {
+						return txParams{big.NewInt(2), nil, nil, nil}
+					}),
+					Entry("dynamic tx", func() txParams {
+						return txParams{nil, big.NewInt(2), big.NewInt(2), &ethtypes.AccessList{}}
+					}),
+				)
+
+				DescribeTable("should reject transactions with MinGasPrices < gasPrice < EffectivePrice",
+					func(malleate getprices) {
+						p := malleate()
+						to := tests.GenerateAddress()
+						msgEthereumTx := buildEthTx(privKey, &to, p.gasPrice, p.gasFeeCap, p.gasTipCap, p.accesses)
+						res := deliverEthTx(privKey, msgEthereumTx)
+						Expect(res.IsOK()).To(Equal(false), "transaction should have failed")
+						Expect(
+							strings.Contains(res.GetLog(),
+								"insufficient fee"),
+						).To(BeTrue(), res.GetLog())
+					},
+					Entry("legacy tx", func() txParams {
+						return txParams{big.NewInt(20), nil, nil, nil}
+					}),
+					Entry("dynamic tx", func() txParams {
+						return txParams{nil, big.NewInt(20), big.NewInt(20), &ethtypes.AccessList{}}
+					}),
+				)
+
+				DescribeTable("should accept transactions with gasPrice > EffectivePrice",
+					func(malleate getprices) {
+						p := malleate()
+						to := tests.GenerateAddress()
+						msgEthereumTx := buildEthTx(privKey, &to, p.gasPrice, p.gasFeeCap, p.gasTipCap, p.accesses)
+						res := deliverEthTx(privKey, msgEthereumTx)
+						Expect(res.IsOK()).To(Equal(true), "transaction should have succeeded", res.GetLog())
+					},
+					Entry("legacy tx", func() txParams {
+						return txParams{big.NewInt(baseFee + 10), nil, nil, nil}
+					}),
+					Entry("dynamic tx", func() txParams {
+						return txParams{nil, big.NewInt(baseFee + 10), big.NewInt(10), &ethtypes.AccessList{}}
+					}),
+				)
+			})
+		})
+	})
+})
+
+func generateKey() (*ethsecp256k1.PrivKey, sdk.AccAddress) {
+	address, priv := tests.NewAddrKey()
+	return priv.(*ethsecp256k1.PrivKey), sdk.AccAddress(address.Bytes())
+}
+
+func getNonce(addressBytes []byte) uint64 {
+	return s.app.EvmKeeper.GetNonce(
+		s.ctx,
+		common.BytesToAddress(addressBytes),
+	)
+}
+
+func buildEthTx(
+	priv *ethsecp256k1.PrivKey,
+	to *common.Address,
+	gasPrice *big.Int,
+	gasFeeCap *big.Int,
+	gasTipCap *big.Int,
+	accesses *ethtypes.AccessList,
+) *evmtypes.MsgEthereumTx {
+	chainID := s.app.EvmKeeper.ChainID()
+	from := common.BytesToAddress(priv.PubKey().Address().Bytes())
+	nonce := getNonce(from.Bytes())
+	data := make([]byte, 0)
+	gasLimit := uint64(100000)
+	msgEthereumTx := evmtypes.NewTx(
+		chainID,
+		nonce,
+		to,
+		nil,
+		gasLimit,
+		gasPrice,
+		gasFeeCap,
+		gasTipCap,
+		data,
+		accesses,
+	)
+	msgEthereumTx.From = from.String()
+	return msgEthereumTx
+}
+
+func prepareEthTx(priv *ethsecp256k1.PrivKey, msgEthereumTx *evmtypes.MsgEthereumTx) []byte {
+	encodingConfig := encoding.MakeConfig(app.ModuleBasics)
+	option, err := codectypes.NewAnyWithValue(&evmtypes.ExtensionOptionsEthereumTx{})
+	s.Require().NoError(err)
+
+	txBuilder := encodingConfig.TxConfig.NewTxBuilder()
+	builder, ok := txBuilder.(authtx.ExtensionOptionsTxBuilder)
+	s.Require().True(ok)
+	builder.SetExtensionOptions(option)
+
+	err = msgEthereumTx.Sign(s.ethSigner, tests.NewSigner(priv))
+	s.Require().NoError(err)
+
+	err = txBuilder.SetMsgs(msgEthereumTx)
+	s.Require().NoError(err)
+
+	txData, err := evmtypes.UnpackTxData(msgEthereumTx.Data)
+	s.Require().NoError(err)
+
+	evmDenom := s.app.EvmKeeper.GetParams(s.ctx).EvmDenom
+	fees := sdk.Coins{{Denom: evmDenom, Amount: sdk.NewIntFromBigInt(txData.Fee())}}
+	builder.SetFeeAmount(fees)
+	builder.SetGasLimit(msgEthereumTx.GetGas())
+
+	// bz are bytes to be broadcasted over the network
+	bz, err := encodingConfig.TxConfig.TxEncoder()(txBuilder.GetTx())
+	s.Require().NoError(err)
+
+	return bz
+}
+
+func deliverEthTx(priv *ethsecp256k1.PrivKey, msgEthereumTx *evmtypes.MsgEthereumTx) abci.ResponseDeliverTx {
+	bz := prepareEthTx(priv, msgEthereumTx)
+	req := abci.RequestDeliverTx{Tx: bz}
+	res := s.app.BaseApp.DeliverTx(req)
+	return res
+}
+
+func checkEthTx(priv *ethsecp256k1.PrivKey, msgEthereumTx *evmtypes.MsgEthereumTx) abci.ResponseCheckTx {
+	bz := prepareEthTx(priv, msgEthereumTx)
+	req := abci.RequestCheckTx{Tx: bz}
+	res := s.app.BaseApp.CheckTx(req)
+	return res
+}
+
+func prepareCosmosTx(priv *ethsecp256k1.PrivKey, gasPrice *sdk.Int, msgs ...sdk.Msg) []byte {
+	encodingConfig := encoding.MakeConfig(app.ModuleBasics)
+	accountAddress := sdk.AccAddress(priv.PubKey().Address().Bytes())
+
+	txBuilder := encodingConfig.TxConfig.NewTxBuilder()
+
+	txBuilder.SetGasLimit(1000000)
+	if gasPrice == nil {
+		_gasPrice := sdk.NewInt(1)
+		gasPrice = &_gasPrice
+	}
+	fees := &sdk.Coins{{Denom: s.denom, Amount: gasPrice.MulRaw(1000000)}}
+	txBuilder.SetFeeAmount(*fees)
+	err := txBuilder.SetMsgs(msgs...)
+	s.Require().NoError(err)
+
+	seq, err := s.app.AccountKeeper.GetSequence(s.ctx, accountAddress)
+	s.Require().NoError(err)
+
+	// First round: we gather all the signer infos. We use the "set empty
+	// signature" hack to do that.
+	sigV2 := signing.SignatureV2{
+		PubKey: priv.PubKey(),
+		Data: &signing.SingleSignatureData{
+			SignMode:  encodingConfig.TxConfig.SignModeHandler().DefaultMode(),
+			Signature: nil,
+		},
+		Sequence: seq,
+	}
+
+	sigsV2 := []signing.SignatureV2{sigV2}
+
+	err = txBuilder.SetSignatures(sigsV2...)
+	s.Require().NoError(err)
+
+	// Second round: all signer infos are set, so each signer can sign.
+	accNumber := s.app.AccountKeeper.GetAccount(s.ctx, accountAddress).GetAccountNumber()
+	signerData := authsigning.SignerData{
+		ChainID:       s.ctx.ChainID(),
+		AccountNumber: accNumber,
+		Sequence:      seq,
+	}
+	sigV2, err = tx.SignWithPrivKey(
+		encodingConfig.TxConfig.SignModeHandler().DefaultMode(), signerData,
+		txBuilder, priv, encodingConfig.TxConfig,
+		seq,
+	)
+	s.Require().NoError(err)
+
+	sigsV2 = []signing.SignatureV2{sigV2}
+	err = txBuilder.SetSignatures(sigsV2...)
+	s.Require().NoError(err)
+
+	// bz are bytes to be broadcasted over the network
+	bz, err := encodingConfig.TxConfig.TxEncoder()(txBuilder.GetTx())
+	s.Require().NoError(err)
+	return bz
+}
+
+func deliverTx(priv *ethsecp256k1.PrivKey, gasPrice *sdk.Int, msgs ...sdk.Msg) abci.ResponseDeliverTx {
+	bz := prepareCosmosTx(priv, gasPrice, msgs...)
+	req := abci.RequestDeliverTx{Tx: bz}
+	res := s.app.BaseApp.DeliverTx(req)
+	return res
+}
+
+func checkTx(priv *ethsecp256k1.PrivKey, gasPrice *sdk.Int, msgs ...sdk.Msg) abci.ResponseCheckTx {
+	bz := prepareCosmosTx(priv, gasPrice, msgs...)
+	req := abci.RequestCheckTx{Tx: bz}
+	res := s.app.BaseApp.CheckTx(req)
+	return res
+}

x/feemarket/keeper/keeper_test.go

@@ -6,6 +6,9 @@ import (
 	"testing"
 	"time"
 
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 
@@ -15,6 +18,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/crypto/keyring"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 
 	"github.com/tharsis/ethermint/app"
@@ -22,12 +26,14 @@ import (
 	"github.com/tharsis/ethermint/encoding"
 	"github.com/tharsis/ethermint/tests"
 	ethermint "github.com/tharsis/ethermint/types"
+	evmtypes "github.com/tharsis/ethermint/x/evm/types"
 	"github.com/tharsis/ethermint/x/feemarket/types"
 
 	"github.com/ethereum/go-ethereum/common"
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 
+	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto/tmhash"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 	tmversion "github.com/tendermint/tendermint/proto/tendermint/version"
@@ -49,12 +55,29 @@ type KeeperTestSuite struct {
 
 	appCodec codec.Codec
 	signer   keyring.Signer
+	denom    string
 }
 
-/// DoSetupTest setup test environment, it uses`require.TestingT` to support both `testing.T` and `testing.B`.
-func (suite *KeeperTestSuite) DoSetupTest(t require.TestingT) {
-	checkTx := false
+var s *KeeperTestSuite
 
+func TestKeeperTestSuite(t *testing.T) {
+	s = new(KeeperTestSuite)
+	suite.Run(t, s)
+
+	// Run Ginkgo integration tests
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Keeper Suite")
+}
+
+/// SetupTest setup test environment, it uses`require.TestingT` to support both `testing.T` and `testing.B`.
+func (suite *KeeperTestSuite) SetupTest() {
+	checkTx := false
+	suite.app = app.Setup(checkTx, nil)
+	suite.SetupApp(checkTx)
+}
+
+func (suite *KeeperTestSuite) SetupApp(checkTx bool) {
+	t := suite.T()
 	// account key
 	priv, err := ethsecp256k1.GenerateKey()
 	require.NoError(t, err)
@@ -66,7 +89,6 @@ func (suite *KeeperTestSuite) DoSetupTest(t require.TestingT) {
 	require.NoError(t, err)
 	suite.consAddress = sdk.ConsAddress(priv.PubKey().Address())
 
-	suite.app = app.Setup(checkTx, nil)
 	suite.ctx = suite.app.BaseApp.NewContext(checkTx, tmproto.Header{
 		Height:          1,
 		ChainID:         "ethermint_9000-1",
@@ -104,8 +126,10 @@ func (suite *KeeperTestSuite) DoSetupTest(t require.TestingT) {
 
 	valAddr := sdk.ValAddress(suite.address.Bytes())
 	validator, err := stakingtypes.NewValidator(valAddr, priv.PubKey(), stakingtypes.Description{})
-	err = suite.app.StakingKeeper.SetValidatorByConsAddr(suite.ctx, validator)
 	require.NoError(t, err)
+	validator = stakingkeeper.TestingUpdateValidator(suite.app.StakingKeeper, suite.ctx, validator, true)
+	suite.app.StakingKeeper.AfterValidatorCreated(suite.ctx, validator.GetOperator())
+
 	err = suite.app.StakingKeeper.SetValidatorByConsAddr(suite.ctx, validator)
 	require.NoError(t, err)
 	suite.app.StakingKeeper.SetValidator(suite.ctx, validator)
@@ -114,14 +138,32 @@ func (suite *KeeperTestSuite) DoSetupTest(t require.TestingT) {
 	suite.clientCtx = client.Context{}.WithTxConfig(encodingConfig.TxConfig)
 	suite.ethSigner = ethtypes.LatestSignerForChainID(suite.app.EvmKeeper.ChainID())
 	suite.appCodec = encodingConfig.Marshaler
+	suite.denom = evmtypes.DefaultEVMDenom
 }
 
-func (suite *KeeperTestSuite) SetupTest() {
-	suite.DoSetupTest(suite.T())
+// Commit commits and starts a new block with an updated context.
+func (suite *KeeperTestSuite) Commit() {
+	suite.CommitAfter(time.Second * 0)
 }
 
-func TestKeeperTestSuite(t *testing.T) {
-	suite.Run(t, new(KeeperTestSuite))
+// Commit commits a block at a given time.
+func (suite *KeeperTestSuite) CommitAfter(t time.Duration) {
+	header := suite.ctx.BlockHeader()
+	suite.app.EndBlock(abci.RequestEndBlock{Height: header.Height})
+	_ = suite.app.Commit()
+
+	header.Height += 1
+	header.Time = header.Time.Add(t)
+	suite.app.BeginBlock(abci.RequestBeginBlock{
+		Header: header,
+	})
+
+	// update ctx
+	suite.ctx = suite.app.BaseApp.NewContext(false, header)
+
+	queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, suite.app.InterfaceRegistry())
+	types.RegisterQueryServer(queryHelper, suite.app.FeeMarketKeeper)
+	suite.queryClient = types.NewQueryClient(queryHelper)
 }
 
 func (suite *KeeperTestSuite) TestSetGetBlockGasUsed() {

x/feemarket/keeper/migrations.go

@@ -4,6 +4,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	v010 "github.com/tharsis/ethermint/x/feemarket/migrations/v010"
+	v011 "github.com/tharsis/ethermint/x/feemarket/migrations/v011"
 )
 
 // Migrator is a struct for handling in-place store migrations.
@@ -22,3 +23,8 @@ func NewMigrator(keeper Keeper) Migrator {
 func (m Migrator) Migrate1to2(ctx sdk.Context) error {
 	return v010.MigrateStore(ctx, &m.keeper.paramSpace, m.keeper.storeKey)
 }
+
+// Migrate2to3 migrates the store from consensus version v2 to v3
+func (m Migrator) Migrate2to3(ctx sdk.Context) error {
+	return v011.MigrateStore(ctx, &m.keeper.paramSpace)
+}

x/feemarket/migrations/v010/migrate.go

@@ -6,8 +6,8 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
+	"github.com/tharsis/ethermint/x/feemarket/migrations/v010/types"
 	v09types "github.com/tharsis/ethermint/x/feemarket/migrations/v09/types"
-	"github.com/tharsis/ethermint/x/feemarket/types"
 )
 
 // KeyPrefixBaseFeeV1 is the base fee key prefix used in version 1

x/feemarket/migrations/v010/types/feemarket.pb.go

@@ -0,0 +1,472 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: ethermint/feemarket/v1/feemarket.proto
+
+package types
+
+import (
+	fmt "fmt"
+	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
+	_ "github.com/gogo/protobuf/gogoproto"
+	proto "github.com/gogo/protobuf/proto"
+	io "io"
+	math "math"
+	math_bits "math/bits"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// Params defines the EVM module parameters
+type Params struct {
+	// no base fee forces the EIP-1559 base fee to 0 (needed for 0 price calls)
+	NoBaseFee bool `protobuf:"varint,1,opt,name=no_base_fee,json=noBaseFee,proto3" json:"no_base_fee,omitempty"`
+	// base fee change denominator bounds the amount the base fee can change
+	// between blocks.
+	BaseFeeChangeDenominator uint32 `protobuf:"varint,2,opt,name=base_fee_change_denominator,json=baseFeeChangeDenominator,proto3" json:"base_fee_change_denominator,omitempty"`
+	// elasticity multiplier bounds the maximum gas limit an EIP-1559 block may
+	// have.
+	ElasticityMultiplier uint32 `protobuf:"varint,3,opt,name=elasticity_multiplier,json=elasticityMultiplier,proto3" json:"elasticity_multiplier,omitempty"`
+	// height at which the base fee calculation is enabled.
+	EnableHeight int64 `protobuf:"varint,5,opt,name=enable_height,json=enableHeight,proto3" json:"enable_height,omitempty"`
+	// base fee for EIP-1559 blocks.
+	BaseFee github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,6,opt,name=base_fee,json=baseFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"base_fee"`
+}
+
+func (m *Params) Reset()         { *m = Params{} }
+func (m *Params) String() string { return proto.CompactTextString(m) }
+func (*Params) ProtoMessage()    {}
+func (*Params) Descriptor() ([]byte, []int) {
+	return fileDescriptor_4feb8b20cf98e6e1, []int{0}
+}
+func (m *Params) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Params.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 *Params) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Params.Merge(m, src)
+}
+func (m *Params) XXX_Size() int {
+	return m.Size()
+}
+func (m *Params) XXX_DiscardUnknown() {
+	xxx_messageInfo_Params.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Params proto.InternalMessageInfo
+
+func (m *Params) GetNoBaseFee() bool {
+	if m != nil {
+		return m.NoBaseFee
+	}
+	return false
+}
+
+func (m *Params) GetBaseFeeChangeDenominator() uint32 {
+	if m != nil {
+		return m.BaseFeeChangeDenominator
+	}
+	return 0
+}
+
+func (m *Params) GetElasticityMultiplier() uint32 {
+	if m != nil {
+		return m.ElasticityMultiplier
+	}
+	return 0
+}
+
+func (m *Params) GetEnableHeight() int64 {
+	if m != nil {
+		return m.EnableHeight
+	}
+	return 0
+}
+
+var fileDescriptor_4feb8b20cf98e6e1 = []byte{
+	// 343 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x91, 0xcf, 0x6a, 0xea, 0x40,
+	0x14, 0x87, 0x33, 0xfe, 0xbb, 0x9a, 0x7b, 0x05, 0x09, 0xde, 0x4b, 0xb8, 0x85, 0x18, 0x5a, 0x90,
+	0x6c, 0x9a, 0x20, 0xae, 0xbb, 0xb1, 0xa5, 0x68, 0xa1, 0x50, 0xb2, 0xec, 0x26, 0x4c, 0xe2, 0x31,
+	0x19, 0x4c, 0x66, 0x64, 0xe6, 0x28, 0xf5, 0x2d, 0xfa, 0x10, 0x7d, 0x18, 0x97, 0x2e, 0x4b, 0x17,
+	0x52, 0xf4, 0x45, 0x4a, 0xa3, 0x4d, 0x5c, 0xcd, 0xcc, 0xf9, 0xbe, 0xe1, 0x1c, 0xce, 0x4f, 0xef,
+	0x03, 0x26, 0x20, 0x33, 0xc6, 0xd1, 0x9b, 0x01, 0x64, 0x54, 0xce, 0x01, 0xbd, 0xd5, 0xa0, 0x7c,
+	0xb8, 0x0b, 0x29, 0x50, 0x18, 0xff, 0x0a, 0xcf, 0x2d, 0xd1, 0x6a, 0xf0, 0xbf, 0x1b, 0x8b, 0x58,
+	0xe4, 0x8a, 0xf7, 0x7d, 0x3b, 0xda, 0x97, 0x6f, 0x15, 0xbd, 0xf1, 0x44, 0x25, 0xcd, 0x94, 0x61,
+	0xe9, 0xbf, 0xb9, 0x08, 0x42, 0xaa, 0x20, 0x98, 0x01, 0x98, 0xc4, 0x26, 0x4e, 0xd3, 0x6f, 0x71,
+	0x31, 0xa2, 0x0a, 0xee, 0x01, 0x8c, 0x1b, 0xfd, 0xe2, 0x07, 0x06, 0x51, 0x42, 0x79, 0x0c, 0xc1,
+	0x14, 0xb8, 0xc8, 0x18, 0xa7, 0x28, 0xa4, 0x59, 0xb1, 0x89, 0xd3, 0xf6, 0xcd, 0xf0, 0x68, 0xdf,
+	0xe6, 0xc2, 0x5d, 0xc9, 0x8d, 0xa1, 0xfe, 0x17, 0x52, 0xaa, 0x90, 0x45, 0x0c, 0xd7, 0x41, 0xb6,
+	0x4c, 0x91, 0x2d, 0x52, 0x06, 0xd2, 0xac, 0xe6, 0x1f, 0xbb, 0x25, 0x7c, 0x2c, 0x98, 0x71, 0xa5,
+	0xb7, 0x81, 0xd3, 0x30, 0x85, 0x20, 0x01, 0x16, 0x27, 0x68, 0xd6, 0x6d, 0xe2, 0x54, 0xfd, 0x3f,
+	0xc7, 0xe2, 0x38, 0xaf, 0x19, 0x13, 0xbd, 0x59, 0x4c, 0xdd, 0xb0, 0x89, 0xd3, 0x1a, 0xb9, 0x9b,
+	0x5d, 0x4f, 0xfb, 0xd8, 0xf5, 0xfa, 0x31, 0xc3, 0x64, 0x19, 0xba, 0x91, 0xc8, 0xbc, 0x48, 0xa8,
+	0x4c, 0xa8, 0xd3, 0x71, 0xad, 0xa6, 0x73, 0x0f, 0xd7, 0x0b, 0x50, 0xee, 0x84, 0xa3, 0xff, 0xeb,
+	0x34, 0xf5, 0x43, 0xad, 0x59, 0xeb, 0xd4, 0xfd, 0x0e, 0xe3, 0x0c, 0x19, 0x4d, 0x8b, 0x65, 0x8c,
+	0xc6, 0x9b, 0xbd, 0x45, 0xb6, 0x7b, 0x8b, 0x7c, 0xee, 0x2d, 0xf2, 0x7a, 0xb0, 0xb4, 0xed, 0xc1,
+	0xd2, 0xde, 0x0f, 0x96, 0xf6, 0xec, 0x9e, 0xb5, 0xc0, 0x84, 0x4a, 0xc5, 0x94, 0x57, 0x26, 0xf5,
+	0x72, 0x96, 0x55, 0xde, 0x2e, 0x6c, 0xe4, 0x7b, 0x1f, 0x7e, 0x05, 0x00, 0x00, 0xff, 0xff, 0xee,
+	0xfc, 0x5c, 0x06, 0xcf, 0x01, 0x00, 0x00,
+}
+
+func (m *Params) 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 *Params) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.BaseFee.Size()
+		i -= size
+		if _, err := m.BaseFee.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintFeemarket(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x32
+	if m.EnableHeight != 0 {
+		i = encodeVarintFeemarket(dAtA, i, uint64(m.EnableHeight))
+		i--
+		dAtA[i] = 0x28
+	}
+	if m.ElasticityMultiplier != 0 {
+		i = encodeVarintFeemarket(dAtA, i, uint64(m.ElasticityMultiplier))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.BaseFeeChangeDenominator != 0 {
+		i = encodeVarintFeemarket(dAtA, i, uint64(m.BaseFeeChangeDenominator))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.NoBaseFee {
+		i--
+		if m.NoBaseFee {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintFeemarket(dAtA []byte, offset int, v uint64) int {
+	offset -= sovFeemarket(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *Params) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.NoBaseFee {
+		n += 2
+	}
+	if m.BaseFeeChangeDenominator != 0 {
+		n += 1 + sovFeemarket(uint64(m.BaseFeeChangeDenominator))
+	}
+	if m.ElasticityMultiplier != 0 {
+		n += 1 + sovFeemarket(uint64(m.ElasticityMultiplier))
+	}
+	if m.EnableHeight != 0 {
+		n += 1 + sovFeemarket(uint64(m.EnableHeight))
+	}
+	l = m.BaseFee.Size()
+	n += 1 + l + sovFeemarket(uint64(l))
+	return n
+}
+
+func sovFeemarket(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozFeemarket(x uint64) (n int) {
+	return sovFeemarket(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *Params) 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 ErrIntOverflowFeemarket
+			}
+			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: Params: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NoBaseFee", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeemarket
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.NoBaseFee = bool(v != 0)
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BaseFeeChangeDenominator", wireType)
+			}
+			m.BaseFeeChangeDenominator = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeemarket
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BaseFeeChangeDenominator |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ElasticityMultiplier", wireType)
+			}
+			m.ElasticityMultiplier = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeemarket
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ElasticityMultiplier |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EnableHeight", wireType)
+			}
+			m.EnableHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeemarket
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EnableHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BaseFee", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeemarket
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthFeemarket
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthFeemarket
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.BaseFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipFeemarket(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthFeemarket
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipFeemarket(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowFeemarket
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowFeemarket
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowFeemarket
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthFeemarket
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupFeemarket
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthFeemarket
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthFeemarket        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowFeemarket          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupFeemarket = fmt.Errorf("proto: unexpected end of group")
+)

x/feemarket/migrations/v010/types/genesis.pb.go

@@ -0,0 +1,356 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: ethermint/feemarket/v1/genesis.proto
+
+package types
+
+import (
+	fmt "fmt"
+	_ "github.com/gogo/protobuf/gogoproto"
+	proto "github.com/gogo/protobuf/proto"
+	io "io"
+	math "math"
+	math_bits "math/bits"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// GenesisState defines the feemarket module's genesis state.
+type GenesisState struct {
+	// params defines all the paramaters of the module.
+	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
+	// block gas is the amount of gas used on the last block before the upgrade.
+	// Zero by default.
+	BlockGas uint64 `protobuf:"varint,3,opt,name=block_gas,json=blockGas,proto3" json:"block_gas,omitempty"`
+}
+
+func (m *GenesisState) Reset()         { *m = GenesisState{} }
+func (m *GenesisState) String() string { return proto.CompactTextString(m) }
+func (*GenesisState) ProtoMessage()    {}
+func (*GenesisState) Descriptor() ([]byte, []int) {
+	return fileDescriptor_6241c21661288629, []int{0}
+}
+func (m *GenesisState) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_GenesisState.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 *GenesisState) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GenesisState.Merge(m, src)
+}
+func (m *GenesisState) XXX_Size() int {
+	return m.Size()
+}
+func (m *GenesisState) XXX_DiscardUnknown() {
+	xxx_messageInfo_GenesisState.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GenesisState proto.InternalMessageInfo
+
+func (m *GenesisState) GetParams() Params {
+	if m != nil {
+		return m.Params
+	}
+	return Params{}
+}
+
+func (m *GenesisState) GetBlockGas() uint64 {
+	if m != nil {
+		return m.BlockGas
+	}
+	return 0
+}
+
+var fileDescriptor_6241c21661288629 = []byte{
+	// 246 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x49, 0x2d, 0xc9, 0x48,
+	0x2d, 0xca, 0xcd, 0xcc, 0x2b, 0xd1, 0x4f, 0x4b, 0x4d, 0xcd, 0x4d, 0x2c, 0xca, 0x4e, 0x2d, 0xd1,
+	0x2f, 0x33, 0xd4, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9,
+	0x17, 0x12, 0x83, 0xab, 0xd2, 0x83, 0xab, 0xd2, 0x2b, 0x33, 0x94, 0x12, 0x49, 0xcf, 0x4f, 0xcf,
+	0x07, 0x2b, 0xd1, 0x07, 0xb1, 0x20, 0xaa, 0xa5, 0xd4, 0x70, 0x98, 0x89, 0xd0, 0x0a, 0x56, 0xa7,
+	0x54, 0xc9, 0xc5, 0xe3, 0x0e, 0xb1, 0x26, 0xb8, 0x24, 0xb1, 0x24, 0x55, 0xc8, 0x86, 0x8b, 0xad,
+	0x20, 0xb1, 0x28, 0x31, 0xb7, 0x58, 0x82, 0x51, 0x81, 0x51, 0x83, 0xdb, 0x48, 0x4e, 0x0f, 0xbb,
+	0xb5, 0x7a, 0x01, 0x60, 0x55, 0x4e, 0x2c, 0x27, 0xee, 0xc9, 0x33, 0x04, 0x41, 0xf5, 0x08, 0x49,
+	0x73, 0x71, 0x26, 0xe5, 0xe4, 0x27, 0x67, 0xc7, 0xa7, 0x27, 0x16, 0x4b, 0x30, 0x2b, 0x30, 0x6a,
+	0xb0, 0x04, 0x71, 0x80, 0x05, 0xdc, 0x13, 0x8b, 0xbd, 0x58, 0x38, 0x98, 0x04, 0x98, 0x83, 0x38,
+	0x92, 0x12, 0x8b, 0x53, 0xe3, 0xd3, 0x52, 0x53, 0x9d, 0x3c, 0x4e, 0x3c, 0x92, 0x63, 0xbc, 0xf0,
+	0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, 0xb8,
+	0xf1, 0x58, 0x8e, 0x21, 0x4a, 0x2f, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57,
+	0xbf, 0x24, 0x23, 0xb1, 0xa8, 0x38, 0xb3, 0x58, 0x1f, 0xe1, 0x9f, 0x0a, 0x24, 0x1f, 0x95, 0x54,
+	0x16, 0xa4, 0x16, 0x27, 0xb1, 0x81, 0xfd, 0x62, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x3c, 0x4e,
+	0x2a, 0x68, 0x49, 0x01, 0x00, 0x00,
+}
+
+func (m *GenesisState) 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 *GenesisState) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.BlockGas != 0 {
+		i = encodeVarintGenesis(dAtA, i, uint64(m.BlockGas))
+		i--
+		dAtA[i] = 0x18
+	}
+	{
+		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenesis(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
+	offset -= sovGenesis(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *GenesisState) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Params.Size()
+	n += 1 + l + sovGenesis(uint64(l))
+	if m.BlockGas != 0 {
+		n += 1 + sovGenesis(uint64(m.BlockGas))
+	}
+	return n
+}
+
+func sovGenesis(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozGenesis(x uint64) (n int) {
+	return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *GenesisState) 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 ErrIntOverflowGenesis
+			}
+			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: GenesisState: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 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.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockGas", wireType)
+			}
+			m.BlockGas = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BlockGas |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenesis(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipGenesis(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowGenesis
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthGenesis
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupGenesis
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthGenesis
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
+)

x/feemarket/migrations/v010/types/params.go

@@ -0,0 +1,134 @@
+package types
+
+import (
+	"fmt"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
+	"github.com/ethereum/go-ethereum/params"
+)
+
+var _ paramtypes.ParamSet = &Params{}
+
+// Parameter keys
+var (
+	ParamStoreKeyNoBaseFee                = []byte("NoBaseFee")
+	ParamStoreKeyBaseFeeChangeDenominator = []byte("BaseFeeChangeDenominator")
+	ParamStoreKeyElasticityMultiplier     = []byte("ElasticityMultiplier")
+	ParamStoreKeyBaseFee                  = []byte("BaseFee")
+	ParamStoreKeyEnableHeight             = []byte("EnableHeight")
+)
+
+// ParamKeyTable returns the parameter key table.
+func ParamKeyTable() paramtypes.KeyTable {
+	return paramtypes.NewKeyTable().RegisterParamSet(&Params{})
+}
+
+// NewParams creates a new Params instance
+func NewParams(noBaseFee bool, baseFeeChangeDenom, elasticityMultiplier uint32, baseFee uint64, enableHeight int64) Params {
+	return Params{
+		NoBaseFee:                noBaseFee,
+		BaseFeeChangeDenominator: baseFeeChangeDenom,
+		ElasticityMultiplier:     elasticityMultiplier,
+		BaseFee:                  sdk.NewIntFromUint64(baseFee),
+		EnableHeight:             enableHeight,
+	}
+}
+
+// DefaultParams returns default evm parameters
+func DefaultParams() Params {
+	return Params{
+		NoBaseFee:                false,
+		BaseFeeChangeDenominator: params.BaseFeeChangeDenominator,
+		ElasticityMultiplier:     params.ElasticityMultiplier,
+		BaseFee:                  sdk.NewIntFromUint64(params.InitialBaseFee),
+		EnableHeight:             0,
+	}
+}
+
+// ParamSetPairs returns the parameter set pairs.
+func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
+	return paramtypes.ParamSetPairs{
+		paramtypes.NewParamSetPair(ParamStoreKeyNoBaseFee, &p.NoBaseFee, validateBool),
+		paramtypes.NewParamSetPair(ParamStoreKeyBaseFeeChangeDenominator, &p.BaseFeeChangeDenominator, validateBaseFeeChangeDenominator),
+		paramtypes.NewParamSetPair(ParamStoreKeyElasticityMultiplier, &p.ElasticityMultiplier, validateElasticityMultiplier),
+		paramtypes.NewParamSetPair(ParamStoreKeyBaseFee, &p.BaseFee, validateBaseFee),
+		paramtypes.NewParamSetPair(ParamStoreKeyEnableHeight, &p.EnableHeight, validateEnableHeight),
+	}
+}
+
+// Validate performs basic validation on fee market parameters.
+func (p Params) Validate() error {
+	if p.BaseFeeChangeDenominator == 0 {
+		return fmt.Errorf("base fee change denominator cannot be 0")
+	}
+
+	if p.BaseFee.IsNegative() {
+		return fmt.Errorf("initial base fee cannot be negative: %s", p.BaseFee)
+	}
+
+	if p.EnableHeight < 0 {
+		return fmt.Errorf("enable height cannot be negative: %d", p.EnableHeight)
+	}
+
+	return nil
+}
+
+func (p *Params) IsBaseFeeEnabled(height int64) bool {
+	return !p.NoBaseFee && height >= p.EnableHeight
+}
+
+func validateBool(i interface{}) error {
+	_, ok := i.(bool)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", i)
+	}
+	return nil
+}
+
+func validateBaseFeeChangeDenominator(i interface{}) error {
+	value, ok := i.(uint32)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", i)
+	}
+
+	if value == 0 {
+		return fmt.Errorf("base fee change denominator cannot be 0")
+	}
+
+	return nil
+}
+
+func validateElasticityMultiplier(i interface{}) error {
+	_, ok := i.(uint32)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", i)
+	}
+	return nil
+}
+
+func validateBaseFee(i interface{}) error {
+	value, ok := i.(sdk.Int)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", i)
+	}
+
+	if value.IsNegative() {
+		return fmt.Errorf("base fee cannot be negative")
+	}
+
+	return nil
+}
+
+func validateEnableHeight(i interface{}) error {
+	value, ok := i.(int64)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", i)
+	}
+
+	if value < 0 {
+		return fmt.Errorf("enable height cannot be negative: %d", value)
+	}
+
+	return nil
+}

x/feemarket/migrations/v011/migrate.go

@@ -0,0 +1,37 @@
+package v011
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
+	v010types "github.com/tharsis/ethermint/x/feemarket/migrations/v010/types"
+	"github.com/tharsis/ethermint/x/feemarket/types"
+)
+
+// MigrateStore adds the MinGasPrice param with a value of 0
+func MigrateStore(ctx sdk.Context, paramstore *paramtypes.Subspace) error {
+	if !paramstore.HasKeyTable() {
+		ps := paramstore.WithKeyTable(types.ParamKeyTable())
+		paramstore = &ps
+	}
+
+	paramstore.Set(ctx, types.ParamStoreKeyMinGasPrice, sdk.ZeroDec())
+	return nil
+}
+
+// MigrateJSON accepts exported v0.10 x/feemarket genesis state and migrates it to
+// v0.11 x/feemarket genesis state. The migration includes:
+// - add MinGasPrice param
+func MigrateJSON(oldState v010types.GenesisState) types.GenesisState {
+	return types.GenesisState{
+		Params: types.Params{
+			NoBaseFee:                oldState.Params.NoBaseFee,
+			BaseFeeChangeDenominator: oldState.Params.BaseFeeChangeDenominator,
+			ElasticityMultiplier:     oldState.Params.ElasticityMultiplier,
+			EnableHeight:             oldState.Params.EnableHeight,
+			BaseFee:                  oldState.Params.BaseFee,
+			MinGasPrice:              sdk.ZeroDec(),
+		},
+		BlockGas: oldState.BlockGas,
+	}
+}

x/feemarket/migrations/v011/migrate_test.go

@@ -0,0 +1,73 @@
+package v011_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/testutil"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
+
+	"github.com/tharsis/ethermint/encoding"
+
+	"github.com/tharsis/ethermint/app"
+	v010types "github.com/tharsis/ethermint/x/feemarket/migrations/v010/types"
+	v011 "github.com/tharsis/ethermint/x/feemarket/migrations/v011"
+	feemarkettypes "github.com/tharsis/ethermint/x/feemarket/types"
+)
+
+func TestMigrateStore(t *testing.T) {
+	encCfg := encoding.MakeConfig(app.ModuleBasics)
+	feemarketKey := sdk.NewKVStoreKey(feemarkettypes.StoreKey)
+	tFeeMarketKey := sdk.NewTransientStoreKey(fmt.Sprintf("%s_test", feemarkettypes.StoreKey))
+	ctx := testutil.DefaultContext(feemarketKey, tFeeMarketKey)
+	paramstore := paramtypes.NewSubspace(
+		encCfg.Marshaler, encCfg.Amino, feemarketKey, tFeeMarketKey, "feemarket",
+	)
+
+	paramstore = paramstore.WithKeyTable(feemarkettypes.ParamKeyTable())
+	require.True(t, paramstore.HasKeyTable())
+
+	// check no MinGasPrice param
+	require.False(t, paramstore.Has(ctx, feemarkettypes.ParamStoreKeyMinGasPrice))
+
+	// Run migrations
+	err := v011.MigrateStore(ctx, &paramstore)
+	require.NoError(t, err)
+
+	// Make sure the params are set
+	require.True(t, paramstore.Has(ctx, feemarkettypes.ParamStoreKeyMinGasPrice))
+
+	var minGasPrice sdk.Dec
+
+	// Make sure the new params are set
+	require.NotPanics(t, func() {
+		paramstore.Get(ctx, feemarkettypes.ParamStoreKeyMinGasPrice, &minGasPrice)
+	})
+
+	// check the params are updated
+	require.True(t, minGasPrice.IsZero())
+}
+
+func TestMigrateJSON(t *testing.T) {
+	rawJson := `{
+		"block_gas": "0",
+		"params": {
+			"base_fee_change_denominator": 8,
+			"elasticity_multiplier": 2,
+			"enable_height": "0",
+			"base_fee": "1000000000",
+			"no_base_fee": false
+		}
+  }`
+	encCfg := encoding.MakeConfig(app.ModuleBasics)
+	var genState v010types.GenesisState
+	err := encCfg.Marshaler.UnmarshalJSON([]byte(rawJson), &genState)
+	require.NoError(t, err)
+
+	migratedGenState := v011.MigrateJSON(genState)
+
+	require.True(t, migratedGenState.Params.MinGasPrice.IsZero())
+}

x/feemarket/module.go

@@ -44,7 +44,7 @@ func (AppModuleBasic) RegisterLegacyAminoCodec(_ *codec.LegacyAmino) {
 
 // ConsensusVersion returns the consensus state-breaking version for the module.
 func (AppModuleBasic) ConsensusVersion() uint64 {
-	return 2
+	return 3
 }
 
 // DefaultGenesis returns default genesis state as raw bytes for the fee market
@@ -122,6 +122,11 @@ func (am AppModule) RegisterServices(cfg module.Configurator) {
 	if err != nil {
 		panic(err)
 	}
+
+	err = cfg.RegisterMigration(types.ModuleName, 2, m.Migrate2to3)
+	if err != nil {
+		panic(err)
+	}
 }
 
 // Route returns the message routing key for the fee market module.

x/feemarket/simulation/genesis.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/module"
 
 	"github.com/tharsis/ethermint/x/feemarket/types"
@@ -11,7 +12,8 @@ import (
 
 // RandomizedGenState generates a random GenesisState for nft
 func RandomizedGenState(simState *module.SimulationState) {
-	params := types.NewParams(simState.Rand.Uint32()%2 == 0, simState.Rand.Uint32(), simState.Rand.Uint32(), simState.Rand.Uint64(), simState.Rand.Int63())
+	params := types.NewParams(simState.Rand.Uint32()%2 == 0, simState.Rand.Uint32(), simState.Rand.Uint32(), simState.Rand.Uint64(), simState.Rand.Int63(), sdk.ZeroDec())
+
 	blockGas := simState.Rand.Uint64()
 	feemarketGenesis := types.NewGenesisState(params, blockGas)
 

x/feemarket/spec/01_concepts.md

@@ -33,3 +33,6 @@ Transactions specify a maximum fee per gas they are willing to pay total (aka: m
 
 Reference: [EIP1559](https://eips.ethereum.org/EIPS/eip-1559)
 
+## Global Minimum Gas Price
+
+The minimum gas price needed for transactions to be processed. It applies to both Cosmos and EVM transactions. Governance can change this `feemarket` module parameter value. If the effective gas price or the minimum gas price is lower than the global `MinGasPrice` (`min-gas-price (local) < MinGasPrice (global) OR EffectiveGasPrice < MinGasPrice`), then `MinGasPrice` is used as a lower bound. If transactions are rejected due to having a gas price lower than `MinGasPrice`, users need to resend the transactions with a gas price higher than `MinGasPrice`. In the case of EIP-1559 (dynamic fee transactions), users must increase the priority fee for their transactions to be valid.

x/feemarket/spec/07_params.md

@@ -11,4 +11,5 @@ The `x/feemarket` module contains the following parameters:
 | BaseFeeChangeDenominator      | uint32 | 8           | bounds the amount the base fee that can change between blocks |
 | ElasticityMultiplier          | uint32 | 2           | bounds the threshold which the base fee will increase or decrease depending on the total gas used in the previous block|
 | BaseFee                      | uint32 | 1000000000  | base fee for EIP-1559 blocks |
-| EnableHeight                  | uint32 | 0           | height which enable fee adjustment |
+| EnableHeight                  | uint32 | 0           | height which enable fee adjustment |
+| MinGasPrice                   | sdk.Dec | 0          | global minimum gas price that needs to be paid to include a transaction in a block |

x/feemarket/spec/09_antehandlers.md

@@ -0,0 +1,25 @@
+<!--
+order: 5
+-->
+
+# AnteHandlers
+
+The `x/feemarket` module provides `AnteDecorator`s that are recursively chained together into a single [`Antehandler`](https://github.com/cosmos/cosmos-sdk/blob/v0.43.0-alpha1/docs/architecture/adr-010-modular-antehandler.md). These decorators perform basic validity checks on an Ethereum or Cosmos SDK transaction, such that it could be thrown out of the transaction Mempool.
+
+Note that the `AnteHandler` is run for every transaction and called on both `CheckTx` and `DeliverTx`.
+
+## Decorators
+
+### `MinGasPriceDecorator`
+
+Rejects Cosmos SDK transactions with transaction fees lower than `MinGasPrice * GasLimit`.
+
+### `EthMinGasPriceDecorator`
+
+Rejects EVM transactions with transactions fees lower than `MinGasPrice * GasLimit`.
+    - For `LegacyTx` and `AccessListTx`, the `GasPrice * GasLimit` is used.
+    - For EIP-1559 (*aka.* `DynamicFeeTx`), the `EffectivePrice * GasLimit` is used.
+
+::: tip
+**Note**: For dynamic transactions, if the `feemarket` formula results in a `BaseFee` that lowers `EffectivePrice < MinGasPrices`, the users must increase the `GasTipCap` (priority fee) until `EffectivePrice > MinGasPrices`. Transactions with `MinGasPrices * GasLimit < transaction fee < EffectiveFee` are rejected by the `feemarket` `AnteHandle`.
+:::

x/feemarket/types/feemarket.pb.go

@@ -38,6 +38,8 @@ type Params struct {
 	EnableHeight int64 `protobuf:"varint,5,opt,name=enable_height,json=enableHeight,proto3" json:"enable_height,omitempty"`
 	// base fee for EIP-1559 blocks.
 	BaseFee github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,6,opt,name=base_fee,json=baseFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"base_fee"`
+	// min_gas_price defines the minimum gas price value for cosmos and eth transactions
+	MinGasPrice github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,7,opt,name=min_gas_price,json=minGasPrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"min_gas_price"`
 }
 
 func (m *Params) Reset()         { *m = Params{} }
@@ -110,29 +112,31 @@ func init() {
 }
 
 var fileDescriptor_4feb8b20cf98e6e1 = []byte{
-	// 343 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x91, 0xcf, 0x6a, 0xea, 0x40,
-	0x14, 0x87, 0x33, 0xfe, 0xbb, 0x9a, 0x7b, 0x05, 0x09, 0xde, 0x4b, 0xb8, 0x85, 0x18, 0x5a, 0x90,
-	0x6c, 0x9a, 0x20, 0xae, 0xbb, 0xb1, 0xa5, 0x68, 0xa1, 0x50, 0xb2, 0xec, 0x26, 0x4c, 0xe2, 0x31,
-	0x19, 0x4c, 0x66, 0x64, 0xe6, 0x28, 0xf5, 0x2d, 0xfa, 0x10, 0x7d, 0x18, 0x97, 0x2e, 0x4b, 0x17,
-	0x52, 0xf4, 0x45, 0x4a, 0xa3, 0x4d, 0x5c, 0xcd, 0xcc, 0xf9, 0xbe, 0xe1, 0x1c, 0xce, 0x4f, 0xef,
-	0x03, 0x26, 0x20, 0x33, 0xc6, 0xd1, 0x9b, 0x01, 0x64, 0x54, 0xce, 0x01, 0xbd, 0xd5, 0xa0, 0x7c,
-	0xb8, 0x0b, 0x29, 0x50, 0x18, 0xff, 0x0a, 0xcf, 0x2d, 0xd1, 0x6a, 0xf0, 0xbf, 0x1b, 0x8b, 0x58,
-	0xe4, 0x8a, 0xf7, 0x7d, 0x3b, 0xda, 0x97, 0x6f, 0x15, 0xbd, 0xf1, 0x44, 0x25, 0xcd, 0x94, 0x61,
-	0xe9, 0xbf, 0xb9, 0x08, 0x42, 0xaa, 0x20, 0x98, 0x01, 0x98, 0xc4, 0x26, 0x4e, 0xd3, 0x6f, 0x71,
-	0x31, 0xa2, 0x0a, 0xee, 0x01, 0x8c, 0x1b, 0xfd, 0xe2, 0x07, 0x06, 0x51, 0x42, 0x79, 0x0c, 0xc1,
-	0x14, 0xb8, 0xc8, 0x18, 0xa7, 0x28, 0xa4, 0x59, 0xb1, 0x89, 0xd3, 0xf6, 0xcd, 0xf0, 0x68, 0xdf,
-	0xe6, 0xc2, 0x5d, 0xc9, 0x8d, 0xa1, 0xfe, 0x17, 0x52, 0xaa, 0x90, 0x45, 0x0c, 0xd7, 0x41, 0xb6,
-	0x4c, 0x91, 0x2d, 0x52, 0x06, 0xd2, 0xac, 0xe6, 0x1f, 0xbb, 0x25, 0x7c, 0x2c, 0x98, 0x71, 0xa5,
-	0xb7, 0x81, 0xd3, 0x30, 0x85, 0x20, 0x01, 0x16, 0x27, 0x68, 0xd6, 0x6d, 0xe2, 0x54, 0xfd, 0x3f,
-	0xc7, 0xe2, 0x38, 0xaf, 0x19, 0x13, 0xbd, 0x59, 0x4c, 0xdd, 0xb0, 0x89, 0xd3, 0x1a, 0xb9, 0x9b,
-	0x5d, 0x4f, 0xfb, 0xd8, 0xf5, 0xfa, 0x31, 0xc3, 0x64, 0x19, 0xba, 0x91, 0xc8, 0xbc, 0x48, 0xa8,
-	0x4c, 0xa8, 0xd3, 0x71, 0xad, 0xa6, 0x73, 0x0f, 0xd7, 0x0b, 0x50, 0xee, 0x84, 0xa3, 0xff, 0xeb,
-	0x34, 0xf5, 0x43, 0xad, 0x59, 0xeb, 0xd4, 0xfd, 0x0e, 0xe3, 0x0c, 0x19, 0x4d, 0x8b, 0x65, 0x8c,
-	0xc6, 0x9b, 0xbd, 0x45, 0xb6, 0x7b, 0x8b, 0x7c, 0xee, 0x2d, 0xf2, 0x7a, 0xb0, 0xb4, 0xed, 0xc1,
-	0xd2, 0xde, 0x0f, 0x96, 0xf6, 0xec, 0x9e, 0xb5, 0xc0, 0x84, 0x4a, 0xc5, 0x94, 0x57, 0x26, 0xf5,
-	0x72, 0x96, 0x55, 0xde, 0x2e, 0x6c, 0xe4, 0x7b, 0x1f, 0x7e, 0x05, 0x00, 0x00, 0xff, 0xff, 0xee,
-	0xfc, 0x5c, 0x06, 0xcf, 0x01, 0x00, 0x00,
+	// 371 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x91, 0x4f, 0xeb, 0xda, 0x30,
+	0x18, 0xc7, 0x9b, 0xdf, 0x1f, 0xff, 0xc4, 0x09, 0x52, 0xdc, 0x28, 0x1b, 0xd4, 0xb2, 0x81, 0xf4,
+	0xb2, 0x16, 0xf1, 0xbc, 0x8b, 0x93, 0x4d, 0x07, 0x03, 0xe9, 0x71, 0x97, 0x90, 0xd6, 0xc7, 0x36,
+	0xd8, 0x24, 0x25, 0x89, 0x32, 0xdf, 0xc5, 0x5e, 0x96, 0x47, 0x8f, 0x63, 0x07, 0x19, 0xfa, 0x26,
+	0x76, 0x1c, 0x56, 0xd7, 0x7a, 0xdd, 0xa9, 0xcd, 0xf3, 0xf9, 0xe4, 0x79, 0x1e, 0xf2, 0xc5, 0x43,
+	0x30, 0x19, 0x28, 0xce, 0x84, 0x09, 0x57, 0x00, 0x9c, 0xaa, 0x35, 0x98, 0x70, 0x3b, 0xaa, 0x0f,
+	0x41, 0xa1, 0xa4, 0x91, 0xf6, 0xab, 0xca, 0x0b, 0x6a, 0xb4, 0x1d, 0xbd, 0xee, 0xa7, 0x32, 0x95,
+	0xa5, 0x12, 0x5e, 0xfe, 0xae, 0xf6, 0xdb, 0x3f, 0x0f, 0xb8, 0xb1, 0xa0, 0x8a, 0x72, 0x6d, 0xbb,
+	0xb8, 0x23, 0x24, 0x89, 0xa9, 0x06, 0xb2, 0x02, 0x70, 0x90, 0x87, 0xfc, 0x56, 0xd4, 0x16, 0x72,
+	0x42, 0x35, 0x7c, 0x02, 0xb0, 0x3f, 0xe0, 0x37, 0xff, 0x20, 0x49, 0x32, 0x2a, 0x52, 0x20, 0x4b,
+	0x10, 0x92, 0x33, 0x41, 0x8d, 0x54, 0xce, 0x83, 0x87, 0xfc, 0x6e, 0xe4, 0xc4, 0x57, 0xfb, 0x63,
+	0x29, 0x4c, 0x6b, 0x6e, 0x8f, 0xf1, 0x4b, 0xc8, 0xa9, 0x36, 0x2c, 0x61, 0x66, 0x47, 0xf8, 0x26,
+	0x37, 0xac, 0xc8, 0x19, 0x28, 0xe7, 0xb1, 0xbc, 0xd8, 0xaf, 0xe1, 0xd7, 0x8a, 0xd9, 0xef, 0x70,
+	0x17, 0x04, 0x8d, 0x73, 0x20, 0x19, 0xb0, 0x34, 0x33, 0xce, 0xb3, 0x87, 0xfc, 0xc7, 0xe8, 0xc5,
+	0xb5, 0x38, 0x2b, 0x6b, 0xf6, 0x1c, 0xb7, 0xaa, 0xad, 0x1b, 0x1e, 0xf2, 0xdb, 0x93, 0x60, 0x7f,
+	0x1c, 0x58, 0xbf, 0x8e, 0x83, 0x61, 0xca, 0x4c, 0xb6, 0x89, 0x83, 0x44, 0xf2, 0x30, 0x91, 0x9a,
+	0x4b, 0x7d, 0xfb, 0xbc, 0xd7, 0xcb, 0x75, 0x68, 0x76, 0x05, 0xe8, 0x60, 0x2e, 0x4c, 0xd4, 0xbc,
+	0x6d, 0x6d, 0x47, 0xb8, 0xcb, 0x99, 0x20, 0x29, 0xd5, 0xa4, 0x50, 0x2c, 0x01, 0xa7, 0xf9, 0xdf,
+	0xfd, 0xa6, 0x90, 0x44, 0x1d, 0xce, 0xc4, 0x67, 0xaa, 0x17, 0x97, 0x16, 0x5f, 0x9e, 0x5a, 0x4f,
+	0xbd, 0xe7, 0xa8, 0xc7, 0x04, 0x33, 0x8c, 0xe6, 0xd5, 0x03, 0x4f, 0x66, 0xfb, 0x93, 0x8b, 0x0e,
+	0x27, 0x17, 0xfd, 0x3e, 0xb9, 0xe8, 0xc7, 0xd9, 0xb5, 0x0e, 0x67, 0xd7, 0xfa, 0x79, 0x76, 0xad,
+	0x6f, 0xc1, 0xdd, 0x18, 0x93, 0x51, 0xa5, 0x99, 0x0e, 0xeb, 0xf4, 0xbf, 0xdf, 0xe5, 0x5f, 0x8e,
+	0x8c, 0x1b, 0x65, 0x96, 0xe3, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x3c, 0x5d, 0x33, 0x70, 0x23,
+	0x02, 0x00, 0x00,
 }
 
 func (m *Params) Marshal() (dAtA []byte, err error) {
@@ -155,6 +159,16 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	{
+		size := m.MinGasPrice.Size()
+		i -= size
+		if _, err := m.MinGasPrice.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintFeemarket(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x3a
 	{
 		size := m.BaseFee.Size()
 		i -= size
@@ -224,6 +238,8 @@ func (m *Params) Size() (n int) {
 	}
 	l = m.BaseFee.Size()
 	n += 1 + l + sovFeemarket(uint64(l))
+	l = m.MinGasPrice.Size()
+	n += 1 + l + sovFeemarket(uint64(l))
 	return n
 }
 
@@ -373,6 +389,40 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MinGasPrice", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeemarket
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthFeemarket
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthFeemarket
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.MinGasPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipFeemarket(dAtA[iNdEx:])

x/feemarket/types/params.go

@@ -17,6 +17,7 @@ var (
 	ParamStoreKeyElasticityMultiplier     = []byte("ElasticityMultiplier")
 	ParamStoreKeyBaseFee                  = []byte("BaseFee")
 	ParamStoreKeyEnableHeight             = []byte("EnableHeight")
+	ParamStoreKeyMinGasPrice              = []byte("MinGasPrice")
 )
 
 // ParamKeyTable returns the parameter key table.
@@ -25,13 +26,21 @@ func ParamKeyTable() paramtypes.KeyTable {
 }
 
 // NewParams creates a new Params instance
-func NewParams(noBaseFee bool, baseFeeChangeDenom, elasticityMultiplier uint32, baseFee uint64, enableHeight int64) Params {
+func NewParams(
+	noBaseFee bool,
+	baseFeeChangeDenom,
+	elasticityMultiplier uint32,
+	baseFee uint64,
+	enableHeight int64,
+	minGasPrice sdk.Dec,
+) Params {
 	return Params{
 		NoBaseFee:                noBaseFee,
 		BaseFeeChangeDenominator: baseFeeChangeDenom,
 		ElasticityMultiplier:     elasticityMultiplier,
 		BaseFee:                  sdk.NewIntFromUint64(baseFee),
 		EnableHeight:             enableHeight,
+		MinGasPrice:              minGasPrice,
 	}
 }
 
@@ -43,6 +52,7 @@ func DefaultParams() Params {
 		ElasticityMultiplier:     params.ElasticityMultiplier,
 		BaseFee:                  sdk.NewIntFromUint64(params.InitialBaseFee),
 		EnableHeight:             0,
+		MinGasPrice:              sdk.ZeroDec(),
 	}
 }
 
@@ -54,6 +64,7 @@ func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
 		paramtypes.NewParamSetPair(ParamStoreKeyElasticityMultiplier, &p.ElasticityMultiplier, validateElasticityMultiplier),
 		paramtypes.NewParamSetPair(ParamStoreKeyBaseFee, &p.BaseFee, validateBaseFee),
 		paramtypes.NewParamSetPair(ParamStoreKeyEnableHeight, &p.EnableHeight, validateEnableHeight),
+		paramtypes.NewParamSetPair(ParamStoreKeyMinGasPrice, &p.MinGasPrice, validateMinGasPrice),
 	}
 }
 
@@ -71,7 +82,7 @@ func (p Params) Validate() error {
 		return fmt.Errorf("enable height cannot be negative: %d", p.EnableHeight)
 	}
 
-	return nil
+	return validateMinGasPrice(p.MinGasPrice)
 }
 
 func (p *Params) IsBaseFeeEnabled(height int64) bool {
@@ -132,3 +143,21 @@ func validateEnableHeight(i interface{}) error {
 
 	return nil
 }
+
+func validateMinGasPrice(i interface{}) error {
+	v, ok := i.(sdk.Dec)
+
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", i)
+	}
+
+	if v.IsNil() {
+		return fmt.Errorf("invalid parameter: nil")
+	}
+
+	if v.IsNegative() {
+		return fmt.Errorf("value cannot be negative: %s", i)
+	}
+
+	return nil
+}

x/feemarket/types/params_test.go

@@ -1,9 +1,10 @@
 package types
 
 import (
-	sdk "github.com/cosmos/cosmos-sdk/types"
 	"testing"
 
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
 	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
 	"github.com/stretchr/testify/suite"
 )
@@ -29,7 +30,7 @@ func (suite *ParamsTestSuite) TestParamsValidate() {
 		{"default", DefaultParams(), false},
 		{
 			"valid",
-			NewParams(true, 7, 3, 2000000000, int64(544435345345435345)),
+			NewParams(true, 7, 3, 2000000000, int64(544435345345435345), sdk.NewDecWithPrec(20, 4)),
 			false,
 		},
 		{
@@ -39,7 +40,12 @@ func (suite *ParamsTestSuite) TestParamsValidate() {
 		},
 		{
 			"base fee change denominator is 0 ",
-			NewParams(true, 0, 3, 2000000000, int64(544435345345435345)),
+			NewParams(true, 0, 3, 2000000000, int64(544435345345435345), sdk.NewDecWithPrec(20, 4)),
+			true,
+		},
+		{
+			"invalid: min gas price negative",
+			NewParams(true, 7, 3, 2000000000, int64(544435345345435345), sdk.NewDecFromInt(sdk.NewInt(-1))),
 			true,
 		},
 	}
@@ -71,3 +77,30 @@ func (suite *ParamsTestSuite) TestParamsValidatePriv() {
 	suite.Require().Error(validateEnableHeight(int64(-544435345345435345)))
 	suite.Require().NoError(validateEnableHeight(int64(544435345345435345)))
 }
+
+func (suite *ParamsTestSuite) TestParamsValidateMinGasPrice() {
+	testCases := []struct {
+		name     string
+		value    interface{}
+		expError bool
+	}{
+		{"default", DefaultParams().MinGasPrice, false},
+		{"valid", sdk.NewDecFromInt(sdk.NewInt(1)), false},
+		{"invalid - wrong type - bool", false, true},
+		{"invalid - wrong type - string", "", true},
+		{"invalid - wrong type - int64", int64(123), true},
+		{"invalid - wrong type - sdk.Int", sdk.NewInt(1), true},
+		{"invalid - is nil", nil, true},
+		{"invalid - is negative", sdk.NewDecFromInt(sdk.NewInt(-1)), true},
+	}
+
+	for _, tc := range testCases {
+		err := validateMinGasPrice(tc.value)
+
+		if tc.expError {
+			suite.Require().Error(err, tc.name)
+		} else {
+			suite.Require().NoError(err, tc.name)
+		}
+	}
+}