fix: revert changes from TypedEvents (#1600)

* fix: revert changes from TypedEvents

* fix: formatter and linter

* fix: double quote to prevent globbing and word splitting

* fix: added token to codecov

* fix: re-added events.proto for usage later

.github/workflows/test.yml

@@ -38,6 +38,7 @@ jobs:
         with:
           file: ./coverage.txt
           fail_ci_if_error: true
+          token: ${{ secrets.CODECOV_TOKEN }}
         if: env.GIT_DIFF
 
   test-importer:

scripts/integration-test-all.sh

@@ -3,7 +3,7 @@
 # "stable" mode tests assume data is static
 # "live" mode tests assume data dynamic
 
-SCRIPT=$(basename ${BASH_SOURCE[0]})
+SCRIPT=$(basename "${BASH_SOURCE[0]}")
 TEST=""
 QTD=1
 SLEEP_TIMEOUT=5
@@ -145,7 +145,7 @@ echo "done sleeping"
 set +e
 
 if [[ -z $TEST || $TEST == "rpc" ||  $TEST == "pending" ]]; then
-    time_out=900s
+    time_out=300s
     if [[ $TEST == "pending" ]]; then
       time_out=60m0s
     fi

tests/rpc/rpc_test.go

@@ -347,37 +347,36 @@ func TestEth_IncompleteSendTransaction(t *testing.T) {
 	require.NotEqual(t, err.Error(), "method handler crashed", "no from field dealt with incorrectly")
 }
 
-// TODO: Investigate why it's failing
+func TestEth_GetFilterChanges_NoTopics(t *testing.T) {
-//func TestEth_GetFilterChanges_NoTopics(t *testing.T) {
+	rpcRes := call(t, "eth_blockNumber", []string{})
-//	rpcRes := call(t, "eth_blockNumber", []string{})
+
-//
+	var res hexutil.Uint64
-//	var res hexutil.Uint64
+	err := res.UnmarshalJSON(rpcRes.Result)
-//	err := res.UnmarshalJSON(rpcRes.Result)
+	require.NoError(t, err)
-//	require.NoError(t, err)
+
-//
+	param := make([]map[string]interface{}, 1)
-//	param := make([]map[string]interface{}, 1)
+	param[0] = make(map[string]interface{})
-//	param[0] = make(map[string]interface{})
+	param[0]["topics"] = []string{}
-//	param[0]["topics"] = []string{}
+	param[0]["fromBlock"] = res.String()
-//	param[0]["fromBlock"] = res.String()
+
-//
+	// instantiate new filter
-//	// instantiate new filter
+	rpcRes = call(t, "eth_newFilter", param)
-//	rpcRes = call(t, "eth_newFilter", param)
+	require.Nil(t, rpcRes.Error)
-//	require.Nil(t, rpcRes.Error)
+	var ID string
-//	var ID string
+	err = json.Unmarshal(rpcRes.Result, &ID)
-//	err = json.Unmarshal(rpcRes.Result, &ID)
+	require.NoError(t, err)
-//	require.NoError(t, err)
+
-//
+	// deploy contract, emitting some event
-//	// deploy contract, emitting some event
+	deployTestContract(t)
-//	deployTestContract(t)
+
-//
+	// get filter changes
-//	// get filter changes
+	changesRes := call(t, "eth_getFilterChanges", []string{ID})
-//	changesRes := call(t, "eth_getFilterChanges", []string{ID})
+
-//
+	var logs []*ethtypes.Log
-//	var logs []*ethtypes.Log
+	err = json.Unmarshal(changesRes.Result, &logs)
-//	err = json.Unmarshal(changesRes.Result, &logs)
+	require.NoError(t, err)
-//	require.NoError(t, err)
+	require.Equal(t, 1, len(logs))
-//	require.Equal(t, 1, len(logs))
+}
-//}
 
 // hash of Hello event
 var helloTopic = "0x775a94827b8fd9b519d36cd827093c664f93347070a554f65e4a6f56cd738898"
@@ -427,68 +426,66 @@ func deployTestContractWithFunction(t *testing.T) hexutil.Bytes {
 	return hash
 }
 
-// TODO: Investigate why it's failing
 // Tests topics case where there are topics in first two positions
-//func TestEth_GetFilterChanges_Topics_AB(t *testing.T) {
+func TestEth_GetFilterChanges_Topics_AB(t *testing.T) {
-//	rpcRes := call(t, "eth_blockNumber", []string{})
+	rpcRes := call(t, "eth_blockNumber", []string{})
-//
-//	var res hexutil.Uint64
-//	err := res.UnmarshalJSON(rpcRes.Result)
-//	require.NoError(t, err)
-//
-//	param := make([]map[string]interface{}, 1)
-//	param[0] = make(map[string]interface{})
-//	param[0]["topics"] = []string{helloTopic, worldTopic}
-//	param[0]["fromBlock"] = res.String()
-//
-//	// instantiate new filter
-//	rpcRes = call(t, "eth_newFilter", param)
-//	var ID string
-//	err = json.Unmarshal(rpcRes.Result, &ID)
-//	require.NoError(t, err, string(rpcRes.Result))
-//
-//	deployTestContractWithFunction(t)
-//
-//	// get filter changes
-//	changesRes := call(t, "eth_getFilterChanges", []string{ID})
-//
-//	var logs []*ethtypes.Log
-//	err = json.Unmarshal(changesRes.Result, &logs)
-//	require.NoError(t, err)
-//
-//	require.Equal(t, 1, len(logs))
-//}
 
-// TODO: Investigate why it's failing
+	var res hexutil.Uint64
-//func TestEth_GetFilterChanges_Topics_XB(t *testing.T) {
+	err := res.UnmarshalJSON(rpcRes.Result)
-//	rpcRes := call(t, "eth_blockNumber", []string{})
+	require.NoError(t, err)
-//
+
-//	var res hexutil.Uint64
+	param := make([]map[string]interface{}, 1)
-//	err := res.UnmarshalJSON(rpcRes.Result)
+	param[0] = make(map[string]interface{})
-//	require.NoError(t, err)
+	param[0]["topics"] = []string{helloTopic, worldTopic}
-//
+	param[0]["fromBlock"] = res.String()
-//	param := make([]map[string]interface{}, 1)
+
-//	param[0] = make(map[string]interface{})
+	// instantiate new filter
-//	param[0]["topics"] = []interface{}{nil, worldTopic}
+	rpcRes = call(t, "eth_newFilter", param)
-//	param[0]["fromBlock"] = res.String()
+	var ID string
-//
+	err = json.Unmarshal(rpcRes.Result, &ID)
-//	// instantiate new filter
+	require.NoError(t, err, string(rpcRes.Result))
-//	rpcRes = call(t, "eth_newFilter", param)
+
-//	var ID string
+	deployTestContractWithFunction(t)
-//	err = json.Unmarshal(rpcRes.Result, &ID)
+
-//	require.NoError(t, err)
+	// get filter changes
-//
+	changesRes := call(t, "eth_getFilterChanges", []string{ID})
-//	deployTestContractWithFunction(t)
+
-//
+	var logs []*ethtypes.Log
-//	// get filter changes
+	err = json.Unmarshal(changesRes.Result, &logs)
-//	changesRes := call(t, "eth_getFilterChanges", []string{ID})
+	require.NoError(t, err)
-//
+
-//	var logs []*ethtypes.Log
+	require.Equal(t, 1, len(logs))
-//	err = json.Unmarshal(changesRes.Result, &logs)
+}
-//	require.NoError(t, err)
+
-//
+func TestEth_GetFilterChanges_Topics_XB(t *testing.T) {
-//	require.Equal(t, 1, len(logs))
+	rpcRes := call(t, "eth_blockNumber", []string{})
-//}
+
+	var res hexutil.Uint64
+	err := res.UnmarshalJSON(rpcRes.Result)
+	require.NoError(t, err)
+
+	param := make([]map[string]interface{}, 1)
+	param[0] = make(map[string]interface{})
+	param[0]["topics"] = []interface{}{nil, worldTopic}
+	param[0]["fromBlock"] = res.String()
+
+	// instantiate new filter
+	rpcRes = call(t, "eth_newFilter", param)
+	var ID string
+	err = json.Unmarshal(rpcRes.Result, &ID)
+	require.NoError(t, err)
+
+	deployTestContractWithFunction(t)
+
+	// get filter changes
+	changesRes := call(t, "eth_getFilterChanges", []string{ID})
+
+	var logs []*ethtypes.Log
+	err = json.Unmarshal(changesRes.Result, &logs)
+	require.NoError(t, err)
+
+	require.Equal(t, 1, len(logs))
+}
 
 func TestEth_PendingTransactionFilter(t *testing.T) {
 	rpcRes := call(t, "eth_newPendingTransactionFilter", []string{})

x/evm/keeper/abci_test.go

@@ -1,6 +1,7 @@
 package keeper_test
 
 import (
+	evmtypes "github.com/evmos/ethermint/x/evm/types"
 	"github.com/tendermint/tendermint/abci/types"
 )
 
@@ -13,5 +14,5 @@ func (suite *KeeperTestSuite) TestEndBlock() {
 
 	// should emit 1 EventTypeBlockBloom event on EndBlock
 	suite.Require().Equal(1, len(em.Events()))
-	suite.Require().Equal("ethermint.evm.v1.EventBlockBloom", em.Events()[0].Type)
+	suite.Require().Equal(evmtypes.EventTypeBlockBloom, em.Events()[0].Type)
 }

x/evm/keeper/keeper.go

@@ -147,14 +147,12 @@ func (k Keeper) ChainID() *big.Int {
 
 // EmitBlockBloomEvent emit block bloom events
 func (k Keeper) EmitBlockBloomEvent(ctx sdk.Context, bloom ethtypes.Bloom) {
-	err := ctx.EventManager().EmitTypedEvent(
+	ctx.EventManager().EmitEvent(
-		&types.EventBlockBloom{
+		sdk.NewEvent(
-			Bloom: string(bloom.Bytes()),
+			types.EventTypeBlockBloom,
-		},
+			sdk.NewAttribute(types.AttributeKeyEthereumBloom, string(bloom.Bytes())),
+		),
 	)
-	if err != nil {
-		k.Logger(ctx).Error(err.Error())
-	}
 }
 
 // GetAuthority returns the x/evm module authority address

x/evm/keeper/msg_server.go

@@ -89,52 +89,56 @@ func (k *Keeper) EthereumTx(goCtx context.Context, msg *types.MsgEthereumTx) (*t
 		}
 	}()
 
-	eventEthereumTx := &types.EventEthereumTx{
+	attrs := []sdk.Attribute{
-		Amount: tx.Value().String(),
+		sdk.NewAttribute(sdk.AttributeKeyAmount, tx.Value().String()),
 		// add event for ethereum transaction hash format
-		EthHash: response.Hash,
+		sdk.NewAttribute(types.AttributeKeyEthereumTxHash, response.Hash),
 		// add event for index of valid ethereum tx
-		Index: strconv.FormatUint(txIndex, 10),
+		sdk.NewAttribute(types.AttributeKeyTxIndex, strconv.FormatUint(txIndex, 10)),
 		// add event for eth tx gas used, we can't get it from cosmos tx result when it contains multiple eth tx msgs.
-		GasUsed: strconv.FormatUint(response.GasUsed, 10),
+		sdk.NewAttribute(types.AttributeKeyTxGasUsed, strconv.FormatUint(response.GasUsed, 10)),
 	}
 
 	if len(ctx.TxBytes()) > 0 {
 		// add event for tendermint transaction hash format
 		hash := tmbytes.HexBytes(tmtypes.Tx(ctx.TxBytes()).Hash())
-		eventEthereumTx.Hash = hash.String()
+		attrs = append(attrs, sdk.NewAttribute(types.AttributeKeyTxHash, hash.String()))
 	}
 
 	if to := tx.To(); to != nil {
-		eventEthereumTx.Recipient = to.Hex()
+		attrs = append(attrs, sdk.NewAttribute(types.AttributeKeyRecipient, to.Hex()))
 	}
 
 	if response.Failed() {
-		eventEthereumTx.EthTxFailed = response.VmError
+		attrs = append(attrs, sdk.NewAttribute(types.AttributeKeyEthereumTxFailed, response.VmError))
 	}
 
-	eventTxLogs := &types.EventTxLog{TxLogs: make([]string, len(response.Logs))}
+	txLogAttrs := make([]sdk.Attribute, len(response.Logs))
 	for i, log := range response.Logs {
 		value, err := json.Marshal(log)
 		if err != nil {
 			return nil, errorsmod.Wrap(err, "failed to encode log")
 		}
-		eventTxLogs.TxLogs[i] = string(value)
+		txLogAttrs[i] = sdk.NewAttribute(types.AttributeKeyTxLog, string(value))
 	}
 
-	err = ctx.EventManager().EmitTypedEvents(
+	// emit events
-		eventEthereumTx,
+	ctx.EventManager().EmitEvents(sdk.Events{
-		eventTxLogs,
+		sdk.NewEvent(
-		&types.EventMessage{
+			types.EventTypeEthereumTx,
-			Module: types.AttributeValueCategory,
+			attrs...,
-			Sender: sender,
+		),
-			TxType: fmt.Sprintf("%d", tx.Type()),
+		sdk.NewEvent(
-		},
+			types.EventTypeTxLog,
-	)
+			txLogAttrs...,
-
+		),
-	if err != nil {
+		sdk.NewEvent(
-		k.Logger(ctx).Error(err.Error())
+			sdk.EventTypeMessage,
-	}
+			sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory),
+			sdk.NewAttribute(sdk.AttributeKeySender, sender),
+			sdk.NewAttribute(types.AttributeKeyTxType, fmt.Sprintf("%d", tx.Type())),
+		),
+	})
 
 	return response, nil
 }

x/feemarket/keeper/abci.go

@@ -41,12 +41,12 @@ func (k *Keeper) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) {
 	}()
 
 	// Store current base fee in event
-	err := ctx.EventManager().EmitTypedEvent(&types.EventFeeMarket{
+	ctx.EventManager().EmitEvents(sdk.Events{
-		BaseFee: baseFee.String(),
+		sdk.NewEvent(
+			types.EventTypeFeeMarket,
+			sdk.NewAttribute(types.AttributeKeyBaseFee, baseFee.String()),
+		),
 	})
-	if err != nil {
-		k.Logger(ctx).Error(err.Error())
-	}
 }
 
 // EndBlock update block gas wanted.
@@ -74,11 +74,9 @@ func (k *Keeper) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) {
 		telemetry.SetGauge(float32(gasWanted), "feemarket", "block_gas")
 	}()
 
-	err := ctx.EventManager().EmitTypedEvents(&types.EventBlockGas{
+	ctx.EventManager().EmitEvent(sdk.NewEvent(
-		Height: fmt.Sprintf("%d", ctx.BlockHeight()),
+		"block_gas",
-		Amount: fmt.Sprintf("%d", gasWanted),
+		sdk.NewAttribute("height", fmt.Sprintf("%d", ctx.BlockHeight())),
-	})
+		sdk.NewAttribute("amount", fmt.Sprintf("%d", gasWanted)),
-	if err != nil {
+	))
-		k.Logger(ctx).Error(err.Error())
-	}
 }

