diff --git a/app/ante/handler_options.go b/app/ante/handler_options.go index 84665bf931..2510dacdb2 100644 --- a/app/ante/handler_options.go +++ b/app/ante/handler_options.go @@ -16,6 +16,8 @@ package ante import ( + "math/big" + errorsmod "cosmossdk.io/errors" storetypes "cosmossdk.io/store/types" txsigning "cosmossdk.io/x/tx/signing" @@ -92,6 +94,35 @@ func newEthAnteHandler(options HandlerOptions) sdk.AnteHandler { baseFee := blockCfg.BaseFee rules := blockCfg.Rules + isZeroGas := false + fromAddrs := make([]sdk.AccAddress, 0) + for _, m := range tx.GetMsgs() { + msgEthTx, ok := m.(*evmtypes.MsgEthereumTx) + if !ok { + return ctx, errorsmod.Wrapf(errortypes.ErrUnknownRequest, "invalid message type %T, expected %T", m, (*evmtypes.MsgEthereumTx)(nil)) + } + msg := msgEthTx.AsMessage(nil) + + fromAddrs = append(fromAddrs, msg.From.Bytes()) + + if msg.To != nil && len(msg.Data) >= 4 { + toAddr := msg.To.Bytes() + signature := msg.Data[:4] + if options.EvmKeeper.HasZeroGas(ctx, toAddr, signature) { + isZeroGas = true + } + } + } + if isZeroGas { + for _, fromAddr := range fromAddrs { + if options.AccountKeeper.GetAccount(ctx, fromAddr) == nil { + newAcc := options.AccountKeeper.NewAccountWithAddress(ctx, fromAddr) + options.AccountKeeper.SetAccount(ctx, newAcc) + } + } + baseFee = big.NewInt(0) + } + // all transactions must implement FeeTx _, ok := tx.(sdk.FeeTx) if !ok { diff --git a/app/ante/interfaces.go b/app/ante/interfaces.go index c81683daa0..393d151f0e 100644 --- a/app/ante/interfaces.go +++ b/app/ante/interfaces.go @@ -33,6 +33,7 @@ type EVMKeeper interface { ChainID() *big.Int EVMBlockConfig(sdk.Context, *big.Int) (*evmkeeper.EVMBlockConfig, error) + HasZeroGas(ctx sdk.Context, addr []byte, sig []byte) bool DeductTxCostsFromUserBalance(ctx sdk.Context, fees sdk.Coins, from common.Address) error } diff --git a/proto/ethermint/evm/v1/genesis.proto b/proto/ethermint/evm/v1/genesis.proto index 67092d42d9..530db1f492 100644 --- a/proto/ethermint/evm/v1/genesis.proto +++ b/proto/ethermint/evm/v1/genesis.proto @@ -2,6 +2,7 @@ syntax = "proto3"; package ethermint.evm.v1; import "ethermint/evm/v1/params.proto"; +import "ethermint/evm/v1/zero_gas.proto"; import "ethermint/evm/v1/state.proto"; import "gogoproto/gogo.proto"; @@ -13,6 +14,8 @@ message GenesisState { repeated GenesisAccount accounts = 1 [(gogoproto.nullable) = false]; // params defines all the parameters of the module. Params params = 2 [(gogoproto.nullable) = false]; + // zero_gas defines the zero gas config for the module. + repeated ZeroGas zero_gas = 3 [(gogoproto.nullable) = false]; } // GenesisAccount defines an account to be initialized in the genesis state. diff --git a/proto/ethermint/evm/v1/query.proto b/proto/ethermint/evm/v1/query.proto index 8898dd7287..3cbc377021 100644 --- a/proto/ethermint/evm/v1/query.proto +++ b/proto/ethermint/evm/v1/query.proto @@ -6,6 +6,7 @@ import "ethermint/evm/v1/tx.proto"; import "ethermint/evm/v1/log.proto"; import "ethermint/evm/v1/params.proto"; import "ethermint/evm/v1/trace_config.proto"; +import "ethermint/evm/v1/zero_gas.proto"; import "gogoproto/gogo.proto"; import "google/api/annotations.proto"; import "google/protobuf/timestamp.proto"; @@ -81,6 +82,16 @@ service Query { rpc BaseFee(QueryBaseFeeRequest) returns (QueryBaseFeeResponse) { option (google.api.http).get = "/ethermint/evm/v1/base_fee"; } + + // ZeroGas queries the zero gas config for a given contract address and signature + rpc ZeroGas(QueryZeroGasRequest) returns (QueryZeroGasResponse) { + option (google.api.http).get = "/ethermint/evm/v1/zero_gas"; + } + + // AllZeroGas queries all the zero gas + rpc AllZeroGas(QueryAllZeroGasRequest) returns (QueryAllZeroGasResponse) { + option (google.api.http).get = "/ethermint/evm/v1/all_zero_gas"; + } } // QueryAccountRequest is the request type for the Query/Account RPC method. @@ -336,3 +347,24 @@ message QueryBaseFeeResponse { // base_fee is the EIP1559 base fee string base_fee = 1 [(gogoproto.customtype) = "cosmossdk.io/math.Int"]; } + +// QueryZeroGasRequest defines ZeroGas request +message QueryZeroGasRequest { + // contract_address is the contract address to query the zero gas for + string contract_address = 1; +} + +// QueryZeroGasResponse defines ZeroGas response +message QueryZeroGasResponse { + // items is the zero gas items + repeated string signatures = 1; +} + +// QueryAllZeroGasRequest defines AllZeroGas request +message QueryAllZeroGasRequest {} + +// QueryAllZeroGasResponse defines AllZeroGas response +message QueryAllZeroGasResponse { + // items is the zero gas items + repeated ZeroGas items = 1 [ (gogoproto.nullable) = false ]; +} diff --git a/proto/ethermint/evm/v1/tx.proto b/proto/ethermint/evm/v1/tx.proto index cea3279399..6a7e02acec 100644 --- a/proto/ethermint/evm/v1/tx.proto +++ b/proto/ethermint/evm/v1/tx.proto @@ -6,9 +6,11 @@ import "cosmos_proto/cosmos.proto"; import "gogoproto/gogo.proto"; import "google/api/annotations.proto"; import "google/protobuf/any.proto"; +import "amino/amino.proto"; import "ethermint/evm/v1/access_tuple.proto"; import "ethermint/evm/v1/log.proto"; import "ethermint/evm/v1/params.proto"; +import "ethermint/evm/v1/zero_gas.proto"; option go_package = "github.com/evmos/ethermint/x/evm/types"; @@ -22,6 +24,8 @@ service Msg { // UpdateParams defined a governance operation for updating the x/evm module parameters. // The authority is hard-coded to the Cosmos SDK x/gov module account rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse); + // UpdateZeroGas defines a method for updating the zero gas config + rpc UpdateZeroGas(MsgUpdateZeroGas) returns (MsgUpdateZeroGasResponse); } // MsgEthereumTx encapsulates an Ethereum transaction as an SDK message. @@ -187,3 +191,22 @@ message MsgUpdateParams { // MsgUpdateParamsResponse defines the response structure for executing a // MsgUpdateParams message. message MsgUpdateParamsResponse {} + +// MsgUpdateZeroGas defines a Msg for updating the x/evm module zero gas config. +message MsgUpdateZeroGas { + option (cosmos.msg.v1.signer) = "authority"; + + // authority is the address that controls the module (defaults to x/gov unless + // overwritten). + string authority = 1 [ (cosmos_proto.scalar) = "cosmos.AddressString" ]; + option (amino.name) = "basechain/MsgUpdateZeroGasConfig"; + + option (gogoproto.equal) = false; + + // metadata defines the zero gas to update. + UpdateZeroGasMetadata metadata = 2 [(gogoproto.nullable) = false]; +} + +// MsgUpdateZeroGasResponse defines the response structure for executing a +// MsgUpdateZeroGas message. +message MsgUpdateZeroGasResponse {} diff --git a/proto/ethermint/evm/v1/zero_gas.proto b/proto/ethermint/evm/v1/zero_gas.proto new file mode 100644 index 0000000000..a8238988e6 --- /dev/null +++ b/proto/ethermint/evm/v1/zero_gas.proto @@ -0,0 +1,23 @@ +syntax = "proto3"; +package ethermint.evm.v1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/evmos/ethermint/x/evm/types"; + +// ZeroGas defines the parameters for zero gas fee transactions +message ZeroGas { + // contract_address specifies the target contract address for zero gas fee transactions + string contract_address = 1 [(gogoproto.moretags) = "yaml:\"contract_address\""]; + // signatures is a list of function signatures that will have zero gas fee + // when called on the specified contract_address + repeated string signatures = 2 [(gogoproto.moretags) = "yaml:\"signatures\""]; +} + +message UpdateZeroGasMetadata { + // zero gas items to be added + repeated ZeroGas add_items = 1; + + // zero gas items to be removed + repeated ZeroGas remove_items = 2; +} diff --git a/rpc/backend/mocks/evm_query_client.go b/rpc/backend/mocks/evm_query_client.go index 845dae72d9..353657d45a 100644 --- a/rpc/backend/mocks/evm_query_client.go +++ b/rpc/backend/mocks/evm_query_client.go @@ -407,6 +407,64 @@ func (_m *EVMQueryClient) ValidatorAccount(ctx context.Context, in *types.QueryV return r0, r1 } +func (_m *EVMQueryClient) ZeroGas(ctx context.Context, in *types.QueryZeroGasRequest, opts ...grpc.CallOption) (*types.QueryZeroGasResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *types.QueryZeroGasResponse + if rf, ok := ret.Get(0).(func(context.Context, *types.QueryZeroGasRequest, ...grpc.CallOption) *types.QueryZeroGasResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.QueryZeroGasResponse) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *types.QueryZeroGasRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +func (_m *EVMQueryClient) AllZeroGas(ctx context.Context, in *types.QueryAllZeroGasRequest, opts ...grpc.CallOption) (*types.QueryAllZeroGasResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *types.QueryAllZeroGasResponse + if rf, ok := ret.Get(0).(func(context.Context, *types.QueryAllZeroGasRequest, ...grpc.CallOption) *types.QueryAllZeroGasResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.QueryAllZeroGasResponse) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *types.QueryAllZeroGasRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + type mockConstructorTestingTNewEVMQueryClient interface { mock.TestingT Cleanup(func()) diff --git a/x/evm/client/cli/query.go b/x/evm/client/cli/query.go index bc3c6886b3..6a5c1ed880 100644 --- a/x/evm/client/cli/query.go +++ b/x/evm/client/cli/query.go @@ -39,6 +39,8 @@ func GetQueryCmd() *cobra.Command { GetStorageCmd(), GetCodeCmd(), GetParamsCmd(), + GetZeroGasCmd(), + GetAllZeroGasCmd(), ) return cmd } @@ -147,3 +149,59 @@ func GetParamsCmd() *cobra.Command { flags.AddQueryFlagsToCmd(cmd) return cmd } + +// GetZeroGasCmd queries the zero gas for a given contract address +func GetZeroGasCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "zero-gas ADDRESS", + Short: "Get the zero gas for a given contract address", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + + queryClient := types.NewQueryClient(clientCtx) + + res, err := queryClient.ZeroGas(cmd.Context(), &types.QueryZeroGasRequest{ + ContractAddress: args[0], + }) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + return cmd +} + +// GetAllZeroGasCmd queries the all zero gas for a given contract address +func GetAllZeroGasCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "all-zero-gas", + Short: "Get the all zero gas", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + + queryClient := types.NewQueryClient(clientCtx) + + res, err := queryClient.AllZeroGas(cmd.Context(), &types.QueryAllZeroGasRequest{}) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + return cmd +} diff --git a/x/evm/genesis.go b/x/evm/genesis.go index db3799d35b..62aa1e07ad 100644 --- a/x/evm/genesis.go +++ b/x/evm/genesis.go @@ -82,6 +82,25 @@ func InitGenesis( } } + for _, config := range data.ZeroGas { + if !common.IsHexAddress(config.ContractAddress) { + panic(fmt.Sprintf("invalid contract address: %s", config.ContractAddress)) + } + + contractAddr := common.FromHex(config.ContractAddress) + for _, s := range config.Signatures { + sig := common.FromHex(s) + if len(sig) != 4 { + panic(fmt.Sprintf("invalid signature: %s", s)) + } + + err = k.SetZeroGas(ctx, contractAddr, sig) + if err != nil { + panic(fmt.Errorf("error setting zero gas config %s", err)) + } + } + } + return []abci.ValidatorUpdate{} } @@ -112,5 +131,6 @@ func ExportGenesis(ctx sdk.Context, k *keeper.Keeper, ak types.AccountKeeper) *t return &types.GenesisState{ Accounts: ethGenAccounts, Params: k.GetParams(ctx), + ZeroGas: k.GetAllZeroGas(ctx), } } diff --git a/x/evm/keeper/grpc_query.go b/x/evm/keeper/grpc_query.go index 12179d35f4..a296def71f 100644 --- a/x/evm/keeper/grpc_query.go +++ b/x/evm/keeper/grpc_query.go @@ -767,3 +767,23 @@ func getChainID(ctx sdk.Context, chainID int64) (*big.Int, error) { } return big.NewInt(chainID), nil } + +// ZeroGas implements the Query/ZeroGas gRPC method +func (k Keeper) ZeroGas(c context.Context, req *types.QueryZeroGasRequest) (*types.QueryZeroGasResponse, error) { + ctx := sdk.UnwrapSDKContext(c) + + if !common.IsHexAddress(req.ContractAddress) { + return nil, status.Errorf(codes.Internal, "invalid contract address: %s", req.ContractAddress) + } + + contractAddr := common.FromHex(req.ContractAddress) + sigs := k.GetAllZeroGasSigsByAddr(ctx, contractAddr) + return &types.QueryZeroGasResponse{Signatures: sigs}, nil +} + +// AllZeroGas implements the Query/AllZeroGas gRPC method +func (k Keeper) AllZeroGas(c context.Context, req *types.QueryAllZeroGasRequest) (*types.QueryAllZeroGasResponse, error) { + ctx := sdk.UnwrapSDKContext(c) + items := k.GetAllZeroGas(ctx) + return &types.QueryAllZeroGasResponse{Items: items}, nil +} diff --git a/x/evm/keeper/msg_server.go b/x/evm/keeper/msg_server.go index ed799c6ea7..c860d5c87c 100644 --- a/x/evm/keeper/msg_server.go +++ b/x/evm/keeper/msg_server.go @@ -31,6 +31,8 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/hashicorp/go-metrics" + "github.com/ethereum/go-ethereum/common" + ethermint "github.com/evmos/ethermint/types" "github.com/evmos/ethermint/x/evm/types" ) @@ -150,3 +152,51 @@ func (k *Keeper) UpdateParams(goCtx context.Context, req *types.MsgUpdateParams) return &types.MsgUpdateParamsResponse{}, nil } + +func (k *Keeper) UpdateZeroGas(goCtx context.Context, req *types.MsgUpdateZeroGas) (*types.MsgUpdateZeroGasResponse, error) { + if k.authority.String() != req.Authority { + return nil, errorsmod.Wrapf(govtypes.ErrInvalidSigner, "invalid authority, expected %s, got %s", k.authority.String(), req.Authority) + } + + ctx := sdk.UnwrapSDKContext(goCtx) + + for _, item := range req.Metadata.AddItems { + if !common.IsHexAddress(item.ContractAddress) { + return nil, errorsmod.Wrapf(govtypes.ErrInvalidProposalContent, "invalid contract address: %s", item.ContractAddress) + } + + contractAddr := common.FromHex(item.ContractAddress) + for _, s := range item.Signatures { + sig := common.FromHex(s) + if len(sig) != 4 { + return nil, errorsmod.Wrapf(govtypes.ErrInvalidProposalContent, "invalid signature: %s", s) + } + + err := k.SetZeroGas(ctx, contractAddr, sig) + if err != nil { + return nil, err + } + } + } + + for _, item := range req.Metadata.RemoveItems { + if !common.IsHexAddress(item.ContractAddress) { + return nil, errorsmod.Wrapf(govtypes.ErrInvalidProposalContent, "invalid contract address: %s", item.ContractAddress) + } + + contractAddr := common.FromHex(item.ContractAddress) + for _, s := range item.Signatures { + sig := common.FromHex(s) + if len(sig) != 4 { + return nil, errorsmod.Wrapf(govtypes.ErrInvalidProposalContent, "invalid signature: %s", s) + } + + err := k.DeleteZeroGas(ctx, contractAddr, sig) + if err != nil { + return nil, err + } + } + } + + return &types.MsgUpdateZeroGasResponse{}, nil +} diff --git a/x/evm/keeper/zero_gas.go b/x/evm/keeper/zero_gas.go new file mode 100644 index 0000000000..8a8986df6c --- /dev/null +++ b/x/evm/keeper/zero_gas.go @@ -0,0 +1,78 @@ +package keeper + +import ( + "encoding/hex" + + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/ethereum/go-ethereum/common" + + "github.com/evmos/ethermint/x/evm/types" +) + +func (k Keeper) GetAllZeroGas(ctx sdk.Context) []types.ZeroGas { + store := ctx.KVStore(k.storeKey) + iter := store.Iterator(types.KeyPrefixZeroGas, nil) + defer iter.Close() + + // Use map to group signatures by contract address + addrMap := make(map[string]*types.ZeroGas) + + for ; iter.Valid(); iter.Next() { + addr, sig := types.ParseZeroGasByAddrSigKey(iter.Key()) + addrStr := common.BytesToAddress(addr).Hex() + sigStr := hex.EncodeToString(sig) + + if zeroGas, exists := addrMap[addrStr]; exists { + // If contract address already exists, append the signature + zeroGas.Signatures = append(zeroGas.Signatures, sigStr) + } else { + // If new contract address, create new ZeroGas entry + addrMap[addrStr] = &types.ZeroGas{ + ContractAddress: addrStr, + Signatures: []string{sigStr}, + } + } + } + + // Convert map to slice + result := make([]types.ZeroGas, 0, len(addrMap)) + for _, zeroGas := range addrMap { + result = append(result, *zeroGas) + } + + return result +} + +// GetAllZeroGasSigsByAddr returns all the zero gas signatures by contract address. +func (k Keeper) GetAllZeroGasSigsByAddr(ctx sdk.Context, addr []byte) []string { + store := ctx.KVStore(k.storeKey) + iter := store.Iterator(types.GetZeroGasByAddrKey(addr), nil) + defer iter.Close() + + var sigs []string + for ; iter.Valid(); iter.Next() { + _, sig := types.ParseZeroGasByAddrSigKey(iter.Key()) + sigStr := hex.EncodeToString(sig) + sigs = append(sigs, sigStr) + } + return sigs +} + +func (k Keeper) HasZeroGas(ctx sdk.Context, addr []byte, sig []byte) bool { + store := ctx.KVStore(k.storeKey) + return store.Has(types.GetZeroGasByAddrSigKey(addr, sig)) +} + +// SetZeroGas sets the EVM zero gas. +func (k Keeper) SetZeroGas(ctx sdk.Context, addr []byte, sig []byte) error { + store := ctx.KVStore(k.storeKey) + store.Set(types.GetZeroGasByAddrSigKey(addr, sig), []byte{}) + return nil +} + +func (k Keeper) DeleteZeroGas(ctx sdk.Context, addr []byte, sig []byte) error { + store := ctx.KVStore(k.storeKey) + store.Delete(types.GetZeroGasByAddrSigKey(addr, sig)) + return nil +} diff --git a/x/evm/types/genesis.pb.go b/x/evm/types/genesis.pb.go index 8b9d6f33e6..a4be3d483f 100644 --- a/x/evm/types/genesis.pb.go +++ b/x/evm/types/genesis.pb.go @@ -29,6 +29,8 @@ type GenesisState struct { Accounts []GenesisAccount `protobuf:"bytes,1,rep,name=accounts,proto3" json:"accounts"` // params defines all the parameters of the module. Params Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params"` + // zero_gas defines the zero gas config for the module. + ZeroGas []ZeroGas `protobuf:"bytes,3,rep,name=zero_gas,json=zeroGas,proto3" json:"zero_gas"` } func (m *GenesisState) Reset() { *m = GenesisState{} } @@ -78,6 +80,13 @@ func (m *GenesisState) GetParams() Params { return Params{} } +func (m *GenesisState) GetZeroGas() []ZeroGas { + if m != nil { + return m.ZeroGas + } + return nil +} + // GenesisAccount defines an account to be initialized in the genesis state. // Its main difference between with Geth's GenesisAccount is that it uses a // custom storage type and that it doesn't contain the private key field. @@ -152,27 +161,29 @@ func init() { func init() { proto.RegisterFile("ethermint/evm/v1/genesis.proto", fileDescriptor_9bcdec50cc9d156d) } var fileDescriptor_9bcdec50cc9d156d = []byte{ - // 305 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x50, 0x31, 0x4f, 0x83, 0x40, - 0x18, 0xe5, 0x6c, 0x53, 0xec, 0xd5, 0xa8, 0xb9, 0x98, 0x48, 0x1a, 0xbd, 0x92, 0x0e, 0x86, 0xe9, - 0x48, 0x6b, 0xe2, 0xac, 0x2c, 0xae, 0x86, 0x6e, 0x6e, 0x57, 0xf8, 0x42, 0x19, 0xe0, 0x08, 0x77, - 0x25, 0xba, 0x3a, 0x3a, 0xf9, 0x3b, 0xfc, 0x25, 0x1d, 0x3b, 0x3a, 0xa9, 0x81, 0x3f, 0x62, 0x38, - 0x68, 0x8d, 0xb2, 0x3d, 0x78, 0xef, 0x7d, 0xef, 0xdd, 0xc3, 0x14, 0xd4, 0x0a, 0xf2, 0x24, 0x4e, - 0x95, 0x0b, 0x45, 0xe2, 0x16, 0x33, 0x37, 0x82, 0x14, 0x64, 0x2c, 0x59, 0x96, 0x0b, 0x25, 0xc8, - 0xe9, 0x9e, 0x67, 0x50, 0x24, 0xac, 0x98, 0x8d, 0x2f, 0x3b, 0x8e, 0x8c, 0xe7, 0x3c, 0x69, 0x0d, - 0xe3, 0x8b, 0x0e, 0x2d, 0x15, 0x57, 0xd0, 0xb2, 0x67, 0x91, 0x88, 0x84, 0x86, 0x6e, 0x8d, 0x9a, - 0xbf, 0xd3, 0x57, 0x84, 0x8f, 0xee, 0x9b, 0xd8, 0x45, 0x2d, 0x26, 0x1e, 0x3e, 0xe4, 0x41, 0x20, - 0xd6, 0xa9, 0x92, 0x16, 0xb2, 0x7b, 0xce, 0x68, 0x6e, 0xb3, 0xff, 0x45, 0x58, 0xeb, 0xb8, 0x6b, - 0x84, 0x5e, 0x7f, 0xf3, 0x39, 0x31, 0xfc, 0xbd, 0x8f, 0xdc, 0xe0, 0x41, 0x53, 0xcc, 0x3a, 0xb0, - 0x91, 0x33, 0x9a, 0x5b, 0xdd, 0x0b, 0x0f, 0x9a, 0x6f, 0x9d, 0xad, 0x7a, 0xfa, 0x82, 0xf0, 0xf1, - 0xdf, 0xd3, 0xc4, 0xc2, 0x26, 0x0f, 0xc3, 0x1c, 0x64, 0xdd, 0x06, 0x39, 0x43, 0x7f, 0xf7, 0x49, - 0x08, 0xee, 0x07, 0x22, 0x04, 0x1d, 0x31, 0xf4, 0x35, 0x26, 0x1e, 0x36, 0xa5, 0x12, 0x39, 0x8f, - 0xc0, 0xea, 0xe9, 0xee, 0xe7, 0xdd, 0x64, 0xfd, 0x4c, 0xef, 0xa4, 0x0e, 0x7e, 0xff, 0x9a, 0x98, - 0x8b, 0x46, 0xef, 0xef, 0x8c, 0xde, 0xed, 0xa6, 0xa4, 0x68, 0x5b, 0x52, 0xf4, 0x5d, 0x52, 0xf4, - 0x56, 0x51, 0x63, 0x5b, 0x51, 0xe3, 0xa3, 0xa2, 0xc6, 0xe3, 0x55, 0x14, 0xab, 0xd5, 0x7a, 0xc9, - 0x02, 0x91, 0xd4, 0x03, 0x0b, 0xe9, 0xfe, 0x0e, 0xfe, 0xa4, 0x27, 0x57, 0xcf, 0x19, 0xc8, 0xe5, - 0x40, 0x4f, 0x7b, 0xfd, 0x13, 0x00, 0x00, 0xff, 0xff, 0xf4, 0x26, 0xbe, 0x33, 0xe1, 0x01, 0x00, - 0x00, + // 340 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x91, 0xb1, 0x4e, 0xc2, 0x40, + 0x1c, 0xc6, 0x7b, 0x42, 0x28, 0x1c, 0x46, 0xcd, 0xc5, 0xc4, 0x4a, 0xf4, 0x20, 0x0c, 0x86, 0xa9, + 0x0d, 0x98, 0x38, 0x38, 0x69, 0x17, 0x56, 0x53, 0x36, 0x16, 0x73, 0x94, 0x7f, 0x0a, 0x43, 0x39, + 0x72, 0x77, 0x34, 0xca, 0xe8, 0x13, 0xf8, 0x1c, 0x3e, 0x88, 0x61, 0x64, 0x74, 0x52, 0x43, 0x5f, + 0xc4, 0xf4, 0xda, 0x62, 0xf4, 0xb6, 0xff, 0xf5, 0xff, 0xfd, 0xfa, 0x7d, 0x77, 0x1f, 0xa6, 0xa0, + 0x66, 0x20, 0xe2, 0xf9, 0x42, 0x79, 0x90, 0xc4, 0x5e, 0xd2, 0xf7, 0x22, 0x58, 0x80, 0x9c, 0x4b, + 0x77, 0x29, 0xb8, 0xe2, 0xe4, 0x64, 0xbf, 0x77, 0x21, 0x89, 0xdd, 0xa4, 0xdf, 0xba, 0x34, 0x88, + 0x25, 0x13, 0x2c, 0x2e, 0x80, 0x56, 0xdb, 0x58, 0xaf, 0x41, 0xf0, 0xc7, 0x88, 0x95, 0x82, 0x0b, + 0x43, 0x20, 0x15, 0x53, 0x50, 0x6c, 0x4f, 0x23, 0x1e, 0x71, 0x3d, 0x7a, 0xd9, 0x94, 0x7f, 0xed, + 0xbe, 0x23, 0x7c, 0x38, 0xcc, 0x73, 0x8d, 0x32, 0x31, 0xf1, 0x71, 0x9d, 0x85, 0x21, 0x5f, 0x2d, + 0x94, 0x74, 0x50, 0xa7, 0xd2, 0x6b, 0x0e, 0x3a, 0xee, 0xff, 0xa4, 0x6e, 0x41, 0xdc, 0xe7, 0x42, + 0xbf, 0xba, 0xf9, 0x6c, 0x5b, 0xc1, 0x9e, 0x23, 0x37, 0xb8, 0x96, 0x27, 0x77, 0x0e, 0x3a, 0xa8, + 0xd7, 0x1c, 0x38, 0xe6, 0x1f, 0x1e, 0xf4, 0xbe, 0x20, 0x0b, 0x35, 0xb9, 0xc5, 0xf5, 0xf2, 0x4a, + 0x4e, 0x45, 0x7b, 0x9f, 0x9b, 0xe4, 0x18, 0x04, 0x1f, 0xb2, 0x12, 0xb5, 0xd7, 0xf9, 0xb1, 0xfb, + 0x82, 0xf0, 0xd1, 0xdf, 0x58, 0xc4, 0xc1, 0x36, 0x9b, 0x4e, 0x05, 0xc8, 0xec, 0x26, 0xa8, 0xd7, + 0x08, 0xca, 0x23, 0x21, 0xb8, 0x1a, 0xf2, 0x29, 0xe8, 0x78, 0x8d, 0x40, 0xcf, 0xc4, 0xc7, 0xb6, + 0x54, 0x5c, 0xb0, 0x08, 0x0a, 0xef, 0x33, 0xd3, 0x5b, 0x3f, 0x91, 0x7f, 0x9c, 0x39, 0xbf, 0x7d, + 0xb5, 0xed, 0x51, 0xae, 0x0f, 0x4a, 0xd0, 0xbf, 0xdb, 0xec, 0x28, 0xda, 0xee, 0x28, 0xfa, 0xde, + 0x51, 0xf4, 0x9a, 0x52, 0x6b, 0x9b, 0x52, 0xeb, 0x23, 0xa5, 0xd6, 0xf8, 0x2a, 0x9a, 0xab, 0xd9, + 0x6a, 0xe2, 0x86, 0x3c, 0xce, 0xca, 0xe1, 0xd2, 0xfb, 0x2d, 0xeb, 0x49, 0xd7, 0xa5, 0x9e, 0x97, + 0x20, 0x27, 0x35, 0x5d, 0xcb, 0xf5, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x49, 0x26, 0xbc, 0x5c, + 0x3e, 0x02, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -195,6 +206,20 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.ZeroGas) > 0 { + for iNdEx := len(m.ZeroGas) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ZeroGas[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } { size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) if err != nil { @@ -298,6 +323,12 @@ func (m *GenesisState) Size() (n int) { } l = m.Params.Size() n += 1 + l + sovGenesis(uint64(l)) + if len(m.ZeroGas) > 0 { + for _, e := range m.ZeroGas { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } return n } @@ -426,6 +457,40 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ZeroGas", 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 + } + m.ZeroGas = append(m.ZeroGas, ZeroGas{}) + if err := m.ZeroGas[len(m.ZeroGas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenesis(dAtA[iNdEx:]) diff --git a/x/evm/types/key.go b/x/evm/types/key.go index 569ce7bb90..8460965b77 100644 --- a/x/evm/types/key.go +++ b/x/evm/types/key.go @@ -45,6 +45,7 @@ const ( prefixStorage prefixParams prefixHeaderHash + prefixZeroGas ) // prefix bytes for the EVM object store @@ -60,6 +61,7 @@ var ( KeyPrefixStorage = []byte{prefixStorage} KeyPrefixParams = []byte{prefixParams} KeyPrefixHeaderHash = []byte{prefixHeaderHash} + KeyPrefixZeroGas = []byte{prefixZeroGas} ) // Object Store key prefixes @@ -119,3 +121,28 @@ func GetHeaderHashKey(height uint64) []byte { binary.BigEndian.PutUint64(key[1:], height) return key[:] } + +// GetZeroGasByAddrKey returns the key for the zero gas by contract address +func GetZeroGasByAddrKey(addr []byte) []byte { + // contractAddr is 20 bytes + return append(KeyPrefixZeroGas, addr...) +} + +// ParseZeroGasByAddrKey parses the key for the zero gas by contract address +func ParseZeroGasByAddrKey(key []byte) []byte { + addr := key[len(KeyPrefixZeroGas) : len(KeyPrefixZeroGas)+20] + return addr +} + +// GetZeroGasByAddrSigKey returns the key for the zero gas by contract address and signature +func GetZeroGasByAddrSigKey(addr []byte, sig []byte) []byte { + // contractAddr is 20 bytes, signature is 4 bytes + return append(GetZeroGasByAddrKey(addr), sig...) +} + +// ParseZeroGasByAddrSigKey parses the key for the zero gas by contract address and signature +func ParseZeroGasByAddrSigKey(key []byte) ([]byte, []byte) { + addr := key[len(KeyPrefixZeroGas) : len(KeyPrefixZeroGas)+20] + sig := key[len(KeyPrefixZeroGas)+20:] + return addr, sig +} diff --git a/x/evm/types/query.pb.go b/x/evm/types/query.pb.go index 253948b1c9..8d5ccae0e7 100644 --- a/x/evm/types/query.pb.go +++ b/x/evm/types/query.pb.go @@ -1468,6 +1468,181 @@ func (m *QueryBaseFeeResponse) XXX_DiscardUnknown() { var xxx_messageInfo_QueryBaseFeeResponse proto.InternalMessageInfo +// QueryZeroGasRequest defines ZeroGas request +type QueryZeroGasRequest struct { + // contract_address is the contract address to query the zero gas for + ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"` +} + +func (m *QueryZeroGasRequest) Reset() { *m = QueryZeroGasRequest{} } +func (m *QueryZeroGasRequest) String() string { return proto.CompactTextString(m) } +func (*QueryZeroGasRequest) ProtoMessage() {} +func (*QueryZeroGasRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{26} +} +func (m *QueryZeroGasRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryZeroGasRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryZeroGasRequest.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 *QueryZeroGasRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryZeroGasRequest.Merge(m, src) +} +func (m *QueryZeroGasRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryZeroGasRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryZeroGasRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryZeroGasRequest proto.InternalMessageInfo + +func (m *QueryZeroGasRequest) GetContractAddress() string { + if m != nil { + return m.ContractAddress + } + return "" +} + +// QueryZeroGasResponse defines ZeroGas response +type QueryZeroGasResponse struct { + // items is the zero gas items + Signatures []string `protobuf:"bytes,1,rep,name=signatures,proto3" json:"signatures,omitempty"` +} + +func (m *QueryZeroGasResponse) Reset() { *m = QueryZeroGasResponse{} } +func (m *QueryZeroGasResponse) String() string { return proto.CompactTextString(m) } +func (*QueryZeroGasResponse) ProtoMessage() {} +func (*QueryZeroGasResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{27} +} +func (m *QueryZeroGasResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryZeroGasResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryZeroGasResponse.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 *QueryZeroGasResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryZeroGasResponse.Merge(m, src) +} +func (m *QueryZeroGasResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryZeroGasResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryZeroGasResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryZeroGasResponse proto.InternalMessageInfo + +func (m *QueryZeroGasResponse) GetSignatures() []string { + if m != nil { + return m.Signatures + } + return nil +} + +// QueryAllZeroGasRequest defines AllZeroGas request +type QueryAllZeroGasRequest struct { +} + +func (m *QueryAllZeroGasRequest) Reset() { *m = QueryAllZeroGasRequest{} } +func (m *QueryAllZeroGasRequest) String() string { return proto.CompactTextString(m) } +func (*QueryAllZeroGasRequest) ProtoMessage() {} +func (*QueryAllZeroGasRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{28} +} +func (m *QueryAllZeroGasRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllZeroGasRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllZeroGasRequest.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 *QueryAllZeroGasRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllZeroGasRequest.Merge(m, src) +} +func (m *QueryAllZeroGasRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryAllZeroGasRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllZeroGasRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllZeroGasRequest proto.InternalMessageInfo + +// QueryAllZeroGasResponse defines AllZeroGas response +type QueryAllZeroGasResponse struct { + // items is the zero gas items + Items []ZeroGas `protobuf:"bytes,1,rep,name=items,proto3" json:"items"` +} + +func (m *QueryAllZeroGasResponse) Reset() { *m = QueryAllZeroGasResponse{} } +func (m *QueryAllZeroGasResponse) String() string { return proto.CompactTextString(m) } +func (*QueryAllZeroGasResponse) ProtoMessage() {} +func (*QueryAllZeroGasResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{29} +} +func (m *QueryAllZeroGasResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllZeroGasResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllZeroGasResponse.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 *QueryAllZeroGasResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllZeroGasResponse.Merge(m, src) +} +func (m *QueryAllZeroGasResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryAllZeroGasResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllZeroGasResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllZeroGasResponse proto.InternalMessageInfo + +func (m *QueryAllZeroGasResponse) GetItems() []ZeroGas { + if m != nil { + return m.Items + } + return nil +} + func init() { proto.RegisterType((*QueryAccountRequest)(nil), "ethermint.evm.v1.QueryAccountRequest") proto.RegisterType((*QueryAccountResponse)(nil), "ethermint.evm.v1.QueryAccountResponse") @@ -1495,110 +1670,123 @@ func init() { proto.RegisterType((*QueryTraceBlockResponse)(nil), "ethermint.evm.v1.QueryTraceBlockResponse") proto.RegisterType((*QueryBaseFeeRequest)(nil), "ethermint.evm.v1.QueryBaseFeeRequest") proto.RegisterType((*QueryBaseFeeResponse)(nil), "ethermint.evm.v1.QueryBaseFeeResponse") + proto.RegisterType((*QueryZeroGasRequest)(nil), "ethermint.evm.v1.QueryZeroGasRequest") + proto.RegisterType((*QueryZeroGasResponse)(nil), "ethermint.evm.v1.QueryZeroGasResponse") + proto.RegisterType((*QueryAllZeroGasRequest)(nil), "ethermint.evm.v1.QueryAllZeroGasRequest") + proto.RegisterType((*QueryAllZeroGasResponse)(nil), "ethermint.evm.v1.QueryAllZeroGasResponse") } func init() { proto.RegisterFile("ethermint/evm/v1/query.proto", fileDescriptor_e15a877459347994) } var fileDescriptor_e15a877459347994 = []byte{ - // 1566 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0x4d, 0x6f, 0x13, 0xc7, - 0x1b, 0xcf, 0xc6, 0x4e, 0xec, 0x8c, 0x13, 0xc8, 0x7f, 0x48, 0xfe, 0x38, 0xdb, 0xc4, 0x0e, 0x1b, - 0xf2, 0x06, 0x61, 0xb7, 0x71, 0x11, 0x52, 0xb9, 0x14, 0x62, 0x05, 0x4a, 0x81, 0x8a, 0x6e, 0xa3, - 0x1e, 0x2a, 0x55, 0xd6, 0x78, 0x3d, 0xac, 0xad, 0x78, 0x77, 0xcc, 0xce, 0xd8, 0x75, 0x78, 0xe9, - 0xa1, 0x6a, 0x29, 0x15, 0x52, 0x85, 0xd4, 0x7b, 0xc5, 0x37, 0xe8, 0xd7, 0xe0, 0x88, 0x54, 0x55, - 0xaa, 0x7a, 0xa0, 0x08, 0x7a, 0xe8, 0x27, 0xe8, 0xa1, 0xa7, 0x6a, 0x66, 0x67, 0xed, 0xb5, 0xd7, - 0x6b, 0x87, 0x8a, 0x4a, 0x48, 0x3d, 0x79, 0x5e, 0x9e, 0x79, 0x9e, 0xdf, 0xcc, 0xf3, 0xf6, 0x5b, - 0x83, 0x45, 0xcc, 0xaa, 0xd8, 0x73, 0x6a, 0x2e, 0x33, 0x70, 0xcb, 0x31, 0x5a, 0xdb, 0xc6, 0xad, - 0x26, 0xf6, 0x0e, 0xf4, 0x86, 0x47, 0x18, 0x81, 0xb3, 0x9d, 0x5d, 0x1d, 0xb7, 0x1c, 0xbd, 0xb5, - 0xad, 0x9e, 0xb2, 0x08, 0x75, 0x08, 0x35, 0xca, 0x88, 0x62, 0x5f, 0xd4, 0x68, 0x6d, 0x97, 0x31, - 0x43, 0xdb, 0x46, 0x03, 0xd9, 0x35, 0x17, 0xb1, 0x1a, 0x71, 0xfd, 0xd3, 0xea, 0x42, 0x44, 0x37, - 0x6b, 0xcb, 0x2d, 0x35, 0xb2, 0x55, 0x27, 0xb6, 0xdc, 0x5b, 0x8a, 0xec, 0x35, 0x90, 0x87, 0x1c, - 0x2a, 0xb7, 0x57, 0xa2, 0x5a, 0x3d, 0x64, 0xe1, 0x92, 0x45, 0xdc, 0x9b, 0xb5, 0x40, 0xc7, 0x9c, - 0x4d, 0x6c, 0x22, 0x86, 0x06, 0x1f, 0xc9, 0xd5, 0x45, 0x9b, 0x10, 0xbb, 0x8e, 0x0d, 0xd4, 0xa8, - 0x19, 0xc8, 0x75, 0x09, 0x13, 0x68, 0x03, 0xc5, 0x79, 0xb9, 0x2b, 0x66, 0xe5, 0xe6, 0x4d, 0x83, - 0xd5, 0x1c, 0x4c, 0x19, 0x72, 0x1a, 0xbe, 0x80, 0xf6, 0x2e, 0x38, 0xf6, 0x11, 0xbf, 0xf1, 0x45, - 0xcb, 0x22, 0x4d, 0x97, 0x99, 0xf8, 0x56, 0x13, 0x53, 0x06, 0xb3, 0x20, 0x85, 0x2a, 0x15, 0x0f, - 0x53, 0x9a, 0x55, 0x96, 0x95, 0x8d, 0x29, 0x33, 0x98, 0x9e, 0x4f, 0x3f, 0x78, 0x9c, 0x1f, 0xfb, - 0xe3, 0x71, 0x7e, 0x4c, 0xb3, 0xc0, 0x5c, 0xef, 0x51, 0xda, 0x20, 0x2e, 0xc5, 0xfc, 0x6c, 0x19, - 0xd5, 0x91, 0x6b, 0xe1, 0xe0, 0xac, 0x9c, 0xc2, 0xb7, 0xc0, 0x94, 0x45, 0x2a, 0xb8, 0x54, 0x45, - 0xb4, 0x9a, 0x1d, 0x17, 0x7b, 0x69, 0xbe, 0xf0, 0x3e, 0xa2, 0x55, 0x38, 0x07, 0x26, 0x5c, 0xc2, - 0x0f, 0x25, 0x96, 0x95, 0x8d, 0xa4, 0xe9, 0x4f, 0xb4, 0xf7, 0xc0, 0x82, 0x30, 0x52, 0x14, 0x2e, - 0xfa, 0x07, 0x28, 0xef, 0x2b, 0x40, 0x1d, 0xa4, 0x41, 0x82, 0x5d, 0x05, 0x47, 0x7c, 0xef, 0x97, - 0x7a, 0x35, 0xcd, 0xf8, 0xab, 0x17, 0xfd, 0x45, 0xa8, 0x82, 0x34, 0xe5, 0x46, 0x39, 0xbe, 0x71, - 0x81, 0xaf, 0x33, 0xe7, 0x2a, 0x90, 0xaf, 0xb5, 0xe4, 0x36, 0x9d, 0x32, 0xf6, 0xe4, 0x0d, 0x66, - 0xe4, 0xea, 0x87, 0x62, 0x51, 0xbb, 0x0a, 0x16, 0x05, 0x8e, 0x4f, 0x50, 0xbd, 0x56, 0x41, 0x8c, - 0x78, 0x7d, 0x97, 0x39, 0x01, 0xa6, 0x2d, 0xe2, 0xf6, 0xe3, 0xc8, 0xf0, 0xb5, 0x8b, 0x91, 0x5b, - 0x3d, 0x54, 0xc0, 0x52, 0x8c, 0x36, 0x79, 0xb1, 0x75, 0x70, 0x34, 0x40, 0xd5, 0xab, 0x31, 0x00, - 0xfb, 0x1a, 0xaf, 0x16, 0x04, 0xd1, 0x8e, 0xef, 0xe7, 0x57, 0x71, 0xcf, 0xdb, 0x32, 0x88, 0x3a, - 0x47, 0x47, 0x05, 0x91, 0x76, 0x55, 0x1a, 0xfb, 0x98, 0x11, 0x0f, 0xd9, 0xa3, 0x8d, 0xc1, 0x59, - 0x90, 0xd8, 0xc7, 0x07, 0x32, 0xde, 0xf8, 0x30, 0x64, 0x7e, 0x4b, 0x9a, 0xef, 0x28, 0x93, 0xe6, - 0xe7, 0xc0, 0x44, 0x0b, 0xd5, 0x9b, 0x81, 0x71, 0x7f, 0xa2, 0x9d, 0x03, 0xb3, 0x32, 0x94, 0x2a, - 0xaf, 0x74, 0xc9, 0x75, 0xf0, 0xbf, 0xd0, 0x39, 0x69, 0x02, 0x82, 0x24, 0x8f, 0x7d, 0x71, 0x6a, - 0xda, 0x14, 0x63, 0xed, 0x36, 0x80, 0x42, 0x70, 0xaf, 0x7d, 0x8d, 0xd8, 0x34, 0x30, 0x01, 0x41, - 0x52, 0x64, 0x8c, 0xaf, 0x5f, 0x8c, 0xe1, 0x25, 0x00, 0xba, 0xb5, 0x49, 0xdc, 0x2d, 0x53, 0x58, - 0xd3, 0xfd, 0xa0, 0xd5, 0x79, 0x21, 0xd3, 0xfd, 0x9a, 0x27, 0x0b, 0x99, 0x7e, 0xa3, 0xfb, 0x54, - 0x66, 0xe8, 0x64, 0x08, 0xe4, 0xb7, 0x8a, 0x7c, 0xd8, 0xc0, 0xb8, 0xc4, 0xb9, 0x09, 0x92, 0x75, - 0x62, 0xf3, 0xdb, 0x25, 0x36, 0x32, 0x85, 0x79, 0xbd, 0xbf, 0x7c, 0xea, 0xd7, 0x88, 0x6d, 0x0a, - 0x11, 0x78, 0x79, 0x00, 0xa8, 0xf5, 0x91, 0xa0, 0x7c, 0x3b, 0x61, 0x54, 0xda, 0x9c, 0x7c, 0x87, - 0x1b, 0xa2, 0x48, 0x4a, 0xdc, 0xda, 0x75, 0x09, 0x30, 0x58, 0x95, 0x00, 0xcf, 0x81, 0x49, 0xbf, - 0x98, 0x8a, 0x07, 0xca, 0x14, 0xb2, 0x51, 0x88, 0xfe, 0x89, 0x9d, 0xe4, 0x93, 0x67, 0xf9, 0x31, - 0x53, 0x4a, 0x6b, 0x3f, 0x2b, 0xe0, 0xc8, 0x2e, 0xab, 0x16, 0x51, 0xbd, 0x1e, 0x7a, 0x69, 0xe4, - 0xd9, 0x34, 0xf0, 0x09, 0x1f, 0xc3, 0xe3, 0x20, 0x65, 0x23, 0x5a, 0xb2, 0x50, 0x43, 0xa6, 0xc7, - 0xa4, 0x8d, 0x68, 0x11, 0x35, 0xe0, 0x67, 0x60, 0xb6, 0xe1, 0x91, 0x06, 0xa1, 0xd8, 0xeb, 0xa4, - 0x18, 0x4f, 0x8f, 0xe9, 0x9d, 0xc2, 0x5f, 0xcf, 0xf2, 0xba, 0x5d, 0x63, 0xd5, 0x66, 0x59, 0xb7, - 0x88, 0x63, 0xc8, 0xfe, 0xe2, 0xff, 0x9c, 0xa1, 0x95, 0x7d, 0x83, 0x1d, 0x34, 0x30, 0xd5, 0x8b, - 0xdd, 0xdc, 0x36, 0x8f, 0x06, 0xba, 0x82, 0xbc, 0x5c, 0x00, 0x69, 0xab, 0x8a, 0x6a, 0x6e, 0xa9, - 0x56, 0xc9, 0x26, 0x97, 0x95, 0x8d, 0x84, 0x99, 0x12, 0xf3, 0x2b, 0x15, 0xb8, 0x08, 0xa6, 0x48, - 0x0b, 0x7b, 0x5e, 0xad, 0x82, 0x69, 0x76, 0x42, 0x60, 0xed, 0x2e, 0x68, 0x7b, 0xe0, 0xd8, 0x2e, - 0x65, 0x35, 0x07, 0x31, 0x7c, 0x19, 0x75, 0x9f, 0x69, 0x16, 0x24, 0x6c, 0xe4, 0x5f, 0x2d, 0x69, - 0xf2, 0x21, 0x5f, 0xf1, 0x30, 0x13, 0xb7, 0x9a, 0x36, 0xf9, 0x90, 0xdb, 0x6c, 0x39, 0x25, 0xec, - 0x79, 0xc4, 0xcf, 0xf4, 0x29, 0x33, 0xd5, 0x72, 0x76, 0xf9, 0x54, 0x7b, 0x9e, 0x08, 0xc2, 0x83, - 0x77, 0xa6, 0xbd, 0x76, 0xf0, 0x64, 0xdb, 0x20, 0xe1, 0x50, 0x5b, 0x3e, 0x7d, 0x3e, 0xfa, 0xf4, - 0xd7, 0xa9, 0xbd, 0xcb, 0xd7, 0x70, 0xd3, 0xd9, 0x6b, 0x9b, 0x5c, 0x16, 0x5e, 0x00, 0xd3, 0xe1, - 0xf6, 0x26, 0x2c, 0x65, 0x0a, 0x4b, 0xd1, 0xb3, 0xc2, 0x54, 0x51, 0x08, 0x99, 0x19, 0xd6, 0x9d, - 0xc0, 0x22, 0x98, 0x6e, 0x78, 0xb8, 0x82, 0x2d, 0x4c, 0x29, 0xf1, 0x68, 0x36, 0x29, 0x62, 0x73, - 0xa4, 0xf5, 0x9e, 0x43, 0xbc, 0xe0, 0x96, 0xeb, 0xc4, 0xda, 0x0f, 0x4a, 0xdb, 0x84, 0x78, 0xe4, - 0x8c, 0x58, 0xf3, 0x0b, 0x1b, 0x5c, 0x02, 0xc0, 0x17, 0x11, 0xf9, 0x37, 0x29, 0x5e, 0x64, 0x4a, - 0xac, 0x88, 0x96, 0x55, 0x0c, 0xb6, 0x79, 0x57, 0xcd, 0xa6, 0xc4, 0x35, 0x54, 0xdd, 0x6f, 0xb9, - 0x7a, 0xd0, 0x72, 0xf5, 0xbd, 0xa0, 0xe5, 0xee, 0xa4, 0x79, 0xfc, 0x3d, 0xfa, 0x2d, 0xaf, 0x48, - 0x25, 0x7c, 0x67, 0x60, 0x18, 0xa5, 0xff, 0x9d, 0x30, 0x9a, 0xea, 0x09, 0xa3, 0x0f, 0x92, 0xe9, - 0xf1, 0xd9, 0x84, 0x99, 0x66, 0xed, 0x52, 0xcd, 0xad, 0xe0, 0xb6, 0x76, 0x4a, 0x16, 0xc3, 0x8e, - 0x87, 0xbb, 0x95, 0xaa, 0x82, 0x18, 0x0a, 0xb2, 0x82, 0x8f, 0xb5, 0x6f, 0x12, 0x60, 0xbe, 0x2b, - 0xfc, 0xa6, 0xe6, 0x50, 0x7f, 0xa4, 0x25, 0x5f, 0x39, 0xd2, 0xde, 0x90, 0x20, 0x09, 0x7b, 0x31, - 0xdd, 0xe3, 0x45, 0x6d, 0x0b, 0xfc, 0xbf, 0xdf, 0x11, 0x43, 0xfc, 0xf6, 0x5d, 0x22, 0x2c, 0xbe, - 0xc3, 0x0d, 0x84, 0x32, 0x99, 0xb5, 0x83, 0x3a, 0x3f, 0x3a, 0x93, 0x59, 0x9b, 0xbe, 0x86, 0x4c, - 0xfe, 0xaf, 0x27, 0xa1, 0x76, 0x06, 0x1c, 0x8f, 0xf8, 0x63, 0x88, 0xff, 0xe6, 0x3b, 0x54, 0x8b, - 0xe2, 0x4b, 0x38, 0x68, 0xe9, 0xda, 0xb5, 0x0e, 0x8d, 0x92, 0xcb, 0x52, 0xc5, 0x59, 0x90, 0xe6, - 0x7d, 0xb7, 0x74, 0x13, 0x4b, 0x2a, 0xb3, 0xb3, 0xf0, 0xeb, 0xb3, 0xfc, 0xbc, 0x8f, 0x9e, 0x56, - 0xf6, 0xf5, 0x1a, 0x31, 0x1c, 0xc4, 0xaa, 0xfa, 0x15, 0x97, 0x71, 0x8a, 0x25, 0x4e, 0x17, 0xfe, - 0x9c, 0x01, 0x13, 0x42, 0x1d, 0xfc, 0x5a, 0x01, 0x29, 0xc9, 0x2c, 0xe1, 0x6a, 0xd4, 0xad, 0x03, - 0x3e, 0x1d, 0xd4, 0xb5, 0x51, 0x62, 0x3e, 0x34, 0xed, 0xf4, 0x97, 0x3f, 0xfd, 0xfe, 0xfd, 0xf8, - 0x2a, 0x5c, 0x31, 0x22, 0x1f, 0x3f, 0x92, 0x5d, 0x1a, 0x77, 0xa4, 0x2b, 0xee, 0xc1, 0x1f, 0x14, - 0x30, 0xd3, 0x43, 0xe0, 0xe1, 0xe9, 0x18, 0x33, 0x83, 0x3e, 0x14, 0xd4, 0xad, 0xc3, 0x09, 0x4b, - 0x64, 0x05, 0x81, 0x6c, 0x0b, 0x9e, 0x8a, 0x22, 0x0b, 0xbe, 0x15, 0x22, 0x00, 0x7f, 0x54, 0xc0, - 0x6c, 0x3f, 0x17, 0x87, 0x7a, 0x8c, 0xd9, 0x98, 0x4f, 0x00, 0xd5, 0x38, 0xb4, 0xbc, 0x44, 0x7a, - 0x5e, 0x20, 0x3d, 0x0b, 0x0b, 0x51, 0xa4, 0xad, 0xe0, 0x4c, 0x17, 0x6c, 0xf8, 0xf3, 0xe2, 0x1e, - 0xbc, 0xaf, 0x80, 0x94, 0x64, 0xdd, 0xb1, 0xae, 0xed, 0x25, 0xf4, 0xb1, 0xae, 0xed, 0x23, 0xef, - 0xda, 0x96, 0x80, 0xb5, 0x06, 0x4f, 0x46, 0x61, 0x49, 0x16, 0x4f, 0x43, 0x4f, 0xf7, 0x50, 0x01, - 0x29, 0xc9, 0xbf, 0x63, 0x81, 0xf4, 0x92, 0xfd, 0x58, 0x20, 0x7d, 0x34, 0x5e, 0xdb, 0x16, 0x40, - 0x4e, 0xc3, 0xcd, 0x28, 0x10, 0xea, 0x8b, 0x76, 0x71, 0x18, 0x77, 0xf6, 0xf1, 0xc1, 0x3d, 0x78, - 0x1b, 0x24, 0x39, 0x4d, 0x87, 0x5a, 0x6c, 0xc8, 0x74, 0xb8, 0xbf, 0xba, 0x32, 0x54, 0x46, 0x62, - 0xd8, 0x14, 0x18, 0x56, 0xe0, 0x89, 0x41, 0xd1, 0x54, 0xe9, 0x79, 0x89, 0xcf, 0xc1, 0xa4, 0xcf, - 0x54, 0xe1, 0xc9, 0x18, 0xcd, 0x3d, 0x84, 0x58, 0x5d, 0x1d, 0x21, 0x25, 0x11, 0x2c, 0x0b, 0x04, - 0x2a, 0xcc, 0x1a, 0x31, 0xff, 0x42, 0xc0, 0x36, 0x48, 0x49, 0x26, 0x0c, 0x97, 0xa3, 0x3a, 0x7b, - 0x49, 0xb2, 0xba, 0x3e, 0xaa, 0x35, 0x04, 0x76, 0x35, 0x61, 0x77, 0x11, 0xaa, 0x51, 0xbb, 0x98, - 0x55, 0x4b, 0x16, 0x37, 0xf7, 0x05, 0xc8, 0x84, 0xc8, 0xea, 0x21, 0xac, 0x0f, 0xb8, 0xf3, 0x00, - 0xb6, 0xab, 0xad, 0x09, 0xdb, 0xcb, 0x30, 0x37, 0xc0, 0xb6, 0x14, 0x2f, 0x71, 0x0e, 0x7c, 0x17, - 0xa4, 0x24, 0xdd, 0x89, 0x8d, 0xbd, 0x5e, 0xc2, 0x1b, 0x1b, 0x7b, 0x7d, 0xac, 0x69, 0xd8, 0xed, - 0xfd, 0x9e, 0xc9, 0xda, 0xf0, 0x81, 0x02, 0x40, 0xb7, 0xf0, 0xc3, 0x8d, 0x61, 0xaa, 0xc3, 0xbd, - 0x5a, 0xdd, 0x3c, 0x84, 0xa4, 0xc4, 0xb1, 0x2a, 0x70, 0xe4, 0xe1, 0x52, 0x1c, 0x0e, 0xd1, 0x05, - 0xe1, 0x57, 0x0a, 0x98, 0xea, 0x50, 0x08, 0xb8, 0x3e, 0x4c, 0x7f, 0xd8, 0x1d, 0x1b, 0xa3, 0x05, - 0x25, 0x8e, 0x93, 0x02, 0x47, 0x0e, 0x2e, 0xc6, 0xe1, 0x10, 0xf1, 0x70, 0x97, 0x17, 0x25, 0xd1, - 0x85, 0x86, 0x14, 0xa5, 0x70, 0xeb, 0x1b, 0x52, 0x94, 0x7a, 0x5a, 0xe1, 0x30, 0x7f, 0x04, 0x2d, - 0x72, 0xe7, 0xc2, 0x93, 0x17, 0x39, 0xe5, 0xe9, 0x8b, 0x9c, 0xf2, 0xfc, 0x45, 0x4e, 0x79, 0xf4, - 0x32, 0x37, 0xf6, 0xf4, 0x65, 0x6e, 0xec, 0x97, 0x97, 0xb9, 0xb1, 0x4f, 0xd7, 0x42, 0x14, 0x00, - 0xb7, 0x38, 0x03, 0xe8, 0x6a, 0x69, 0x0b, 0x3d, 0x82, 0x06, 0x94, 0x27, 0x05, 0xe3, 0x78, 0xe7, - 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2b, 0x0f, 0xce, 0x6b, 0x84, 0x14, 0x00, 0x00, + // 1703 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0x5f, 0x6f, 0x13, 0xcb, + 0x15, 0xcf, 0xc6, 0x4e, 0x6c, 0x8f, 0x03, 0xb8, 0x43, 0x52, 0x1c, 0x37, 0xb1, 0xc3, 0x86, 0xfc, + 0x83, 0xb0, 0xdb, 0xb8, 0x14, 0xa9, 0xbc, 0x94, 0x24, 0x0a, 0x94, 0x02, 0x15, 0xdd, 0x46, 0x7d, + 0x40, 0xaa, 0xac, 0xf1, 0x7a, 0x58, 0xaf, 0xe2, 0xdd, 0x31, 0x3b, 0x6b, 0xd7, 0xe1, 0x4f, 0x55, + 0x55, 0x2d, 0x05, 0x21, 0x55, 0x48, 0x7d, 0xaf, 0xf8, 0x06, 0xfd, 0x1a, 0x3c, 0x22, 0x55, 0x95, + 0xaa, 0x3e, 0x50, 0x04, 0x7d, 0xb8, 0x9f, 0xe1, 0x3e, 0x5d, 0xcd, 0xec, 0x8c, 0xbd, 0xeb, 0xf5, + 0xda, 0xe1, 0x8a, 0x2b, 0x21, 0xdd, 0x27, 0xef, 0xcc, 0x9c, 0x73, 0x7e, 0xbf, 0x99, 0x39, 0x73, + 0xfe, 0x18, 0x2c, 0x61, 0xbf, 0x89, 0x3d, 0xc7, 0x76, 0x7d, 0x1d, 0x77, 0x1d, 0xbd, 0xbb, 0xa3, + 0x3f, 0xec, 0x60, 0xef, 0x58, 0x6b, 0x7b, 0xc4, 0x27, 0xb0, 0xd0, 0x5f, 0xd5, 0x70, 0xd7, 0xd1, + 0xba, 0x3b, 0xa5, 0x8b, 0x26, 0xa1, 0x0e, 0xa1, 0x7a, 0x1d, 0x51, 0x1c, 0x88, 0xea, 0xdd, 0x9d, + 0x3a, 0xf6, 0xd1, 0x8e, 0xde, 0x46, 0x96, 0xed, 0x22, 0xdf, 0x26, 0x6e, 0xa0, 0x5d, 0x5a, 0x8c, + 0xd9, 0xf6, 0x7b, 0x62, 0xa9, 0x14, 0x5b, 0x6a, 0x11, 0x4b, 0xac, 0x2d, 0xc7, 0xd6, 0xda, 0xc8, + 0x43, 0x0e, 0x15, 0xcb, 0xab, 0x71, 0xab, 0x1e, 0x32, 0x71, 0xcd, 0x24, 0xee, 0x03, 0x5b, 0xda, + 0xa8, 0xc4, 0x84, 0x1e, 0x61, 0x8f, 0xd4, 0x2c, 0x24, 0xad, 0xcc, 0x5b, 0xc4, 0x22, 0xfc, 0x53, + 0x67, 0x5f, 0x62, 0x76, 0xc9, 0x22, 0xc4, 0x6a, 0x61, 0x1d, 0xb5, 0x6d, 0x1d, 0xb9, 0x2e, 0xf1, + 0xf9, 0x76, 0xa4, 0x4e, 0x45, 0xac, 0xf2, 0x51, 0xbd, 0xf3, 0x40, 0xf7, 0x6d, 0x07, 0x53, 0x1f, + 0x39, 0xed, 0x40, 0x40, 0xfd, 0x19, 0x38, 0xfb, 0x6b, 0x76, 0x24, 0xbb, 0xa6, 0x49, 0x3a, 0xae, + 0x6f, 0xe0, 0x87, 0x1d, 0x4c, 0x7d, 0x58, 0x04, 0x19, 0xd4, 0x68, 0x78, 0x98, 0xd2, 0xa2, 0xb2, + 0xa2, 0x6c, 0xe6, 0x0c, 0x39, 0xbc, 0x96, 0x7d, 0xfe, 0xba, 0x32, 0xf5, 0xd5, 0xeb, 0xca, 0x94, + 0x6a, 0x82, 0xf9, 0xa8, 0x2a, 0x6d, 0x13, 0x97, 0x62, 0xa6, 0x5b, 0x47, 0x2d, 0xe4, 0x9a, 0x58, + 0xea, 0x8a, 0x21, 0xfc, 0x11, 0xc8, 0x99, 0xa4, 0x81, 0x6b, 0x4d, 0x44, 0x9b, 0xc5, 0x69, 0xbe, + 0x96, 0x65, 0x13, 0xbf, 0x40, 0xb4, 0x09, 0xe7, 0xc1, 0x8c, 0x4b, 0x98, 0x52, 0x6a, 0x45, 0xd9, + 0x4c, 0x1b, 0xc1, 0x40, 0xfd, 0x39, 0x58, 0xe4, 0x20, 0xfb, 0xfc, 0x0e, 0xbf, 0x05, 0xcb, 0x67, + 0x0a, 0x28, 0x8d, 0xb2, 0x20, 0xc8, 0xae, 0x81, 0xd3, 0x81, 0x7b, 0xd4, 0xa2, 0x96, 0x4e, 0x05, + 0xb3, 0xbb, 0xc1, 0x24, 0x2c, 0x81, 0x2c, 0x65, 0xa0, 0x8c, 0xdf, 0x34, 0xe7, 0xd7, 0x1f, 0x33, + 0x13, 0x28, 0xb0, 0x5a, 0x73, 0x3b, 0x4e, 0x1d, 0x7b, 0x62, 0x07, 0xa7, 0xc4, 0xec, 0xaf, 0xf8, + 0xa4, 0x7a, 0x1b, 0x2c, 0x71, 0x1e, 0xbf, 0x45, 0x2d, 0xbb, 0x81, 0x7c, 0xe2, 0x0d, 0x6d, 0xe6, + 0x3c, 0x98, 0x33, 0x89, 0x3b, 0xcc, 0x23, 0xcf, 0xe6, 0x76, 0x63, 0xbb, 0x7a, 0xa9, 0x80, 0xe5, + 0x04, 0x6b, 0x62, 0x63, 0x1b, 0xe0, 0x8c, 0x64, 0x15, 0xb5, 0x28, 0xc9, 0x7e, 0xc6, 0xad, 0x49, + 0x27, 0xda, 0x0b, 0xee, 0xf9, 0x53, 0xae, 0xe7, 0xc7, 0xc2, 0x89, 0xfa, 0xaa, 0x93, 0x9c, 0x48, + 0xbd, 0x2d, 0xc0, 0x7e, 0xe3, 0x13, 0x0f, 0x59, 0x93, 0xc1, 0x60, 0x01, 0xa4, 0x8e, 0xf0, 0xb1, + 0xf0, 0x37, 0xf6, 0x19, 0x82, 0xdf, 0x16, 0xf0, 0x7d, 0x63, 0x02, 0x7e, 0x1e, 0xcc, 0x74, 0x51, + 0xab, 0x23, 0xc1, 0x83, 0x81, 0x7a, 0x15, 0x14, 0x84, 0x2b, 0x35, 0x3e, 0x69, 0x93, 0x1b, 0xe0, + 0x07, 0x21, 0x3d, 0x01, 0x01, 0x41, 0x9a, 0xf9, 0x3e, 0xd7, 0x9a, 0x33, 0xf8, 0xb7, 0xfa, 0x08, + 0x40, 0x2e, 0x78, 0xd8, 0xbb, 0x43, 0x2c, 0x2a, 0x21, 0x20, 0x48, 0xf3, 0x17, 0x13, 0xd8, 0xe7, + 0xdf, 0xf0, 0x06, 0x00, 0x83, 0xe0, 0xc5, 0xf7, 0x96, 0xaf, 0xae, 0x6b, 0x81, 0xd3, 0x6a, 0x2c, + 0xd2, 0x69, 0x41, 0x50, 0x14, 0x91, 0x4e, 0xbb, 0x37, 0x38, 0x2a, 0x23, 0xa4, 0x19, 0x22, 0xf9, + 0x42, 0x11, 0x07, 0x2b, 0xc1, 0x05, 0xcf, 0x2d, 0x90, 0x6e, 0x11, 0x8b, 0xed, 0x2e, 0xb5, 0x99, + 0xaf, 0x2e, 0x68, 0xc3, 0xf1, 0x55, 0xbb, 0x43, 0x2c, 0x83, 0x8b, 0xc0, 0x9b, 0x23, 0x48, 0x6d, + 0x4c, 0x24, 0x15, 0xe0, 0x84, 0x59, 0xa9, 0xf3, 0xe2, 0x1c, 0xee, 0xf1, 0x28, 0x2a, 0x78, 0xab, + 0x77, 0x05, 0x41, 0x39, 0x2b, 0x08, 0x5e, 0x05, 0xb3, 0x41, 0xb4, 0xe5, 0x07, 0x94, 0xaf, 0x16, + 0xe3, 0x14, 0x03, 0x8d, 0xbd, 0xf4, 0x9b, 0x77, 0x95, 0x29, 0x43, 0x48, 0xab, 0xff, 0x56, 0xc0, + 0xe9, 0x03, 0xbf, 0xb9, 0x8f, 0x5a, 0xad, 0xd0, 0x49, 0x23, 0xcf, 0xa2, 0xf2, 0x4e, 0xd8, 0x37, + 0x3c, 0x07, 0x32, 0x16, 0xa2, 0x35, 0x13, 0xb5, 0xc5, 0xf3, 0x98, 0xb5, 0x10, 0xdd, 0x47, 0x6d, + 0xf8, 0x3b, 0x50, 0x68, 0x7b, 0xa4, 0x4d, 0x28, 0xf6, 0xfa, 0x4f, 0x8c, 0x3d, 0x8f, 0xb9, 0xbd, + 0xea, 0xd7, 0xef, 0x2a, 0x9a, 0x65, 0xfb, 0xcd, 0x4e, 0x5d, 0x33, 0x89, 0xa3, 0x8b, 0x04, 0x14, + 0xfc, 0x5c, 0xa6, 0x8d, 0x23, 0xdd, 0x3f, 0x6e, 0x63, 0xaa, 0xed, 0x0f, 0xde, 0xb6, 0x71, 0x46, + 0xda, 0x92, 0xef, 0x72, 0x11, 0x64, 0xcd, 0x26, 0xb2, 0xdd, 0x9a, 0xdd, 0x28, 0xa6, 0x57, 0x94, + 0xcd, 0x94, 0x91, 0xe1, 0xe3, 0x5b, 0x0d, 0xb8, 0x04, 0x72, 0xa4, 0x8b, 0x3d, 0xcf, 0x6e, 0x60, + 0x5a, 0x9c, 0xe1, 0x5c, 0x07, 0x13, 0xea, 0x21, 0x38, 0x7b, 0x40, 0x7d, 0xdb, 0x41, 0x3e, 0xbe, + 0x89, 0x06, 0xc7, 0x54, 0x00, 0x29, 0x0b, 0x05, 0x5b, 0x4b, 0x1b, 0xec, 0x93, 0xcd, 0x78, 0xd8, + 0xe7, 0xbb, 0x9a, 0x33, 0xd8, 0x27, 0xc3, 0xec, 0x3a, 0x35, 0xec, 0x79, 0x24, 0x78, 0xe9, 0x39, + 0x23, 0xd3, 0x75, 0x0e, 0xd8, 0x50, 0x7d, 0x9f, 0x92, 0xee, 0xc1, 0x52, 0xd7, 0x61, 0x4f, 0x1e, + 0xd9, 0x0e, 0x48, 0x39, 0xd4, 0x12, 0x47, 0x5f, 0x89, 0x1f, 0xfd, 0x5d, 0x6a, 0x1d, 0xb0, 0x39, + 0xdc, 0x71, 0x0e, 0x7b, 0x06, 0x93, 0x85, 0xd7, 0xc1, 0x5c, 0x38, 0xff, 0x71, 0xa4, 0x7c, 0x75, + 0x39, 0xae, 0xcb, 0xa1, 0xf6, 0xb9, 0x90, 0x91, 0xf7, 0x07, 0x03, 0xb8, 0x0f, 0xe6, 0xda, 0x1e, + 0x6e, 0x60, 0x13, 0x53, 0x4a, 0x3c, 0x5a, 0x4c, 0x73, 0xdf, 0x9c, 0x88, 0x1e, 0x51, 0x62, 0x01, + 0xb7, 0xde, 0x22, 0xe6, 0x91, 0x0c, 0x6d, 0x33, 0xfc, 0x90, 0xf3, 0x7c, 0x2e, 0x08, 0x6c, 0x70, + 0x19, 0x80, 0x40, 0x84, 0xbf, 0xbf, 0x59, 0x7e, 0x22, 0x39, 0x3e, 0xc3, 0x53, 0xd6, 0xbe, 0x5c, + 0x66, 0x59, 0xb5, 0x98, 0xe1, 0xdb, 0x28, 0x69, 0x41, 0xca, 0xd5, 0x64, 0xca, 0xd5, 0x0e, 0x65, + 0xca, 0xdd, 0xcb, 0x32, 0xff, 0x7b, 0xf5, 0xbf, 0x8a, 0x22, 0x8c, 0xb0, 0x95, 0x91, 0x6e, 0x94, + 0xfd, 0x6e, 0xdc, 0x28, 0x17, 0x71, 0xa3, 0x5f, 0xa6, 0xb3, 0xd3, 0x85, 0x94, 0x91, 0xf5, 0x7b, + 0x35, 0xdb, 0x6d, 0xe0, 0x9e, 0x7a, 0x51, 0x04, 0xc3, 0xfe, 0x0d, 0x0f, 0x22, 0x55, 0x03, 0xf9, + 0x48, 0xbe, 0x0a, 0xf6, 0xad, 0xfe, 0x35, 0x05, 0x16, 0x06, 0xc2, 0x5f, 0xea, 0x1b, 0x1a, 0xf6, + 0xb4, 0xf4, 0x27, 0x7b, 0xda, 0x17, 0xe2, 0x24, 0xe1, 0x5b, 0xcc, 0x46, 0x6e, 0x51, 0xdd, 0x06, + 0x3f, 0x1c, 0xbe, 0x88, 0x31, 0xf7, 0xf6, 0xb7, 0x54, 0x58, 0x7c, 0x8f, 0x01, 0x84, 0x5e, 0xb2, + 0xdf, 0x93, 0x71, 0x7e, 0xf2, 0x4b, 0xf6, 0x7b, 0xf4, 0x33, 0xbc, 0xe4, 0xef, 0xfb, 0x23, 0x54, + 0x2f, 0x83, 0x73, 0xb1, 0xfb, 0x18, 0x73, 0x7f, 0x0b, 0xfd, 0x52, 0x8b, 0xe2, 0x1b, 0x58, 0xa6, + 0x74, 0xf5, 0x4e, 0xbf, 0x8c, 0x12, 0xd3, 0xc2, 0xc4, 0x15, 0x90, 0x65, 0x79, 0xb7, 0xf6, 0x00, + 0x8b, 0x52, 0x66, 0x6f, 0xf1, 0xbf, 0xef, 0x2a, 0x0b, 0x01, 0x7b, 0xda, 0x38, 0xd2, 0x6c, 0xa2, + 0x3b, 0xc8, 0x6f, 0x6a, 0xb7, 0x5c, 0x9f, 0x95, 0x58, 0x5c, 0x5b, 0xbd, 0x2e, 0x40, 0xee, 0x63, + 0x8f, 0xf0, 0x14, 0x12, 0x38, 0xc8, 0x16, 0x28, 0x98, 0xc4, 0x65, 0xb7, 0x37, 0x5c, 0x53, 0x9e, + 0x91, 0xf3, 0x62, 0xc3, 0xea, 0x55, 0xc1, 0xa7, 0x6f, 0x41, 0xf0, 0x29, 0x03, 0x40, 0x6d, 0xcb, + 0x45, 0x7e, 0xc7, 0xc3, 0x81, 0xab, 0xe5, 0x8c, 0xd0, 0x8c, 0x5a, 0x14, 0xde, 0xb9, 0xdb, 0x6a, + 0x45, 0xc1, 0xd5, 0x7b, 0xe2, 0x9c, 0xc2, 0x2b, 0xc2, 0xe8, 0x4f, 0xc1, 0x8c, 0xed, 0x63, 0x47, + 0xba, 0xee, 0x62, 0xdc, 0xfd, 0x84, 0x86, 0x28, 0x00, 0x02, 0xe9, 0xea, 0x1f, 0x0b, 0x60, 0x86, + 0x9b, 0x84, 0x7f, 0x51, 0x40, 0x46, 0xd4, 0xcf, 0x70, 0x2d, 0xae, 0x3d, 0xa2, 0x41, 0x2a, 0xad, + 0x4f, 0x12, 0x0b, 0xb8, 0xa9, 0x97, 0xfe, 0xf4, 0xaf, 0xff, 0xff, 0x7d, 0x7a, 0x0d, 0xae, 0xea, + 0xb1, 0xf6, 0x4e, 0xd4, 0xd0, 0xfa, 0x63, 0x71, 0x96, 0x4f, 0xe1, 0x3f, 0x14, 0x70, 0x2a, 0xd2, + 0xa6, 0xc0, 0x4b, 0x09, 0x30, 0xa3, 0xda, 0xa1, 0xd2, 0xf6, 0xc9, 0x84, 0x05, 0xb3, 0x2a, 0x67, + 0xb6, 0x0d, 0x2f, 0xc6, 0x99, 0xc9, 0x8e, 0x28, 0x46, 0xf0, 0x9f, 0x0a, 0x28, 0x0c, 0x77, 0x1c, + 0x50, 0x4b, 0x80, 0x4d, 0x68, 0x74, 0x4a, 0xfa, 0x89, 0xe5, 0x05, 0xd3, 0x6b, 0x9c, 0xe9, 0x15, + 0x58, 0x8d, 0x33, 0xed, 0x4a, 0x9d, 0x01, 0xd9, 0x70, 0x13, 0xf5, 0x14, 0x3e, 0x53, 0x40, 0x46, + 0xf4, 0x16, 0x89, 0x57, 0x1b, 0x6d, 0x5b, 0x12, 0xaf, 0x76, 0xa8, 0x45, 0x51, 0xb7, 0x39, 0xad, + 0x75, 0x78, 0x21, 0x4e, 0x4b, 0xf4, 0x2a, 0x34, 0x74, 0x74, 0x2f, 0x15, 0x90, 0x11, 0x5d, 0x46, + 0x22, 0x91, 0x68, 0x4b, 0x93, 0x48, 0x64, 0xa8, 0x59, 0x51, 0x77, 0x38, 0x91, 0x4b, 0x70, 0x2b, + 0x4e, 0x84, 0x06, 0xa2, 0x03, 0x1e, 0xfa, 0xe3, 0x23, 0x7c, 0xfc, 0x14, 0x3e, 0x02, 0x69, 0xd6, + 0x8c, 0x40, 0x35, 0xd1, 0x65, 0xfa, 0x1d, 0x4e, 0x69, 0x75, 0xac, 0x8c, 0xe0, 0xb0, 0xc5, 0x39, + 0xac, 0xc2, 0xf3, 0xa3, 0xbc, 0xa9, 0x11, 0x39, 0x89, 0xdf, 0x83, 0xd9, 0xa0, 0x1e, 0x87, 0x17, + 0x12, 0x2c, 0x47, 0xca, 0xfe, 0xd2, 0xda, 0x04, 0x29, 0xc1, 0x60, 0x85, 0x33, 0x28, 0xc1, 0xa2, + 0x9e, 0xf0, 0x67, 0x0c, 0xec, 0x81, 0x8c, 0xa8, 0xf7, 0xe1, 0x4a, 0xdc, 0x66, 0xb4, 0x15, 0x28, + 0x6d, 0x4c, 0x4a, 0x80, 0x12, 0x57, 0xe5, 0xb8, 0x4b, 0xb0, 0x14, 0xc7, 0xc5, 0x7e, 0xb3, 0x66, + 0x32, 0xb8, 0x3f, 0x80, 0x7c, 0xa8, 0x24, 0x3f, 0x01, 0xfa, 0x88, 0x3d, 0x8f, 0xa8, 0xe9, 0xd5, + 0x75, 0x8e, 0xbd, 0x02, 0xcb, 0x23, 0xb0, 0x85, 0x78, 0x8d, 0x55, 0xfa, 0x4f, 0x40, 0x46, 0x14, + 0x75, 0x89, 0xbe, 0x17, 0x2d, 0xeb, 0x13, 0x7d, 0x6f, 0xa8, 0x36, 0x1c, 0xb7, 0xfb, 0xa0, 0x32, + 0xf0, 0x7b, 0xf0, 0xb9, 0x02, 0xc0, 0x20, 0xbd, 0xc1, 0xcd, 0x71, 0xa6, 0xc3, 0x15, 0x49, 0x69, + 0xeb, 0x04, 0x92, 0x82, 0xc7, 0x1a, 0xe7, 0x51, 0x81, 0xcb, 0x49, 0x3c, 0x78, 0xae, 0x87, 0x7f, + 0x56, 0x40, 0xae, 0x5f, 0x28, 0xc1, 0x8d, 0x71, 0xf6, 0xc3, 0xd7, 0xb1, 0x39, 0x59, 0x50, 0xf0, + 0xb8, 0xc0, 0x79, 0x94, 0xe1, 0x52, 0x12, 0x0f, 0xee, 0x0f, 0x4f, 0x58, 0x50, 0xe2, 0xb9, 0x76, + 0x4c, 0x50, 0x0a, 0x27, 0xf8, 0x31, 0x41, 0x29, 0x92, 0xf0, 0xc7, 0xdd, 0x87, 0x2c, 0x04, 0x18, + 0xba, 0x48, 0x88, 0x89, 0xe8, 0xd1, 0xe4, 0x9b, 0x88, 0x3e, 0x94, 0x89, 0xc7, 0xa1, 0xcb, 0x3f, + 0x33, 0xe1, 0x0b, 0x05, 0x80, 0x41, 0x12, 0x4f, 0xf4, 0x86, 0x58, 0x05, 0x90, 0xe8, 0x0d, 0xf1, + 0x8a, 0x60, 0xdc, 0xbb, 0x40, 0xad, 0x56, 0x4d, 0x72, 0xd9, 0xbb, 0xfe, 0xe6, 0x43, 0x59, 0x79, + 0xfb, 0xa1, 0xac, 0xbc, 0xff, 0x50, 0x56, 0x5e, 0x7d, 0x2c, 0x4f, 0xbd, 0xfd, 0x58, 0x9e, 0xfa, + 0xcf, 0xc7, 0xf2, 0xd4, 0xfd, 0xf5, 0x50, 0xc9, 0x87, 0xbb, 0xac, 0xe2, 0x1b, 0x58, 0xea, 0x71, + 0x5b, 0xbc, 0xec, 0xab, 0xcf, 0xf2, 0x0a, 0xf3, 0x27, 0xdf, 0x04, 0x00, 0x00, 0xff, 0xff, 0xab, + 0x8f, 0x1a, 0xb8, 0x95, 0x16, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1642,6 +1830,10 @@ type QueryClient interface { // BaseFee queries the base fee of the parent block of the current block, // it's similar to feemarket module's method, but also checks london hardfork status. BaseFee(ctx context.Context, in *QueryBaseFeeRequest, opts ...grpc.CallOption) (*QueryBaseFeeResponse, error) + // ZeroGas queries the zero gas config for a given contract address and signature + ZeroGas(ctx context.Context, in *QueryZeroGasRequest, opts ...grpc.CallOption) (*QueryZeroGasResponse, error) + // AllZeroGas queries all the zero gas + AllZeroGas(ctx context.Context, in *QueryAllZeroGasRequest, opts ...grpc.CallOption) (*QueryAllZeroGasResponse, error) } type queryClient struct { @@ -1769,6 +1961,24 @@ func (c *queryClient) BaseFee(ctx context.Context, in *QueryBaseFeeRequest, opts return out, nil } +func (c *queryClient) ZeroGas(ctx context.Context, in *QueryZeroGasRequest, opts ...grpc.CallOption) (*QueryZeroGasResponse, error) { + out := new(QueryZeroGasResponse) + err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Query/ZeroGas", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) AllZeroGas(ctx context.Context, in *QueryAllZeroGasRequest, opts ...grpc.CallOption) (*QueryAllZeroGasResponse, error) { + out := new(QueryAllZeroGasResponse) + err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Query/AllZeroGas", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // QueryServer is the server API for Query service. type QueryServer interface { // Account queries an Ethereum account. @@ -1800,6 +2010,10 @@ type QueryServer interface { // BaseFee queries the base fee of the parent block of the current block, // it's similar to feemarket module's method, but also checks london hardfork status. BaseFee(context.Context, *QueryBaseFeeRequest) (*QueryBaseFeeResponse, error) + // ZeroGas queries the zero gas config for a given contract address and signature + ZeroGas(context.Context, *QueryZeroGasRequest) (*QueryZeroGasResponse, error) + // AllZeroGas queries all the zero gas + AllZeroGas(context.Context, *QueryAllZeroGasRequest) (*QueryAllZeroGasResponse, error) } // UnimplementedQueryServer can be embedded to have forward compatible implementations. @@ -1845,6 +2059,12 @@ func (*UnimplementedQueryServer) TraceCall(ctx context.Context, req *QueryTraceC func (*UnimplementedQueryServer) BaseFee(ctx context.Context, req *QueryBaseFeeRequest) (*QueryBaseFeeResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method BaseFee not implemented") } +func (*UnimplementedQueryServer) ZeroGas(ctx context.Context, req *QueryZeroGasRequest) (*QueryZeroGasResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ZeroGas not implemented") +} +func (*UnimplementedQueryServer) AllZeroGas(ctx context.Context, req *QueryAllZeroGasRequest) (*QueryAllZeroGasResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AllZeroGas not implemented") +} func RegisterQueryServer(s grpc1.Server, srv QueryServer) { s.RegisterService(&_Query_serviceDesc, srv) @@ -2084,6 +2304,42 @@ func _Query_BaseFee_Handler(srv interface{}, ctx context.Context, dec func(inter return interceptor(ctx, in, info, handler) } +func _Query_ZeroGas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryZeroGasRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ZeroGas(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethermint.evm.v1.Query/ZeroGas", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ZeroGas(ctx, req.(*QueryZeroGasRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_AllZeroGas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryAllZeroGasRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).AllZeroGas(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethermint.evm.v1.Query/AllZeroGas", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).AllZeroGas(ctx, req.(*QueryAllZeroGasRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _Query_serviceDesc = grpc.ServiceDesc{ ServiceName: "ethermint.evm.v1.Query", HandlerType: (*QueryServer)(nil), @@ -2140,6 +2396,14 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "BaseFee", Handler: _Query_BaseFee_Handler, }, + { + MethodName: "ZeroGas", + Handler: _Query_ZeroGas_Handler, + }, + { + MethodName: "AllZeroGas", + Handler: _Query_AllZeroGas_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "ethermint/evm/v1/query.proto", @@ -3188,6 +3452,128 @@ func (m *QueryBaseFeeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *QueryZeroGasRequest) 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 *QueryZeroGasRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryZeroGasRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ContractAddress) > 0 { + i -= len(m.ContractAddress) + copy(dAtA[i:], m.ContractAddress) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ContractAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryZeroGasResponse) 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 *QueryZeroGasResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryZeroGasResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Signatures) > 0 { + for iNdEx := len(m.Signatures) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Signatures[iNdEx]) + copy(dAtA[i:], m.Signatures[iNdEx]) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Signatures[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryAllZeroGasRequest) 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 *QueryAllZeroGasRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllZeroGasRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryAllZeroGasResponse) 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 *QueryAllZeroGasResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllZeroGasResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Items) > 0 { + for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { offset -= sovQuery(v) base := offset @@ -3652,13 +4038,65 @@ func (m *QueryBaseFeeResponse) Size() (n int) { return n } -func sovQuery(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozQuery(x uint64) (n int) { - return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +func (m *QueryZeroGasRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ContractAddress) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n } -func (m *QueryAccountRequest) Unmarshal(dAtA []byte) error { + +func (m *QueryZeroGasResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Signatures) > 0 { + for _, s := range m.Signatures { + l = len(s) + n += 1 + l + sovQuery(uint64(l)) + } + } + return n +} + +func (m *QueryAllZeroGasRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryAllZeroGasResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Items) > 0 { + for _, e := range m.Items { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + return n +} + +func sovQuery(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozQuery(x uint64) (n int) { + return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *QueryAccountRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -6713,6 +7151,304 @@ func (m *QueryBaseFeeResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *QueryZeroGasRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryZeroGasRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryZeroGasRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + 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 ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContractAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryZeroGasResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryZeroGasResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryZeroGasResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + 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 ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signatures = append(m.Signatures, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllZeroGasRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryAllZeroGasRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllZeroGasRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllZeroGasResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryAllZeroGasResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllZeroGasResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Items = append(m.Items, ZeroGas{}) + if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/query.pb.gw.go b/x/evm/types/query.pb.gw.go index c52b6b2cc6..aeb5fa3190 100644 --- a/x/evm/types/query.pb.gw.go +++ b/x/evm/types/query.pb.gw.go @@ -595,6 +595,60 @@ func local_request_Query_BaseFee_0(ctx context.Context, marshaler runtime.Marsha } +var ( + filter_Query_ZeroGas_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_Query_ZeroGas_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryZeroGasRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ZeroGas_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.ZeroGas(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_ZeroGas_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryZeroGasRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ZeroGas_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.ZeroGas(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_AllZeroGas_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryAllZeroGasRequest + var metadata runtime.ServerMetadata + + msg, err := client.AllZeroGas(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_AllZeroGas_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryAllZeroGasRequest + var metadata runtime.ServerMetadata + + msg, err := server.AllZeroGas(ctx, &protoReq) + return msg, metadata, err + +} + // RegisterQueryHandlerServer registers the http handlers for service Query to "mux". // UnaryRPC :call QueryServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. @@ -900,6 +954,52 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_ZeroGas_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_ZeroGas_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_ZeroGas_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_AllZeroGas_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_AllZeroGas_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_AllZeroGas_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -1201,6 +1301,46 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_ZeroGas_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_ZeroGas_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_ZeroGas_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_AllZeroGas_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_AllZeroGas_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_AllZeroGas_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -1230,6 +1370,10 @@ var ( pattern_Query_TraceCall_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"ethermint", "evm", "v1", "trace_call"}, "", runtime.AssumeColonVerbOpt(false))) pattern_Query_BaseFee_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"ethermint", "evm", "v1", "base_fee"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_ZeroGas_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"ethermint", "evm", "v1", "zero_gas"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_AllZeroGas_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"ethermint", "evm", "v1", "all_zero_gas"}, "", runtime.AssumeColonVerbOpt(false))) ) var ( @@ -1258,4 +1402,8 @@ var ( forward_Query_TraceCall_0 = runtime.ForwardResponseMessage forward_Query_BaseFee_0 = runtime.ForwardResponseMessage + + forward_Query_ZeroGas_0 = runtime.ForwardResponseMessage + + forward_Query_AllZeroGas_0 = runtime.ForwardResponseMessage ) diff --git a/x/evm/types/tx.pb.go b/x/evm/types/tx.pb.go index e889b73d00..bec6cf491f 100644 --- a/x/evm/types/tx.pb.go +++ b/x/evm/types/tx.pb.go @@ -11,6 +11,7 @@ import ( _ "github.com/cosmos/cosmos-proto" types "github.com/cosmos/cosmos-sdk/codec/types" _ "github.com/cosmos/cosmos-sdk/types/msgservice" + _ "github.com/cosmos/cosmos-sdk/types/tx/amino" _ "github.com/cosmos/gogoproto/gogoproto" grpc1 "github.com/cosmos/gogoproto/grpc" proto "github.com/cosmos/gogoproto/proto" @@ -445,6 +446,100 @@ func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo +// MsgUpdateZeroGas defines a Msg for updating the x/evm module zero gas config. +type MsgUpdateZeroGas struct { + // authority is the address that controls the module (defaults to x/gov unless + // overwritten). + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + // metadata defines the zero gas to update. + Metadata UpdateZeroGasMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata"` +} + +func (m *MsgUpdateZeroGas) Reset() { *m = MsgUpdateZeroGas{} } +func (m *MsgUpdateZeroGas) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateZeroGas) ProtoMessage() {} +func (*MsgUpdateZeroGas) Descriptor() ([]byte, []int) { + return fileDescriptor_f75ac0a12d075f21, []int{8} +} +func (m *MsgUpdateZeroGas) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateZeroGas) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateZeroGas.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 *MsgUpdateZeroGas) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateZeroGas.Merge(m, src) +} +func (m *MsgUpdateZeroGas) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateZeroGas) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateZeroGas.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateZeroGas proto.InternalMessageInfo + +func (m *MsgUpdateZeroGas) GetAuthority() string { + if m != nil { + return m.Authority + } + return "" +} + +func (m *MsgUpdateZeroGas) GetMetadata() UpdateZeroGasMetadata { + if m != nil { + return m.Metadata + } + return UpdateZeroGasMetadata{} +} + +// MsgUpdateZeroGasResponse defines the response structure for executing a +// MsgUpdateZeroGas message. +type MsgUpdateZeroGasResponse struct { +} + +func (m *MsgUpdateZeroGasResponse) Reset() { *m = MsgUpdateZeroGasResponse{} } +func (m *MsgUpdateZeroGasResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateZeroGasResponse) ProtoMessage() {} +func (*MsgUpdateZeroGasResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_f75ac0a12d075f21, []int{9} +} +func (m *MsgUpdateZeroGasResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateZeroGasResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateZeroGasResponse.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 *MsgUpdateZeroGasResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateZeroGasResponse.Merge(m, src) +} +func (m *MsgUpdateZeroGasResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateZeroGasResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateZeroGasResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateZeroGasResponse proto.InternalMessageInfo + func init() { proto.RegisterType((*MsgEthereumTx)(nil), "ethermint.evm.v1.MsgEthereumTx") proto.RegisterType((*LegacyTx)(nil), "ethermint.evm.v1.LegacyTx") @@ -454,79 +549,88 @@ func init() { proto.RegisterType((*MsgEthereumTxResponse)(nil), "ethermint.evm.v1.MsgEthereumTxResponse") proto.RegisterType((*MsgUpdateParams)(nil), "ethermint.evm.v1.MsgUpdateParams") proto.RegisterType((*MsgUpdateParamsResponse)(nil), "ethermint.evm.v1.MsgUpdateParamsResponse") + proto.RegisterType((*MsgUpdateZeroGas)(nil), "ethermint.evm.v1.MsgUpdateZeroGas") + proto.RegisterType((*MsgUpdateZeroGasResponse)(nil), "ethermint.evm.v1.MsgUpdateZeroGasResponse") } func init() { proto.RegisterFile("ethermint/evm/v1/tx.proto", fileDescriptor_f75ac0a12d075f21) } var fileDescriptor_f75ac0a12d075f21 = []byte{ - // 1064 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xcf, 0x6f, 0x1b, 0x45, - 0x14, 0xce, 0xda, 0xeb, 0x5f, 0x63, 0x37, 0xad, 0x46, 0x89, 0xba, 0xb6, 0x88, 0xd7, 0x6c, 0xf9, - 0xe1, 0x16, 0x65, 0x57, 0x0d, 0xa8, 0x52, 0x73, 0x22, 0xdb, 0x24, 0x50, 0x94, 0x88, 0x6a, 0x71, - 0x2f, 0x80, 0x64, 0x4d, 0x76, 0x27, 0xeb, 0x55, 0xbd, 0x3b, 0xab, 0x9d, 0xb1, 0xb1, 0x91, 0x90, - 0xaa, 0x9e, 0x38, 0x52, 0xf1, 0x0f, 0x70, 0xe6, 0xd4, 0x43, 0xcf, 0x5c, 0xb8, 0x54, 0x9c, 0x2a, - 0xb8, 0xa0, 0x1e, 0x0c, 0x4a, 0x90, 0x2a, 0x72, 0xe4, 0xcc, 0x01, 0xcd, 0xcc, 0x3a, 0xb6, 0x6b, - 0x9c, 0x40, 0x25, 0xb8, 0xcd, 0x9b, 0xf7, 0xbd, 0x99, 0xf7, 0xbe, 0x6f, 0xf6, 0xbd, 0x05, 0x55, - 0xcc, 0x3a, 0x38, 0x09, 0x83, 0x88, 0x59, 0xb8, 0x1f, 0x5a, 0xfd, 0xeb, 0x16, 0x1b, 0x98, 0x71, - 0x42, 0x18, 0x81, 0x97, 0x4e, 0x5d, 0x26, 0xee, 0x87, 0x66, 0xff, 0x7a, 0xed, 0xb2, 0x4b, 0x68, - 0x48, 0xa8, 0x15, 0x52, 0x9f, 0x23, 0x43, 0xea, 0x4b, 0x68, 0xad, 0x2a, 0x1d, 0x6d, 0x61, 0x59, - 0xd2, 0x48, 0x5d, 0x2b, 0x3e, 0xf1, 0x89, 0xdc, 0xe7, 0xab, 0x74, 0xf7, 0x15, 0x9f, 0x10, 0xbf, - 0x8b, 0x2d, 0x14, 0x07, 0x16, 0x8a, 0x22, 0xc2, 0x10, 0x0b, 0x48, 0x34, 0x8e, 0xa9, 0xa6, 0x5e, - 0x61, 0x1d, 0xf4, 0x0e, 0x2d, 0x14, 0x0d, 0x53, 0xd7, 0x95, 0xb9, 0x7c, 0x91, 0xeb, 0x62, 0x4a, - 0xdb, 0xac, 0x17, 0x77, 0x71, 0x0a, 0xaa, 0xcd, 0x81, 0xba, 0x64, 0x9c, 0xea, 0xda, 0x9c, 0x2f, - 0x46, 0x09, 0x0a, 0xd3, 0xab, 0x8d, 0xfb, 0x19, 0x70, 0x61, 0x9f, 0xfa, 0x3b, 0x1c, 0x84, 0x7b, - 0x61, 0x6b, 0x00, 0x9b, 0x40, 0xf5, 0x10, 0x43, 0x9a, 0xd2, 0x50, 0x9a, 0xe5, 0x8d, 0x15, 0x53, - 0xe6, 0x66, 0x8e, 0x73, 0x33, 0xb7, 0xa2, 0xa1, 0x23, 0x10, 0xb0, 0x0a, 0x54, 0x1a, 0x7c, 0x8e, - 0xb5, 0x4c, 0x43, 0x69, 0x2a, 0x76, 0xee, 0x64, 0xa4, 0x2b, 0xeb, 0x8e, 0xd8, 0x82, 0xef, 0x80, - 0x8b, 0x1e, 0x8e, 0x13, 0xec, 0x22, 0x86, 0xbd, 0x76, 0x07, 0xd1, 0x8e, 0x96, 0x6d, 0x28, 0xcd, - 0x92, 0x5d, 0xfe, 0x63, 0xa4, 0x17, 0x92, 0x6e, 0xbc, 0x69, 0xac, 0x1b, 0xce, 0xf2, 0x04, 0xf3, - 0x3e, 0xa2, 0x1d, 0xf8, 0xd6, 0x4c, 0xd4, 0x61, 0x42, 0x42, 0x4d, 0x15, 0x51, 0x19, 0x4d, 0x99, - 0x06, 0xef, 0x26, 0x24, 0x84, 0x10, 0xa8, 0x02, 0x91, 0x6b, 0x28, 0xcd, 0x8a, 0x23, 0xd6, 0xf0, - 0x35, 0x90, 0x4d, 0xd0, 0x67, 0x5a, 0x9e, 0x6f, 0xd9, 0xf0, 0xc9, 0x48, 0x5f, 0x7a, 0x36, 0xd2, - 0xc1, 0xa4, 0x38, 0x87, 0xbb, 0x37, 0x2f, 0x7c, 0xf9, 0x8d, 0xbe, 0xf4, 0xe0, 0xf9, 0xa3, 0x6b, - 0x22, 0xc8, 0x78, 0x98, 0x01, 0xc5, 0x3d, 0xec, 0x23, 0x77, 0xd8, 0x1a, 0xc0, 0x15, 0x90, 0x8b, - 0x48, 0xe4, 0x62, 0x51, 0xbe, 0xea, 0x48, 0x03, 0xde, 0x00, 0x25, 0x1f, 0x71, 0xb9, 0x03, 0x57, - 0x96, 0x5b, 0xb2, 0xab, 0xcf, 0x46, 0xfa, 0xaa, 0x54, 0x9e, 0x7a, 0xf7, 0xcc, 0x80, 0x58, 0x21, - 0x62, 0x1d, 0xf3, 0x76, 0xc4, 0x9c, 0xa2, 0x8f, 0xe8, 0x1d, 0x0e, 0x85, 0x75, 0x90, 0xf5, 0x11, - 0x15, 0xa5, 0xab, 0x76, 0xe5, 0x68, 0xa4, 0x17, 0xdf, 0x43, 0x74, 0x2f, 0x08, 0x03, 0xe6, 0x70, - 0x07, 0x5c, 0x06, 0x19, 0x46, 0x64, 0x8d, 0x4e, 0x86, 0x11, 0x78, 0x13, 0xe4, 0xfa, 0xa8, 0xdb, - 0xc3, 0xa2, 0xa8, 0x92, 0x7d, 0x65, 0xe1, 0x1d, 0x47, 0x23, 0x3d, 0xbf, 0x15, 0x92, 0x5e, 0xc4, - 0x1c, 0x19, 0xc1, 0xe9, 0x10, 0xb2, 0xe5, 0x25, 0x1d, 0x42, 0xa0, 0x0a, 0x50, 0xfa, 0x5a, 0x41, - 0x6c, 0x28, 0x7d, 0x6e, 0x25, 0x5a, 0x51, 0x5a, 0x09, 0xb7, 0xa8, 0x56, 0x92, 0x16, 0xdd, 0x5c, - 0xe6, 0x94, 0xfc, 0xf0, 0x78, 0x3d, 0xdf, 0x1a, 0x6c, 0x23, 0x86, 0x8c, 0xef, 0xb2, 0xa0, 0xb2, - 0x25, 0x1e, 0xda, 0x5e, 0x40, 0x59, 0x6b, 0x00, 0x3f, 0x00, 0x45, 0xb7, 0x83, 0x82, 0xa8, 0x1d, - 0x78, 0x82, 0x9a, 0x92, 0x6d, 0x9d, 0x95, 0x5c, 0xe1, 0x16, 0x07, 0xdf, 0xde, 0x3e, 0x19, 0xe9, - 0x05, 0x57, 0x2e, 0x9d, 0x74, 0xe1, 0x4d, 0x38, 0xce, 0x2c, 0xe4, 0x38, 0xfb, 0xaf, 0x39, 0x56, - 0xcf, 0xe6, 0x38, 0x37, 0xcf, 0x71, 0xfe, 0xa5, 0x39, 0x2e, 0x4c, 0x71, 0xfc, 0x09, 0x28, 0xca, - 0x2f, 0x12, 0x53, 0xad, 0xd8, 0xc8, 0x36, 0xcb, 0x1b, 0x6b, 0xe6, 0x8b, 0x8d, 0xc4, 0x94, 0x54, - 0xb6, 0xf8, 0x27, 0x6b, 0x37, 0xf8, 0xb3, 0x3c, 0x19, 0xe9, 0x00, 0x9d, 0xf2, 0xfb, 0xed, 0x2f, - 0x3a, 0x98, 0xb0, 0xed, 0x9c, 0x1e, 0x28, 0x05, 0x2c, 0xcd, 0x08, 0x08, 0x66, 0x04, 0x2c, 0x2f, - 0x12, 0xf0, 0xcf, 0x2c, 0xa8, 0x6c, 0x0f, 0x23, 0x14, 0x06, 0xee, 0x2e, 0xc6, 0xff, 0x8b, 0x80, - 0x37, 0x41, 0x99, 0x0b, 0xc8, 0x82, 0xb8, 0xed, 0xa2, 0xf8, 0x7c, 0x09, 0xb9, 0xdc, 0xad, 0x20, - 0xbe, 0x85, 0xe2, 0x71, 0xe8, 0x21, 0xc6, 0x22, 0x54, 0xfd, 0x27, 0xa1, 0xbb, 0x18, 0xf3, 0xd0, - 0x54, 0xfe, 0xdc, 0xd9, 0xf2, 0xe7, 0xe7, 0xe5, 0x2f, 0xbc, 0xb4, 0xfc, 0xc5, 0x05, 0xf2, 0x97, - 0xfe, 0x13, 0xf9, 0xc1, 0x8c, 0xfc, 0xe5, 0x19, 0xf9, 0x2b, 0x8b, 0xe4, 0x37, 0x40, 0x6d, 0x67, - 0xc0, 0x70, 0x44, 0x03, 0x12, 0x7d, 0x18, 0x8b, 0x59, 0x33, 0xe9, 0x82, 0x9b, 0x2a, 0x47, 0x1b, - 0xdf, 0x2b, 0x60, 0x75, 0xa6, 0xf5, 0x3b, 0x98, 0xc6, 0x24, 0xa2, 0xa2, 0x50, 0xd1, 0xb2, 0xc5, - 0x3b, 0x71, 0xc4, 0x1a, 0x5e, 0x05, 0x6a, 0x97, 0xf8, 0x54, 0xcb, 0x88, 0x22, 0x57, 0xe7, 0x8b, - 0xdc, 0x23, 0xbe, 0x23, 0x20, 0xf0, 0x12, 0xc8, 0x26, 0x98, 0x89, 0x07, 0x50, 0x71, 0xf8, 0x12, - 0x56, 0x41, 0xb1, 0x1f, 0xb6, 0x71, 0x92, 0x90, 0x24, 0xed, 0x76, 0x85, 0x7e, 0xb8, 0xc3, 0x4d, - 0xee, 0xe2, 0xd2, 0xf7, 0x28, 0xf6, 0xa4, 0x88, 0x4e, 0xc1, 0x47, 0xf4, 0x2e, 0xc5, 0x1e, 0x5c, - 0x03, 0xe0, 0xa0, 0x4b, 0xdc, 0x7b, 0x72, 0x7e, 0xc8, 0xc6, 0x56, 0x12, 0x3b, 0x7c, 0x5a, 0xa4, - 0x55, 0x3c, 0x54, 0xc0, 0xc5, 0x7d, 0xea, 0xdf, 0x8d, 0x3d, 0xc4, 0xf0, 0x1d, 0x31, 0xda, 0x78, - 0x2b, 0x41, 0x3d, 0xd6, 0x21, 0x49, 0xc0, 0x86, 0xe9, 0x63, 0xd7, 0x7e, 0x7c, 0xbc, 0xbe, 0x92, - 0x0e, 0xea, 0x2d, 0xcf, 0x4b, 0x30, 0xa5, 0x1f, 0xb1, 0x24, 0x88, 0x7c, 0x67, 0x02, 0x85, 0x37, - 0x40, 0x5e, 0x0e, 0x47, 0xf1, 0xb0, 0xcb, 0x1b, 0xda, 0x7c, 0x95, 0xf2, 0x06, 0x5b, 0xe5, 0x2a, - 0x3a, 0x29, 0x7a, 0x73, 0x99, 0x0f, 0x93, 0xc9, 0x39, 0x46, 0x15, 0x5c, 0x7e, 0x21, 0xa5, 0x31, - 0xb5, 0x1b, 0xbf, 0x2b, 0x20, 0xbb, 0x4f, 0x7d, 0xf8, 0x05, 0x98, 0x1a, 0x4b, 0x50, 0x9f, 0xbf, - 0x68, 0x46, 0x99, 0xda, 0x9b, 0xe7, 0x00, 0xc6, 0xe7, 0x1b, 0xaf, 0x3f, 0xf8, 0xe9, 0xb7, 0xaf, - 0x33, 0xba, 0xb1, 0x66, 0xcd, 0xcd, 0x7d, 0x9c, 0xa2, 0xdb, 0x6c, 0x00, 0x3f, 0x05, 0x95, 0x19, - 0xc6, 0x5e, 0xfd, 0xdb, 0xf3, 0xa7, 0x21, 0xb5, 0xab, 0xe7, 0x42, 0xc6, 0x49, 0xd4, 0x72, 0xf7, - 0x9f, 0x3f, 0xba, 0xa6, 0xd8, 0xef, 0x3e, 0x39, 0xaa, 0x2b, 0x4f, 0x8f, 0xea, 0xca, 0xaf, 0x47, - 0x75, 0xe5, 0xab, 0xe3, 0xfa, 0xd2, 0xd3, 0xe3, 0xfa, 0xd2, 0xcf, 0xc7, 0xf5, 0xa5, 0x8f, 0xdf, - 0xf0, 0x03, 0xd6, 0xe9, 0x1d, 0x98, 0x2e, 0x09, 0x79, 0x76, 0x84, 0x4e, 0x65, 0x3b, 0x10, 0xf9, - 0xb2, 0x61, 0x8c, 0xe9, 0x41, 0x5e, 0xfc, 0x75, 0xbc, 0xfd, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, - 0xb5, 0x29, 0xc9, 0x6e, 0xb6, 0x09, 0x00, 0x00, + // 1172 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xcd, 0x6f, 0x1b, 0xc5, + 0x1b, 0xce, 0xfa, 0xdb, 0x63, 0x37, 0xcd, 0x6f, 0x94, 0xa8, 0x6b, 0xeb, 0x17, 0xaf, 0xd9, 0x02, + 0x75, 0x83, 0xe2, 0x55, 0x03, 0x2a, 0xaa, 0x4f, 0xc4, 0xf9, 0x28, 0x41, 0x89, 0xa8, 0x16, 0xf7, + 0x52, 0x90, 0xac, 0xc9, 0x7a, 0xb2, 0x5e, 0xd5, 0xbb, 0xb3, 0xda, 0x19, 0x1b, 0xbb, 0x12, 0x52, + 0xd5, 0x13, 0xe2, 0x44, 0xc5, 0x3f, 0xc0, 0x99, 0x53, 0x0e, 0x3d, 0x73, 0xe1, 0x52, 0xf5, 0x80, + 0x2a, 0xb8, 0xa0, 0x1e, 0x0c, 0x4a, 0x90, 0x82, 0x72, 0xe4, 0xcc, 0x01, 0xcd, 0xcc, 0xda, 0x8e, + 0xb3, 0x24, 0x81, 0x48, 0x70, 0xb1, 0x66, 0xe6, 0x7d, 0xde, 0xdd, 0xf7, 0x79, 0x9e, 0x77, 0xe7, + 0x35, 0x28, 0x60, 0xd6, 0xc6, 0x81, 0xeb, 0x78, 0xcc, 0xc0, 0x3d, 0xd7, 0xe8, 0xdd, 0x32, 0x58, + 0xbf, 0xea, 0x07, 0x84, 0x11, 0x38, 0x37, 0x0e, 0x55, 0x71, 0xcf, 0xad, 0xf6, 0x6e, 0x15, 0xaf, + 0x59, 0x84, 0xba, 0x84, 0x1a, 0x2e, 0xb5, 0x39, 0xd2, 0xa5, 0xb6, 0x84, 0x16, 0x0b, 0x32, 0xd0, + 0x14, 0x3b, 0x43, 0x6e, 0xc2, 0xd0, 0xbc, 0x4d, 0x6c, 0x22, 0xcf, 0xf9, 0x2a, 0x3c, 0xfd, 0xbf, + 0x4d, 0x88, 0xdd, 0xc1, 0x06, 0xf2, 0x1d, 0x03, 0x79, 0x1e, 0x61, 0x88, 0x39, 0xc4, 0x1b, 0xe5, + 0x14, 0xc2, 0xa8, 0xd8, 0xed, 0x76, 0xf7, 0x0c, 0xe4, 0x0d, 0xc2, 0xd0, 0xff, 0x90, 0xeb, 0x78, + 0xc4, 0x10, 0xbf, 0xe1, 0xd1, 0xf5, 0x08, 0x05, 0x64, 0x59, 0x98, 0xd2, 0x26, 0xeb, 0xfa, 0x1d, + 0x1c, 0x82, 0x8a, 0x11, 0x50, 0x87, 0x8c, 0xaa, 0x5f, 0x8c, 0xc4, 0x7c, 0x14, 0x20, 0x77, 0x54, + 0x8d, 0x16, 0x09, 0x3f, 0xc2, 0x01, 0x69, 0xda, 0x28, 0x04, 0xe8, 0x8f, 0x63, 0xe0, 0xca, 0x0e, + 0xb5, 0x37, 0x38, 0x0c, 0x77, 0xdd, 0x46, 0x1f, 0x56, 0x40, 0xa2, 0x85, 0x18, 0x52, 0x95, 0xb2, + 0x52, 0xc9, 0xad, 0xcc, 0x57, 0x25, 0x9f, 0xea, 0x88, 0x4f, 0x75, 0xd5, 0x1b, 0x98, 0x02, 0x01, + 0x0b, 0x20, 0x41, 0x9d, 0x47, 0x58, 0x8d, 0x95, 0x95, 0x8a, 0x52, 0x4f, 0x1e, 0x0f, 0x35, 0x65, + 0xd9, 0x14, 0x47, 0xf0, 0x1d, 0x70, 0xb5, 0x85, 0xfd, 0x00, 0x5b, 0x88, 0xe1, 0x56, 0xb3, 0x8d, + 0x68, 0x5b, 0x8d, 0x97, 0x95, 0x4a, 0xb6, 0x9e, 0xfb, 0x7d, 0xa8, 0xa5, 0x83, 0x8e, 0x5f, 0xd3, + 0x97, 0x75, 0x73, 0x76, 0x82, 0x79, 0x1f, 0xd1, 0x36, 0x7c, 0x6b, 0x2a, 0x6b, 0x2f, 0x20, 0xae, + 0x9a, 0x10, 0x59, 0x31, 0x55, 0x39, 0x09, 0xde, 0x0c, 0x88, 0x0b, 0x21, 0x48, 0x08, 0x44, 0xb2, + 0xac, 0x54, 0xf2, 0xa6, 0x58, 0xc3, 0xd7, 0x41, 0x3c, 0x40, 0x9f, 0xaa, 0x29, 0x7e, 0x54, 0x87, + 0xcf, 0x87, 0xda, 0xcc, 0xab, 0xa1, 0x06, 0x26, 0xe4, 0x4c, 0x1e, 0xae, 0x5d, 0xf9, 0xfc, 0x6b, + 0x6d, 0xe6, 0xc9, 0xd1, 0xfe, 0x92, 0x48, 0xd2, 0x9f, 0xc6, 0x40, 0x66, 0x1b, 0xdb, 0xc8, 0x1a, + 0x34, 0xfa, 0x70, 0x1e, 0x24, 0x3d, 0xe2, 0x59, 0x58, 0xd0, 0x4f, 0x98, 0x72, 0x03, 0x6f, 0x83, + 0xac, 0x8d, 0x78, 0x8b, 0x38, 0x96, 0xa4, 0x9b, 0xad, 0x17, 0x5e, 0x0d, 0xb5, 0x05, 0xd9, 0x2d, + 0xb4, 0xf5, 0xb0, 0xea, 0x10, 0xc3, 0x45, 0xac, 0x5d, 0xdd, 0xf2, 0x98, 0x99, 0xb1, 0x11, 0xbd, + 0xc7, 0xa1, 0xb0, 0x04, 0xe2, 0x36, 0xa2, 0x82, 0x7a, 0xa2, 0x9e, 0x3f, 0x18, 0x6a, 0x99, 0xbb, + 0x88, 0x6e, 0x3b, 0xae, 0xc3, 0x4c, 0x1e, 0x80, 0xb3, 0x20, 0xc6, 0x88, 0xe4, 0x68, 0xc6, 0x18, + 0x81, 0x77, 0x40, 0xb2, 0x87, 0x3a, 0x5d, 0x2c, 0x48, 0x65, 0xeb, 0xd7, 0xcf, 0x7c, 0xc7, 0xc1, + 0x50, 0x4b, 0xad, 0xba, 0xa4, 0xeb, 0x31, 0x53, 0x66, 0x70, 0x39, 0x84, 0x6d, 0x29, 0x29, 0x87, + 0x30, 0x28, 0x0f, 0x94, 0x9e, 0x9a, 0x16, 0x07, 0x4a, 0x8f, 0xef, 0x02, 0x35, 0x23, 0x77, 0x01, + 0xdf, 0x51, 0x35, 0x2b, 0x77, 0xb4, 0x36, 0xcb, 0x25, 0x79, 0xf1, 0x6c, 0x39, 0xd5, 0xe8, 0xaf, + 0x23, 0x86, 0xf4, 0x6f, 0xe3, 0x20, 0xbf, 0x2a, 0x3a, 0x71, 0xdb, 0xa1, 0xac, 0xd1, 0x87, 0x1f, + 0x80, 0x8c, 0xd5, 0x46, 0x8e, 0xd7, 0x74, 0x5a, 0x42, 0x9a, 0x6c, 0xdd, 0x38, 0xaf, 0xb8, 0xf4, + 0x1a, 0x07, 0x6f, 0xad, 0x1f, 0x0f, 0xb5, 0xb4, 0x25, 0x97, 0x66, 0xb8, 0x68, 0x4d, 0x34, 0x8e, + 0x9d, 0xa9, 0x71, 0xfc, 0x1f, 0x6b, 0x9c, 0x38, 0x5f, 0xe3, 0x64, 0x54, 0xe3, 0xd4, 0xa5, 0x35, + 0x4e, 0x9f, 0xd0, 0xf8, 0x63, 0x90, 0x91, 0x9f, 0x2c, 0xa6, 0x6a, 0xa6, 0x1c, 0xaf, 0xe4, 0x56, + 0x16, 0xab, 0xa7, 0x2f, 0x9f, 0xaa, 0x94, 0xb2, 0xc1, 0xbf, 0xe9, 0x7a, 0x99, 0xb7, 0xe5, 0xf1, + 0x50, 0x03, 0x68, 0xac, 0xef, 0x37, 0x3f, 0x6b, 0x60, 0xa2, 0xb6, 0x39, 0x7e, 0xa0, 0x34, 0x30, + 0x3b, 0x65, 0x20, 0x98, 0x32, 0x30, 0x77, 0x96, 0x81, 0x7f, 0xc4, 0x41, 0x7e, 0x7d, 0xe0, 0x21, + 0xd7, 0xb1, 0x36, 0x31, 0xfe, 0x4f, 0x0c, 0xbc, 0x03, 0x72, 0xdc, 0x40, 0xe6, 0xf8, 0x4d, 0x0b, + 0xf9, 0x17, 0x5b, 0xc8, 0xed, 0x6e, 0x38, 0xfe, 0x1a, 0xf2, 0x47, 0xa9, 0x7b, 0x18, 0x8b, 0xd4, + 0xc4, 0xdf, 0x49, 0xdd, 0xc4, 0x98, 0xa7, 0x86, 0xf6, 0x27, 0xcf, 0xb7, 0x3f, 0x15, 0xb5, 0x3f, + 0x7d, 0x69, 0xfb, 0x33, 0x67, 0xd8, 0x9f, 0xfd, 0x57, 0xec, 0x07, 0x53, 0xf6, 0xe7, 0xa6, 0xec, + 0xcf, 0x9f, 0x65, 0xbf, 0x0e, 0x8a, 0x1b, 0x7d, 0x86, 0x3d, 0xea, 0x10, 0xef, 0x43, 0x5f, 0xcc, + 0xa7, 0xc9, 0x2d, 0x58, 0x4b, 0x70, 0xb4, 0xfe, 0x9d, 0x02, 0x16, 0xa6, 0xae, 0x7e, 0x13, 0x53, + 0x9f, 0x78, 0x54, 0x10, 0x15, 0x57, 0xb6, 0xe8, 0x13, 0x53, 0xac, 0xe1, 0x4d, 0x90, 0xe8, 0x10, + 0x9b, 0xaa, 0x31, 0x41, 0x72, 0x21, 0x4a, 0x72, 0x9b, 0xd8, 0xa6, 0x80, 0xc0, 0x39, 0x10, 0x0f, + 0x30, 0x13, 0x0d, 0x90, 0x37, 0xf9, 0x12, 0x16, 0x40, 0xa6, 0xe7, 0x36, 0x71, 0x10, 0x90, 0x20, + 0xbc, 0xed, 0xd2, 0x3d, 0x77, 0x83, 0x6f, 0x79, 0x88, 0x5b, 0xdf, 0xa5, 0xb8, 0x25, 0x4d, 0x34, + 0xd3, 0x36, 0xa2, 0xf7, 0x29, 0x6e, 0xc1, 0x45, 0x00, 0x76, 0x3b, 0xc4, 0x7a, 0x28, 0xe7, 0x87, + 0xbc, 0xd8, 0xb2, 0xe2, 0x84, 0x4f, 0x8b, 0x90, 0xc5, 0x53, 0x05, 0x5c, 0xdd, 0xa1, 0xf6, 0x7d, + 0xbf, 0x85, 0x18, 0xbe, 0x27, 0x66, 0x1f, 0xbf, 0x4a, 0x50, 0x97, 0xb5, 0x49, 0xe0, 0xb0, 0x41, + 0xd8, 0xec, 0xea, 0x0f, 0xcf, 0x96, 0xe7, 0xc3, 0xe1, 0xbe, 0xda, 0x6a, 0x05, 0x98, 0xd2, 0x8f, + 0x58, 0xe0, 0x78, 0xb6, 0x39, 0x81, 0xc2, 0xdb, 0x20, 0x25, 0xa7, 0xa7, 0x68, 0xec, 0xdc, 0x8a, + 0x1a, 0x65, 0x29, 0xdf, 0x50, 0x4f, 0x70, 0x17, 0xcd, 0x10, 0x5d, 0x9b, 0xe5, 0xc3, 0x64, 0xf2, + 0x1c, 0xbd, 0x00, 0xae, 0x9d, 0x2a, 0x69, 0x24, 0xad, 0xfe, 0xbd, 0x02, 0xe6, 0xc6, 0xb1, 0x07, + 0x38, 0x20, 0x77, 0xd1, 0xe5, 0xeb, 0xdd, 0x02, 0x19, 0x17, 0x33, 0x24, 0x9a, 0x52, 0x56, 0x7c, + 0x23, 0x5a, 0xf1, 0xd4, 0xab, 0x76, 0x42, 0x78, 0x48, 0x60, 0x9c, 0x5e, 0x7b, 0xf7, 0xb7, 0x70, + 0x26, 0x4e, 0x1e, 0xff, 0xc5, 0xd1, 0xfe, 0x52, 0x79, 0x17, 0x51, 0x2c, 0x3e, 0x7b, 0xe3, 0x74, + 0xd5, 0x6b, 0xc4, 0xdb, 0x73, 0x6c, 0xbd, 0x08, 0xd4, 0xd3, 0x91, 0x11, 0xd9, 0x95, 0x17, 0x31, + 0x10, 0xdf, 0xa1, 0x36, 0xfc, 0x0c, 0x9c, 0x98, 0xc1, 0x50, 0x8b, 0xd6, 0x38, 0xd5, 0x86, 0xc5, + 0x1b, 0x17, 0x00, 0xc6, 0x62, 0xbe, 0xf1, 0xe4, 0xc7, 0x5f, 0xbf, 0x8a, 0x69, 0xfa, 0xa2, 0x11, + 0xf9, 0x9b, 0x83, 0x43, 0x74, 0x93, 0xf5, 0xe1, 0x27, 0x20, 0x3f, 0xd5, 0x1e, 0xaf, 0xfd, 0xe5, + 0xf3, 0x4f, 0x42, 0x8a, 0x37, 0x2f, 0x84, 0x8c, 0x3f, 0x96, 0x26, 0xb8, 0x32, 0xed, 0xa6, 0x7e, + 0x4e, 0x6e, 0x88, 0x29, 0x2e, 0x5d, 0x8c, 0x19, 0xbd, 0xa0, 0x98, 0x7c, 0x7c, 0xb4, 0xbf, 0xa4, + 0xd4, 0xdf, 0x7b, 0x7e, 0x50, 0x52, 0x5e, 0x1e, 0x94, 0x94, 0x5f, 0x0e, 0x4a, 0xca, 0x97, 0x87, + 0xa5, 0x99, 0x97, 0x87, 0xa5, 0x99, 0x9f, 0x0e, 0x4b, 0x33, 0x0f, 0xde, 0xb4, 0x1d, 0xd6, 0xee, + 0xee, 0x56, 0x2d, 0xe2, 0x72, 0xfa, 0x84, 0x9e, 0x90, 0xa3, 0x2f, 0x04, 0x61, 0x03, 0x1f, 0xd3, + 0xdd, 0x94, 0xf8, 0x0f, 0xf7, 0xf6, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x18, 0x5c, 0xab, 0xe9, + 0x38, 0x0b, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -546,6 +650,8 @@ type MsgClient interface { // UpdateParams defined a governance operation for updating the x/evm module parameters. // The authority is hard-coded to the Cosmos SDK x/gov module account UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) + // UpdateZeroGas defines a method for updating the zero gas config + UpdateZeroGas(ctx context.Context, in *MsgUpdateZeroGas, opts ...grpc.CallOption) (*MsgUpdateZeroGasResponse, error) } type msgClient struct { @@ -574,6 +680,15 @@ func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts return out, nil } +func (c *msgClient) UpdateZeroGas(ctx context.Context, in *MsgUpdateZeroGas, opts ...grpc.CallOption) (*MsgUpdateZeroGasResponse, error) { + out := new(MsgUpdateZeroGasResponse) + err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Msg/UpdateZeroGas", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. type MsgServer interface { // EthereumTx defines a method submitting Ethereum transactions. @@ -581,6 +696,8 @@ type MsgServer interface { // UpdateParams defined a governance operation for updating the x/evm module parameters. // The authority is hard-coded to the Cosmos SDK x/gov module account UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) + // UpdateZeroGas defines a method for updating the zero gas config + UpdateZeroGas(context.Context, *MsgUpdateZeroGas) (*MsgUpdateZeroGasResponse, error) } // UnimplementedMsgServer can be embedded to have forward compatible implementations. @@ -593,6 +710,9 @@ func (*UnimplementedMsgServer) EthereumTx(ctx context.Context, req *MsgEthereumT func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") } +func (*UnimplementedMsgServer) UpdateZeroGas(ctx context.Context, req *MsgUpdateZeroGas) (*MsgUpdateZeroGasResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateZeroGas not implemented") +} func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) @@ -634,6 +754,24 @@ func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(in return interceptor(ctx, in, info, handler) } +func _Msg_UpdateZeroGas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateZeroGas) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateZeroGas(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethermint.evm.v1.Msg/UpdateZeroGas", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateZeroGas(ctx, req.(*MsgUpdateZeroGas)) + } + return interceptor(ctx, in, info, handler) +} + var _Msg_serviceDesc = grpc.ServiceDesc{ ServiceName: "ethermint.evm.v1.Msg", HandlerType: (*MsgServer)(nil), @@ -646,6 +784,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "UpdateParams", Handler: _Msg_UpdateParams_Handler, }, + { + MethodName: "UpdateZeroGas", + Handler: _Msg_UpdateZeroGas_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "ethermint/evm/v1/tx.proto", @@ -1219,6 +1361,69 @@ func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } +func (m *MsgUpdateZeroGas) 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 *MsgUpdateZeroGas) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateZeroGas) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Authority) > 0 { + i -= len(m.Authority) + copy(dAtA[i:], m.Authority) + i = encodeVarintTx(dAtA, i, uint64(len(m.Authority))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateZeroGasResponse) 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 *MsgUpdateZeroGasResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateZeroGasResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + func encodeVarintTx(dAtA []byte, offset int, v uint64) int { offset -= sovTx(v) base := offset @@ -1480,6 +1685,30 @@ func (m *MsgUpdateParamsResponse) Size() (n int) { return n } +func (m *MsgUpdateZeroGas) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Authority) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Metadata.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgUpdateZeroGasResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + func sovTx(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -3324,6 +3553,171 @@ func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *MsgUpdateZeroGas) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateZeroGas: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateZeroGas: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgUpdateZeroGasResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateZeroGasResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateZeroGasResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/evm/types/zero_gas.pb.go b/x/evm/types/zero_gas.pb.go new file mode 100644 index 0000000000..84cd637a63 --- /dev/null +++ b/x/evm/types/zero_gas.pb.go @@ -0,0 +1,629 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: ethermint/evm/v1/zero_gas.proto + +package types + +import ( + fmt "fmt" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/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 + +// ZeroGas defines the parameters for zero gas fee transactions +type ZeroGas struct { + // contract_address specifies the target contract address for zero gas fee transactions + ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty" yaml:"contract_address"` + // signatures is a list of function signatures that will have zero gas fee + // when called on the specified contract_address + Signatures []string `protobuf:"bytes,2,rep,name=signatures,proto3" json:"signatures,omitempty" yaml:"signatures"` +} + +func (m *ZeroGas) Reset() { *m = ZeroGas{} } +func (m *ZeroGas) String() string { return proto.CompactTextString(m) } +func (*ZeroGas) ProtoMessage() {} +func (*ZeroGas) Descriptor() ([]byte, []int) { + return fileDescriptor_a5ca33d3a7a6d940, []int{0} +} +func (m *ZeroGas) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ZeroGas) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ZeroGas.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 *ZeroGas) XXX_Merge(src proto.Message) { + xxx_messageInfo_ZeroGas.Merge(m, src) +} +func (m *ZeroGas) XXX_Size() int { + return m.Size() +} +func (m *ZeroGas) XXX_DiscardUnknown() { + xxx_messageInfo_ZeroGas.DiscardUnknown(m) +} + +var xxx_messageInfo_ZeroGas proto.InternalMessageInfo + +func (m *ZeroGas) GetContractAddress() string { + if m != nil { + return m.ContractAddress + } + return "" +} + +func (m *ZeroGas) GetSignatures() []string { + if m != nil { + return m.Signatures + } + return nil +} + +type UpdateZeroGasMetadata struct { + // zero gas items to be added + AddItems []*ZeroGas `protobuf:"bytes,1,rep,name=add_items,json=addItems,proto3" json:"add_items,omitempty"` + // zero gas items to be removed + RemoveItems []*ZeroGas `protobuf:"bytes,2,rep,name=remove_items,json=removeItems,proto3" json:"remove_items,omitempty"` +} + +func (m *UpdateZeroGasMetadata) Reset() { *m = UpdateZeroGasMetadata{} } +func (m *UpdateZeroGasMetadata) String() string { return proto.CompactTextString(m) } +func (*UpdateZeroGasMetadata) ProtoMessage() {} +func (*UpdateZeroGasMetadata) Descriptor() ([]byte, []int) { + return fileDescriptor_a5ca33d3a7a6d940, []int{1} +} +func (m *UpdateZeroGasMetadata) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UpdateZeroGasMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UpdateZeroGasMetadata.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 *UpdateZeroGasMetadata) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateZeroGasMetadata.Merge(m, src) +} +func (m *UpdateZeroGasMetadata) XXX_Size() int { + return m.Size() +} +func (m *UpdateZeroGasMetadata) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateZeroGasMetadata.DiscardUnknown(m) +} + +var xxx_messageInfo_UpdateZeroGasMetadata proto.InternalMessageInfo + +func (m *UpdateZeroGasMetadata) GetAddItems() []*ZeroGas { + if m != nil { + return m.AddItems + } + return nil +} + +func (m *UpdateZeroGasMetadata) GetRemoveItems() []*ZeroGas { + if m != nil { + return m.RemoveItems + } + return nil +} + +func init() { + proto.RegisterType((*ZeroGas)(nil), "ethermint.evm.v1.ZeroGas") + proto.RegisterType((*UpdateZeroGasMetadata)(nil), "ethermint.evm.v1.UpdateZeroGasMetadata") +} + +func init() { proto.RegisterFile("ethermint/evm/v1/zero_gas.proto", fileDescriptor_a5ca33d3a7a6d940) } + +var fileDescriptor_a5ca33d3a7a6d940 = []byte{ + // 311 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0x2d, 0xc9, 0x48, + 0x2d, 0xca, 0xcd, 0xcc, 0x2b, 0xd1, 0x4f, 0x2d, 0xcb, 0xd5, 0x2f, 0x33, 0xd4, 0xaf, 0x4a, 0x2d, + 0xca, 0x8f, 0x4f, 0x4f, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x80, 0x2b, 0xd0, + 0x4b, 0x2d, 0xcb, 0xd5, 0x2b, 0x33, 0x94, 0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0x4b, 0xea, 0x83, + 0x58, 0x10, 0x75, 0x4a, 0x1d, 0x8c, 0x5c, 0xec, 0x51, 0xa9, 0x45, 0xf9, 0xee, 0x89, 0xc5, 0x42, + 0x6e, 0x5c, 0x02, 0xc9, 0xf9, 0x79, 0x25, 0x45, 0x89, 0xc9, 0x25, 0xf1, 0x89, 0x29, 0x29, 0x45, + 0xa9, 0xc5, 0xc5, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x9c, 0x4e, 0xd2, 0x9f, 0xee, 0xc9, 0x8b, 0x57, + 0x26, 0xe6, 0xe6, 0x58, 0x29, 0xa1, 0xab, 0x50, 0x0a, 0xe2, 0x87, 0x09, 0x39, 0x42, 0x44, 0x84, + 0x4c, 0xb9, 0xb8, 0x8a, 0x33, 0xd3, 0xf3, 0x12, 0x4b, 0x4a, 0x8b, 0x52, 0x8b, 0x25, 0x98, 0x14, + 0x98, 0x35, 0x38, 0x9d, 0x44, 0x3f, 0xdd, 0x93, 0x17, 0x84, 0x98, 0x80, 0x90, 0x53, 0x0a, 0x42, + 0x52, 0xa8, 0xd4, 0xcb, 0xc8, 0x25, 0x1a, 0x5a, 0x90, 0x92, 0x58, 0x92, 0x0a, 0x75, 0x90, 0x6f, + 0x6a, 0x49, 0x62, 0x4a, 0x62, 0x49, 0xa2, 0x90, 0x19, 0x17, 0x67, 0x62, 0x4a, 0x4a, 0x7c, 0x66, + 0x49, 0x6a, 0x2e, 0xc8, 0x45, 0xcc, 0x1a, 0xdc, 0x46, 0x92, 0x7a, 0xe8, 0x1e, 0xd4, 0x83, 0xea, + 0x0a, 0xe2, 0x48, 0x4c, 0x49, 0xf1, 0x04, 0x29, 0x15, 0xb2, 0xe1, 0xe2, 0x29, 0x4a, 0xcd, 0xcd, + 0x2f, 0x4b, 0x85, 0x6a, 0x65, 0x22, 0xa4, 0x95, 0x1b, 0xa2, 0x1c, 0xac, 0xdb, 0xc9, 0xe1, 0xc4, + 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58, 0x8e, 0xe1, + 0xc2, 0x63, 0x39, 0x86, 0x1b, 0x8f, 0xe5, 0x18, 0xa2, 0xd4, 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, + 0xf4, 0x92, 0xf3, 0x73, 0x41, 0xc1, 0x9f, 0x5f, 0xac, 0x8f, 0x88, 0x8e, 0x0a, 0x70, 0x84, 0x94, + 0x54, 0x16, 0xa4, 0x16, 0x27, 0xb1, 0x81, 0xc3, 0xd8, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xf2, 0x20, 0xae, 0x01, 0x00, 0x00, +} + +func (m *ZeroGas) 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 *ZeroGas) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ZeroGas) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Signatures) > 0 { + for iNdEx := len(m.Signatures) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Signatures[iNdEx]) + copy(dAtA[i:], m.Signatures[iNdEx]) + i = encodeVarintZeroGas(dAtA, i, uint64(len(m.Signatures[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if len(m.ContractAddress) > 0 { + i -= len(m.ContractAddress) + copy(dAtA[i:], m.ContractAddress) + i = encodeVarintZeroGas(dAtA, i, uint64(len(m.ContractAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UpdateZeroGasMetadata) 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 *UpdateZeroGasMetadata) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UpdateZeroGasMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.RemoveItems) > 0 { + for iNdEx := len(m.RemoveItems) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RemoveItems[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintZeroGas(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.AddItems) > 0 { + for iNdEx := len(m.AddItems) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.AddItems[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintZeroGas(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintZeroGas(dAtA []byte, offset int, v uint64) int { + offset -= sovZeroGas(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *ZeroGas) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ContractAddress) + if l > 0 { + n += 1 + l + sovZeroGas(uint64(l)) + } + if len(m.Signatures) > 0 { + for _, s := range m.Signatures { + l = len(s) + n += 1 + l + sovZeroGas(uint64(l)) + } + } + return n +} + +func (m *UpdateZeroGasMetadata) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.AddItems) > 0 { + for _, e := range m.AddItems { + l = e.Size() + n += 1 + l + sovZeroGas(uint64(l)) + } + } + if len(m.RemoveItems) > 0 { + for _, e := range m.RemoveItems { + l = e.Size() + n += 1 + l + sovZeroGas(uint64(l)) + } + } + return n +} + +func sovZeroGas(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozZeroGas(x uint64) (n int) { + return sovZeroGas(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ZeroGas) 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 ErrIntOverflowZeroGas + } + 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: ZeroGas: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ZeroGas: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowZeroGas + } + 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 ErrInvalidLengthZeroGas + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthZeroGas + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContractAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowZeroGas + } + 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 ErrInvalidLengthZeroGas + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthZeroGas + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signatures = append(m.Signatures, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipZeroGas(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthZeroGas + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UpdateZeroGasMetadata) 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 ErrIntOverflowZeroGas + } + 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: UpdateZeroGasMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpdateZeroGasMetadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AddItems", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowZeroGas + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthZeroGas + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthZeroGas + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AddItems = append(m.AddItems, &ZeroGas{}) + if err := m.AddItems[len(m.AddItems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RemoveItems", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowZeroGas + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthZeroGas + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthZeroGas + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RemoveItems = append(m.RemoveItems, &ZeroGas{}) + if err := m.RemoveItems[len(m.RemoveItems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipZeroGas(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthZeroGas + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipZeroGas(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, ErrIntOverflowZeroGas + } + 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, ErrIntOverflowZeroGas + } + 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, ErrIntOverflowZeroGas + } + 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, ErrInvalidLengthZeroGas + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupZeroGas + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthZeroGas + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthZeroGas = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowZeroGas = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupZeroGas = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/evm/types/zero_gas_config.pb.go b/x/evm/types/zero_gas_config.pb.go new file mode 100644 index 0000000000..18198011d0 --- /dev/null +++ b/x/evm/types/zero_gas_config.pb.go @@ -0,0 +1,632 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: ethermint/evm/v1/zero_gas_config.proto + +package types + +import ( + fmt "fmt" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/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 + +// ZeroGasConfig defines the parameters for zero gas fee transactions +type ZeroGasConfig struct { + // contract_address specifies the target contract address for zero gas fee transactions + ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty" yaml:"contract_address"` + // signatures is a list of function signatures that will have zero gas fee + // when called on the specified contract_address + Signatures []string `protobuf:"bytes,2,rep,name=signatures,proto3" json:"signatures,omitempty" yaml:"signatures"` +} + +func (m *ZeroGasConfig) Reset() { *m = ZeroGasConfig{} } +func (m *ZeroGasConfig) String() string { return proto.CompactTextString(m) } +func (*ZeroGasConfig) ProtoMessage() {} +func (*ZeroGasConfig) Descriptor() ([]byte, []int) { + return fileDescriptor_a68491dbbfc670d8, []int{0} +} +func (m *ZeroGasConfig) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ZeroGasConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ZeroGasConfig.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 *ZeroGasConfig) XXX_Merge(src proto.Message) { + xxx_messageInfo_ZeroGasConfig.Merge(m, src) +} +func (m *ZeroGasConfig) XXX_Size() int { + return m.Size() +} +func (m *ZeroGasConfig) XXX_DiscardUnknown() { + xxx_messageInfo_ZeroGasConfig.DiscardUnknown(m) +} + +var xxx_messageInfo_ZeroGasConfig proto.InternalMessageInfo + +func (m *ZeroGasConfig) GetContractAddress() string { + if m != nil { + return m.ContractAddress + } + return "" +} + +func (m *ZeroGasConfig) GetSignatures() []string { + if m != nil { + return m.Signatures + } + return nil +} + +type UpdateZeroGasConfigMetadata struct { + // zero gas configs to be added + AddZeroGasConfigs []*ZeroGasConfig `protobuf:"bytes,1,rep,name=add_zero_gas_configs,json=addZeroGasConfigs,proto3" json:"add_zero_gas_configs,omitempty"` + // zero gas configs to be removed + RemoveZeroGasConfigs []*ZeroGasConfig `protobuf:"bytes,2,rep,name=remove_zero_gas_configs,json=removeZeroGasConfigs,proto3" json:"remove_zero_gas_configs,omitempty"` +} + +func (m *UpdateZeroGasConfigMetadata) Reset() { *m = UpdateZeroGasConfigMetadata{} } +func (m *UpdateZeroGasConfigMetadata) String() string { return proto.CompactTextString(m) } +func (*UpdateZeroGasConfigMetadata) ProtoMessage() {} +func (*UpdateZeroGasConfigMetadata) Descriptor() ([]byte, []int) { + return fileDescriptor_a68491dbbfc670d8, []int{1} +} +func (m *UpdateZeroGasConfigMetadata) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UpdateZeroGasConfigMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UpdateZeroGasConfigMetadata.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 *UpdateZeroGasConfigMetadata) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateZeroGasConfigMetadata.Merge(m, src) +} +func (m *UpdateZeroGasConfigMetadata) XXX_Size() int { + return m.Size() +} +func (m *UpdateZeroGasConfigMetadata) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateZeroGasConfigMetadata.DiscardUnknown(m) +} + +var xxx_messageInfo_UpdateZeroGasConfigMetadata proto.InternalMessageInfo + +func (m *UpdateZeroGasConfigMetadata) GetAddZeroGasConfigs() []*ZeroGasConfig { + if m != nil { + return m.AddZeroGasConfigs + } + return nil +} + +func (m *UpdateZeroGasConfigMetadata) GetRemoveZeroGasConfigs() []*ZeroGasConfig { + if m != nil { + return m.RemoveZeroGasConfigs + } + return nil +} + +func init() { + proto.RegisterType((*ZeroGasConfig)(nil), "ethermint.evm.v1.ZeroGasConfig") + proto.RegisterType((*UpdateZeroGasConfigMetadata)(nil), "ethermint.evm.v1.UpdateZeroGasConfigMetadata") +} + +func init() { + proto.RegisterFile("ethermint/evm/v1/zero_gas_config.proto", fileDescriptor_a68491dbbfc670d8) +} + +var fileDescriptor_a68491dbbfc670d8 = []byte{ + // 321 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x4b, 0x2d, 0xc9, 0x48, + 0x2d, 0xca, 0xcd, 0xcc, 0x2b, 0xd1, 0x4f, 0x2d, 0xcb, 0xd5, 0x2f, 0x33, 0xd4, 0xaf, 0x4a, 0x2d, + 0xca, 0x8f, 0x4f, 0x4f, 0x2c, 0x8e, 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0x2b, 0x28, 0xca, + 0x2f, 0xc9, 0x17, 0x12, 0x80, 0xab, 0xd3, 0x4b, 0x2d, 0xcb, 0xd5, 0x2b, 0x33, 0x94, 0x12, 0x49, + 0xcf, 0x4f, 0xcf, 0x07, 0x4b, 0xea, 0x83, 0x58, 0x10, 0x75, 0x4a, 0x7d, 0x8c, 0x5c, 0xbc, 0x51, + 0xa9, 0x45, 0xf9, 0xee, 0x89, 0xc5, 0xce, 0x60, 0xfd, 0x42, 0x6e, 0x5c, 0x02, 0xc9, 0xf9, 0x79, + 0x25, 0x45, 0x89, 0xc9, 0x25, 0xf1, 0x89, 0x29, 0x29, 0x45, 0xa9, 0xc5, 0xc5, 0x12, 0x8c, 0x0a, + 0x8c, 0x1a, 0x9c, 0x4e, 0xd2, 0x9f, 0xee, 0xc9, 0x8b, 0x57, 0x26, 0xe6, 0xe6, 0x58, 0x29, 0xa1, + 0xab, 0x50, 0x0a, 0xe2, 0x87, 0x09, 0x39, 0x42, 0x44, 0x84, 0x4c, 0xb9, 0xb8, 0x8a, 0x33, 0xd3, + 0xf3, 0x12, 0x4b, 0x4a, 0x8b, 0x52, 0x8b, 0x25, 0x98, 0x14, 0x98, 0x35, 0x38, 0x9d, 0x44, 0x3f, + 0xdd, 0x93, 0x17, 0x84, 0x98, 0x80, 0x90, 0x53, 0x0a, 0x42, 0x52, 0xa8, 0x74, 0x9c, 0x91, 0x4b, + 0x3a, 0xb4, 0x20, 0x25, 0xb1, 0x24, 0x15, 0xc5, 0x59, 0xbe, 0xa9, 0x25, 0x89, 0x29, 0x89, 0x25, + 0x89, 0x42, 0x01, 0x5c, 0x22, 0x89, 0x29, 0x29, 0xf1, 0x68, 0xbe, 0x06, 0x39, 0x91, 0x59, 0x83, + 0xdb, 0x48, 0x5e, 0x0f, 0xdd, 0xdf, 0x7a, 0x28, 0xc6, 0x04, 0x09, 0x26, 0xa6, 0xa4, 0xa0, 0x88, + 0x14, 0x0b, 0x85, 0x71, 0x89, 0x17, 0xa5, 0xe6, 0xe6, 0x97, 0xa5, 0x62, 0x1a, 0xca, 0x44, 0x9c, + 0xa1, 0x22, 0x10, 0xfd, 0xa8, 0xe6, 0x3a, 0x39, 0x9c, 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, 0x5a, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0x2e, 0x28, 0x16, + 0xf3, 0x8b, 0xf5, 0x11, 0xb1, 0x5a, 0x01, 0x8e, 0xd7, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, + 0x70, 0x1c, 0x19, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x05, 0x74, 0x38, 0x77, 0xf5, 0x01, 0x00, + 0x00, +} + +func (m *ZeroGasConfig) 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 *ZeroGasConfig) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ZeroGasConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Signatures) > 0 { + for iNdEx := len(m.Signatures) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Signatures[iNdEx]) + copy(dAtA[i:], m.Signatures[iNdEx]) + i = encodeVarintZeroGasConfig(dAtA, i, uint64(len(m.Signatures[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if len(m.ContractAddress) > 0 { + i -= len(m.ContractAddress) + copy(dAtA[i:], m.ContractAddress) + i = encodeVarintZeroGasConfig(dAtA, i, uint64(len(m.ContractAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UpdateZeroGasConfigMetadata) 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 *UpdateZeroGasConfigMetadata) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UpdateZeroGasConfigMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.RemoveZeroGasConfigs) > 0 { + for iNdEx := len(m.RemoveZeroGasConfigs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RemoveZeroGasConfigs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintZeroGasConfig(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.AddZeroGasConfigs) > 0 { + for iNdEx := len(m.AddZeroGasConfigs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.AddZeroGasConfigs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintZeroGasConfig(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintZeroGasConfig(dAtA []byte, offset int, v uint64) int { + offset -= sovZeroGasConfig(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *ZeroGasConfig) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ContractAddress) + if l > 0 { + n += 1 + l + sovZeroGasConfig(uint64(l)) + } + if len(m.Signatures) > 0 { + for _, s := range m.Signatures { + l = len(s) + n += 1 + l + sovZeroGasConfig(uint64(l)) + } + } + return n +} + +func (m *UpdateZeroGasConfigMetadata) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.AddZeroGasConfigs) > 0 { + for _, e := range m.AddZeroGasConfigs { + l = e.Size() + n += 1 + l + sovZeroGasConfig(uint64(l)) + } + } + if len(m.RemoveZeroGasConfigs) > 0 { + for _, e := range m.RemoveZeroGasConfigs { + l = e.Size() + n += 1 + l + sovZeroGasConfig(uint64(l)) + } + } + return n +} + +func sovZeroGasConfig(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozZeroGasConfig(x uint64) (n int) { + return sovZeroGasConfig(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ZeroGasConfig) 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 ErrIntOverflowZeroGasConfig + } + 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: ZeroGasConfig: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ZeroGasConfig: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowZeroGasConfig + } + 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 ErrInvalidLengthZeroGasConfig + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthZeroGasConfig + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContractAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowZeroGasConfig + } + 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 ErrInvalidLengthZeroGasConfig + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthZeroGasConfig + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signatures = append(m.Signatures, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipZeroGasConfig(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthZeroGasConfig + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UpdateZeroGasConfigMetadata) 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 ErrIntOverflowZeroGasConfig + } + 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: UpdateZeroGasConfigMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpdateZeroGasConfigMetadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AddZeroGasConfigs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowZeroGasConfig + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthZeroGasConfig + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthZeroGasConfig + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AddZeroGasConfigs = append(m.AddZeroGasConfigs, &ZeroGasConfig{}) + if err := m.AddZeroGasConfigs[len(m.AddZeroGasConfigs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RemoveZeroGasConfigs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowZeroGasConfig + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthZeroGasConfig + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthZeroGasConfig + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RemoveZeroGasConfigs = append(m.RemoveZeroGasConfigs, &ZeroGasConfig{}) + if err := m.RemoveZeroGasConfigs[len(m.RemoveZeroGasConfigs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipZeroGasConfig(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthZeroGasConfig + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipZeroGasConfig(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, ErrIntOverflowZeroGasConfig + } + 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, ErrIntOverflowZeroGasConfig + } + 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, ErrIntOverflowZeroGasConfig + } + 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, ErrInvalidLengthZeroGasConfig + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupZeroGasConfig + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthZeroGasConfig + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthZeroGasConfig = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowZeroGasConfig = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupZeroGasConfig = fmt.Errorf("proto: unexpected end of group") +)