rpcevents.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: rpcevents.proto

package rpcevents

import (
	context "context"
	fmt "fmt"
	io "io"
	math "math"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	golang_proto "github.com/golang/protobuf/proto"
	github_com_hyperledger_burrow_binary "github.com/hyperledger/burrow/binary"
	exec "github.com/hyperledger/burrow/execution/exec"
	grpc "google.golang.org/grpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = golang_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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type Bound_BoundType int32

const (
	// Index is absolute index of an item
	Bound_ABSOLUTE Bound_BoundType = 0
	// Index is an offset relative to last item
	Bound_RELATIVE Bound_BoundType = 1
	// The first block
	Bound_FIRST Bound_BoundType = 2
	// Ignore provided index and evaluate to latest index
	Bound_LATEST Bound_BoundType = 3
	// Ignore provided index and stream new objects as they are generated
	Bound_STREAM Bound_BoundType = 4
)

var Bound_BoundType_name = map[int32]string{
	0: "ABSOLUTE",
	1: "RELATIVE",
	2: "FIRST",
	3: "LATEST",
	4: "STREAM",
}

var Bound_BoundType_value = map[string]int32{
	"ABSOLUTE": 0,
	"RELATIVE": 1,
	"FIRST":    2,
	"LATEST":   3,
	"STREAM":   4,
}

func (x Bound_BoundType) String() string {
	return proto.EnumName(Bound_BoundType_name, int32(x))
}

func (Bound_BoundType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_580b21d8d2fd68e4, []int{6, 0}
}

type GetBlockRequest struct {
	// Height of block required
	Height uint64 `protobuf:"varint,1,opt,name=Height,proto3" json:"Height,omitempty"`
	// Whether to wait for the block to become available
	Wait                 bool     `protobuf:"varint,2,opt,name=Wait,proto3" json:"Wait,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetBlockRequest) Reset()         { *m = GetBlockRequest{} }
func (m *GetBlockRequest) String() string { return proto.CompactTextString(m) }
func (*GetBlockRequest) ProtoMessage()    {}
func (*GetBlockRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_580b21d8d2fd68e4, []int{0}
}
func (m *GetBlockRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetBlockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetBlockRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetBlockRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetBlockRequest.Merge(m, src)
}
func (m *GetBlockRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetBlockRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetBlockRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetBlockRequest proto.InternalMessageInfo

func (m *GetBlockRequest) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *GetBlockRequest) GetWait() bool {
	if m != nil {
		return m.Wait
	}
	return false
}

func (*GetBlockRequest) XXX_MessageName() string {
	return "rpcevents.GetBlockRequest"
}

type TxRequest struct {
	// Height of block required
	TxHash github_com_hyperledger_burrow_binary.HexBytes `protobuf:"bytes,1,opt,name=TxHash,proto3,customtype=github.com/hyperledger/burrow/binary.HexBytes" json:"TxHash"`
	// Whether to wait for the block to become available
	Wait                 bool     `protobuf:"varint,2,opt,name=Wait,proto3" json:"Wait,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TxRequest) Reset()         { *m = TxRequest{} }
func (m *TxRequest) String() string { return proto.CompactTextString(m) }
func (*TxRequest) ProtoMessage()    {}
func (*TxRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_580b21d8d2fd68e4, []int{1}
}
func (m *TxRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TxRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TxRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TxRequest.Merge(m, src)
}
func (m *TxRequest) XXX_Size() int {
	return m.Size()
}
func (m *TxRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TxRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TxRequest proto.InternalMessageInfo

func (m *TxRequest) GetWait() bool {
	if m != nil {
		return m.Wait
	}
	return false
}

func (*TxRequest) XXX_MessageName() string {
	return "rpcevents.TxRequest"
}

type BlocksRequest struct {
	BlockRange *BlockRange `protobuf:"bytes,1,opt,name=BlockRange,proto3" json:"BlockRange,omitempty"`
	// Specify a query on which to match the tags of events.
	// Tag        | Match type | Values
	// -----------------------------------------
	//   All events
	// -----------------------------------------
	// TxType       | String     | "UnknownTx", "SendTx", "CallTx", "NameTx", "BondTx", "UnbondTx", "PermissionsTx", "GovernanceTx"
	// TxHash       | String     | bytes
	// EventType    | String     | "CallEvent", "LogEvent", "AccountInputEvent", "AccountOutputEvent"
	// EventID      | String     | string
	// Height       | Integer    | uint64
	// Index        | Integer    | uint64
	// MessageType  | String     | Go type name
	// -----------------------------------------
	//   Log event
	// -----------------------------------------
	// Address      | String     | Address (hex)
	// Log<0-4>     | String     | Word256 (hex)
	// Log<0-4>Text | String     | string (trimmed)
	// -----------------------------------------
	//   Call event
	// -----------------------------------------
	// Origin       | String     | Address (hex)
	// Callee       | String     | Address (hex)
	// Caller       | String     | Address (hex)
	// Value        | Integer    | uint64
	// Gas          | Integer    | uint64
	// StackDepth   | Integer    | uint64
	// Exception    | String     | string
	// -----------------------------------------
	//   Tx event (input/output)
	// -----------------------------------------
	// Exception  | String     | string
	//
	// For example:
	// EventType = 'LogEvent' AND EventID CONTAINS 'bar' AND TxHash = '020304' AND Height >= 34 AND Index < 3 AND Address = 'DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF'
	Query                string   `protobuf:"bytes,2,opt,name=Query,proto3" json:"Query,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BlocksRequest) Reset()         { *m = BlocksRequest{} }
func (m *BlocksRequest) String() string { return proto.CompactTextString(m) }
func (*BlocksRequest) ProtoMessage()    {}
func (*BlocksRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_580b21d8d2fd68e4, []int{2}
}
func (m *BlocksRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlocksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlocksRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BlocksRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlocksRequest.Merge(m, src)
}
func (m *BlocksRequest) XXX_Size() int {
	return m.Size()
}
func (m *BlocksRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BlocksRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BlocksRequest proto.InternalMessageInfo

func (m *BlocksRequest) GetBlockRange() *BlockRange {
	if m != nil {
		return m.BlockRange
	}
	return nil
}

func (m *BlocksRequest) GetQuery() string {
	if m != nil {
		return m.Query
	}
	return ""
}

func (*BlocksRequest) XXX_MessageName() string {
	return "rpcevents.BlocksRequest"
}

type EventsResponse struct {
	Height               uint64        `protobuf:"varint,1,opt,name=Height,proto3" json:"Height,omitempty"`
	Events               []*exec.Event `protobuf:"bytes,2,rep,name=Events,proto3" json:"Events,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *EventsResponse) Reset()         { *m = EventsResponse{} }
func (m *EventsResponse) String() string { return proto.CompactTextString(m) }
func (*EventsResponse) ProtoMessage()    {}
func (*EventsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_580b21d8d2fd68e4, []int{3}
}
func (m *EventsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EventsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventsResponse.Merge(m, src)
}
func (m *EventsResponse) XXX_Size() int {
	return m.Size()
}
func (m *EventsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_EventsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_EventsResponse proto.InternalMessageInfo

func (m *EventsResponse) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *EventsResponse) GetEvents() []*exec.Event {
	if m != nil {
		return m.Events
	}
	return nil
}

func (*EventsResponse) XXX_MessageName() string {
	return "rpcevents.EventsResponse"
}

type GetTxsRequest struct {
	StartHeight          uint64   `protobuf:"varint,1,opt,name=StartHeight,proto3" json:"StartHeight,omitempty"`
	EndHeight            uint64   `protobuf:"varint,2,opt,name=EndHeight,proto3" json:"EndHeight,omitempty"`
	Query                string   `protobuf:"bytes,3,opt,name=Query,proto3" json:"Query,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetTxsRequest) Reset()         { *m = GetTxsRequest{} }
func (m *GetTxsRequest) String() string { return proto.CompactTextString(m) }
func (*GetTxsRequest) ProtoMessage()    {}
func (*GetTxsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_580b21d8d2fd68e4, []int{4}
}
func (m *GetTxsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetTxsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetTxsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetTxsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetTxsRequest.Merge(m, src)
}
func (m *GetTxsRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetTxsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetTxsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetTxsRequest proto.InternalMessageInfo

func (m *GetTxsRequest) GetStartHeight() uint64 {
	if m != nil {
		return m.StartHeight
	}
	return 0
}

func (m *GetTxsRequest) GetEndHeight() uint64 {
	if m != nil {
		return m.EndHeight
	}
	return 0
}

func (m *GetTxsRequest) GetQuery() string {
	if m != nil {
		return m.Query
	}
	return ""
}

func (*GetTxsRequest) XXX_MessageName() string {
	return "rpcevents.GetTxsRequest"
}

type GetTxsResponse struct {
	Height               uint64              `protobuf:"varint,1,opt,name=Height,proto3" json:"Height,omitempty"`
	TxExecutions         []*exec.TxExecution `protobuf:"bytes,2,rep,name=TxExecutions,proto3" json:"TxExecutions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *GetTxsResponse) Reset()         { *m = GetTxsResponse{} }
func (m *GetTxsResponse) String() string { return proto.CompactTextString(m) }
func (*GetTxsResponse) ProtoMessage()    {}
func (*GetTxsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_580b21d8d2fd68e4, []int{5}
}
func (m *GetTxsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetTxsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetTxsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetTxsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetTxsResponse.Merge(m, src)
}
func (m *GetTxsResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetTxsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetTxsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetTxsResponse proto.InternalMessageInfo

func (m *GetTxsResponse) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *GetTxsResponse) GetTxExecutions() []*exec.TxExecution {
	if m != nil {
		return m.TxExecutions
	}
	return nil
}

func (*GetTxsResponse) XXX_MessageName() string {
	return "rpcevents.GetTxsResponse"
}

type Bound struct {
	Type                 Bound_BoundType `protobuf:"varint,1,opt,name=Type,proto3,enum=rpcevents.Bound_BoundType" json:"Type,omitempty"`
	Index                uint64          `protobuf:"varint,2,opt,name=Index,proto3" json:"Index,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *Bound) Reset()         { *m = Bound{} }
func (m *Bound) String() string { return proto.CompactTextString(m) }
func (*Bound) ProtoMessage()    {}
func (*Bound) Descriptor() ([]byte, []int) {
	return fileDescriptor_580b21d8d2fd68e4, []int{6}
}
func (m *Bound) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Bound) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Bound.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Bound) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Bound.Merge(m, src)
}
func (m *Bound) XXX_Size() int {
	return m.Size()
}
func (m *Bound) XXX_DiscardUnknown() {
	xxx_messageInfo_Bound.DiscardUnknown(m)
}

var xxx_messageInfo_Bound proto.InternalMessageInfo

func (m *Bound) GetType() Bound_BoundType {
	if m != nil {
		return m.Type
	}
	return Bound_ABSOLUTE
}

func (m *Bound) GetIndex() uint64 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (*Bound) XXX_MessageName() string {
	return "rpcevents.Bound"
}

// An inclusive range of blocks to include in output
type BlockRange struct {
	// Bounds can be set to:
	// absolute: block height
	// relative: block height counting back from latest
	// latest: latest block when call is processed
	// stream: for End keep sending new blocks, for start same as latest
	Start                *Bound   `protobuf:"bytes,1,opt,name=Start,proto3" json:"Start,omitempty"`
	End                  *Bound   `protobuf:"bytes,2,opt,name=End,proto3" json:"End,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BlockRange) Reset()         { *m = BlockRange{} }
func (m *BlockRange) String() string { return proto.CompactTextString(m) }
func (*BlockRange) ProtoMessage()    {}
func (*BlockRange) Descriptor() ([]byte, []int) {
	return fileDescriptor_580b21d8d2fd68e4, []int{7}
}
func (m *BlockRange) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockRange.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BlockRange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockRange.Merge(m, src)
}
func (m *BlockRange) XXX_Size() int {
	return m.Size()
}
func (m *BlockRange) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockRange.DiscardUnknown(m)
}

var xxx_messageInfo_BlockRange proto.InternalMessageInfo

func (m *BlockRange) GetStart() *Bound {
	if m != nil {
		return m.Start
	}
	return nil
}

func (m *BlockRange) GetEnd() *Bound {
	if m != nil {
		return m.End
	}
	return nil
}

func (*BlockRange) XXX_MessageName() string {
	return "rpcevents.BlockRange"
}
func init() {
	proto.RegisterEnum("rpcevents.Bound_BoundType", Bound_BoundType_name, Bound_BoundType_value)
	golang_proto.RegisterEnum("rpcevents.Bound_BoundType", Bound_BoundType_name, Bound_BoundType_value)
	proto.RegisterType((*GetBlockRequest)(nil), "rpcevents.GetBlockRequest")
	golang_proto.RegisterType((*GetBlockRequest)(nil), "rpcevents.GetBlockRequest")
	proto.RegisterType((*TxRequest)(nil), "rpcevents.TxRequest")
	golang_proto.RegisterType((*TxRequest)(nil), "rpcevents.TxRequest")
	proto.RegisterType((*BlocksRequest)(nil), "rpcevents.BlocksRequest")
	golang_proto.RegisterType((*BlocksRequest)(nil), "rpcevents.BlocksRequest")
	proto.RegisterType((*EventsResponse)(nil), "rpcevents.EventsResponse")
	golang_proto.RegisterType((*EventsResponse)(nil), "rpcevents.EventsResponse")
	proto.RegisterType((*GetTxsRequest)(nil), "rpcevents.GetTxsRequest")
	golang_proto.RegisterType((*GetTxsRequest)(nil), "rpcevents.GetTxsRequest")
	proto.RegisterType((*GetTxsResponse)(nil), "rpcevents.GetTxsResponse")
	golang_proto.RegisterType((*GetTxsResponse)(nil), "rpcevents.GetTxsResponse")
	proto.RegisterType((*Bound)(nil), "rpcevents.Bound")
	golang_proto.RegisterType((*Bound)(nil), "rpcevents.Bound")
	proto.RegisterType((*BlockRange)(nil), "rpcevents.BlockRange")
	golang_proto.RegisterType((*BlockRange)(nil), "rpcevents.BlockRange")
}

func init() { proto.RegisterFile("rpcevents.proto", fileDescriptor_580b21d8d2fd68e4) }
func init() { golang_proto.RegisterFile("rpcevents.proto", fileDescriptor_580b21d8d2fd68e4) }

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// ExecutionEventsClient is the client API for ExecutionEvents service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ExecutionEventsClient interface {
	// Get StreamEvents (including transactions) for a range of block heights
	Stream(ctx context.Context, in *BlocksRequest, opts ...grpc.CallOption) (ExecutionEvents_StreamClient, error)
	// Get a particular TxExecution by hash
	Tx(ctx context.Context, in *TxRequest, opts ...grpc.CallOption) (*exec.TxExecution, error)
	// GetEvents provides events streaming one block at a time - that is all events emitted in a particular block
	// are guaranteed to be delivered in each GetEventsResponse
	Events(ctx context.Context, in *BlocksRequest, opts ...grpc.CallOption) (ExecutionEvents_EventsClient, error)
}

type executionEventsClient struct {
	cc *grpc.ClientConn
}

func NewExecutionEventsClient(cc *grpc.ClientConn) ExecutionEventsClient {
	return &executionEventsClient{cc}
}

func (c *executionEventsClient) Stream(ctx context.Context, in *BlocksRequest, opts ...grpc.CallOption) (ExecutionEvents_StreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ExecutionEvents_serviceDesc.Streams[0], "/rpcevents.ExecutionEvents/Stream", opts...)
	if err != nil {
		return nil, err
	}
	x := &executionEventsStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ExecutionEvents_StreamClient interface {
	Recv() (*exec.StreamEvent, error)
	grpc.ClientStream
}

type executionEventsStreamClient struct {
	grpc.ClientStream
}

func (x *executionEventsStreamClient) Recv() (*exec.StreamEvent, error) {
	m := new(exec.StreamEvent)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *executionEventsClient) Tx(ctx context.Context, in *TxRequest, opts ...grpc.CallOption) (*exec.TxExecution, error) {
	out := new(exec.TxExecution)
	err := c.cc.Invoke(ctx, "/rpcevents.ExecutionEvents/Tx", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *executionEventsClient) Events(ctx context.Context, in *BlocksRequest, opts ...grpc.CallOption) (ExecutionEvents_EventsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ExecutionEvents_serviceDesc.Streams[1], "/rpcevents.ExecutionEvents/Events", opts...)
	if err != nil {
		return nil, err
	}
	x := &executionEventsEventsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ExecutionEvents_EventsClient interface {
	Recv() (*EventsResponse, error)
	grpc.ClientStream
}

type executionEventsEventsClient struct {
	grpc.ClientStream
}

func (x *executionEventsEventsClient) Recv() (*EventsResponse, error) {
	m := new(EventsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// ExecutionEventsServer is the server API for ExecutionEvents service.
type ExecutionEventsServer interface {
	// Get StreamEvents (including transactions) for a range of block heights
	Stream(*BlocksRequest, ExecutionEvents_StreamServer) error
	// Get a particular TxExecution by hash
	Tx(context.Context, *TxRequest) (*exec.TxExecution, error)
	// GetEvents provides events streaming one block at a time - that is all events emitted in a particular block
	// are guaranteed to be delivered in each GetEventsResponse
	Events(*BlocksRequest, ExecutionEvents_EventsServer) error
}

func RegisterExecutionEventsServer(s *grpc.Server, srv ExecutionEventsServer) {
	s.RegisterService(&_ExecutionEvents_serviceDesc, srv)
}

func _ExecutionEvents_Stream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(BlocksRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ExecutionEventsServer).Stream(m, &executionEventsStreamServer{stream})
}

type ExecutionEvents_StreamServer interface {
	Send(*exec.StreamEvent) error
	grpc.ServerStream
}

type executionEventsStreamServer struct {
	grpc.ServerStream
}

func (x *executionEventsStreamServer) Send(m *exec.StreamEvent) error {
	return x.ServerStream.SendMsg(m)
}

func _ExecutionEvents_Tx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TxRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExecutionEventsServer).Tx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcevents.ExecutionEvents/Tx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExecutionEventsServer).Tx(ctx, req.(*TxRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ExecutionEvents_Events_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(BlocksRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ExecutionEventsServer).Events(m, &executionEventsEventsServer{stream})
}

type ExecutionEvents_EventsServer interface {
	Send(*EventsResponse) error
	grpc.ServerStream
}

type executionEventsEventsServer struct {
	grpc.ServerStream
}

func (x *executionEventsEventsServer) Send(m *EventsResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _ExecutionEvents_serviceDesc = grpc.ServiceDesc{
	ServiceName: "rpcevents.ExecutionEvents",
	HandlerType: (*ExecutionEventsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Tx",
			Handler:    _ExecutionEvents_Tx_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Stream",
			Handler:       _ExecutionEvents_Stream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Events",
			Handler:       _ExecutionEvents_Events_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "rpcevents.proto",
}

func (m *GetBlockRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetBlockRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Height != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRpcevents(dAtA, i, uint64(m.Height))
	}
	if m.Wait {
		dAtA[i] = 0x10
		i++
		if m.Wait {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *TxRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TxRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintRpcevents(dAtA, i, uint64(m.TxHash.Size()))
	n1, err := m.TxHash.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n1
	if m.Wait {
		dAtA[i] = 0x10
		i++
		if m.Wait {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *BlocksRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BlocksRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.BlockRange != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRpcevents(dAtA, i, uint64(m.BlockRange.Size()))
		n2, err := m.BlockRange.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if len(m.Query) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRpcevents(dAtA, i, uint64(len(m.Query)))
		i += copy(dAtA[i:], m.Query)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *EventsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EventsResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Height != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRpcevents(dAtA, i, uint64(m.Height))
	}
	if len(m.Events) > 0 {
		for _, msg := range m.Events {
			dAtA[i] = 0x12
			i++
			i = encodeVarintRpcevents(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetTxsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetTxsRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.StartHeight != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRpcevents(dAtA, i, uint64(m.StartHeight))
	}
	if m.EndHeight != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintRpcevents(dAtA, i, uint64(m.EndHeight))
	}
	if len(m.Query) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintRpcevents(dAtA, i, uint64(len(m.Query)))
		i += copy(dAtA[i:], m.Query)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetTxsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetTxsResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Height != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRpcevents(dAtA, i, uint64(m.Height))
	}
	if len(m.TxExecutions) > 0 {
		for _, msg := range m.TxExecutions {
			dAtA[i] = 0x12
			i++
			i = encodeVarintRpcevents(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Bound) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Bound) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRpcevents(dAtA, i, uint64(m.Type))
	}
	if m.Index != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintRpcevents(dAtA, i, uint64(m.Index))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *BlockRange) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BlockRange) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Start != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRpcevents(dAtA, i, uint64(m.Start.Size()))
		n3, err := m.Start.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.End != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRpcevents(dAtA, i, uint64(m.End.Size()))
		n4, err := m.End.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintRpcevents(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *GetBlockRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovRpcevents(uint64(m.Height))
	}
	if m.Wait {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.TxHash.Size()
	n += 1 + l + sovRpcevents(uint64(l))
	if m.Wait {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BlocksRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockRange != nil {
		l = m.BlockRange.Size()
		n += 1 + l + sovRpcevents(uint64(l))
	}
	l = len(m.Query)
	if l > 0 {
		n += 1 + l + sovRpcevents(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EventsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovRpcevents(uint64(m.Height))
	}
	if len(m.Events) > 0 {
		for _, e := range m.Events {
			l = e.Size()
			n += 1 + l + sovRpcevents(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetTxsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StartHeight != 0 {
		n += 1 + sovRpcevents(uint64(m.StartHeight))
	}
	if m.EndHeight != 0 {
		n += 1 + sovRpcevents(uint64(m.EndHeight))
	}
	l = len(m.Query)
	if l > 0 {
		n += 1 + l + sovRpcevents(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetTxsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovRpcevents(uint64(m.Height))
	}
	if len(m.TxExecutions) > 0 {
		for _, e := range m.TxExecutions {
			l = e.Size()
			n += 1 + l + sovRpcevents(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Bound) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovRpcevents(uint64(m.Type))
	}
	if m.Index != 0 {
		n += 1 + sovRpcevents(uint64(m.Index))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BlockRange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Start != nil {
		l = m.Start.Size()
		n += 1 + l + sovRpcevents(uint64(l))
	}
	if m.End != nil {
		l = m.End.Size()
		n += 1 + l + sovRpcevents(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovRpcevents(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozRpcevents(x uint64) (n int) {
	return sovRpcevents(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GetBlockRequest) 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 ErrIntOverflowRpcevents
			}
			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: GetBlockRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetBlockRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Wait", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Wait = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipRpcevents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TxRequest) 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 ErrIntOverflowRpcevents
			}
			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: TxRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TxRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRpcevents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRpcevents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TxHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Wait", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Wait = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipRpcevents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlocksRequest) 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 ErrIntOverflowRpcevents
			}
			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: BlocksRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlocksRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockRange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRpcevents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRpcevents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BlockRange == nil {
				m.BlockRange = &BlockRange{}
			}
			if err := m.BlockRange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				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 ErrInvalidLengthRpcevents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRpcevents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Query = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRpcevents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventsResponse) 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 ErrIntOverflowRpcevents
			}
			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: EventsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRpcevents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRpcevents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Events = append(m.Events, &exec.Event{})
			if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRpcevents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetTxsRequest) 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 ErrIntOverflowRpcevents
			}
			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: GetTxsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetTxsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType)
			}
			m.StartHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartHeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndHeight", wireType)
			}
			m.EndHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EndHeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				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 ErrInvalidLengthRpcevents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRpcevents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Query = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRpcevents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetTxsResponse) 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 ErrIntOverflowRpcevents
			}
			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: GetTxsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetTxsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxExecutions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRpcevents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRpcevents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxExecutions = append(m.TxExecutions, &exec.TxExecution{})
			if err := m.TxExecutions[len(m.TxExecutions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRpcevents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Bound) 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 ErrIntOverflowRpcevents
			}
			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: Bound: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Bound: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= Bound_BoundType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRpcevents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockRange) 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 ErrIntOverflowRpcevents
			}
			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: BlockRange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockRange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRpcevents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRpcevents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Start == nil {
				m.Start = &Bound{}
			}
			if err := m.Start.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRpcevents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRpcevents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.End == nil {
				m.End = &Bound{}
			}
			if err := m.End.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRpcevents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRpcevents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipRpcevents(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowRpcevents
			}
			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, ErrIntOverflowRpcevents
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowRpcevents
				}
				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, ErrInvalidLengthRpcevents
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthRpcevents
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowRpcevents
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipRpcevents(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthRpcevents
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthRpcevents = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRpcevents   = fmt.Errorf("proto: integer overflow")
)