diff --git a/indexer/kv_indexer.go b/indexer/kv_indexer.go
index 26b4c40468..a9f79de6c3 100644
--- a/indexer/kv_indexer.go
+++ b/indexer/kv_indexer.go
@@ -71,7 +71,7 @@ func (kv *KVIndexer) IndexBlock(block *tmtypes.Block, txResults []*abci.Response
 	var ethTxIndex int32
 	for txIndex, tx := range block.Txs {
 		result := txResults[txIndex]
-		if !rpctypes.TxSuccessOrExceedsBlockGasLimit(result) {
+		if !rpctypes.TxSucessOrExpectedFailure(result) {
 			continue
 		}
 
diff --git a/proto/ethermint/evm/v1/query.proto b/proto/ethermint/evm/v1/query.proto
index e533edc927..795dec2650 100644
--- a/proto/ethermint/evm/v1/query.proto
+++ b/proto/ethermint/evm/v1/query.proto
@@ -255,6 +255,8 @@ message QueryTraceTxRequest {
   bytes proposer_address = 8 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ConsAddress"];
   // chain_id is the the eip155 chain id parsed from the requested block header
   int64 chain_id = 9;
+  // block_max_gas of the block of the requested transaction
+  int64 block_max_gas = 10;
 }
 
 // QueryTraceTxResponse defines TraceTx response
@@ -279,6 +281,8 @@ message QueryTraceBlockRequest {
   bytes proposer_address = 8 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ConsAddress"];
   // chain_id is the eip155 chain id parsed from the requested block header
   int64 chain_id = 9;
+  // block_max_gas of the traced block
+  int64 block_max_gas = 10;
 }
 
 // QueryTraceBlockResponse defines TraceBlock response
diff --git a/rpc/backend/blocks.go b/rpc/backend/blocks.go
index c4f09d7009..c6960626ec 100644
--- a/rpc/backend/blocks.go
+++ b/rpc/backend/blocks.go
@@ -257,8 +257,9 @@ func (b *Backend) EthMsgsFromTendermintBlock(
 	for i, tx := range block.Txs {
 		// Check if tx exists on EVM by cross checking with blockResults:
 		//  - Include unsuccessful tx that exceeds block gas limit
+		//  - Include unsuccessful tx that failed when committing changes to stateDB
 		//  - Exclude unsuccessful tx with any other error but ExceedBlockGasLimit
-		if !rpctypes.TxSuccessOrExceedsBlockGasLimit(txResults[i]) {
+		if !rpctypes.TxSucessOrExpectedFailure(txResults[i]) {
 			b.logger.Debug("invalid tx result code", "cosmos-hash", hexutil.Encode(tx.Hash()))
 			continue
 		}
diff --git a/rpc/backend/evm_query_client_test.go b/rpc/backend/evm_query_client_test.go
index 00adc0dcbd..9779bc1d5f 100644
--- a/rpc/backend/evm_query_client_test.go
+++ b/rpc/backend/evm_query_client_test.go
@@ -34,18 +34,18 @@ var _ evmtypes.QueryClient = &mocks.EVMQueryClient{}
 func RegisterTraceTransactionWithPredecessors(queryClient *mocks.EVMQueryClient, msgEthTx *evmtypes.MsgEthereumTx, predecessors []*evmtypes.MsgEthereumTx) {
 	data := []byte{0x7b, 0x22, 0x74, 0x65, 0x73, 0x74, 0x22, 0x3a, 0x20, 0x22, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x22, 0x7d}
 	queryClient.On("TraceTx", rpc.ContextWithHeight(1),
-		&evmtypes.QueryTraceTxRequest{Msg: msgEthTx, BlockNumber: 1, Predecessors: predecessors, ChainId: 9000}).
+		&evmtypes.QueryTraceTxRequest{Msg: msgEthTx, BlockNumber: 1, Predecessors: predecessors, ChainId: 9000, BlockMaxGas: -1}).
 		Return(&evmtypes.QueryTraceTxResponse{Data: data}, nil)
 }
 
 func RegisterTraceTransaction(queryClient *mocks.EVMQueryClient, msgEthTx *evmtypes.MsgEthereumTx) {
 	data := []byte{0x7b, 0x22, 0x74, 0x65, 0x73, 0x74, 0x22, 0x3a, 0x20, 0x22, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x22, 0x7d}
-	queryClient.On("TraceTx", rpc.ContextWithHeight(1), &evmtypes.QueryTraceTxRequest{Msg: msgEthTx, BlockNumber: 1, ChainId: 9000}).
+	queryClient.On("TraceTx", rpc.ContextWithHeight(1), &evmtypes.QueryTraceTxRequest{Msg: msgEthTx, BlockNumber: 1, ChainId: 9000, BlockMaxGas: -1}).
 		Return(&evmtypes.QueryTraceTxResponse{Data: data}, nil)
 }
 
 func RegisterTraceTransactionError(queryClient *mocks.EVMQueryClient, msgEthTx *evmtypes.MsgEthereumTx) {
-	queryClient.On("TraceTx", rpc.ContextWithHeight(1), &evmtypes.QueryTraceTxRequest{Msg: msgEthTx, BlockNumber: 1, ChainId: 9000}).
+	queryClient.On("TraceTx", rpc.ContextWithHeight(1), &evmtypes.QueryTraceTxRequest{Msg: msgEthTx, BlockNumber: 1, ChainId: 9000, BlockMaxGas: -1}).
 		Return(nil, errortypes.ErrInvalidRequest)
 }
 
diff --git a/rpc/backend/tracing.go b/rpc/backend/tracing.go
index 64aee968ed..c6eb201662 100644
--- a/rpc/backend/tracing.go
+++ b/rpc/backend/tracing.go
@@ -92,6 +92,12 @@ func (b *Backend) TraceTransaction(hash common.Hash, config *evmtypes.TraceConfi
 		return nil, fmt.Errorf("invalid transaction type %T", tx)
 	}
 
+	// fetch consensus params for determining block max gas value
+	cp, err := b.clientCtx.Client.ConsensusParams(b.ctx, &blk.Block.Height)
+	if err != nil {
+		return nil, err
+	}
+
 	traceTxRequest := evmtypes.QueryTraceTxRequest{
 		Msg:             ethMessage,
 		Predecessors:    predecessors,
@@ -100,6 +106,7 @@ func (b *Backend) TraceTransaction(hash common.Hash, config *evmtypes.TraceConfi
 		BlockHash:       common.Bytes2Hex(blk.BlockID.Hash),
 		ProposerAddress: sdk.ConsAddress(blk.Block.ProposerAddress),
 		ChainId:         b.chainID.Int64(),
+		BlockMaxGas:     cp.ConsensusParams.Block.MaxGas,
 	}
 
 	if config != nil {
@@ -171,6 +178,12 @@ func (b *Backend) TraceBlock(height rpctypes.BlockNumber,
 	}
 	ctxWithHeight := rpctypes.ContextWithHeight(int64(contextHeight))
 
+	// fetch consensus params for determining block max gas value
+	cp, err := b.clientCtx.Client.ConsensusParams(b.ctx, &block.Block.Height)
+	if err != nil {
+		return nil, err
+	}
+
 	traceBlockRequest := &evmtypes.QueryTraceBlockRequest{
 		Txs:             txsMessages,
 		TraceConfig:     config,
@@ -179,6 +192,7 @@ func (b *Backend) TraceBlock(height rpctypes.BlockNumber,
 		BlockHash:       common.Bytes2Hex(block.BlockID.Hash),
 		ProposerAddress: sdk.ConsAddress(block.Block.ProposerAddress),
 		ChainId:         b.chainID.Int64(),
+		BlockMaxGas:     cp.ConsensusParams.Block.MaxGas,
 	}
 
 	res, err := b.queryClient.TraceBlock(ctxWithHeight, traceBlockRequest)
diff --git a/rpc/backend/tracing_test.go b/rpc/backend/tracing_test.go
index ba2d8bcbc5..cc56d35dc1 100644
--- a/rpc/backend/tracing_test.go
+++ b/rpc/backend/tracing_test.go
@@ -106,10 +106,15 @@ func (suite *BackendTestSuite) TestTraceTransaction() {
 		{
 			"pass - transaction found in a block with multiple transactions",
 			func() {
-				queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient)
-				client := suite.backend.clientCtx.Client.(*mocks.Client)
-				RegisterBlockMultipleTxs(client, 1, []types.Tx{txBz, txBz2})
+				var (
+					queryClient       = suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient)
+					client            = suite.backend.clientCtx.Client.(*mocks.Client)
+					height      int64 = 1
+				)
+				_, err := RegisterBlockMultipleTxs(client, height, []types.Tx{txBz, txBz2})
+				suite.Require().NoError(err)
 				RegisterTraceTransactionWithPredecessors(queryClient, msgEthereumTx, []*evmtypes.MsgEthereumTx{msgEthereumTx})
+				RegisterConsensusParams(client, height)
 			},
 			&types.Block{Header: types.Header{Height: 1, ChainID: ChainID}, Data: types.Data{Txs: []types.Tx{txBz, txBz2}}},
 			[]*abci.ResponseDeliverTx{
@@ -146,10 +151,15 @@ func (suite *BackendTestSuite) TestTraceTransaction() {
 		{
 			"pass - transaction found",
 			func() {
-				queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient)
-				client := suite.backend.clientCtx.Client.(*mocks.Client)
-				RegisterBlock(client, 1, txBz)
+				var (
+					queryClient       = suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient)
+					client            = suite.backend.clientCtx.Client.(*mocks.Client)
+					height      int64 = 1
+				)
+				_, err := RegisterBlock(client, height, txBz)
+				suite.Require().NoError(err)
 				RegisterTraceTransaction(queryClient, msgEthereumTx)
+				RegisterConsensusParams(client, height)
 			},
 			&types.Block{Header: types.Header{Height: 1}, Data: types.Data{Txs: []types.Tx{txBz}}},
 			[]*abci.ResponseDeliverTx{
@@ -223,7 +233,9 @@ func (suite *BackendTestSuite) TestTraceBlock() {
 			"fail - cannot unmarshal data",
 			func() {
 				queryClient := suite.backend.queryClient.QueryClient.(*mocks.EVMQueryClient)
+				client := suite.backend.clientCtx.Client.(*mocks.Client)
 				RegisterTraceBlock(queryClient, []*evmtypes.MsgEthereumTx{msgEthTx})
+				RegisterConsensusParams(client, 1)
 			},
 			[]*evmtypes.TxTraceResult{},
 			&resBlockFilled,
diff --git a/rpc/backend/tx_info.go b/rpc/backend/tx_info.go
index 687b4c1617..58dbd8b7b3 100644
--- a/rpc/backend/tx_info.go
+++ b/rpc/backend/tx_info.go
@@ -341,7 +341,7 @@ func (b *Backend) queryTendermintTxIndexer(query string, txGetter func(*rpctypes
 		return nil, errors.New("ethereum tx not found")
 	}
 	txResult := resTxs.Txs[0]
-	if !rpctypes.TxSuccessOrExceedsBlockGasLimit(&txResult.TxResult) {
+	if !rpctypes.TxSucessOrExpectedFailure(&txResult.TxResult) {
 		return nil, errors.New("invalid ethereum tx")
 	}
 
diff --git a/rpc/types/utils.go b/rpc/types/utils.go
index fcafeec019..b8a4ec18ef 100644
--- a/rpc/types/utils.go
+++ b/rpc/types/utils.go
@@ -43,6 +43,11 @@ import (
 // The tx fee is deducted in ante handler, so it shouldn't be ignored in JSON-RPC API.
 const ExceedBlockGasLimitError = "out of gas in location: block gas meter; gasWanted:"
 
+// StateDBCommitError defines the error message when commit after executing EVM transaction, for example
+// transfer native token to a distribution module account 0x93354845030274cD4bf1686Abd60AB28EC52e1a7 using an evm type transaction
+// note: the transfer amount cannot be set to 0, otherwise this problem will not be triggered
+const StateDBCommitError = "failed to commit stateDB"
+
 // RawTxToEthTx returns a evm MsgEthereum transaction from raw tx bytes.
 func RawTxToEthTx(clientCtx client.Context, txBz tmtypes.Tx) ([]*evmtypes.MsgEthereumTx, error) {
 	tx, err := clientCtx.TxConfig.TxDecoder()(txBz)
@@ -273,8 +278,13 @@ func TxExceedBlockGasLimit(res *abci.ResponseDeliverTx) bool {
 	return strings.Contains(res.Log, ExceedBlockGasLimitError)
 }
 
-// TxSuccessOrExceedsBlockGasLimit returnsrue if the transaction was successful
-// or if it failed with an ExceedBlockGasLimit error
-func TxSuccessOrExceedsBlockGasLimit(res *abci.ResponseDeliverTx) bool {
-	return res.Code == 0 || TxExceedBlockGasLimit(res)
+// TxStateDBCommitError returns true if the evm tx commit error.
+func TxStateDBCommitError(res *abci.ResponseDeliverTx) bool {
+	return strings.Contains(res.Log, StateDBCommitError)
+}
+
+// TxSucessOrExpectedFailure returns true if the transaction was successful
+// or if it failed with an ExceedBlockGasLimit error or TxStateDBCommitError error
+func TxSucessOrExpectedFailure(res *abci.ResponseDeliverTx) bool {
+	return res.Code == 0 || TxExceedBlockGasLimit(res) || TxStateDBCommitError(res)
 }
diff --git a/x/evm/keeper/grpc_query.go b/x/evm/keeper/grpc_query.go
index c825c76f34..d862e4b0c9 100644
--- a/x/evm/keeper/grpc_query.go
+++ b/x/evm/keeper/grpc_query.go
@@ -38,6 +38,7 @@ import (
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
 	ethparams "github.com/ethereum/go-ethereum/params"
+	abci "github.com/tendermint/tendermint/abci/types"
 
 	ethermint "github.com/evmos/ethermint/types"
 	"github.com/evmos/ethermint/x/evm/statedb"
@@ -402,8 +403,8 @@ func (k Keeper) TraceTx(c context.Context, req *types.QueryTraceTxRequest) (*typ
 		return nil, status.Errorf(codes.InvalidArgument, "output limit cannot be negative, got %d", req.TraceConfig.Limit)
 	}
 
-	// minus one to get the context of block beginning
-	contextHeight := req.BlockNumber - 1
+	// get the context of block beginning
+	contextHeight := req.BlockNumber
 	if contextHeight < 1 {
 		// 0 is a special value in `ContextWithHeight`
 		contextHeight = 1
@@ -413,6 +414,12 @@ func (k Keeper) TraceTx(c context.Context, req *types.QueryTraceTxRequest) (*typ
 	ctx = ctx.WithBlockHeight(contextHeight)
 	ctx = ctx.WithBlockTime(req.BlockTime)
 	ctx = ctx.WithHeaderHash(common.Hex2Bytes(req.BlockHash))
+
+	// to get the base fee we only need the block max gas in the consensus params
+	ctx = ctx.WithConsensusParams(&abci.ConsensusParams{
+		Block: &abci.BlockParams{MaxGas: req.BlockMaxGas},
+	})
+
 	chainID, err := getChainID(ctx, req.ChainId)
 	if err != nil {
 		return nil, status.Error(codes.InvalidArgument, err.Error())
@@ -421,9 +428,21 @@ func (k Keeper) TraceTx(c context.Context, req *types.QueryTraceTxRequest) (*typ
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "failed to load evm config: %s", err.Error())
 	}
+
+	// compute and use base fee of the height that is being traced
+	baseFee := k.feeMarketKeeper.CalculateBaseFee(ctx)
+	if baseFee != nil {
+		cfg.BaseFee = baseFee
+	}
+
 	signer := ethtypes.MakeSigner(cfg.ChainConfig, big.NewInt(ctx.BlockHeight()))
 
 	txConfig := statedb.NewEmptyTxConfig(common.BytesToHash(ctx.HeaderHash().Bytes()))
+
+	// gas used at this point corresponds to GetProposerAddress & CalculateBaseFee
+	// need to reset gas meter per transaction to be consistent with tx execution
+	// and avoid stacking the gas used of every predecessor in the same gas meter
+
 	for i, tx := range req.Predecessors {
 		ethTx := tx.AsTransaction()
 		msg, err := ethTx.AsMessage(signer, cfg.BaseFee)
@@ -432,6 +451,8 @@ func (k Keeper) TraceTx(c context.Context, req *types.QueryTraceTxRequest) (*typ
 		}
 		txConfig.TxHash = ethTx.Hash()
 		txConfig.TxIndex = uint(i)
+		// reset gas meter for each transaction
+		ctx = ctx.WithGasMeter(ethermint.NewInfiniteGasMeterWithLimit(uint64(0)))
 		rsp, err := k.ApplyMessageWithConfig(ctx, msg, types.NewNoOpTracer(), true, cfg, txConfig)
 		if err != nil {
 			continue
@@ -479,8 +500,8 @@ func (k Keeper) TraceBlock(c context.Context, req *types.QueryTraceBlockRequest)
 		return nil, status.Errorf(codes.InvalidArgument, "output limit cannot be negative, got %d", req.TraceConfig.Limit)
 	}
 
-	// minus one to get the context of block beginning
-	contextHeight := req.BlockNumber - 1
+	// get the context of block beginning
+	contextHeight := req.BlockNumber
 	if contextHeight < 1 {
 		// 0 is a special value in `ContextWithHeight`
 		contextHeight = 1
@@ -490,6 +511,12 @@ func (k Keeper) TraceBlock(c context.Context, req *types.QueryTraceBlockRequest)
 	ctx = ctx.WithBlockHeight(contextHeight)
 	ctx = ctx.WithBlockTime(req.BlockTime)
 	ctx = ctx.WithHeaderHash(common.Hex2Bytes(req.BlockHash))
+
+	// to get the base fee we only need the block max gas in the consensus params
+	ctx = ctx.WithConsensusParams(&abci.ConsensusParams{
+		Block: &abci.BlockParams{MaxGas: req.BlockMaxGas},
+	})
+
 	chainID, err := getChainID(ctx, req.ChainId)
 	if err != nil {
 		return nil, status.Error(codes.InvalidArgument, err.Error())
@@ -499,6 +526,13 @@ func (k Keeper) TraceBlock(c context.Context, req *types.QueryTraceBlockRequest)
 	if err != nil {
 		return nil, status.Error(codes.Internal, "failed to load evm config")
 	}
+
+	// compute and use base fee of height that is being traced
+	baseFee := k.feeMarketKeeper.CalculateBaseFee(ctx)
+	if baseFee != nil {
+		cfg.BaseFee = baseFee
+	}
+
 	signer := ethtypes.MakeSigner(cfg.ChainConfig, big.NewInt(ctx.BlockHeight()))
 	txsLength := len(req.Txs)
 	results := make([]*types.TxTraceResult, 0, txsLength)
@@ -601,7 +635,9 @@ func (k *Keeper) traceTx(
 			tracer.Stop(errors.New("execution timeout"))
 		}
 	}()
-
+	// reset gas meter for tx
+	// to be consistent with tx execution gas meter
+	ctx = ctx.WithGasMeter(ethermint.NewInfiniteGasMeterWithLimit(msg.Gas()))
 	res, err := k.ApplyMessageWithConfig(ctx, msg, tracer, commitMessage, cfg, txConfig)
 	if err != nil {
 		return nil, 0, status.Error(codes.Internal, err.Error())
diff --git a/x/evm/keeper/keeper.go b/x/evm/keeper/keeper.go
index 9c47491d8d..d35e9ac15a 100644
--- a/x/evm/keeper/keeper.go
+++ b/x/evm/keeper/keeper.go
@@ -358,12 +358,7 @@ func (k Keeper) getBaseFee(ctx sdk.Context, london bool) *big.Int {
 
 // GetMinGasMultiplier returns the MinGasMultiplier param from the fee market module
 func (k Keeper) GetMinGasMultiplier(ctx sdk.Context) sdk.Dec {
-	fmkParmas := k.feeMarketKeeper.GetParams(ctx)
-	if fmkParmas.MinGasMultiplier.IsNil() {
-		// in case we are executing eth_call on a legacy block, returns a zero value.
-		return sdk.ZeroDec()
-	}
-	return fmkParmas.MinGasMultiplier
+	return k.feeMarketKeeper.GetParams(ctx).MinGasMultiplier
 }
 
 // ResetTransientGasUsed reset gas used to prepare for execution of current cosmos tx, called in ante handler.
diff --git a/x/evm/types/interfaces.go b/x/evm/types/interfaces.go
index 62c6a08134..e4e96216b8 100644
--- a/x/evm/types/interfaces.go
+++ b/x/evm/types/interfaces.go
@@ -62,6 +62,7 @@ type FeeMarketKeeper interface {
 	GetBaseFee(ctx sdk.Context) *big.Int
 	GetParams(ctx sdk.Context) feemarkettypes.Params
 	AddTransientGasWanted(ctx sdk.Context, gasWanted uint64) (uint64, error)
+	CalculateBaseFee(ctx sdk.Context) *big.Int
 }
 
 // Event Hooks
diff --git a/x/evm/types/query.pb.go b/x/evm/types/query.pb.go
index d259a96d2b..33a197eb0d 100644
--- a/x/evm/types/query.pb.go
+++ b/x/evm/types/query.pb.go
@@ -924,6 +924,8 @@ type QueryTraceTxRequest struct {
 	ProposerAddress github_com_cosmos_cosmos_sdk_types.ConsAddress `protobuf:"bytes,8,opt,name=proposer_address,json=proposerAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ConsAddress" json:"proposer_address,omitempty"`
 	// chain_id is the the eip155 chain id parsed from the requested block header
 	ChainId int64 `protobuf:"varint,9,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
+	// block_max_gas of the block of the requested transaction
+	BlockMaxGas int64 `protobuf:"varint,10,opt,name=block_max_gas,json=blockMaxGas,proto3" json:"block_max_gas,omitempty"`
 }
 
 func (m *QueryTraceTxRequest) Reset()         { *m = QueryTraceTxRequest{} }
@@ -1015,6 +1017,13 @@ func (m *QueryTraceTxRequest) GetChainId() int64 {
 	return 0
 }
 
+func (m *QueryTraceTxRequest) GetBlockMaxGas() int64 {
+	if m != nil {
+		return m.BlockMaxGas
+	}
+	return 0
+}
+
 // QueryTraceTxResponse defines TraceTx response
 type QueryTraceTxResponse struct {
 	// data is the response serialized in bytes
@@ -1077,6 +1086,8 @@ type QueryTraceBlockRequest struct {
 	ProposerAddress github_com_cosmos_cosmos_sdk_types.ConsAddress `protobuf:"bytes,8,opt,name=proposer_address,json=proposerAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ConsAddress" json:"proposer_address,omitempty"`
 	// chain_id is the eip155 chain id parsed from the requested block header
 	ChainId int64 `protobuf:"varint,9,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
+	// block_max_gas of the traced block
+	BlockMaxGas int64 `protobuf:"varint,10,opt,name=block_max_gas,json=blockMaxGas,proto3" json:"block_max_gas,omitempty"`
 }
 
 func (m *QueryTraceBlockRequest) Reset()         { *m = QueryTraceBlockRequest{} }
@@ -1161,6 +1172,13 @@ func (m *QueryTraceBlockRequest) GetChainId() int64 {
 	return 0
 }
 
+func (m *QueryTraceBlockRequest) GetBlockMaxGas() int64 {
+	if m != nil {
+		return m.BlockMaxGas
+	}
+	return 0
+}
+
 // QueryTraceBlockResponse defines TraceBlock response
 type QueryTraceBlockResponse struct {
 	// data is the response serialized in bytes
@@ -1314,97 +1332,98 @@ func init() {
 func init() { proto.RegisterFile("ethermint/evm/v1/query.proto", fileDescriptor_e15a877459347994) }
 
 var fileDescriptor_e15a877459347994 = []byte{
-	// 1434 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x56, 0xcd, 0x6f, 0x13, 0x47,
-	0x14, 0xcf, 0xc6, 0x4e, 0xec, 0x3c, 0x07, 0x70, 0x87, 0x50, 0xcc, 0x36, 0xb1, 0xc3, 0x42, 0x3e,
-	0x09, 0xbb, 0x8d, 0x5b, 0x21, 0x95, 0x4b, 0xc1, 0x56, 0xa0, 0x14, 0xa8, 0xa8, 0x1b, 0xf5, 0x50,
-	0x09, 0x59, 0xe3, 0xf5, 0xb0, 0xb6, 0x62, 0xef, 0x9a, 0x9d, 0xb1, 0xeb, 0x40, 0xe9, 0xa1, 0x52,
-	0x11, 0x15, 0x52, 0x85, 0xd4, 0x7b, 0xc5, 0x7f, 0xd0, 0x63, 0xff, 0x05, 0x8e, 0x48, 0xbd, 0x54,
-	0x3d, 0x50, 0x44, 0x7a, 0xe8, 0xad, 0xf7, 0x9e, 0xaa, 0x99, 0x9d, 0xf1, 0xd7, 0xfa, 0x23, 0x54,
-	0xf4, 0xd4, 0xd3, 0xee, 0xcc, 0xbc, 0x79, 0xef, 0xf7, 0x3e, 0xe6, 0xbd, 0x1f, 0x2c, 0x12, 0x56,
-	0x21, 0x7e, 0xbd, 0xea, 0x32, 0x8b, 0xb4, 0xea, 0x56, 0x6b, 0xdb, 0xba, 0xdb, 0x24, 0xfe, 0xbe,
-	0xd9, 0xf0, 0x3d, 0xe6, 0xa1, 0x64, 0xe7, 0xd4, 0x24, 0xad, 0xba, 0xd9, 0xda, 0xd6, 0x37, 0x6d,
-	0x8f, 0xd6, 0x3d, 0x6a, 0x95, 0x30, 0x25, 0x81, 0xa8, 0xd5, 0xda, 0x2e, 0x11, 0x86, 0xb7, 0xad,
-	0x06, 0x76, 0xaa, 0x2e, 0x66, 0x55, 0xcf, 0x0d, 0x6e, 0xeb, 0x7a, 0x48, 0x37, 0x57, 0x12, 0x9c,
-	0x9d, 0x0a, 0x9d, 0xb1, 0xb6, 0x3c, 0x5a, 0x70, 0x3c, 0xc7, 0x13, 0xbf, 0x16, 0xff, 0x93, 0xbb,
-	0x8b, 0x8e, 0xe7, 0x39, 0x35, 0x62, 0xe1, 0x46, 0xd5, 0xc2, 0xae, 0xeb, 0x31, 0x61, 0x89, 0xca,
-	0xd3, 0x8c, 0x3c, 0x15, 0xab, 0x52, 0xf3, 0x8e, 0xc5, 0xaa, 0x75, 0x42, 0x19, 0xae, 0x37, 0x02,
-	0x01, 0xe3, 0x03, 0x38, 0xfe, 0x29, 0x47, 0x7b, 0xd9, 0xb6, 0xbd, 0xa6, 0xcb, 0x0a, 0xe4, 0x6e,
-	0x93, 0x50, 0x86, 0x52, 0x10, 0xc3, 0xe5, 0xb2, 0x4f, 0x28, 0x4d, 0x69, 0xcb, 0xda, 0xfa, 0x5c,
-	0x41, 0x2d, 0x2f, 0xc6, 0x1f, 0x3d, 0xcd, 0x4c, 0xfd, 0xf9, 0x34, 0x33, 0x65, 0xd8, 0xb0, 0xd0,
-	0x7f, 0x95, 0x36, 0x3c, 0x97, 0x12, 0x7e, 0xb7, 0x84, 0x6b, 0xd8, 0xb5, 0x89, 0xba, 0x2b, 0x97,
-	0xe8, 0x1d, 0x98, 0xb3, 0xbd, 0x32, 0x29, 0x56, 0x30, 0xad, 0xa4, 0xa6, 0xc5, 0x59, 0x9c, 0x6f,
-	0x7c, 0x84, 0x69, 0x05, 0x2d, 0xc0, 0x8c, 0xeb, 0xf1, 0x4b, 0x91, 0x65, 0x6d, 0x3d, 0x5a, 0x08,
-	0x16, 0xc6, 0x87, 0x70, 0x4a, 0x18, 0xc9, 0x8b, 0xf0, 0xfe, 0x0b, 0x94, 0x0f, 0x35, 0xd0, 0x87,
-	0x69, 0x90, 0x60, 0x57, 0xe0, 0x68, 0x90, 0xb9, 0x62, 0xbf, 0xa6, 0x23, 0xc1, 0xee, 0xe5, 0x60,
-	0x13, 0xe9, 0x10, 0xa7, 0xdc, 0x28, 0xc7, 0x37, 0x2d, 0xf0, 0x75, 0xd6, 0x5c, 0x05, 0x0e, 0xb4,
-	0x16, 0xdd, 0x66, 0xbd, 0x44, 0x7c, 0xe9, 0xc1, 0x11, 0xb9, 0xfb, 0x89, 0xd8, 0x34, 0xae, 0xc3,
-	0xa2, 0xc0, 0xf1, 0x39, 0xae, 0x55, 0xcb, 0x98, 0x79, 0xfe, 0x80, 0x33, 0xa7, 0x61, 0xde, 0xf6,
-	0xdc, 0x41, 0x1c, 0x09, 0xbe, 0x77, 0x39, 0xe4, 0xd5, 0x63, 0x0d, 0x96, 0x46, 0x68, 0x93, 0x8e,
-	0xad, 0xc1, 0x31, 0x85, 0xaa, 0x5f, 0xa3, 0x02, 0xfb, 0x06, 0x5d, 0x53, 0x45, 0x94, 0x0b, 0xf2,
-	0xfc, 0x3a, 0xe9, 0x79, 0x57, 0x16, 0x51, 0xe7, 0xea, 0xa4, 0x22, 0x32, 0xae, 0x4b, 0x63, 0x9f,
-	0x31, 0xcf, 0xc7, 0xce, 0x64, 0x63, 0x28, 0x09, 0x91, 0x3d, 0xb2, 0x2f, 0xeb, 0x8d, 0xff, 0xf6,
-	0x98, 0xdf, 0x92, 0xe6, 0x3b, 0xca, 0xa4, 0xf9, 0x05, 0x98, 0x69, 0xe1, 0x5a, 0x53, 0x19, 0x0f,
-	0x16, 0xc6, 0x05, 0x48, 0xca, 0x52, 0x2a, 0xbf, 0x96, 0x93, 0x6b, 0xf0, 0x56, 0xcf, 0x3d, 0x69,
-	0x02, 0x41, 0x94, 0xd7, 0xbe, 0xb8, 0x35, 0x5f, 0x10, 0xff, 0xc6, 0x3d, 0x40, 0x42, 0x70, 0xb7,
-	0x7d, 0xc3, 0x73, 0xa8, 0x32, 0x81, 0x20, 0x2a, 0x5e, 0x4c, 0xa0, 0x5f, 0xfc, 0xa3, 0x2b, 0x00,
-	0xdd, 0xbe, 0x22, 0x7c, 0x4b, 0x64, 0x57, 0xcd, 0xa0, 0x68, 0x4d, 0xde, 0x84, 0xcc, 0xa0, 0x5f,
-	0xc9, 0x26, 0x64, 0xde, 0xea, 0x86, 0xaa, 0xd0, 0x73, 0xb3, 0x07, 0xe4, 0x77, 0x9a, 0x0c, 0xac,
-	0x32, 0x2e, 0x71, 0x6e, 0x40, 0xb4, 0xe6, 0x39, 0xdc, 0xbb, 0xc8, 0x7a, 0x22, 0x7b, 0xc2, 0x1c,
-	0x6c, 0x7d, 0xe6, 0x0d, 0xcf, 0x29, 0x08, 0x11, 0x74, 0x75, 0x08, 0xa8, 0xb5, 0x89, 0xa0, 0x02,
-	0x3b, 0xbd, 0xa8, 0x8c, 0x05, 0x19, 0x87, 0x5b, 0xd8, 0xc7, 0x75, 0x15, 0x07, 0xe3, 0xa6, 0x04,
-	0xa8, 0x76, 0x25, 0xc0, 0x0b, 0x30, 0xdb, 0x10, 0x3b, 0x22, 0x40, 0x89, 0x6c, 0x2a, 0x0c, 0x31,
-	0xb8, 0x91, 0x8b, 0x3e, 0x7b, 0x91, 0x99, 0x2a, 0x48, 0x69, 0xe3, 0x67, 0x0d, 0x8e, 0xee, 0xb0,
-	0x4a, 0x1e, 0xd7, 0x6a, 0x3d, 0x91, 0xc6, 0xbe, 0x43, 0x55, 0x4e, 0xf8, 0x3f, 0x3a, 0x09, 0x31,
-	0x07, 0xd3, 0xa2, 0x8d, 0x1b, 0xf2, 0x79, 0xcc, 0x3a, 0x98, 0xe6, 0x71, 0x03, 0xdd, 0x86, 0x64,
-	0xc3, 0xf7, 0x1a, 0x1e, 0x25, 0x7e, 0xe7, 0x89, 0xf1, 0xe7, 0x31, 0x9f, 0xcb, 0xfe, 0xfd, 0x22,
-	0x63, 0x3a, 0x55, 0x56, 0x69, 0x96, 0x4c, 0xdb, 0xab, 0x5b, 0x72, 0x36, 0x04, 0x9f, 0xf3, 0xb4,
-	0xbc, 0x67, 0xb1, 0xfd, 0x06, 0xa1, 0x66, 0xbe, 0xfb, 0xb6, 0x0b, 0xc7, 0x94, 0x2e, 0xf5, 0x2e,
-	0x4f, 0x41, 0xdc, 0xae, 0xe0, 0xaa, 0x5b, 0xac, 0x96, 0x53, 0xd1, 0x65, 0x6d, 0x3d, 0x52, 0x88,
-	0x89, 0xf5, 0xb5, 0xb2, 0xb1, 0x06, 0xc7, 0x77, 0x28, 0xab, 0xd6, 0x31, 0x23, 0x57, 0x71, 0x37,
-	0x10, 0x49, 0x88, 0x38, 0x38, 0x00, 0x1f, 0x2d, 0xf0, 0x5f, 0xe3, 0x65, 0x44, 0xe5, 0xd4, 0xc7,
-	0x36, 0xd9, 0x6d, 0x2b, 0x3f, 0xb7, 0x21, 0x52, 0xa7, 0x8e, 0x8c, 0x57, 0x26, 0x1c, 0xaf, 0x9b,
-	0xd4, 0xd9, 0xe1, 0x7b, 0xa4, 0x59, 0xdf, 0x6d, 0x17, 0xb8, 0x2c, 0xba, 0x04, 0xf3, 0x8c, 0x2b,
-	0x29, 0xda, 0x9e, 0x7b, 0xa7, 0xea, 0x08, 0x4f, 0x13, 0xd9, 0xa5, 0xf0, 0x5d, 0x61, 0x2a, 0x2f,
-	0x84, 0x0a, 0x09, 0xd6, 0x5d, 0xa0, 0x3c, 0xcc, 0x37, 0x7c, 0x52, 0x26, 0x36, 0xa1, 0xd4, 0xf3,
-	0x69, 0x2a, 0x2a, 0x0a, 0x6a, 0xa2, 0xf5, 0xbe, 0x4b, 0xbc, 0x4b, 0x96, 0x6a, 0x9e, 0xbd, 0xa7,
-	0xfa, 0xd1, 0x8c, 0x88, 0x4c, 0x42, 0xec, 0x05, 0xdd, 0x08, 0x2d, 0x01, 0x04, 0x22, 0xe2, 0xd1,
-	0xcc, 0x8a, 0x47, 0x33, 0x27, 0x76, 0xc4, 0x9c, 0xc9, 0xab, 0x63, 0x3e, 0x0a, 0x53, 0x31, 0xe1,
-	0x86, 0x6e, 0x06, 0x73, 0xd2, 0x54, 0x73, 0xd2, 0xdc, 0x55, 0x73, 0x32, 0x17, 0xe7, 0x45, 0xf3,
-	0xe4, 0xf7, 0x8c, 0x26, 0x95, 0xf0, 0x93, 0xa1, 0xb9, 0x8f, 0xff, 0x37, 0xb9, 0x9f, 0xeb, 0xcb,
-	0xfd, 0xc7, 0xd1, 0xf8, 0x74, 0x32, 0x52, 0x88, 0xb3, 0x76, 0xb1, 0xea, 0x96, 0x49, 0xdb, 0xd8,
-	0x94, 0x1d, 0xac, 0x93, 0xe1, 0x6e, 0x7b, 0x29, 0x63, 0x86, 0x55, 0x29, 0xf3, 0x7f, 0xe3, 0xfb,
-	0x08, 0xbc, 0xdd, 0x15, 0xce, 0x71, 0x6f, 0x7a, 0x2a, 0x82, 0xb5, 0xd5, 0x23, 0x9f, 0x5c, 0x11,
-	0xac, 0x4d, 0xdf, 0x40, 0x45, 0xfc, 0xdf, 0x93, 0x69, 0x9c, 0x87, 0x93, 0xa1, 0x7c, 0x8c, 0xc9,
-	0xdf, 0x89, 0xce, 0x9c, 0xa5, 0xe4, 0x0a, 0x51, 0xfd, 0xdc, 0xb8, 0xdd, 0x99, 0xa1, 0x72, 0x5b,
-	0xaa, 0xd8, 0x81, 0x38, 0x6f, 0xba, 0xc5, 0x3b, 0x44, 0xce, 0xb1, 0xdc, 0xe6, 0x6f, 0x2f, 0x32,
-	0xab, 0x87, 0xf0, 0xe7, 0x9a, 0xcb, 0xf8, 0xc0, 0x15, 0xea, 0xb2, 0x7f, 0xcd, 0xc3, 0x8c, 0xd0,
-	0x8f, 0xbe, 0xd5, 0x20, 0x26, 0x79, 0x06, 0x5a, 0x09, 0xe7, 0x79, 0x08, 0x91, 0xd4, 0x57, 0x27,
-	0x89, 0x05, 0x58, 0x8d, 0x73, 0xdf, 0xfc, 0xf2, 0xc7, 0x0f, 0xd3, 0x2b, 0xe8, 0x8c, 0x15, 0x22,
-	0xc0, 0x92, 0x6b, 0x58, 0xf7, 0x65, 0x6e, 0x1e, 0xa0, 0x1f, 0x35, 0x38, 0xd2, 0x47, 0xe7, 0xd0,
-	0xb9, 0x11, 0x66, 0x86, 0xd1, 0x46, 0x7d, 0xeb, 0x70, 0xc2, 0x12, 0x59, 0x56, 0x20, 0xdb, 0x42,
-	0x9b, 0x61, 0x64, 0x8a, 0x39, 0x86, 0x00, 0xfe, 0xa4, 0x41, 0x72, 0x90, 0x99, 0x21, 0x73, 0x84,
-	0xd9, 0x11, 0x84, 0x50, 0xb7, 0x0e, 0x2d, 0x2f, 0x91, 0x5e, 0x14, 0x48, 0xdf, 0x47, 0xd9, 0x30,
-	0xd2, 0x96, 0xba, 0xd3, 0x05, 0xdb, 0x4b, 0x36, 0x1f, 0xa0, 0x87, 0x1a, 0xc4, 0x24, 0x07, 0x1b,
-	0x99, 0xda, 0x7e, 0x7a, 0x37, 0x32, 0xb5, 0x03, 0x54, 0xce, 0xd8, 0x12, 0xb0, 0x56, 0xd1, 0xd9,
-	0x30, 0x2c, 0xc9, 0xe9, 0x68, 0x4f, 0xe8, 0x1e, 0x6b, 0x10, 0x93, 0x6c, 0x6c, 0x24, 0x90, 0x7e,
-	0xea, 0x37, 0x12, 0xc8, 0x00, 0xa9, 0x33, 0xb6, 0x05, 0x90, 0x73, 0x68, 0x23, 0x0c, 0x84, 0x06,
-	0xa2, 0x5d, 0x1c, 0xd6, 0xfd, 0x3d, 0xb2, 0xff, 0x00, 0xdd, 0x83, 0x28, 0x27, 0x6d, 0xc8, 0x18,
-	0x59, 0x32, 0x1d, 0x26, 0xa8, 0x9f, 0x19, 0x2b, 0x23, 0x31, 0x6c, 0x08, 0x0c, 0x67, 0xd0, 0xe9,
-	0x61, 0xd5, 0x54, 0xee, 0x8b, 0xc4, 0x97, 0x30, 0x1b, 0xf0, 0x16, 0x74, 0x76, 0x84, 0xe6, 0x3e,
-	0x7a, 0xa4, 0xaf, 0x4c, 0x90, 0x92, 0x08, 0x96, 0x05, 0x02, 0x1d, 0xa5, 0xc2, 0x08, 0x02, 0x62,
-	0x84, 0xda, 0x10, 0x93, 0xbc, 0x08, 0x2d, 0x87, 0x75, 0xf6, 0x53, 0x26, 0x7d, 0x6d, 0xd2, 0xac,
-	0x50, 0x76, 0x0d, 0x61, 0x77, 0x11, 0xe9, 0x61, 0xbb, 0x84, 0x55, 0x8a, 0x36, 0x37, 0xf7, 0x35,
-	0x24, 0x7a, 0x88, 0xcd, 0x21, 0xac, 0x0f, 0xf1, 0x79, 0x08, 0x33, 0x32, 0x56, 0x85, 0xed, 0x65,
-	0x94, 0x1e, 0x62, 0x5b, 0x8a, 0x17, 0x1d, 0x4c, 0xd1, 0x57, 0x10, 0x93, 0x73, 0x74, 0x64, 0xed,
-	0xf5, 0x33, 0xa9, 0x91, 0xb5, 0x37, 0x30, 0x8e, 0xc7, 0x79, 0x1f, 0x0c, 0x51, 0xd6, 0x46, 0x8f,
-	0x34, 0x80, 0xee, 0x24, 0x40, 0xeb, 0xe3, 0x54, 0xf7, 0x0e, 0x6f, 0x7d, 0xe3, 0x10, 0x92, 0x12,
-	0xc7, 0x8a, 0xc0, 0x91, 0x41, 0x4b, 0xa3, 0x70, 0x88, 0xb1, 0xc8, 0x03, 0x21, 0xa7, 0xc9, 0x98,
-	0x6e, 0xd0, 0x3b, 0x84, 0xc6, 0x74, 0x83, 0xbe, 0xa1, 0x34, 0x2e, 0x10, 0x6a, 0x58, 0xe5, 0x2e,
-	0x3d, 0x7b, 0x95, 0xd6, 0x9e, 0xbf, 0x4a, 0x6b, 0x2f, 0x5f, 0xa5, 0xb5, 0x27, 0x07, 0xe9, 0xa9,
-	0xe7, 0x07, 0xe9, 0xa9, 0x5f, 0x0f, 0xd2, 0x53, 0x5f, 0xf4, 0x0e, 0x2f, 0xd2, 0xe2, 0xb3, 0xab,
-	0xab, 0xa5, 0x2d, 0xf4, 0x88, 0x01, 0x56, 0x9a, 0x15, 0xb3, 0xff, 0xbd, 0x7f, 0x02, 0x00, 0x00,
-	0xff, 0xff, 0xa4, 0xba, 0x06, 0x5b, 0xc7, 0x11, 0x00, 0x00,
+	// 1454 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0xcd, 0x6f, 0x1b, 0x45,
+	0x14, 0xcf, 0xc6, 0x4e, 0xec, 0x3c, 0x27, 0x6d, 0x98, 0xa6, 0xd4, 0x5d, 0x92, 0x38, 0xdd, 0x36,
+	0x9f, 0x4d, 0x77, 0x89, 0x41, 0x95, 0xe8, 0x85, 0xd6, 0x56, 0x5a, 0x4a, 0x5b, 0x54, 0x4c, 0xc4,
+	0x01, 0xa9, 0xb2, 0xc6, 0xeb, 0xe9, 0xda, 0x8a, 0xbd, 0xeb, 0xee, 0x8c, 0x8d, 0xd3, 0x52, 0x0e,
+	0x08, 0xaa, 0xa2, 0x5e, 0x2a, 0x71, 0x47, 0xfd, 0x0f, 0x90, 0xb8, 0xf0, 0x2f, 0xf4, 0x58, 0x89,
+	0x0b, 0xe2, 0x50, 0x50, 0xcb, 0x81, 0x1b, 0x77, 0x4e, 0x68, 0x3e, 0xd6, 0x5e, 0x7b, 0xfd, 0x91,
+	0xa2, 0x72, 0xe3, 0xb4, 0x3b, 0x33, 0x6f, 0xde, 0xfb, 0xbd, 0x8f, 0x79, 0xef, 0x07, 0x8b, 0x84,
+	0x55, 0x88, 0x5f, 0xaf, 0xba, 0xcc, 0x22, 0xad, 0xba, 0xd5, 0xda, 0xb1, 0xee, 0x34, 0x89, 0x7f,
+	0x60, 0x36, 0x7c, 0x8f, 0x79, 0x68, 0xbe, 0x73, 0x6a, 0x92, 0x56, 0xdd, 0x6c, 0xed, 0xe8, 0x5b,
+	0xb6, 0x47, 0xeb, 0x1e, 0xb5, 0x4a, 0x98, 0x12, 0x29, 0x6a, 0xb5, 0x76, 0x4a, 0x84, 0xe1, 0x1d,
+	0xab, 0x81, 0x9d, 0xaa, 0x8b, 0x59, 0xd5, 0x73, 0xe5, 0x6d, 0x5d, 0x8f, 0xe8, 0xe6, 0x4a, 0xe4,
+	0xd9, 0xc9, 0xc8, 0x19, 0x6b, 0xab, 0xa3, 0x05, 0xc7, 0x73, 0x3c, 0xf1, 0x6b, 0xf1, 0x3f, 0xb5,
+	0xbb, 0xe8, 0x78, 0x9e, 0x53, 0x23, 0x16, 0x6e, 0x54, 0x2d, 0xec, 0xba, 0x1e, 0x13, 0x96, 0xa8,
+	0x3a, 0xcd, 0xa8, 0x53, 0xb1, 0x2a, 0x35, 0x6f, 0x5b, 0xac, 0x5a, 0x27, 0x94, 0xe1, 0x7a, 0x43,
+	0x0a, 0x18, 0xef, 0xc1, 0xb1, 0x8f, 0x39, 0xda, 0x4b, 0xb6, 0xed, 0x35, 0x5d, 0x56, 0x20, 0x77,
+	0x9a, 0x84, 0x32, 0x94, 0x86, 0x04, 0x2e, 0x97, 0x7d, 0x42, 0x69, 0x5a, 0x5b, 0xd1, 0x36, 0x66,
+	0x0a, 0xc1, 0xf2, 0x42, 0xf2, 0xe1, 0x93, 0xcc, 0xc4, 0x9f, 0x4f, 0x32, 0x13, 0x86, 0x0d, 0x0b,
+	0xbd, 0x57, 0x69, 0xc3, 0x73, 0x29, 0xe1, 0x77, 0x4b, 0xb8, 0x86, 0x5d, 0x9b, 0x04, 0x77, 0xd5,
+	0x12, 0xbd, 0x05, 0x33, 0xb6, 0x57, 0x26, 0xc5, 0x0a, 0xa6, 0x95, 0xf4, 0xa4, 0x38, 0x4b, 0xf2,
+	0x8d, 0x0f, 0x30, 0xad, 0xa0, 0x05, 0x98, 0x72, 0x3d, 0x7e, 0x29, 0xb6, 0xa2, 0x6d, 0xc4, 0x0b,
+	0x72, 0x61, 0xbc, 0x0f, 0x27, 0x85, 0x91, 0xbc, 0x08, 0xef, 0xbf, 0x40, 0xf9, 0x40, 0x03, 0x7d,
+	0x90, 0x06, 0x05, 0x76, 0x15, 0x8e, 0xc8, 0xcc, 0x15, 0x7b, 0x35, 0xcd, 0xc9, 0xdd, 0x4b, 0x72,
+	0x13, 0xe9, 0x90, 0xa4, 0xdc, 0x28, 0xc7, 0x37, 0x29, 0xf0, 0x75, 0xd6, 0x5c, 0x05, 0x96, 0x5a,
+	0x8b, 0x6e, 0xb3, 0x5e, 0x22, 0xbe, 0xf2, 0x60, 0x4e, 0xed, 0x7e, 0x24, 0x36, 0x8d, 0x6b, 0xb0,
+	0x28, 0x70, 0x7c, 0x8a, 0x6b, 0xd5, 0x32, 0x66, 0x9e, 0xdf, 0xe7, 0xcc, 0x29, 0x98, 0xb5, 0x3d,
+	0xb7, 0x1f, 0x47, 0x8a, 0xef, 0x5d, 0x8a, 0x78, 0xf5, 0x48, 0x83, 0xa5, 0x21, 0xda, 0x94, 0x63,
+	0xeb, 0x70, 0x34, 0x40, 0xd5, 0xab, 0x31, 0x00, 0xfb, 0x1a, 0x5d, 0x0b, 0x8a, 0x28, 0x27, 0xf3,
+	0xfc, 0x2a, 0xe9, 0x79, 0x5b, 0x15, 0x51, 0xe7, 0xea, 0xb8, 0x22, 0x32, 0xae, 0x29, 0x63, 0x9f,
+	0x30, 0xcf, 0xc7, 0xce, 0x78, 0x63, 0x68, 0x1e, 0x62, 0xfb, 0xe4, 0x40, 0xd5, 0x1b, 0xff, 0x0d,
+	0x99, 0xdf, 0x56, 0xe6, 0x3b, 0xca, 0x94, 0xf9, 0x05, 0x98, 0x6a, 0xe1, 0x5a, 0x33, 0x30, 0x2e,
+	0x17, 0xc6, 0x79, 0x98, 0x57, 0xa5, 0x54, 0x7e, 0x25, 0x27, 0xd7, 0xe1, 0x8d, 0xd0, 0x3d, 0x65,
+	0x02, 0x41, 0x9c, 0xd7, 0xbe, 0xb8, 0x35, 0x5b, 0x10, 0xff, 0xc6, 0x5d, 0x40, 0x42, 0x70, 0xaf,
+	0x7d, 0xdd, 0x73, 0x68, 0x60, 0x02, 0x41, 0x5c, 0xbc, 0x18, 0xa9, 0x5f, 0xfc, 0xa3, 0xcb, 0x00,
+	0xdd, 0xbe, 0x22, 0x7c, 0x4b, 0x65, 0xd7, 0x4c, 0x59, 0xb4, 0x26, 0x6f, 0x42, 0xa6, 0xec, 0x57,
+	0xaa, 0x09, 0x99, 0x37, 0xbb, 0xa1, 0x2a, 0x84, 0x6e, 0x86, 0x40, 0x7e, 0xab, 0xa9, 0xc0, 0x06,
+	0xc6, 0x15, 0xce, 0x4d, 0x88, 0xd7, 0x3c, 0x87, 0x7b, 0x17, 0xdb, 0x48, 0x65, 0x8f, 0x9b, 0xfd,
+	0xad, 0xcf, 0xbc, 0xee, 0x39, 0x05, 0x21, 0x82, 0xae, 0x0c, 0x00, 0xb5, 0x3e, 0x16, 0x94, 0xb4,
+	0x13, 0x46, 0x65, 0x2c, 0xa8, 0x38, 0xdc, 0xc4, 0x3e, 0xae, 0x07, 0x71, 0x30, 0x6e, 0x28, 0x80,
+	0xc1, 0xae, 0x02, 0x78, 0x1e, 0xa6, 0x1b, 0x62, 0x47, 0x04, 0x28, 0x95, 0x4d, 0x47, 0x21, 0xca,
+	0x1b, 0xb9, 0xf8, 0xd3, 0xe7, 0x99, 0x89, 0x82, 0x92, 0x36, 0x7e, 0xd2, 0xe0, 0xc8, 0x2e, 0xab,
+	0xe4, 0x71, 0xad, 0x16, 0x8a, 0x34, 0xf6, 0x1d, 0x1a, 0xe4, 0x84, 0xff, 0xa3, 0x13, 0x90, 0x70,
+	0x30, 0x2d, 0xda, 0xb8, 0xa1, 0x9e, 0xc7, 0xb4, 0x83, 0x69, 0x1e, 0x37, 0xd0, 0x2d, 0x98, 0x6f,
+	0xf8, 0x5e, 0xc3, 0xa3, 0xc4, 0xef, 0x3c, 0x31, 0xfe, 0x3c, 0x66, 0x73, 0xd9, 0xbf, 0x9f, 0x67,
+	0x4c, 0xa7, 0xca, 0x2a, 0xcd, 0x92, 0x69, 0x7b, 0x75, 0x4b, 0xcd, 0x06, 0xf9, 0x39, 0x47, 0xcb,
+	0xfb, 0x16, 0x3b, 0x68, 0x10, 0x6a, 0xe6, 0xbb, 0x6f, 0xbb, 0x70, 0x34, 0xd0, 0x15, 0xbc, 0xcb,
+	0x93, 0x90, 0xb4, 0x2b, 0xb8, 0xea, 0x16, 0xab, 0xe5, 0x74, 0x7c, 0x45, 0xdb, 0x88, 0x15, 0x12,
+	0x62, 0x7d, 0xb5, 0x6c, 0xac, 0xc3, 0xb1, 0x5d, 0xca, 0xaa, 0x75, 0xcc, 0xc8, 0x15, 0xdc, 0x0d,
+	0xc4, 0x3c, 0xc4, 0x1c, 0x2c, 0xc1, 0xc7, 0x0b, 0xfc, 0xd7, 0xf8, 0x3a, 0x1e, 0xe4, 0xd4, 0xc7,
+	0x36, 0xd9, 0x6b, 0x07, 0x7e, 0xee, 0x40, 0xac, 0x4e, 0x1d, 0x15, 0xaf, 0x4c, 0x34, 0x5e, 0x37,
+	0xa8, 0xb3, 0xcb, 0xf7, 0x48, 0xb3, 0xbe, 0xd7, 0x2e, 0x70, 0x59, 0x74, 0x11, 0x66, 0x19, 0x57,
+	0x52, 0xb4, 0x3d, 0xf7, 0x76, 0xd5, 0x11, 0x9e, 0xa6, 0xb2, 0x4b, 0xd1, 0xbb, 0xc2, 0x54, 0x5e,
+	0x08, 0x15, 0x52, 0xac, 0xbb, 0x40, 0x79, 0x98, 0x6d, 0xf8, 0xa4, 0x4c, 0x6c, 0x42, 0xa9, 0xe7,
+	0xd3, 0x74, 0x5c, 0x14, 0xd4, 0x58, 0xeb, 0x3d, 0x97, 0x78, 0x97, 0x2c, 0xd5, 0x3c, 0x7b, 0x3f,
+	0xe8, 0x47, 0x53, 0x22, 0x32, 0x29, 0xb1, 0x27, 0xbb, 0x11, 0x5a, 0x02, 0x90, 0x22, 0xe2, 0xd1,
+	0x4c, 0x8b, 0x47, 0x33, 0x23, 0x76, 0xc4, 0x9c, 0xc9, 0x07, 0xc7, 0x7c, 0x14, 0xa6, 0x13, 0xc2,
+	0x0d, 0xdd, 0x94, 0x73, 0xd2, 0x0c, 0xe6, 0xa4, 0xb9, 0x17, 0xcc, 0xc9, 0x5c, 0x92, 0x17, 0xcd,
+	0xe3, 0xdf, 0x32, 0x9a, 0x52, 0xc2, 0x4f, 0x06, 0xe6, 0x3e, 0xf9, 0xdf, 0xe4, 0x7e, 0xa6, 0x27,
+	0xf7, 0xc8, 0x80, 0x39, 0x09, 0xbf, 0x8e, 0xdb, 0x45, 0x9e, 0x6e, 0x08, 0x45, 0xe0, 0x06, 0x6e,
+	0x5f, 0xc1, 0xf4, 0xc3, 0x78, 0x72, 0x72, 0x3e, 0x56, 0x48, 0xb2, 0x76, 0xb1, 0xea, 0x96, 0x49,
+	0xdb, 0xd8, 0x52, 0x5d, 0xae, 0x53, 0x05, 0xdd, 0x16, 0x54, 0xc6, 0x0c, 0x07, 0xe5, 0xce, 0xff,
+	0x8d, 0x1f, 0x63, 0xf0, 0x66, 0x57, 0x38, 0xc7, 0xb5, 0x86, 0xaa, 0x86, 0xb5, 0x83, 0x46, 0x30,
+	0xbe, 0x6a, 0x58, 0x9b, 0xbe, 0x86, 0xaa, 0xf9, 0x3f, 0xe1, 0xe3, 0x13, 0x6e, 0x9c, 0x83, 0x13,
+	0x91, 0x9c, 0x8d, 0xc8, 0xf1, 0xf1, 0xce, 0xbc, 0xa6, 0xe4, 0x32, 0x09, 0xe6, 0x82, 0x71, 0xab,
+	0x33, 0x8b, 0xd5, 0xb6, 0x52, 0xb1, 0x0b, 0x49, 0xde, 0xbc, 0x8b, 0xb7, 0x89, 0x9a, 0x87, 0xb9,
+	0xad, 0x5f, 0x9f, 0x67, 0xd6, 0x0e, 0xe1, 0xf3, 0x55, 0x97, 0xf1, 0xc1, 0x2d, 0xd4, 0x65, 0xff,
+	0x9a, 0x85, 0x29, 0xa1, 0x1f, 0x7d, 0xa3, 0x41, 0x42, 0xf1, 0x15, 0xb4, 0x1a, 0xad, 0x85, 0x01,
+	0x84, 0x54, 0x5f, 0x1b, 0x27, 0x26, 0xb1, 0x1a, 0x67, 0xbf, 0xfa, 0xf9, 0x8f, 0xef, 0x26, 0x57,
+	0xd1, 0x69, 0x2b, 0x42, 0xa4, 0x15, 0x67, 0xb1, 0xee, 0xa9, 0xfc, 0xdd, 0x47, 0xdf, 0x6b, 0x30,
+	0xd7, 0x43, 0x0b, 0xd1, 0xd9, 0x21, 0x66, 0x06, 0xd1, 0x4f, 0x7d, 0xfb, 0x70, 0xc2, 0x0a, 0x59,
+	0x56, 0x20, 0xdb, 0x46, 0x5b, 0x51, 0x64, 0x01, 0x03, 0x8d, 0x00, 0xfc, 0x41, 0x83, 0xf9, 0x7e,
+	0x86, 0x87, 0xcc, 0x21, 0x66, 0x87, 0x10, 0x4b, 0xdd, 0x3a, 0xb4, 0xbc, 0x42, 0x7a, 0x41, 0x20,
+	0x7d, 0x17, 0x65, 0xa3, 0x48, 0x5b, 0xc1, 0x9d, 0x2e, 0xd8, 0x30, 0x69, 0xbd, 0x8f, 0x1e, 0x68,
+	0x90, 0x50, 0x5c, 0x6e, 0x68, 0x6a, 0x7b, 0x69, 0xe2, 0xd0, 0xd4, 0xf6, 0x51, 0x42, 0x63, 0x5b,
+	0xc0, 0x5a, 0x43, 0x67, 0xa2, 0xb0, 0x14, 0x37, 0xa4, 0xa1, 0xd0, 0x3d, 0xd2, 0x20, 0xa1, 0x58,
+	0xdd, 0x50, 0x20, 0xbd, 0x14, 0x72, 0x28, 0x90, 0x3e, 0x72, 0x68, 0xec, 0x08, 0x20, 0x67, 0xd1,
+	0x66, 0x14, 0x08, 0x95, 0xa2, 0x5d, 0x1c, 0xd6, 0xbd, 0x7d, 0x72, 0x70, 0x1f, 0xdd, 0x85, 0x38,
+	0x27, 0x7f, 0xc8, 0x18, 0x5a, 0x32, 0x1d, 0x46, 0xa9, 0x9f, 0x1e, 0x29, 0xa3, 0x30, 0x6c, 0x0a,
+	0x0c, 0xa7, 0xd1, 0xa9, 0x41, 0xd5, 0x54, 0xee, 0x89, 0xc4, 0xe7, 0x30, 0x2d, 0xf9, 0x0f, 0x3a,
+	0x33, 0x44, 0x73, 0x0f, 0xcd, 0xd2, 0x57, 0xc7, 0x48, 0x29, 0x04, 0x2b, 0x02, 0x81, 0x8e, 0xd2,
+	0x51, 0x04, 0x92, 0x60, 0xa1, 0x36, 0x24, 0x14, 0xbf, 0x42, 0x2b, 0x51, 0x9d, 0xbd, 0xd4, 0x4b,
+	0x5f, 0x1f, 0x37, 0x4f, 0x02, 0xbb, 0x86, 0xb0, 0xbb, 0x88, 0xf4, 0xa8, 0x5d, 0xc2, 0x2a, 0x45,
+	0x9b, 0x9b, 0xfb, 0x12, 0x52, 0x21, 0x82, 0x74, 0x08, 0xeb, 0x03, 0x7c, 0x1e, 0xc0, 0xb0, 0x8c,
+	0x35, 0x61, 0x7b, 0x05, 0x2d, 0x0f, 0xb0, 0xad, 0xc4, 0x79, 0x8b, 0x46, 0x5f, 0x40, 0x42, 0xcd,
+	0xda, 0xa1, 0xb5, 0xd7, 0xcb, 0xc8, 0x86, 0xd6, 0x5e, 0xdf, 0xc8, 0x1e, 0xe5, 0xbd, 0x1c, 0xb4,
+	0xac, 0x8d, 0x1e, 0x6a, 0x00, 0xdd, 0x49, 0x80, 0x36, 0x46, 0xa9, 0x0e, 0x0f, 0x78, 0x7d, 0xf3,
+	0x10, 0x92, 0x0a, 0xc7, 0xaa, 0xc0, 0x91, 0x41, 0x4b, 0xc3, 0x70, 0x88, 0xf1, 0xc4, 0x03, 0xa1,
+	0xa6, 0xc9, 0x88, 0x6e, 0x10, 0x1e, 0x42, 0x23, 0xba, 0x41, 0xcf, 0x50, 0x1a, 0x15, 0x88, 0x60,
+	0x58, 0xe5, 0x2e, 0x3e, 0x7d, 0xb1, 0xac, 0x3d, 0x7b, 0xb1, 0xac, 0xfd, 0xfe, 0x62, 0x59, 0x7b,
+	0xfc, 0x72, 0x79, 0xe2, 0xd9, 0xcb, 0xe5, 0x89, 0x5f, 0x5e, 0x2e, 0x4f, 0x7c, 0x16, 0x1e, 0x5e,
+	0xa4, 0xc5, 0x67, 0x57, 0x57, 0x4b, 0x5b, 0xe8, 0x11, 0x03, 0xac, 0x34, 0x2d, 0xf8, 0xc1, 0x3b,
+	0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0xdd, 0x03, 0xec, 0xef, 0x0f, 0x12, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -2554,6 +2573,11 @@ func (m *QueryTraceTxRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.BlockMaxGas != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.BlockMaxGas))
+		i--
+		dAtA[i] = 0x50
+	}
 	if m.ChainId != 0 {
 		i = encodeVarintQuery(dAtA, i, uint64(m.ChainId))
 		i--
@@ -2677,6 +2701,11 @@ func (m *QueryTraceBlockRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	_ = i
 	var l int
 	_ = l
+	if m.BlockMaxGas != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.BlockMaxGas))
+		i--
+		dAtA[i] = 0x50
+	}
 	if m.ChainId != 0 {
 		i = encodeVarintQuery(dAtA, i, uint64(m.ChainId))
 		i--
@@ -3143,6 +3172,9 @@ func (m *QueryTraceTxRequest) Size() (n int) {
 	if m.ChainId != 0 {
 		n += 1 + sovQuery(uint64(m.ChainId))
 	}
+	if m.BlockMaxGas != 0 {
+		n += 1 + sovQuery(uint64(m.BlockMaxGas))
+	}
 	return n
 }
 
@@ -3191,6 +3223,9 @@ func (m *QueryTraceBlockRequest) Size() (n int) {
 	if m.ChainId != 0 {
 		n += 1 + sovQuery(uint64(m.ChainId))
 	}
+	if m.BlockMaxGas != 0 {
+		n += 1 + sovQuery(uint64(m.BlockMaxGas))
+	}
 	return n
 }
 
@@ -5248,6 +5283,25 @@ func (m *QueryTraceTxRequest) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
+		case 10:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockMaxGas", wireType)
+			}
+			m.BlockMaxGas = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BlockMaxGas |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -5589,6 +5643,25 @@ func (m *QueryTraceBlockRequest) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
+		case 10:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockMaxGas", wireType)
+			}
+			m.BlockMaxGas = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BlockMaxGas |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
diff --git a/x/feemarket/keeper/params.go b/x/feemarket/keeper/params.go
index f8a1f3744f..b5c8112fbd 100644
--- a/x/feemarket/keeper/params.go
+++ b/x/feemarket/keeper/params.go
@@ -28,12 +28,20 @@ func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) {
 	store := ctx.KVStore(k.storeKey)
 	bz := store.Get(types.ParamsKey)
 	if len(bz) == 0 {
-		var p types.Params
-		k.ss.GetParamSetIfExists(ctx, &p)
-		return p
+		k.ss.GetParamSetIfExists(ctx, &params)
+	} else {
+		k.cdc.MustUnmarshal(bz, &params)
+	}
+
+	// zero the nil params for legacy blocks
+	if params.MinGasPrice.IsNil() {
+		params.MinGasPrice = sdk.ZeroDec()
+	}
+
+	if params.MinGasMultiplier.IsNil() {
+		params.MinGasMultiplier = sdk.ZeroDec()
 	}
 
-	k.cdc.MustUnmarshal(bz, &params)
 	return params
 }
 
diff --git a/x/feemarket/keeper/params_test.go b/x/feemarket/keeper/params_test.go
index 1601e8f221..7ab711b1e5 100644
--- a/x/feemarket/keeper/params_test.go
+++ b/x/feemarket/keeper/params_test.go
@@ -13,6 +13,13 @@ import (
 	"github.com/evmos/ethermint/x/feemarket/types"
 )
 
+func (suite *KeeperTestSuite) TestGetParams() {
+	params := suite.app.FeeMarketKeeper.GetParams(suite.ctx)
+	suite.Require().NotNil(params.BaseFee)
+	suite.Require().NotNil(params.MinGasPrice)
+	suite.Require().NotNil(params.MinGasMultiplier)
+}
+
 func (suite *KeeperTestSuite) TestSetGetParams() {
 	params := suite.app.FeeMarketKeeper.GetParams(suite.ctx)
 	suite.app.FeeMarketKeeper.SetParams(suite.ctx, params)