events.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: provenance/metadata/v1/events.proto

package types

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// EventTxCompleted is an event message indicating that a TX has completed.
type EventTxCompleted struct {
	// module is the module the TX belongs to.
	Module string `protobuf:"bytes,1,opt,name=module,proto3" json:"module,omitempty"`
	// endpoint is the rpc endpoint that was just completed.
	Endpoint string `protobuf:"bytes,2,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
	// signers are the bech32 address strings of the signers of this TX.
	Signers []string `protobuf:"bytes,3,rep,name=signers,proto3" json:"signers,omitempty"`
}

func (m *EventTxCompleted) Reset()         { *m = EventTxCompleted{} }
func (m *EventTxCompleted) String() string { return proto.CompactTextString(m) }
func (*EventTxCompleted) ProtoMessage()    {}
func (*EventTxCompleted) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{0}
}
func (m *EventTxCompleted) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventTxCompleted) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventTxCompleted.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 *EventTxCompleted) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventTxCompleted.Merge(m, src)
}
func (m *EventTxCompleted) XXX_Size() int {
	return m.Size()
}
func (m *EventTxCompleted) XXX_DiscardUnknown() {
	xxx_messageInfo_EventTxCompleted.DiscardUnknown(m)
}

var xxx_messageInfo_EventTxCompleted proto.InternalMessageInfo

func (m *EventTxCompleted) GetModule() string {
	if m != nil {
		return m.Module
	}
	return ""
}

func (m *EventTxCompleted) GetEndpoint() string {
	if m != nil {
		return m.Endpoint
	}
	return ""
}

func (m *EventTxCompleted) GetSigners() []string {
	if m != nil {
		return m.Signers
	}
	return nil
}

// EventScopeCreated is an event message indicating a scope has been created.
type EventScopeCreated struct {
	// scope_addr is the bech32 address string of the scope id that was created.
	ScopeAddr string `protobuf:"bytes,1,opt,name=scope_addr,json=scopeAddr,proto3" json:"scope_addr,omitempty"`
}

func (m *EventScopeCreated) Reset()         { *m = EventScopeCreated{} }
func (m *EventScopeCreated) String() string { return proto.CompactTextString(m) }
func (*EventScopeCreated) ProtoMessage()    {}
func (*EventScopeCreated) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{1}
}
func (m *EventScopeCreated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventScopeCreated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventScopeCreated.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 *EventScopeCreated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventScopeCreated.Merge(m, src)
}
func (m *EventScopeCreated) XXX_Size() int {
	return m.Size()
}
func (m *EventScopeCreated) XXX_DiscardUnknown() {
	xxx_messageInfo_EventScopeCreated.DiscardUnknown(m)
}

var xxx_messageInfo_EventScopeCreated proto.InternalMessageInfo

func (m *EventScopeCreated) GetScopeAddr() string {
	if m != nil {
		return m.ScopeAddr
	}
	return ""
}

// EventScopeUpdated is an event message indicating a scope has been updated.
type EventScopeUpdated struct {
	// scope_addr is the bech32 address string of the scope id that was updated.
	ScopeAddr string `protobuf:"bytes,1,opt,name=scope_addr,json=scopeAddr,proto3" json:"scope_addr,omitempty"`
}

func (m *EventScopeUpdated) Reset()         { *m = EventScopeUpdated{} }
func (m *EventScopeUpdated) String() string { return proto.CompactTextString(m) }
func (*EventScopeUpdated) ProtoMessage()    {}
func (*EventScopeUpdated) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{2}
}
func (m *EventScopeUpdated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventScopeUpdated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventScopeUpdated.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 *EventScopeUpdated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventScopeUpdated.Merge(m, src)
}
func (m *EventScopeUpdated) XXX_Size() int {
	return m.Size()
}
func (m *EventScopeUpdated) XXX_DiscardUnknown() {
	xxx_messageInfo_EventScopeUpdated.DiscardUnknown(m)
}

var xxx_messageInfo_EventScopeUpdated proto.InternalMessageInfo

func (m *EventScopeUpdated) GetScopeAddr() string {
	if m != nil {
		return m.ScopeAddr
	}
	return ""
}

// EventScopeDeleted is an event message indicating a scope has been deleted.
type EventScopeDeleted struct {
	// scope_addr is the bech32 address string of the scope id that was deleted.
	ScopeAddr string `protobuf:"bytes,1,opt,name=scope_addr,json=scopeAddr,proto3" json:"scope_addr,omitempty"`
}

func (m *EventScopeDeleted) Reset()         { *m = EventScopeDeleted{} }
func (m *EventScopeDeleted) String() string { return proto.CompactTextString(m) }
func (*EventScopeDeleted) ProtoMessage()    {}
func (*EventScopeDeleted) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{3}
}
func (m *EventScopeDeleted) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventScopeDeleted) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventScopeDeleted.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 *EventScopeDeleted) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventScopeDeleted.Merge(m, src)
}
func (m *EventScopeDeleted) XXX_Size() int {
	return m.Size()
}
func (m *EventScopeDeleted) XXX_DiscardUnknown() {
	xxx_messageInfo_EventScopeDeleted.DiscardUnknown(m)
}

var xxx_messageInfo_EventScopeDeleted proto.InternalMessageInfo

func (m *EventScopeDeleted) GetScopeAddr() string {
	if m != nil {
		return m.ScopeAddr
	}
	return ""
}

// EventSessionCreated is an event message indicating a session has been created.
type EventSessionCreated struct {
	// session_addr is the bech32 address string of the session id that was created.
	SessionAddr string `protobuf:"bytes,1,opt,name=session_addr,json=sessionAddr,proto3" json:"session_addr,omitempty"`
	// scope_addr is the bech32 address string of the scope id this session belongs to.
	ScopeAddr string `protobuf:"bytes,2,opt,name=scope_addr,json=scopeAddr,proto3" json:"scope_addr,omitempty"`
}

func (m *EventSessionCreated) Reset()         { *m = EventSessionCreated{} }
func (m *EventSessionCreated) String() string { return proto.CompactTextString(m) }
func (*EventSessionCreated) ProtoMessage()    {}
func (*EventSessionCreated) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{4}
}
func (m *EventSessionCreated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventSessionCreated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventSessionCreated.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 *EventSessionCreated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventSessionCreated.Merge(m, src)
}
func (m *EventSessionCreated) XXX_Size() int {
	return m.Size()
}
func (m *EventSessionCreated) XXX_DiscardUnknown() {
	xxx_messageInfo_EventSessionCreated.DiscardUnknown(m)
}

var xxx_messageInfo_EventSessionCreated proto.InternalMessageInfo

func (m *EventSessionCreated) GetSessionAddr() string {
	if m != nil {
		return m.SessionAddr
	}
	return ""
}

func (m *EventSessionCreated) GetScopeAddr() string {
	if m != nil {
		return m.ScopeAddr
	}
	return ""
}

// EventSessionUpdated is an event message indicating a session has been updated.
type EventSessionUpdated struct {
	// session_addr is the bech32 address string of the session id that was updated.
	SessionAddr string `protobuf:"bytes,1,opt,name=session_addr,json=sessionAddr,proto3" json:"session_addr,omitempty"`
	// scope_addr is the bech32 address string of the scope id this session belongs to.
	ScopeAddr string `protobuf:"bytes,2,opt,name=scope_addr,json=scopeAddr,proto3" json:"scope_addr,omitempty"`
}

func (m *EventSessionUpdated) Reset()         { *m = EventSessionUpdated{} }
func (m *EventSessionUpdated) String() string { return proto.CompactTextString(m) }
func (*EventSessionUpdated) ProtoMessage()    {}
func (*EventSessionUpdated) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{5}
}
func (m *EventSessionUpdated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventSessionUpdated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventSessionUpdated.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 *EventSessionUpdated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventSessionUpdated.Merge(m, src)
}
func (m *EventSessionUpdated) XXX_Size() int {
	return m.Size()
}
func (m *EventSessionUpdated) XXX_DiscardUnknown() {
	xxx_messageInfo_EventSessionUpdated.DiscardUnknown(m)
}

var xxx_messageInfo_EventSessionUpdated proto.InternalMessageInfo

func (m *EventSessionUpdated) GetSessionAddr() string {
	if m != nil {
		return m.SessionAddr
	}
	return ""
}

func (m *EventSessionUpdated) GetScopeAddr() string {
	if m != nil {
		return m.ScopeAddr
	}
	return ""
}

// EventSessionDeleted is an event message indicating a session has been deleted.
type EventSessionDeleted struct {
	// session_addr is the bech32 address string of the session id that was deleted.
	SessionAddr string `protobuf:"bytes,1,opt,name=session_addr,json=sessionAddr,proto3" json:"session_addr,omitempty"`
	// scope_addr is the bech32 address string of the scope id this session belongs to.
	ScopeAddr string `protobuf:"bytes,2,opt,name=scope_addr,json=scopeAddr,proto3" json:"scope_addr,omitempty"`
}

func (m *EventSessionDeleted) Reset()         { *m = EventSessionDeleted{} }
func (m *EventSessionDeleted) String() string { return proto.CompactTextString(m) }
func (*EventSessionDeleted) ProtoMessage()    {}
func (*EventSessionDeleted) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{6}
}
func (m *EventSessionDeleted) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventSessionDeleted) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventSessionDeleted.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 *EventSessionDeleted) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventSessionDeleted.Merge(m, src)
}
func (m *EventSessionDeleted) XXX_Size() int {
	return m.Size()
}
func (m *EventSessionDeleted) XXX_DiscardUnknown() {
	xxx_messageInfo_EventSessionDeleted.DiscardUnknown(m)
}

var xxx_messageInfo_EventSessionDeleted proto.InternalMessageInfo

func (m *EventSessionDeleted) GetSessionAddr() string {
	if m != nil {
		return m.SessionAddr
	}
	return ""
}

func (m *EventSessionDeleted) GetScopeAddr() string {
	if m != nil {
		return m.ScopeAddr
	}
	return ""
}

// EventRecordCreated is an event message indicating a record has been created.
type EventRecordCreated struct {
	// record_addr is the bech32 address string of the record id that was created.
	RecordAddr string `protobuf:"bytes,1,opt,name=record_addr,json=recordAddr,proto3" json:"record_addr,omitempty"`
	// session_addr is the bech32 address string of the session id this record belongs to.
	SessionAddr string `protobuf:"bytes,2,opt,name=session_addr,json=sessionAddr,proto3" json:"session_addr,omitempty"`
	// scope_addr is the bech32 address string of the scope id this record belongs to.
	ScopeAddr string `protobuf:"bytes,3,opt,name=scope_addr,json=scopeAddr,proto3" json:"scope_addr,omitempty"`
}

func (m *EventRecordCreated) Reset()         { *m = EventRecordCreated{} }
func (m *EventRecordCreated) String() string { return proto.CompactTextString(m) }
func (*EventRecordCreated) ProtoMessage()    {}
func (*EventRecordCreated) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{7}
}
func (m *EventRecordCreated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventRecordCreated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventRecordCreated.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 *EventRecordCreated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventRecordCreated.Merge(m, src)
}
func (m *EventRecordCreated) XXX_Size() int {
	return m.Size()
}
func (m *EventRecordCreated) XXX_DiscardUnknown() {
	xxx_messageInfo_EventRecordCreated.DiscardUnknown(m)
}

var xxx_messageInfo_EventRecordCreated proto.InternalMessageInfo

func (m *EventRecordCreated) GetRecordAddr() string {
	if m != nil {
		return m.RecordAddr
	}
	return ""
}

func (m *EventRecordCreated) GetSessionAddr() string {
	if m != nil {
		return m.SessionAddr
	}
	return ""
}

func (m *EventRecordCreated) GetScopeAddr() string {
	if m != nil {
		return m.ScopeAddr
	}
	return ""
}

// EventRecordUpdated is an event message indicating a record has been updated.
type EventRecordUpdated struct {
	// record_addr is the bech32 address string of the record id that was updated.
	RecordAddr string `protobuf:"bytes,1,opt,name=record_addr,json=recordAddr,proto3" json:"record_addr,omitempty"`
	// session_addr is the bech32 address string of the session id this record belongs to.
	SessionAddr string `protobuf:"bytes,2,opt,name=session_addr,json=sessionAddr,proto3" json:"session_addr,omitempty"`
	// scope_addr is the bech32 address string of the scope id this record belongs to.
	ScopeAddr string `protobuf:"bytes,3,opt,name=scope_addr,json=scopeAddr,proto3" json:"scope_addr,omitempty"`
}

func (m *EventRecordUpdated) Reset()         { *m = EventRecordUpdated{} }
func (m *EventRecordUpdated) String() string { return proto.CompactTextString(m) }
func (*EventRecordUpdated) ProtoMessage()    {}
func (*EventRecordUpdated) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{8}
}
func (m *EventRecordUpdated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventRecordUpdated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventRecordUpdated.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 *EventRecordUpdated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventRecordUpdated.Merge(m, src)
}
func (m *EventRecordUpdated) XXX_Size() int {
	return m.Size()
}
func (m *EventRecordUpdated) XXX_DiscardUnknown() {
	xxx_messageInfo_EventRecordUpdated.DiscardUnknown(m)
}

var xxx_messageInfo_EventRecordUpdated proto.InternalMessageInfo

func (m *EventRecordUpdated) GetRecordAddr() string {
	if m != nil {
		return m.RecordAddr
	}
	return ""
}

func (m *EventRecordUpdated) GetSessionAddr() string {
	if m != nil {
		return m.SessionAddr
	}
	return ""
}

func (m *EventRecordUpdated) GetScopeAddr() string {
	if m != nil {
		return m.ScopeAddr
	}
	return ""
}

// EventRecordDeleted is an event message indicating a record has been deleted.
type EventRecordDeleted struct {
	// record is the bech32 address string of the record id that was deleted.
	RecordAddr string `protobuf:"bytes,1,opt,name=record_addr,json=recordAddr,proto3" json:"record_addr,omitempty"`
	// scope_addr is the bech32 address string of the scope id this record belonged to.
	ScopeAddr string `protobuf:"bytes,3,opt,name=scope_addr,json=scopeAddr,proto3" json:"scope_addr,omitempty"`
}

func (m *EventRecordDeleted) Reset()         { *m = EventRecordDeleted{} }
func (m *EventRecordDeleted) String() string { return proto.CompactTextString(m) }
func (*EventRecordDeleted) ProtoMessage()    {}
func (*EventRecordDeleted) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{9}
}
func (m *EventRecordDeleted) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventRecordDeleted) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventRecordDeleted.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 *EventRecordDeleted) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventRecordDeleted.Merge(m, src)
}
func (m *EventRecordDeleted) XXX_Size() int {
	return m.Size()
}
func (m *EventRecordDeleted) XXX_DiscardUnknown() {
	xxx_messageInfo_EventRecordDeleted.DiscardUnknown(m)
}

var xxx_messageInfo_EventRecordDeleted proto.InternalMessageInfo

func (m *EventRecordDeleted) GetRecordAddr() string {
	if m != nil {
		return m.RecordAddr
	}
	return ""
}

func (m *EventRecordDeleted) GetScopeAddr() string {
	if m != nil {
		return m.ScopeAddr
	}
	return ""
}

// EventScopeSpecificationCreated is an event message indicating a scope specification has been created.
type EventScopeSpecificationCreated struct {
	// scope_specification_addr is the bech32 address string of the specification id of the scope specification that was
	// created.
	ScopeSpecificationAddr string `protobuf:"bytes,1,opt,name=scope_specification_addr,json=scopeSpecificationAddr,proto3" json:"scope_specification_addr,omitempty"`
}

func (m *EventScopeSpecificationCreated) Reset()         { *m = EventScopeSpecificationCreated{} }
func (m *EventScopeSpecificationCreated) String() string { return proto.CompactTextString(m) }
func (*EventScopeSpecificationCreated) ProtoMessage()    {}
func (*EventScopeSpecificationCreated) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{10}
}
func (m *EventScopeSpecificationCreated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventScopeSpecificationCreated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventScopeSpecificationCreated.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 *EventScopeSpecificationCreated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventScopeSpecificationCreated.Merge(m, src)
}
func (m *EventScopeSpecificationCreated) XXX_Size() int {
	return m.Size()
}
func (m *EventScopeSpecificationCreated) XXX_DiscardUnknown() {
	xxx_messageInfo_EventScopeSpecificationCreated.DiscardUnknown(m)
}

var xxx_messageInfo_EventScopeSpecificationCreated proto.InternalMessageInfo

func (m *EventScopeSpecificationCreated) GetScopeSpecificationAddr() string {
	if m != nil {
		return m.ScopeSpecificationAddr
	}
	return ""
}

// EventScopeSpecificationUpdated is an event message indicating a scope specification has been updated.
type EventScopeSpecificationUpdated struct {
	// scope_specification_addr is the bech32 address string of the specification id of the scope specification that was
	// updated.
	ScopeSpecificationAddr string `protobuf:"bytes,1,opt,name=scope_specification_addr,json=scopeSpecificationAddr,proto3" json:"scope_specification_addr,omitempty"`
}

func (m *EventScopeSpecificationUpdated) Reset()         { *m = EventScopeSpecificationUpdated{} }
func (m *EventScopeSpecificationUpdated) String() string { return proto.CompactTextString(m) }
func (*EventScopeSpecificationUpdated) ProtoMessage()    {}
func (*EventScopeSpecificationUpdated) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{11}
}
func (m *EventScopeSpecificationUpdated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventScopeSpecificationUpdated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventScopeSpecificationUpdated.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 *EventScopeSpecificationUpdated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventScopeSpecificationUpdated.Merge(m, src)
}
func (m *EventScopeSpecificationUpdated) XXX_Size() int {
	return m.Size()
}
func (m *EventScopeSpecificationUpdated) XXX_DiscardUnknown() {
	xxx_messageInfo_EventScopeSpecificationUpdated.DiscardUnknown(m)
}

var xxx_messageInfo_EventScopeSpecificationUpdated proto.InternalMessageInfo

func (m *EventScopeSpecificationUpdated) GetScopeSpecificationAddr() string {
	if m != nil {
		return m.ScopeSpecificationAddr
	}
	return ""
}

// EventScopeSpecificationDeleted is an event message indicating a scope specification has been deleted.
type EventScopeSpecificationDeleted struct {
	// scope_specification_addr is the bech32 address string of the specification id of the scope specification that was
	// deleted.
	ScopeSpecificationAddr string `protobuf:"bytes,1,opt,name=scope_specification_addr,json=scopeSpecificationAddr,proto3" json:"scope_specification_addr,omitempty"`
}

func (m *EventScopeSpecificationDeleted) Reset()         { *m = EventScopeSpecificationDeleted{} }
func (m *EventScopeSpecificationDeleted) String() string { return proto.CompactTextString(m) }
func (*EventScopeSpecificationDeleted) ProtoMessage()    {}
func (*EventScopeSpecificationDeleted) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{12}
}
func (m *EventScopeSpecificationDeleted) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventScopeSpecificationDeleted) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventScopeSpecificationDeleted.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 *EventScopeSpecificationDeleted) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventScopeSpecificationDeleted.Merge(m, src)
}
func (m *EventScopeSpecificationDeleted) XXX_Size() int {
	return m.Size()
}
func (m *EventScopeSpecificationDeleted) XXX_DiscardUnknown() {
	xxx_messageInfo_EventScopeSpecificationDeleted.DiscardUnknown(m)
}

var xxx_messageInfo_EventScopeSpecificationDeleted proto.InternalMessageInfo

func (m *EventScopeSpecificationDeleted) GetScopeSpecificationAddr() string {
	if m != nil {
		return m.ScopeSpecificationAddr
	}
	return ""
}

// EventContractSpecificationCreated is an event message indicating a contract specification has been created.
type EventContractSpecificationCreated struct {
	// contract_specification_addr is the bech32 address string of the specification id of the contract specification that
	// was created.
	ContractSpecificationAddr string `protobuf:"bytes,1,opt,name=contract_specification_addr,json=contractSpecificationAddr,proto3" json:"contract_specification_addr,omitempty"`
}

func (m *EventContractSpecificationCreated) Reset()         { *m = EventContractSpecificationCreated{} }
func (m *EventContractSpecificationCreated) String() string { return proto.CompactTextString(m) }
func (*EventContractSpecificationCreated) ProtoMessage()    {}
func (*EventContractSpecificationCreated) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{13}
}
func (m *EventContractSpecificationCreated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventContractSpecificationCreated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventContractSpecificationCreated.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 *EventContractSpecificationCreated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventContractSpecificationCreated.Merge(m, src)
}
func (m *EventContractSpecificationCreated) XXX_Size() int {
	return m.Size()
}
func (m *EventContractSpecificationCreated) XXX_DiscardUnknown() {
	xxx_messageInfo_EventContractSpecificationCreated.DiscardUnknown(m)
}

var xxx_messageInfo_EventContractSpecificationCreated proto.InternalMessageInfo

func (m *EventContractSpecificationCreated) GetContractSpecificationAddr() string {
	if m != nil {
		return m.ContractSpecificationAddr
	}
	return ""
}

// EventContractSpecificationUpdated is an event message indicating a contract specification has been updated.
type EventContractSpecificationUpdated struct {
	// contract_specification_addr is the bech32 address string of the specification id of the contract specification that
	// was updated.
	ContractSpecificationAddr string `protobuf:"bytes,1,opt,name=contract_specification_addr,json=contractSpecificationAddr,proto3" json:"contract_specification_addr,omitempty"`
}

func (m *EventContractSpecificationUpdated) Reset()         { *m = EventContractSpecificationUpdated{} }
func (m *EventContractSpecificationUpdated) String() string { return proto.CompactTextString(m) }
func (*EventContractSpecificationUpdated) ProtoMessage()    {}
func (*EventContractSpecificationUpdated) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{14}
}
func (m *EventContractSpecificationUpdated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventContractSpecificationUpdated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventContractSpecificationUpdated.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 *EventContractSpecificationUpdated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventContractSpecificationUpdated.Merge(m, src)
}
func (m *EventContractSpecificationUpdated) XXX_Size() int {
	return m.Size()
}
func (m *EventContractSpecificationUpdated) XXX_DiscardUnknown() {
	xxx_messageInfo_EventContractSpecificationUpdated.DiscardUnknown(m)
}

var xxx_messageInfo_EventContractSpecificationUpdated proto.InternalMessageInfo

func (m *EventContractSpecificationUpdated) GetContractSpecificationAddr() string {
	if m != nil {
		return m.ContractSpecificationAddr
	}
	return ""
}

// EventContractSpecificationDeleted is an event message indicating a contract specification has been deleted.
type EventContractSpecificationDeleted struct {
	// contract_specification_addr is the bech32 address string of the specification id of the contract specification that
	// was deleted.
	ContractSpecificationAddr string `protobuf:"bytes,1,opt,name=contract_specification_addr,json=contractSpecificationAddr,proto3" json:"contract_specification_addr,omitempty"`
}

func (m *EventContractSpecificationDeleted) Reset()         { *m = EventContractSpecificationDeleted{} }
func (m *EventContractSpecificationDeleted) String() string { return proto.CompactTextString(m) }
func (*EventContractSpecificationDeleted) ProtoMessage()    {}
func (*EventContractSpecificationDeleted) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{15}
}
func (m *EventContractSpecificationDeleted) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventContractSpecificationDeleted) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventContractSpecificationDeleted.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 *EventContractSpecificationDeleted) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventContractSpecificationDeleted.Merge(m, src)
}
func (m *EventContractSpecificationDeleted) XXX_Size() int {
	return m.Size()
}
func (m *EventContractSpecificationDeleted) XXX_DiscardUnknown() {
	xxx_messageInfo_EventContractSpecificationDeleted.DiscardUnknown(m)
}

var xxx_messageInfo_EventContractSpecificationDeleted proto.InternalMessageInfo

func (m *EventContractSpecificationDeleted) GetContractSpecificationAddr() string {
	if m != nil {
		return m.ContractSpecificationAddr
	}
	return ""
}

// EventRecordSpecificationCreated is an event message indicating a record specification has been created.
type EventRecordSpecificationCreated struct {
	// record_specification_addr is the bech32 address string of the specification id of the record specification that was
	// created.
	RecordSpecificationAddr string `protobuf:"bytes,1,opt,name=record_specification_addr,json=recordSpecificationAddr,proto3" json:"record_specification_addr,omitempty"`
	// contract_specification_addr is the bech32 address string of the contract specification id this record specification
	// belongs to.
	ContractSpecificationAddr string `protobuf:"bytes,2,opt,name=contract_specification_addr,json=contractSpecificationAddr,proto3" json:"contract_specification_addr,omitempty"`
}

func (m *EventRecordSpecificationCreated) Reset()         { *m = EventRecordSpecificationCreated{} }
func (m *EventRecordSpecificationCreated) String() string { return proto.CompactTextString(m) }
func (*EventRecordSpecificationCreated) ProtoMessage()    {}
func (*EventRecordSpecificationCreated) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{16}
}
func (m *EventRecordSpecificationCreated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventRecordSpecificationCreated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventRecordSpecificationCreated.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 *EventRecordSpecificationCreated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventRecordSpecificationCreated.Merge(m, src)
}
func (m *EventRecordSpecificationCreated) XXX_Size() int {
	return m.Size()
}
func (m *EventRecordSpecificationCreated) XXX_DiscardUnknown() {
	xxx_messageInfo_EventRecordSpecificationCreated.DiscardUnknown(m)
}

var xxx_messageInfo_EventRecordSpecificationCreated proto.InternalMessageInfo

func (m *EventRecordSpecificationCreated) GetRecordSpecificationAddr() string {
	if m != nil {
		return m.RecordSpecificationAddr
	}
	return ""
}

func (m *EventRecordSpecificationCreated) GetContractSpecificationAddr() string {
	if m != nil {
		return m.ContractSpecificationAddr
	}
	return ""
}

// EventRecordSpecificationUpdated is an event message indicating a record specification has been updated.
type EventRecordSpecificationUpdated struct {
	// record_specification_addr is the bech32 address string of the specification id of the record specification that was
	// updated.
	RecordSpecificationAddr string `protobuf:"bytes,1,opt,name=record_specification_addr,json=recordSpecificationAddr,proto3" json:"record_specification_addr,omitempty"`
	// contract_specification_addr is the bech32 address string of the contract specification id this record specification
	// belongs to.
	ContractSpecificationAddr string `protobuf:"bytes,2,opt,name=contract_specification_addr,json=contractSpecificationAddr,proto3" json:"contract_specification_addr,omitempty"`
}

func (m *EventRecordSpecificationUpdated) Reset()         { *m = EventRecordSpecificationUpdated{} }
func (m *EventRecordSpecificationUpdated) String() string { return proto.CompactTextString(m) }
func (*EventRecordSpecificationUpdated) ProtoMessage()    {}
func (*EventRecordSpecificationUpdated) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{17}
}
func (m *EventRecordSpecificationUpdated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventRecordSpecificationUpdated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventRecordSpecificationUpdated.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 *EventRecordSpecificationUpdated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventRecordSpecificationUpdated.Merge(m, src)
}
func (m *EventRecordSpecificationUpdated) XXX_Size() int {
	return m.Size()
}
func (m *EventRecordSpecificationUpdated) XXX_DiscardUnknown() {
	xxx_messageInfo_EventRecordSpecificationUpdated.DiscardUnknown(m)
}

var xxx_messageInfo_EventRecordSpecificationUpdated proto.InternalMessageInfo

func (m *EventRecordSpecificationUpdated) GetRecordSpecificationAddr() string {
	if m != nil {
		return m.RecordSpecificationAddr
	}
	return ""
}

func (m *EventRecordSpecificationUpdated) GetContractSpecificationAddr() string {
	if m != nil {
		return m.ContractSpecificationAddr
	}
	return ""
}

// EventRecordSpecificationDeleted is an event message indicating a record specification has been deleted.
type EventRecordSpecificationDeleted struct {
	// record_specification_addr is the bech32 address string of the specification id of the record specification that was
	// deleted.
	RecordSpecificationAddr string `protobuf:"bytes,1,opt,name=record_specification_addr,json=recordSpecificationAddr,proto3" json:"record_specification_addr,omitempty"`
	// contract_specification_addr is the bech32 address string of the contract specification id this record specification
	// belongs to.
	ContractSpecificationAddr string `protobuf:"bytes,2,opt,name=contract_specification_addr,json=contractSpecificationAddr,proto3" json:"contract_specification_addr,omitempty"`
}

func (m *EventRecordSpecificationDeleted) Reset()         { *m = EventRecordSpecificationDeleted{} }
func (m *EventRecordSpecificationDeleted) String() string { return proto.CompactTextString(m) }
func (*EventRecordSpecificationDeleted) ProtoMessage()    {}
func (*EventRecordSpecificationDeleted) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{18}
}
func (m *EventRecordSpecificationDeleted) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventRecordSpecificationDeleted) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventRecordSpecificationDeleted.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 *EventRecordSpecificationDeleted) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventRecordSpecificationDeleted.Merge(m, src)
}
func (m *EventRecordSpecificationDeleted) XXX_Size() int {
	return m.Size()
}
func (m *EventRecordSpecificationDeleted) XXX_DiscardUnknown() {
	xxx_messageInfo_EventRecordSpecificationDeleted.DiscardUnknown(m)
}

var xxx_messageInfo_EventRecordSpecificationDeleted proto.InternalMessageInfo

func (m *EventRecordSpecificationDeleted) GetRecordSpecificationAddr() string {
	if m != nil {
		return m.RecordSpecificationAddr
	}
	return ""
}

func (m *EventRecordSpecificationDeleted) GetContractSpecificationAddr() string {
	if m != nil {
		return m.ContractSpecificationAddr
	}
	return ""
}

// EventOSLocatorCreated is an event message indicating an object store locator has been created.
type EventOSLocatorCreated struct {
	// owner is the owner in the object store locator that was created.
	Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
}

func (m *EventOSLocatorCreated) Reset()         { *m = EventOSLocatorCreated{} }
func (m *EventOSLocatorCreated) String() string { return proto.CompactTextString(m) }
func (*EventOSLocatorCreated) ProtoMessage()    {}
func (*EventOSLocatorCreated) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{19}
}
func (m *EventOSLocatorCreated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventOSLocatorCreated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventOSLocatorCreated.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 *EventOSLocatorCreated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventOSLocatorCreated.Merge(m, src)
}
func (m *EventOSLocatorCreated) XXX_Size() int {
	return m.Size()
}
func (m *EventOSLocatorCreated) XXX_DiscardUnknown() {
	xxx_messageInfo_EventOSLocatorCreated.DiscardUnknown(m)
}

var xxx_messageInfo_EventOSLocatorCreated proto.InternalMessageInfo

func (m *EventOSLocatorCreated) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

// EventOSLocatorUpdated is an event message indicating an object store locator has been updated.
type EventOSLocatorUpdated struct {
	// owner is the owner in the object store locator that was updated.
	Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
}

func (m *EventOSLocatorUpdated) Reset()         { *m = EventOSLocatorUpdated{} }
func (m *EventOSLocatorUpdated) String() string { return proto.CompactTextString(m) }
func (*EventOSLocatorUpdated) ProtoMessage()    {}
func (*EventOSLocatorUpdated) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{20}
}
func (m *EventOSLocatorUpdated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventOSLocatorUpdated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventOSLocatorUpdated.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 *EventOSLocatorUpdated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventOSLocatorUpdated.Merge(m, src)
}
func (m *EventOSLocatorUpdated) XXX_Size() int {
	return m.Size()
}
func (m *EventOSLocatorUpdated) XXX_DiscardUnknown() {
	xxx_messageInfo_EventOSLocatorUpdated.DiscardUnknown(m)
}

var xxx_messageInfo_EventOSLocatorUpdated proto.InternalMessageInfo

func (m *EventOSLocatorUpdated) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

// EventOSLocatorDeleted is an event message indicating an object store locator has been deleted.
type EventOSLocatorDeleted struct {
	// owner is the owner in the object store locator that was deleted.
	Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
}

func (m *EventOSLocatorDeleted) Reset()         { *m = EventOSLocatorDeleted{} }
func (m *EventOSLocatorDeleted) String() string { return proto.CompactTextString(m) }
func (*EventOSLocatorDeleted) ProtoMessage()    {}
func (*EventOSLocatorDeleted) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{21}
}
func (m *EventOSLocatorDeleted) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventOSLocatorDeleted) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventOSLocatorDeleted.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 *EventOSLocatorDeleted) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventOSLocatorDeleted.Merge(m, src)
}
func (m *EventOSLocatorDeleted) XXX_Size() int {
	return m.Size()
}
func (m *EventOSLocatorDeleted) XXX_DiscardUnknown() {
	xxx_messageInfo_EventOSLocatorDeleted.DiscardUnknown(m)
}

var xxx_messageInfo_EventOSLocatorDeleted proto.InternalMessageInfo

func (m *EventOSLocatorDeleted) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

// EventSetNetAssetValue event emitted when Net Asset Value for a scope is update or added
type EventSetNetAssetValue struct {
	ScopeId string `protobuf:"bytes,1,opt,name=scope_id,json=scopeId,proto3" json:"scope_id,omitempty"`
	Price   string `protobuf:"bytes,2,opt,name=price,proto3" json:"price,omitempty"`
	Source  string `protobuf:"bytes,3,opt,name=source,proto3" json:"source,omitempty"`
}

func (m *EventSetNetAssetValue) Reset()         { *m = EventSetNetAssetValue{} }
func (m *EventSetNetAssetValue) String() string { return proto.CompactTextString(m) }
func (*EventSetNetAssetValue) ProtoMessage()    {}
func (*EventSetNetAssetValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_476cf6cf9459cf25, []int{22}
}
func (m *EventSetNetAssetValue) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventSetNetAssetValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventSetNetAssetValue.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 *EventSetNetAssetValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventSetNetAssetValue.Merge(m, src)
}
func (m *EventSetNetAssetValue) XXX_Size() int {
	return m.Size()
}
func (m *EventSetNetAssetValue) XXX_DiscardUnknown() {
	xxx_messageInfo_EventSetNetAssetValue.DiscardUnknown(m)
}

var xxx_messageInfo_EventSetNetAssetValue proto.InternalMessageInfo

func (m *EventSetNetAssetValue) GetScopeId() string {
	if m != nil {
		return m.ScopeId
	}
	return ""
}

func (m *EventSetNetAssetValue) GetPrice() string {
	if m != nil {
		return m.Price
	}
	return ""
}

func (m *EventSetNetAssetValue) GetSource() string {
	if m != nil {
		return m.Source
	}
	return ""
}

func init() {
	proto.RegisterType((*EventTxCompleted)(nil), "provenance.metadata.v1.EventTxCompleted")
	proto.RegisterType((*EventScopeCreated)(nil), "provenance.metadata.v1.EventScopeCreated")
	proto.RegisterType((*EventScopeUpdated)(nil), "provenance.metadata.v1.EventScopeUpdated")
	proto.RegisterType((*EventScopeDeleted)(nil), "provenance.metadata.v1.EventScopeDeleted")
	proto.RegisterType((*EventSessionCreated)(nil), "provenance.metadata.v1.EventSessionCreated")
	proto.RegisterType((*EventSessionUpdated)(nil), "provenance.metadata.v1.EventSessionUpdated")
	proto.RegisterType((*EventSessionDeleted)(nil), "provenance.metadata.v1.EventSessionDeleted")
	proto.RegisterType((*EventRecordCreated)(nil), "provenance.metadata.v1.EventRecordCreated")
	proto.RegisterType((*EventRecordUpdated)(nil), "provenance.metadata.v1.EventRecordUpdated")
	proto.RegisterType((*EventRecordDeleted)(nil), "provenance.metadata.v1.EventRecordDeleted")
	proto.RegisterType((*EventScopeSpecificationCreated)(nil), "provenance.metadata.v1.EventScopeSpecificationCreated")
	proto.RegisterType((*EventScopeSpecificationUpdated)(nil), "provenance.metadata.v1.EventScopeSpecificationUpdated")
	proto.RegisterType((*EventScopeSpecificationDeleted)(nil), "provenance.metadata.v1.EventScopeSpecificationDeleted")
	proto.RegisterType((*EventContractSpecificationCreated)(nil), "provenance.metadata.v1.EventContractSpecificationCreated")
	proto.RegisterType((*EventContractSpecificationUpdated)(nil), "provenance.metadata.v1.EventContractSpecificationUpdated")
	proto.RegisterType((*EventContractSpecificationDeleted)(nil), "provenance.metadata.v1.EventContractSpecificationDeleted")
	proto.RegisterType((*EventRecordSpecificationCreated)(nil), "provenance.metadata.v1.EventRecordSpecificationCreated")
	proto.RegisterType((*EventRecordSpecificationUpdated)(nil), "provenance.metadata.v1.EventRecordSpecificationUpdated")
	proto.RegisterType((*EventRecordSpecificationDeleted)(nil), "provenance.metadata.v1.EventRecordSpecificationDeleted")
	proto.RegisterType((*EventOSLocatorCreated)(nil), "provenance.metadata.v1.EventOSLocatorCreated")
	proto.RegisterType((*EventOSLocatorUpdated)(nil), "provenance.metadata.v1.EventOSLocatorUpdated")
	proto.RegisterType((*EventOSLocatorDeleted)(nil), "provenance.metadata.v1.EventOSLocatorDeleted")
	proto.RegisterType((*EventSetNetAssetValue)(nil), "provenance.metadata.v1.EventSetNetAssetValue")
}

func init() {
	proto.RegisterFile("provenance/metadata/v1/events.proto", fileDescriptor_476cf6cf9459cf25)
}

var fileDescriptor_476cf6cf9459cf25 = []byte{
	// 556 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0xcd, 0x6e, 0xd3, 0x4c,
	0x14, 0x8d, 0x13, 0x7d, 0x6d, 0x73, 0xfb, 0x2d, 0xc0, 0x40, 0x70, 0x40, 0xb8, 0x3f, 0x6c, 0xba,
	0xa9, 0xad, 0x02, 0x0b, 0xc4, 0x02, 0xa9, 0x04, 0x16, 0x48, 0x08, 0x50, 0x52, 0x40, 0xea, 0x86,
	0x4e, 0x67, 0x2e, 0x65, 0x44, 0xe2, 0xb1, 0x66, 0x26, 0x69, 0x79, 0x0b, 0x5e, 0x80, 0xf7, 0x61,
	0xd9, 0x25, 0x4b, 0x94, 0xbc, 0x08, 0xf2, 0x78, 0x86, 0xb8, 0x8d, 0x8b, 0x81, 0x50, 0x60, 0x79,
	0x66, 0xee, 0x39, 0xe7, 0xde, 0xe3, 0x9b, 0x68, 0xe0, 0x66, 0x2a, 0xc5, 0x08, 0x13, 0x92, 0x50,
	0x8c, 0x07, 0xa8, 0x09, 0x23, 0x9a, 0xc4, 0xa3, 0xad, 0x18, 0x47, 0x98, 0x68, 0x15, 0xa5, 0x52,
	0x68, 0xe1, 0xb7, 0xa6, 0x45, 0x91, 0x2b, 0x8a, 0x46, 0x5b, 0xeb, 0x7b, 0x70, 0xe1, 0x51, 0x56,
	0xb7, 0x73, 0xd4, 0x11, 0x83, 0xb4, 0x8f, 0x1a, 0x99, 0xdf, 0x82, 0x85, 0x81, 0x60, 0xc3, 0x3e,
	0x06, 0xde, 0xaa, 0xb7, 0xd1, 0xec, 0x5a, 0xe4, 0x5f, 0x83, 0x25, 0x4c, 0x58, 0x2a, 0x78, 0xa2,
	0x83, 0xba, 0xb9, 0xf9, 0x86, 0xfd, 0x00, 0x16, 0x15, 0x3f, 0x48, 0x50, 0xaa, 0xa0, 0xb1, 0xda,
	0xd8, 0x68, 0x76, 0x1d, 0x5c, 0xbf, 0x05, 0x17, 0x8d, 0x43, 0x8f, 0x8a, 0x14, 0x3b, 0x12, 0x49,
	0x66, 0x71, 0x03, 0x40, 0x65, 0xf8, 0x35, 0x61, 0x4c, 0x5a, 0x9b, 0xa6, 0x39, 0xd9, 0x66, 0x4c,
	0x9e, 0xe4, 0xbc, 0x48, 0xd9, 0x4f, 0x73, 0x1e, 0x62, 0x3e, 0x4a, 0x05, 0xe7, 0x15, 0x5c, 0xca,
	0x39, 0xa8, 0x14, 0x17, 0x89, 0xeb, 0x6e, 0x0d, 0xfe, 0x57, 0xf9, 0x49, 0x91, 0xb7, 0x6c, 0xcf,
	0x32, 0xe6, 0x29, 0xe1, 0x7a, 0x85, 0xb0, 0x1b, 0xe1, 0xb7, 0x0b, 0xbb, 0x39, 0xe7, 0x17, 0x3e,
	0x04, 0xdf, 0x08, 0x77, 0x91, 0x0a, 0xc9, 0x5c, 0x12, 0x2b, 0xb0, 0x2c, 0xcd, 0x41, 0x51, 0x16,
	0xf2, 0x23, 0xa3, 0x7a, 0xda, 0xb8, 0x5e, 0x65, 0xdc, 0xf8, 0xbe, 0xb1, 0x4b, 0xea, 0x0f, 0x18,
	0xef, 0x9c, 0x30, 0x76, 0x49, 0x56, 0x1a, 0x57, 0xa8, 0xee, 0x42, 0x38, 0x5d, 0xc3, 0x5e, 0x8a,
	0x94, 0xbf, 0xe1, 0x94, 0xe8, 0xc2, 0x76, 0xdd, 0x85, 0x20, 0x17, 0x50, 0xc5, 0xdb, 0xa2, 0x5d,
	0x4b, 0xcd, 0x90, 0x2b, 0xb4, 0x5d, 0x6c, 0xe7, 0xa1, 0xed, 0x92, 0xf9, 0x75, 0x6d, 0x0a, 0x6b,
	0x46, 0xbb, 0x23, 0x12, 0x2d, 0x09, 0xd5, 0xa5, 0xb1, 0xdc, 0x87, 0xeb, 0xd4, 0xde, 0x9f, 0xed,
	0xd0, 0xa6, 0x65, 0x12, 0xd5, 0x26, 0x2e, 0x9f, 0x73, 0x35, 0x71, 0x41, 0xcd, 0x6b, 0xf2, 0xd1,
	0x83, 0x95, 0xc2, 0x66, 0x96, 0xa6, 0x75, 0x0f, 0xda, 0x76, 0x4d, 0xcf, 0x74, 0xb8, 0x2a, 0x67,
	0xe9, 0x66, 0x83, 0x2b, 0xfa, 0xab, 0xcf, 0xd3, 0x9f, 0x0b, 0xfa, 0x5f, 0xed, 0xcf, 0x7d, 0xa3,
	0xbf, 0xd9, 0xdf, 0x26, 0x5c, 0x31, 0xed, 0x3d, 0xeb, 0x3d, 0x11, 0x94, 0x68, 0x21, 0xdd, 0x47,
	0xbd, 0x0c, 0xff, 0x89, 0xc3, 0x04, 0x5d, 0x03, 0x39, 0x98, 0x2d, 0x77, 0x19, 0xff, 0x60, 0xb9,
	0x1b, 0xb9, 0xbc, 0x7c, 0xcf, 0x96, 0xf7, 0x50, 0x3f, 0x45, 0xbd, 0xad, 0x14, 0xea, 0x97, 0xa4,
	0x3f, 0x44, 0xbf, 0x0d, 0x4b, 0xf9, 0xcf, 0x9d, 0x33, 0xcb, 0x58, 0x34, 0xf8, 0xb1, 0x51, 0x4a,
	0x25, 0xa7, 0x68, 0x47, 0xcd, 0x41, 0xf6, 0x6c, 0x50, 0x62, 0x28, 0x29, 0xda, 0x3f, 0x45, 0x8b,
	0x1e, 0xbc, 0xfb, 0x34, 0x0e, 0xbd, 0xe3, 0x71, 0xe8, 0x7d, 0x19, 0x87, 0xde, 0x87, 0x49, 0x58,
	0x3b, 0x9e, 0x84, 0xb5, 0xcf, 0x93, 0xb0, 0x06, 0x6d, 0x2e, 0xa2, 0xf2, 0x77, 0xc9, 0x73, 0x6f,
	0xf7, 0xce, 0x01, 0xd7, 0x6f, 0x87, 0xfb, 0x11, 0x15, 0x83, 0x78, 0x5a, 0xb4, 0xc9, 0x45, 0x01,
	0xc5, 0x47, 0xd3, 0x17, 0x8f, 0x7e, 0x9f, 0xa2, 0xda, 0x5f, 0x30, 0xcf, 0x9d, 0xdb, 0x5f, 0x03,
	0x00, 0x00, 0xff, 0xff, 0xaa, 0xcf, 0x7c, 0x06, 0x15, 0x09, 0x00, 0x00,
}

func (m *EventTxCompleted) 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 *EventTxCompleted) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventTxCompleted) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Signers) > 0 {
		for iNdEx := len(m.Signers) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Signers[iNdEx])
			copy(dAtA[i:], m.Signers[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Signers[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Endpoint) > 0 {
		i -= len(m.Endpoint)
		copy(dAtA[i:], m.Endpoint)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Endpoint)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Module) > 0 {
		i -= len(m.Module)
		copy(dAtA[i:], m.Module)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Module)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventScopeCreated) 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 *EventScopeCreated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventScopeCreated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ScopeAddr) > 0 {
		i -= len(m.ScopeAddr)
		copy(dAtA[i:], m.ScopeAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ScopeAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventScopeUpdated) 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 *EventScopeUpdated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventScopeUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ScopeAddr) > 0 {
		i -= len(m.ScopeAddr)
		copy(dAtA[i:], m.ScopeAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ScopeAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventScopeDeleted) 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 *EventScopeDeleted) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventScopeDeleted) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ScopeAddr) > 0 {
		i -= len(m.ScopeAddr)
		copy(dAtA[i:], m.ScopeAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ScopeAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventSessionCreated) 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 *EventSessionCreated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventSessionCreated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ScopeAddr) > 0 {
		i -= len(m.ScopeAddr)
		copy(dAtA[i:], m.ScopeAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ScopeAddr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SessionAddr) > 0 {
		i -= len(m.SessionAddr)
		copy(dAtA[i:], m.SessionAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.SessionAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventSessionUpdated) 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 *EventSessionUpdated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventSessionUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ScopeAddr) > 0 {
		i -= len(m.ScopeAddr)
		copy(dAtA[i:], m.ScopeAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ScopeAddr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SessionAddr) > 0 {
		i -= len(m.SessionAddr)
		copy(dAtA[i:], m.SessionAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.SessionAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventSessionDeleted) 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 *EventSessionDeleted) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventSessionDeleted) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ScopeAddr) > 0 {
		i -= len(m.ScopeAddr)
		copy(dAtA[i:], m.ScopeAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ScopeAddr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SessionAddr) > 0 {
		i -= len(m.SessionAddr)
		copy(dAtA[i:], m.SessionAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.SessionAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventRecordCreated) 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 *EventRecordCreated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventRecordCreated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ScopeAddr) > 0 {
		i -= len(m.ScopeAddr)
		copy(dAtA[i:], m.ScopeAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ScopeAddr)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.SessionAddr) > 0 {
		i -= len(m.SessionAddr)
		copy(dAtA[i:], m.SessionAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.SessionAddr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.RecordAddr) > 0 {
		i -= len(m.RecordAddr)
		copy(dAtA[i:], m.RecordAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.RecordAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventRecordUpdated) 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 *EventRecordUpdated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventRecordUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ScopeAddr) > 0 {
		i -= len(m.ScopeAddr)
		copy(dAtA[i:], m.ScopeAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ScopeAddr)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.SessionAddr) > 0 {
		i -= len(m.SessionAddr)
		copy(dAtA[i:], m.SessionAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.SessionAddr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.RecordAddr) > 0 {
		i -= len(m.RecordAddr)
		copy(dAtA[i:], m.RecordAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.RecordAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventRecordDeleted) 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 *EventRecordDeleted) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventRecordDeleted) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ScopeAddr) > 0 {
		i -= len(m.ScopeAddr)
		copy(dAtA[i:], m.ScopeAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ScopeAddr)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.RecordAddr) > 0 {
		i -= len(m.RecordAddr)
		copy(dAtA[i:], m.RecordAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.RecordAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventScopeSpecificationCreated) 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 *EventScopeSpecificationCreated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventScopeSpecificationCreated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ScopeSpecificationAddr) > 0 {
		i -= len(m.ScopeSpecificationAddr)
		copy(dAtA[i:], m.ScopeSpecificationAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ScopeSpecificationAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventScopeSpecificationUpdated) 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 *EventScopeSpecificationUpdated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventScopeSpecificationUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ScopeSpecificationAddr) > 0 {
		i -= len(m.ScopeSpecificationAddr)
		copy(dAtA[i:], m.ScopeSpecificationAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ScopeSpecificationAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventScopeSpecificationDeleted) 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 *EventScopeSpecificationDeleted) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventScopeSpecificationDeleted) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ScopeSpecificationAddr) > 0 {
		i -= len(m.ScopeSpecificationAddr)
		copy(dAtA[i:], m.ScopeSpecificationAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ScopeSpecificationAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventContractSpecificationCreated) 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 *EventContractSpecificationCreated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventContractSpecificationCreated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ContractSpecificationAddr) > 0 {
		i -= len(m.ContractSpecificationAddr)
		copy(dAtA[i:], m.ContractSpecificationAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ContractSpecificationAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventContractSpecificationUpdated) 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 *EventContractSpecificationUpdated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventContractSpecificationUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ContractSpecificationAddr) > 0 {
		i -= len(m.ContractSpecificationAddr)
		copy(dAtA[i:], m.ContractSpecificationAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ContractSpecificationAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventContractSpecificationDeleted) 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 *EventContractSpecificationDeleted) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventContractSpecificationDeleted) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ContractSpecificationAddr) > 0 {
		i -= len(m.ContractSpecificationAddr)
		copy(dAtA[i:], m.ContractSpecificationAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ContractSpecificationAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventRecordSpecificationCreated) 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 *EventRecordSpecificationCreated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventRecordSpecificationCreated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ContractSpecificationAddr) > 0 {
		i -= len(m.ContractSpecificationAddr)
		copy(dAtA[i:], m.ContractSpecificationAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ContractSpecificationAddr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.RecordSpecificationAddr) > 0 {
		i -= len(m.RecordSpecificationAddr)
		copy(dAtA[i:], m.RecordSpecificationAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.RecordSpecificationAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventRecordSpecificationUpdated) 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 *EventRecordSpecificationUpdated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventRecordSpecificationUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ContractSpecificationAddr) > 0 {
		i -= len(m.ContractSpecificationAddr)
		copy(dAtA[i:], m.ContractSpecificationAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ContractSpecificationAddr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.RecordSpecificationAddr) > 0 {
		i -= len(m.RecordSpecificationAddr)
		copy(dAtA[i:], m.RecordSpecificationAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.RecordSpecificationAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventRecordSpecificationDeleted) 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 *EventRecordSpecificationDeleted) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventRecordSpecificationDeleted) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ContractSpecificationAddr) > 0 {
		i -= len(m.ContractSpecificationAddr)
		copy(dAtA[i:], m.ContractSpecificationAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ContractSpecificationAddr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.RecordSpecificationAddr) > 0 {
		i -= len(m.RecordSpecificationAddr)
		copy(dAtA[i:], m.RecordSpecificationAddr)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.RecordSpecificationAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventOSLocatorCreated) 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 *EventOSLocatorCreated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventOSLocatorCreated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventOSLocatorUpdated) 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 *EventOSLocatorUpdated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventOSLocatorUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventOSLocatorDeleted) 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 *EventOSLocatorDeleted) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventOSLocatorDeleted) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventSetNetAssetValue) 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 *EventSetNetAssetValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventSetNetAssetValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Source) > 0 {
		i -= len(m.Source)
		copy(dAtA[i:], m.Source)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Source)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Price) > 0 {
		i -= len(m.Price)
		copy(dAtA[i:], m.Price)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Price)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ScopeId) > 0 {
		i -= len(m.ScopeId)
		copy(dAtA[i:], m.ScopeId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ScopeId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintEvents(dAtA []byte, offset int, v uint64) int {
	offset -= sovEvents(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *EventTxCompleted) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Module)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.Endpoint)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.Signers) > 0 {
		for _, s := range m.Signers {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventScopeCreated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ScopeAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventScopeUpdated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ScopeAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventScopeDeleted) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ScopeAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventSessionCreated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SessionAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.ScopeAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventSessionUpdated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SessionAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.ScopeAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventSessionDeleted) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SessionAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.ScopeAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventRecordCreated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RecordAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.SessionAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.ScopeAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventRecordUpdated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RecordAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.SessionAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.ScopeAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventRecordDeleted) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RecordAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.ScopeAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventScopeSpecificationCreated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ScopeSpecificationAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventScopeSpecificationUpdated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ScopeSpecificationAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventScopeSpecificationDeleted) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ScopeSpecificationAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventContractSpecificationCreated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContractSpecificationAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventContractSpecificationUpdated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContractSpecificationAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventContractSpecificationDeleted) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContractSpecificationAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventRecordSpecificationCreated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RecordSpecificationAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.ContractSpecificationAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventRecordSpecificationUpdated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RecordSpecificationAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.ContractSpecificationAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventRecordSpecificationDeleted) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RecordSpecificationAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.ContractSpecificationAddr)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventOSLocatorCreated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventOSLocatorUpdated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventOSLocatorDeleted) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventSetNetAssetValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ScopeId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.Price)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.Source)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func sovEvents(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozEvents(x uint64) (n int) {
	return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *EventTxCompleted) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventTxCompleted: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTxCompleted: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Module", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Module = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Endpoint = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signers", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signers = append(m.Signers, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventScopeCreated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventScopeCreated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventScopeCreated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopeAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScopeAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventScopeUpdated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventScopeUpdated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventScopeUpdated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopeAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScopeAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventScopeDeleted) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventScopeDeleted: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventScopeDeleted: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopeAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScopeAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventSessionCreated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventSessionCreated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventSessionCreated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SessionAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopeAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScopeAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventSessionUpdated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventSessionUpdated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventSessionUpdated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SessionAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopeAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScopeAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventSessionDeleted) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventSessionDeleted: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventSessionDeleted: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SessionAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopeAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScopeAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventRecordCreated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventRecordCreated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventRecordCreated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecordAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SessionAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopeAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScopeAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventRecordUpdated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventRecordUpdated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventRecordUpdated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecordAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SessionAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopeAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScopeAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventRecordDeleted) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventRecordDeleted: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventRecordDeleted: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecordAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopeAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScopeAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventScopeSpecificationCreated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventScopeSpecificationCreated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventScopeSpecificationCreated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopeSpecificationAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScopeSpecificationAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventScopeSpecificationUpdated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventScopeSpecificationUpdated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventScopeSpecificationUpdated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopeSpecificationAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScopeSpecificationAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventScopeSpecificationDeleted) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventScopeSpecificationDeleted: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventScopeSpecificationDeleted: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopeSpecificationAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScopeSpecificationAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventContractSpecificationCreated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventContractSpecificationCreated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventContractSpecificationCreated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractSpecificationAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractSpecificationAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventContractSpecificationUpdated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventContractSpecificationUpdated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventContractSpecificationUpdated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractSpecificationAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractSpecificationAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventContractSpecificationDeleted) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventContractSpecificationDeleted: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventContractSpecificationDeleted: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractSpecificationAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractSpecificationAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventRecordSpecificationCreated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventRecordSpecificationCreated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventRecordSpecificationCreated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordSpecificationAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecordSpecificationAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractSpecificationAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractSpecificationAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventRecordSpecificationUpdated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventRecordSpecificationUpdated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventRecordSpecificationUpdated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordSpecificationAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecordSpecificationAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractSpecificationAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractSpecificationAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventRecordSpecificationDeleted) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventRecordSpecificationDeleted: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventRecordSpecificationDeleted: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordSpecificationAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecordSpecificationAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractSpecificationAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractSpecificationAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventOSLocatorCreated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventOSLocatorCreated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventOSLocatorCreated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventOSLocatorUpdated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventOSLocatorUpdated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventOSLocatorUpdated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventOSLocatorDeleted) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventOSLocatorDeleted: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventOSLocatorDeleted: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventSetNetAssetValue) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventSetNetAssetValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventSetNetAssetValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopeId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScopeId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Price = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Source = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipEvents(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthEvents
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupEvents
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthEvents
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthEvents        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEvents          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupEvents = fmt.Errorf("proto: unexpected end of group")
)