x/feemarket/types/events.pb.go

@@ -1,546 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: ethermint/feemarket/v1/events.proto
-
-package types
-
-import (
-	fmt "fmt"
-	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
-
-// EventFeeMarket is the event type for the fee market module
-type EventFeeMarket struct {
-	// base_fee for EIP-1559 blocks
-	BaseFee string `protobuf:"bytes,1,opt,name=base_fee,json=baseFee,proto3" json:"base_fee,omitempty"`
-}
-
-func (m *EventFeeMarket) Reset()         { *m = EventFeeMarket{} }
-func (m *EventFeeMarket) String() string { return proto.CompactTextString(m) }
-func (*EventFeeMarket) ProtoMessage()    {}
-func (*EventFeeMarket) Descriptor() ([]byte, []int) {
-	return fileDescriptor_c6edce8d670faff7, []int{0}
-}
-func (m *EventFeeMarket) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *EventFeeMarket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_EventFeeMarket.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 *EventFeeMarket) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EventFeeMarket.Merge(m, src)
-}
-func (m *EventFeeMarket) XXX_Size() int {
-	return m.Size()
-}
-func (m *EventFeeMarket) XXX_DiscardUnknown() {
-	xxx_messageInfo_EventFeeMarket.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EventFeeMarket proto.InternalMessageInfo
-
-func (m *EventFeeMarket) GetBaseFee() string {
-	if m != nil {
-		return m.BaseFee
-	}
-	return ""
-}
-
-// EventBlockGas defines the event for a Ethereum block gas
-type EventBlockGas struct {
-	// height is the height of the block
-	Height string `protobuf:"bytes,1,opt,name=height,proto3" json:"height,omitempty"`
-	// amount of gas wanted by the block
-	Amount string `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"`
-}
-
-func (m *EventBlockGas) Reset()         { *m = EventBlockGas{} }
-func (m *EventBlockGas) String() string { return proto.CompactTextString(m) }
-func (*EventBlockGas) ProtoMessage()    {}
-func (*EventBlockGas) Descriptor() ([]byte, []int) {
-	return fileDescriptor_c6edce8d670faff7, []int{1}
-}
-func (m *EventBlockGas) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *EventBlockGas) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_EventBlockGas.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 *EventBlockGas) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EventBlockGas.Merge(m, src)
-}
-func (m *EventBlockGas) XXX_Size() int {
-	return m.Size()
-}
-func (m *EventBlockGas) XXX_DiscardUnknown() {
-	xxx_messageInfo_EventBlockGas.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EventBlockGas proto.InternalMessageInfo
-
-func (m *EventBlockGas) GetHeight() string {
-	if m != nil {
-		return m.Height
-	}
-	return ""
-}
-
-func (m *EventBlockGas) GetAmount() string {
-	if m != nil {
-		return m.Amount
-	}
-	return ""
-}
-
-func init() {
-	proto.RegisterType((*EventFeeMarket)(nil), "ethermint.feemarket.v1.EventFeeMarket")
-	proto.RegisterType((*EventBlockGas)(nil), "ethermint.feemarket.v1.EventBlockGas")
-}
-
-func init() {
-	proto.RegisterFile("ethermint/feemarket/v1/events.proto", fileDescriptor_c6edce8d670faff7)
-}
-
-var fileDescriptor_c6edce8d670faff7 = []byte{
-	// 212 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x4e, 0x2d, 0xc9, 0x48,
-	0x2d, 0xca, 0xcd, 0xcc, 0x2b, 0xd1, 0x4f, 0x4b, 0x4d, 0xcd, 0x4d, 0x2c, 0xca, 0x4e, 0x2d, 0xd1,
-	0x2f, 0x33, 0xd4, 0x4f, 0x2d, 0x4b, 0xcd, 0x2b, 0x29, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17,
-	0x12, 0x83, 0x2b, 0xd2, 0x83, 0x2b, 0xd2, 0x2b, 0x33, 0x54, 0xd2, 0xe6, 0xe2, 0x73, 0x05, 0xa9,
-	0x73, 0x4b, 0x4d, 0xf5, 0x05, 0x0b, 0x0a, 0x49, 0x72, 0x71, 0x24, 0x25, 0x16, 0xa7, 0xc6, 0xa7,
-	0xa5, 0xa6, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x06, 0xb1, 0x83, 0xf8, 0x6e, 0xa9, 0xa9, 0x4a,
-	0xf6, 0x5c, 0xbc, 0x60, 0xc5, 0x4e, 0x39, 0xf9, 0xc9, 0xd9, 0xee, 0x89, 0xc5, 0x42, 0x62, 0x5c,
-	0x6c, 0x19, 0xa9, 0x99, 0xe9, 0x19, 0x25, 0x50, 0x95, 0x50, 0x1e, 0x48, 0x3c, 0x31, 0x37, 0xbf,
-	0x34, 0xaf, 0x44, 0x82, 0x09, 0x22, 0x0e, 0xe1, 0x39, 0xb9, 0x9d, 0x78, 0x24, 0xc7, 0x78, 0xe1,
-	0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70,
-	0xe3, 0xb1, 0x1c, 0x43, 0x94, 0x4e, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae,
-	0x7e, 0x6a, 0x59, 0x6e, 0x7e, 0xb1, 0x3e, 0xc2, 0x57, 0x15, 0x48, 0xfe, 0x2a, 0xa9, 0x2c, 0x48,
-	0x2d, 0x4e, 0x62, 0x03, 0x7b, 0xca, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0xc9, 0x52, 0xc3, 0x38,
-	0xfb, 0x00, 0x00, 0x00,
-}
-
-func (m *EventFeeMarket) 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 *EventFeeMarket) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *EventFeeMarket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.BaseFee) > 0 {
-		i -= len(m.BaseFee)
-		copy(dAtA[i:], m.BaseFee)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.BaseFee)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *EventBlockGas) 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 *EventBlockGas) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *EventBlockGas) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Amount) > 0 {
-		i -= len(m.Amount)
-		copy(dAtA[i:], m.Amount)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.Amount)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.Height) > 0 {
-		i -= len(m.Height)
-		copy(dAtA[i:], m.Height)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.Height)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintEvents(dAtA []byte, offset int, v uint64) int {
-	offset -= sovEvents(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *EventFeeMarket) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.BaseFee)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	return n
-}
-
-func (m *EventBlockGas) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Height)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	l = len(m.Amount)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	return n
-}
-
-func sovEvents(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozEvents(x uint64) (n int) {
-	return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *EventFeeMarket) 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 ErrIntOverflowEvents
-			}
-			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: EventFeeMarket: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: EventFeeMarket: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			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 ErrIntOverflowEvents
-				}
-				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 ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.BaseFee = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipEvents(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *EventBlockGas) 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 ErrIntOverflowEvents
-			}
-			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: EventBlockGas: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: EventBlockGas: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				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 ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Height = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				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 ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Amount = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipEvents(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipEvents(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, ErrIntOverflowEvents
-			}
-			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, ErrIntOverflowEvents
-				}
-				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, ErrIntOverflowEvents
-				}
-				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, ErrInvalidLengthEvents
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupEvents
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthEvents
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthEvents        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowEvents          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupEvents = fmt.Errorf("proto: unexpected end of group")
-)