// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: emissions/v9/events.proto

package types

import (
	bytes "bytes"
	cosmossdk_io_math "cosmossdk.io/math"
	fmt "fmt"
	github_com_allora_network_allora_chain_math "github.com/allora-network/allora-chain/math"
	_ "github.com/cosmos/cosmos-proto"
	_ "github.com/cosmos/cosmos-sdk/types/tx/amino"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type ActorType int32

const (
	ActorType_ACTOR_TYPE_INFERER_UNSPECIFIED ActorType = 0
	ActorType_ACTOR_TYPE_FORECASTER          ActorType = 1
	ActorType_ACTOR_TYPE_REPUTER             ActorType = 2
)

var ActorType_name = map[int32]string{
	0: "ACTOR_TYPE_INFERER_UNSPECIFIED",
	1: "ACTOR_TYPE_FORECASTER",
	2: "ACTOR_TYPE_REPUTER",
}

var ActorType_value = map[string]int32{
	"ACTOR_TYPE_INFERER_UNSPECIFIED": 0,
	"ACTOR_TYPE_FORECASTER":          1,
	"ACTOR_TYPE_REPUTER":             2,
}

func (x ActorType) String() string {
	return proto.EnumName(ActorType_name, int32(x))
}

func (ActorType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2d7671ca936dd333, []int{0}
}

type EventScoresSet struct {
	ActorType   ActorType                                         `protobuf:"varint,1,opt,name=actor_type,json=actorType,proto3,enum=emissions.v9.ActorType" json:"actor_type,omitempty"`
	TopicId     uint64                                            `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64                                             `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Addresses   []string                                          `protobuf:"bytes,4,rep,name=addresses,proto3" json:"addresses,omitempty"`
	Scores      []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,5,rep,name=scores,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"scores"`
}

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

var xxx_messageInfo_EventScoresSet proto.InternalMessageInfo

func (m *EventScoresSet) GetActorType() ActorType {
	if m != nil {
		return m.ActorType
	}
	return ActorType_ACTOR_TYPE_INFERER_UNSPECIFIED
}

func (m *EventScoresSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventScoresSet) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *EventScoresSet) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type EventRewardsSettled struct {
	ActorType     ActorType                                         `protobuf:"varint,1,opt,name=actor_type,json=actorType,proto3,enum=emissions.v9.ActorType" json:"actor_type,omitempty"`
	TopicId       uint64                                            `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight   int64                                             `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Addresses     []string                                          `protobuf:"bytes,4,rep,name=addresses,proto3" json:"addresses,omitempty"`
	Rewards       []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,5,rep,name=rewards,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"rewards"`
	BlockHeightTx int64                                             `protobuf:"varint,6,opt,name=block_height_tx,json=blockHeightTx,proto3" json:"block_height_tx,omitempty"`
}

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

var xxx_messageInfo_EventRewardsSettled proto.InternalMessageInfo

func (m *EventRewardsSettled) GetActorType() ActorType {
	if m != nil {
		return m.ActorType
	}
	return ActorType_ACTOR_TYPE_INFERER_UNSPECIFIED
}

func (m *EventRewardsSettled) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventRewardsSettled) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *EventRewardsSettled) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func (m *EventRewardsSettled) GetBlockHeightTx() int64 {
	if m != nil {
		return m.BlockHeightTx
	}
	return 0
}

type EventNetworkLossSet struct {
	TopicId     uint64            `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64             `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` // Deprecated: Do not use.
	ValueBundle *ValueBundle      `protobuf:"bytes,3,opt,name=value_bundle,json=valueBundle,proto3" json:"value_bundle,omitempty"`  // Deprecated: Do not use.
	Nonce       int64             `protobuf:"varint,4,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Bundle      *EventValueBundle `protobuf:"bytes,5,opt,name=bundle,proto3" json:"bundle,omitempty"`
}

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

var xxx_messageInfo_EventNetworkLossSet proto.InternalMessageInfo

func (m *EventNetworkLossSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

// Deprecated: Do not use.
func (m *EventNetworkLossSet) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

// Deprecated: Do not use.
func (m *EventNetworkLossSet) GetValueBundle() *ValueBundle {
	if m != nil {
		return m.ValueBundle
	}
	return nil
}

func (m *EventNetworkLossSet) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *EventNetworkLossSet) GetBundle() *EventValueBundle {
	if m != nil {
		return m.Bundle
	}
	return nil
}

type EventNetworkInferences struct {
	TopicId     uint64            `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64             `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` // Deprecated: Do not use.
	ValueBundle *ValueBundle      `protobuf:"bytes,3,opt,name=value_bundle,json=valueBundle,proto3" json:"value_bundle,omitempty"`  // Deprecated: Do not use.
	Nonce       int64             `protobuf:"varint,4,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Bundle      *EventValueBundle `protobuf:"bytes,5,opt,name=bundle,proto3" json:"bundle,omitempty"`
}

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

var xxx_messageInfo_EventNetworkInferences proto.InternalMessageInfo

func (m *EventNetworkInferences) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

// Deprecated: Do not use.
func (m *EventNetworkInferences) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

// Deprecated: Do not use.
func (m *EventNetworkInferences) GetValueBundle() *ValueBundle {
	if m != nil {
		return m.ValueBundle
	}
	return nil
}

func (m *EventNetworkInferences) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *EventNetworkInferences) GetBundle() *EventValueBundle {
	if m != nil {
		return m.Bundle
	}
	return nil
}

type EventOutlierResistantNetworkInferences struct {
	TopicId uint64            `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Nonce   int64             `protobuf:"varint,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Bundle  *EventValueBundle `protobuf:"bytes,3,opt,name=bundle,proto3" json:"bundle,omitempty"`
}

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

var xxx_messageInfo_EventOutlierResistantNetworkInferences proto.InternalMessageInfo

func (m *EventOutlierResistantNetworkInferences) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventOutlierResistantNetworkInferences) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *EventOutlierResistantNetworkInferences) GetBundle() *EventValueBundle {
	if m != nil {
		return m.Bundle
	}
	return nil
}

type EventValueBundle struct {
	ExtraData                     []byte                                                 `protobuf:"bytes,1,opt,name=extra_data,json=extraData,proto3" json:"extra_data,omitempty"`
	CombinedValue                 github_com_allora_network_allora_chain_math.Dec        `protobuf:"bytes,2,opt,name=combined_value,json=combinedValue,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"combined_value"`
	NaiveValue                    github_com_allora_network_allora_chain_math.Dec        `protobuf:"bytes,3,opt,name=naive_value,json=naiveValue,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"naive_value"`
	InfererAddresses              []string                                               `protobuf:"bytes,4,rep,name=inferer_addresses,json=infererAddresses,proto3" json:"inferer_addresses,omitempty"`
	ForecasterAddresses           []string                                               `protobuf:"bytes,5,rep,name=forecaster_addresses,json=forecasterAddresses,proto3" json:"forecaster_addresses,omitempty"`
	InfererValues                 []github_com_allora_network_allora_chain_math.Dec      `protobuf:"bytes,6,rep,name=inferer_values,json=infererValues,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"inferer_values"`
	ForecasterValues              []github_com_allora_network_allora_chain_math.Dec      `protobuf:"bytes,7,rep,name=forecaster_values,json=forecasterValues,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"forecaster_values"`
	OneOutInfererValues           []github_com_allora_network_allora_chain_math.Dec      `protobuf:"bytes,8,rep,name=one_out_inferer_values,json=oneOutInfererValues,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"one_out_inferer_values"`
	OneOutForecasterValues        []github_com_allora_network_allora_chain_math.Dec      `protobuf:"bytes,9,rep,name=one_out_forecaster_values,json=oneOutForecasterValues,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"one_out_forecaster_values"`
	OneInForecasterValues         []github_com_allora_network_allora_chain_math.Dec      `protobuf:"bytes,10,rep,name=one_in_forecaster_values,json=oneInForecasterValues,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"one_in_forecaster_values"`
	OneOutInfererForecasterValues []github_com_allora_network_allora_chain_math.DecArray `protobuf:"bytes,11,rep,name=one_out_inferer_forecaster_values,json=oneOutInfererForecasterValues,proto3,customtype=github.com/allora-network/allora-chain/math.DecArray" json:"one_out_inferer_forecaster_values"`
}

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

var xxx_messageInfo_EventValueBundle proto.InternalMessageInfo

func (m *EventValueBundle) GetExtraData() []byte {
	if m != nil {
		return m.ExtraData
	}
	return nil
}

func (m *EventValueBundle) GetInfererAddresses() []string {
	if m != nil {
		return m.InfererAddresses
	}
	return nil
}

func (m *EventValueBundle) GetForecasterAddresses() []string {
	if m != nil {
		return m.ForecasterAddresses
	}
	return nil
}

type EventInsertInfererPayload struct {
	Inferer   string                                          `protobuf:"bytes,1,opt,name=inferer,proto3" json:"inferer,omitempty"`
	Nonce     int64                                           `protobuf:"varint,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
	TopicId   uint64                                          `protobuf:"varint,3,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Value     github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,4,opt,name=value,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"value"`
	ExtraData []byte                                          `protobuf:"bytes,5,opt,name=extra_data,json=extraData,proto3" json:"extra_data,omitempty"`
}

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

var xxx_messageInfo_EventInsertInfererPayload proto.InternalMessageInfo

func (m *EventInsertInfererPayload) GetInferer() string {
	if m != nil {
		return m.Inferer
	}
	return ""
}

func (m *EventInsertInfererPayload) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *EventInsertInfererPayload) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventInsertInfererPayload) GetExtraData() []byte {
	if m != nil {
		return m.ExtraData
	}
	return nil
}

type EventInsertForecasterPayload struct {
	Forecaster       string                                            `protobuf:"bytes,1,opt,name=forecaster,proto3" json:"forecaster,omitempty"`
	Nonce            int64                                             `protobuf:"varint,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
	TopicId          uint64                                            `protobuf:"varint,3,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	InfererAddresses []string                                          `protobuf:"bytes,4,rep,name=inferer_addresses,json=infererAddresses,proto3" json:"inferer_addresses,omitempty"`
	InfererValues    []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,5,rep,name=inferer_values,json=infererValues,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"inferer_values"`
	ExtraData        []byte                                            `protobuf:"bytes,6,opt,name=extra_data,json=extraData,proto3" json:"extra_data,omitempty"`
}

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

var xxx_messageInfo_EventInsertForecasterPayload proto.InternalMessageInfo

func (m *EventInsertForecasterPayload) GetForecaster() string {
	if m != nil {
		return m.Forecaster
	}
	return ""
}

func (m *EventInsertForecasterPayload) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *EventInsertForecasterPayload) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventInsertForecasterPayload) GetInfererAddresses() []string {
	if m != nil {
		return m.InfererAddresses
	}
	return nil
}

func (m *EventInsertForecasterPayload) GetExtraData() []byte {
	if m != nil {
		return m.ExtraData
	}
	return nil
}

type EventCreateNewTopic struct {
	Topic *Topic `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
}

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

var xxx_messageInfo_EventCreateNewTopic proto.InternalMessageInfo

func (m *EventCreateNewTopic) GetTopic() *Topic {
	if m != nil {
		return m.Topic
	}
	return nil
}

type EventAddStake struct {
	TopicId   uint64                `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Reputer   string                `protobuf:"bytes,2,opt,name=reputer,proto3" json:"reputer,omitempty"`
	Delegator string                `protobuf:"bytes,3,opt,name=delegator,proto3" json:"delegator,omitempty"`
	Amount    cosmossdk_io_math.Int `protobuf:"bytes,4,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
}

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

var xxx_messageInfo_EventAddStake proto.InternalMessageInfo

func (m *EventAddStake) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventAddStake) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

func (m *EventAddStake) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

type EventRemoveStake struct {
	TopicId   uint64                `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Reputer   string                `protobuf:"bytes,2,opt,name=reputer,proto3" json:"reputer,omitempty"`
	Delegator string                `protobuf:"bytes,3,opt,name=delegator,proto3" json:"delegator,omitempty"`
	Amount    cosmossdk_io_math.Int `protobuf:"bytes,4,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
}

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

var xxx_messageInfo_EventRemoveStake proto.InternalMessageInfo

func (m *EventRemoveStake) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventRemoveStake) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

func (m *EventRemoveStake) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

type EventRequestStakeRemoval struct {
	TopicId          uint64                `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Reputer          string                `protobuf:"bytes,2,opt,name=reputer,proto3" json:"reputer,omitempty"`
	Delegator        string                `protobuf:"bytes,3,opt,name=delegator,proto3" json:"delegator,omitempty"`
	Amount           cosmossdk_io_math.Int `protobuf:"bytes,4,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
	CompletionHeight int64                 `protobuf:"varint,5,opt,name=completion_height,json=completionHeight,proto3" json:"completion_height,omitempty"`
}

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

var xxx_messageInfo_EventRequestStakeRemoval proto.InternalMessageInfo

func (m *EventRequestStakeRemoval) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventRequestStakeRemoval) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

func (m *EventRequestStakeRemoval) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

func (m *EventRequestStakeRemoval) GetCompletionHeight() int64 {
	if m != nil {
		return m.CompletionHeight
	}
	return 0
}

type EventCancelStakeRemoval struct {
	TopicId   uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Reputer   string `protobuf:"bytes,2,opt,name=reputer,proto3" json:"reputer,omitempty"`
	Delegator string `protobuf:"bytes,3,opt,name=delegator,proto3" json:"delegator,omitempty"`
}

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

var xxx_messageInfo_EventCancelStakeRemoval proto.InternalMessageInfo

func (m *EventCancelStakeRemoval) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventCancelStakeRemoval) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

func (m *EventCancelStakeRemoval) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

// EventReputerStakeUpdated is an event derived from the primitive ones EventAddStake and EventRemoveStake.
// It only expresses a change in the total stake of a reputer for a topic.
//
// Being not a primitive event, it should not be considered in an event sourcing approach, EventAddStake and EventRemoveStake should be used instead.
type EventReputerStakeUpdated struct {
	TopicId uint64                `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Reputer string                `protobuf:"bytes,2,opt,name=reputer,proto3" json:"reputer,omitempty"`
	Amount  cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
}

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

var xxx_messageInfo_EventReputerStakeUpdated proto.InternalMessageInfo

func (m *EventReputerStakeUpdated) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventReputerStakeUpdated) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

type EventRewardDelegateStake struct {
	TopicId   uint64                                          `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Reputer   string                                          `protobuf:"bytes,2,opt,name=reputer,proto3" json:"reputer,omitempty"`
	Delegator string                                          `protobuf:"bytes,3,opt,name=delegator,proto3" json:"delegator,omitempty"`
	Amount    github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,4,opt,name=amount,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"amount"`
}

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

var xxx_messageInfo_EventRewardDelegateStake proto.InternalMessageInfo

func (m *EventRewardDelegateStake) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventRewardDelegateStake) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

func (m *EventRewardDelegateStake) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

type EventInsertReputerPayload struct {
	TopicId uint64            `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Nonce   int64             `protobuf:"varint,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Reputer string            `protobuf:"bytes,3,opt,name=reputer,proto3" json:"reputer,omitempty"`
	Bundle  *EventValueBundle `protobuf:"bytes,5,opt,name=bundle,proto3" json:"bundle,omitempty"`
}

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

var xxx_messageInfo_EventInsertReputerPayload proto.InternalMessageInfo

func (m *EventInsertReputerPayload) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventInsertReputerPayload) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *EventInsertReputerPayload) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

func (m *EventInsertReputerPayload) GetBundle() *EventValueBundle {
	if m != nil {
		return m.Bundle
	}
	return nil
}

type EventReputerRegistered struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Reputer string `protobuf:"bytes,2,opt,name=reputer,proto3" json:"reputer,omitempty"`
	Owner   string `protobuf:"bytes,3,opt,name=owner,proto3" json:"owner,omitempty"`
}

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

var xxx_messageInfo_EventReputerRegistered proto.InternalMessageInfo

func (m *EventReputerRegistered) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventReputerRegistered) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

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

type EventWorkerRegistered struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Worker  string `protobuf:"bytes,2,opt,name=worker,proto3" json:"worker,omitempty"`
	Owner   string `protobuf:"bytes,3,opt,name=owner,proto3" json:"owner,omitempty"`
}

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

var xxx_messageInfo_EventWorkerRegistered proto.InternalMessageInfo

func (m *EventWorkerRegistered) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventWorkerRegistered) GetWorker() string {
	if m != nil {
		return m.Worker
	}
	return ""
}

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

type EventReputerUnregistered struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Reputer string `protobuf:"bytes,2,opt,name=reputer,proto3" json:"reputer,omitempty"`
}

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

var xxx_messageInfo_EventReputerUnregistered proto.InternalMessageInfo

func (m *EventReputerUnregistered) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventReputerUnregistered) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

type EventWorkerUnregistered struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Worker  string `protobuf:"bytes,2,opt,name=worker,proto3" json:"worker,omitempty"`
}

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

var xxx_messageInfo_EventWorkerUnregistered proto.InternalMessageInfo

func (m *EventWorkerUnregistered) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventWorkerUnregistered) GetWorker() string {
	if m != nil {
		return m.Worker
	}
	return ""
}

type EventFundTopic struct {
	TopicId uint64                `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Funder  string                `protobuf:"bytes,2,opt,name=funder,proto3" json:"funder,omitempty"`
	Amount  cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
}

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

var xxx_messageInfo_EventFundTopic proto.InternalMessageInfo

func (m *EventFundTopic) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventFundTopic) GetFunder() string {
	if m != nil {
		return m.Funder
	}
	return ""
}

type EventParamsSet struct {
	Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"`
}

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

var xxx_messageInfo_EventParamsSet proto.InternalMessageInfo

func (m *EventParamsSet) GetParams() *Params {
	if m != nil {
		return m.Params
	}
	return nil
}

type EventWhitelistAdminAdded struct {
	Admin string `protobuf:"bytes,1,opt,name=admin,proto3" json:"admin,omitempty"`
}

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

var xxx_messageInfo_EventWhitelistAdminAdded proto.InternalMessageInfo

func (m *EventWhitelistAdminAdded) GetAdmin() string {
	if m != nil {
		return m.Admin
	}
	return ""
}

type EventWhitelistAdminRemoved struct {
	Admin string `protobuf:"bytes,1,opt,name=admin,proto3" json:"admin,omitempty"`
}

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

var xxx_messageInfo_EventWhitelistAdminRemoved proto.InternalMessageInfo

func (m *EventWhitelistAdminRemoved) GetAdmin() string {
	if m != nil {
		return m.Admin
	}
	return ""
}

type EventGlobalWhitelistAdded struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_EventGlobalWhitelistAdded proto.InternalMessageInfo

func (m *EventGlobalWhitelistAdded) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type EventGlobalWhitelistRemoved struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_EventGlobalWhitelistRemoved proto.InternalMessageInfo

func (m *EventGlobalWhitelistRemoved) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type EventGlobalWorkerWhitelistAdded struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_EventGlobalWorkerWhitelistAdded proto.InternalMessageInfo

func (m *EventGlobalWorkerWhitelistAdded) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type EventGlobalWorkerWhitelistRemoved struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_EventGlobalWorkerWhitelistRemoved proto.InternalMessageInfo

func (m *EventGlobalWorkerWhitelistRemoved) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type EventGlobalReputerWhitelistAdded struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_EventGlobalReputerWhitelistAdded proto.InternalMessageInfo

func (m *EventGlobalReputerWhitelistAdded) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type EventGlobalReputerWhitelistRemoved struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_EventGlobalReputerWhitelistRemoved proto.InternalMessageInfo

func (m *EventGlobalReputerWhitelistRemoved) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type EventGlobalAdminWhitelistAdded struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_EventGlobalAdminWhitelistAdded proto.InternalMessageInfo

func (m *EventGlobalAdminWhitelistAdded) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type EventGlobalAdminWhitelistRemoved struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_EventGlobalAdminWhitelistRemoved proto.InternalMessageInfo

func (m *EventGlobalAdminWhitelistRemoved) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type EventTopicWorkerWhitelistEnabled struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

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

var xxx_messageInfo_EventTopicWorkerWhitelistEnabled proto.InternalMessageInfo

func (m *EventTopicWorkerWhitelistEnabled) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type EventTopicWorkerWhitelistDisabled struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

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

var xxx_messageInfo_EventTopicWorkerWhitelistDisabled proto.InternalMessageInfo

func (m *EventTopicWorkerWhitelistDisabled) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type EventTopicReputerWhitelistEnabled struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

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

var xxx_messageInfo_EventTopicReputerWhitelistEnabled proto.InternalMessageInfo

func (m *EventTopicReputerWhitelistEnabled) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type EventTopicReputerWhitelistDisabled struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

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

var xxx_messageInfo_EventTopicReputerWhitelistDisabled proto.InternalMessageInfo

func (m *EventTopicReputerWhitelistDisabled) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type EventTopicCreatorWhitelistAdded struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_EventTopicCreatorWhitelistAdded proto.InternalMessageInfo

func (m *EventTopicCreatorWhitelistAdded) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type EventTopicCreatorWhitelistRemoved struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_EventTopicCreatorWhitelistRemoved proto.InternalMessageInfo

func (m *EventTopicCreatorWhitelistRemoved) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type EventTopicWorkerWhitelistAdded struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_EventTopicWorkerWhitelistAdded proto.InternalMessageInfo

func (m *EventTopicWorkerWhitelistAdded) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventTopicWorkerWhitelistAdded) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type EventTopicWorkerWhitelistRemoved struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_EventTopicWorkerWhitelistRemoved proto.InternalMessageInfo

func (m *EventTopicWorkerWhitelistRemoved) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventTopicWorkerWhitelistRemoved) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type EventTopicReputerWhitelistAdded struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_EventTopicReputerWhitelistAdded proto.InternalMessageInfo

func (m *EventTopicReputerWhitelistAdded) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventTopicReputerWhitelistAdded) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type EventTopicReputerWhitelistRemoved struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_EventTopicReputerWhitelistRemoved proto.InternalMessageInfo

func (m *EventTopicReputerWhitelistRemoved) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventTopicReputerWhitelistRemoved) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type EventForecastTaskScoreSet struct {
	TopicId          uint64                                          `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Score            github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,2,opt,name=score,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"score"`
	NonceBlockHeight int64                                           `protobuf:"varint,3,opt,name=nonce_block_height,json=nonceBlockHeight,proto3" json:"nonce_block_height,omitempty"`
}

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

var xxx_messageInfo_EventForecastTaskScoreSet proto.InternalMessageInfo

func (m *EventForecastTaskScoreSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventForecastTaskScoreSet) GetNonceBlockHeight() int64 {
	if m != nil {
		return m.NonceBlockHeight
	}
	return 0
}

type EventWorkerLastCommitSet struct {
	TopicId     uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64  `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Nonce       *Nonce `protobuf:"bytes,3,opt,name=nonce,proto3" json:"nonce,omitempty"`
}

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

var xxx_messageInfo_EventWorkerLastCommitSet proto.InternalMessageInfo

func (m *EventWorkerLastCommitSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventWorkerLastCommitSet) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *EventWorkerLastCommitSet) GetNonce() *Nonce {
	if m != nil {
		return m.Nonce
	}
	return nil
}

type EventReputerLastCommitSet struct {
	TopicId     uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64  `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Nonce       *Nonce `protobuf:"bytes,3,opt,name=nonce,proto3" json:"nonce,omitempty"`
}

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

var xxx_messageInfo_EventReputerLastCommitSet proto.InternalMessageInfo

func (m *EventReputerLastCommitSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventReputerLastCommitSet) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *EventReputerLastCommitSet) GetNonce() *Nonce {
	if m != nil {
		return m.Nonce
	}
	return nil
}

type EventTopicRewardsSet struct {
	TopicIds []uint64                                          `protobuf:"varint,1,rep,packed,name=topic_ids,json=topicIds,proto3" json:"topic_ids,omitempty"`
	Rewards  []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,2,rep,name=rewards,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"rewards"`
}

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

var xxx_messageInfo_EventTopicRewardsSet proto.InternalMessageInfo

func (m *EventTopicRewardsSet) GetTopicIds() []uint64 {
	if m != nil {
		return m.TopicIds
	}
	return nil
}

type EventEMAScoresSet struct {
	ActorType ActorType                                         `protobuf:"varint,1,opt,name=actor_type,json=actorType,proto3,enum=emissions.v9.ActorType" json:"actor_type,omitempty"`
	TopicId   uint64                                            `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Nonce     int64                                             `protobuf:"varint,3,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Addresses []string                                          `protobuf:"bytes,4,rep,name=addresses,proto3" json:"addresses,omitempty"`
	Scores    []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,5,rep,name=scores,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"scores"`
	IsActive  []bool                                            `protobuf:"varint,6,rep,packed,name=is_active,json=isActive,proto3" json:"is_active,omitempty"`
}

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

var xxx_messageInfo_EventEMAScoresSet proto.InternalMessageInfo

func (m *EventEMAScoresSet) GetActorType() ActorType {
	if m != nil {
		return m.ActorType
	}
	return ActorType_ACTOR_TYPE_INFERER_UNSPECIFIED
}

func (m *EventEMAScoresSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventEMAScoresSet) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *EventEMAScoresSet) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func (m *EventEMAScoresSet) GetIsActive() []bool {
	if m != nil {
		return m.IsActive
	}
	return nil
}

type EventListeningCoefficientsSet struct {
	ActorType    ActorType                                         `protobuf:"varint,1,opt,name=actor_type,json=actorType,proto3,enum=emissions.v9.ActorType" json:"actor_type,omitempty"`
	TopicId      uint64                                            `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight  int64                                             `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Addresses    []string                                          `protobuf:"bytes,4,rep,name=addresses,proto3" json:"addresses,omitempty"`
	Coefficients []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,5,rep,name=coefficients,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"coefficients"`
}

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

var xxx_messageInfo_EventListeningCoefficientsSet proto.InternalMessageInfo

func (m *EventListeningCoefficientsSet) GetActorType() ActorType {
	if m != nil {
		return m.ActorType
	}
	return ActorType_ACTOR_TYPE_INFERER_UNSPECIFIED
}

func (m *EventListeningCoefficientsSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventListeningCoefficientsSet) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *EventListeningCoefficientsSet) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type EventInfererNetworkRegretSet struct {
	TopicId     uint64                                            `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64                                             `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Addresses   []string                                          `protobuf:"bytes,3,rep,name=addresses,proto3" json:"addresses,omitempty"`
	Regrets     []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,4,rep,name=regrets,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"regrets"`
}

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

var xxx_messageInfo_EventInfererNetworkRegretSet proto.InternalMessageInfo

func (m *EventInfererNetworkRegretSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventInfererNetworkRegretSet) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *EventInfererNetworkRegretSet) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type EventForecasterNetworkRegretSet struct {
	TopicId     uint64                                            `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64                                             `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Addresses   []string                                          `protobuf:"bytes,3,rep,name=addresses,proto3" json:"addresses,omitempty"`
	Regrets     []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,4,rep,name=regrets,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"regrets"`
}

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

var xxx_messageInfo_EventForecasterNetworkRegretSet proto.InternalMessageInfo

func (m *EventForecasterNetworkRegretSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventForecasterNetworkRegretSet) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *EventForecasterNetworkRegretSet) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type EventNaiveInfererNetworkRegretSet struct {
	TopicId     uint64                                            `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64                                             `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Addresses   []string                                          `protobuf:"bytes,3,rep,name=addresses,proto3" json:"addresses,omitempty"`
	Regrets     []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,4,rep,name=regrets,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"regrets"`
}

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

var xxx_messageInfo_EventNaiveInfererNetworkRegretSet proto.InternalMessageInfo

func (m *EventNaiveInfererNetworkRegretSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventNaiveInfererNetworkRegretSet) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *EventNaiveInfererNetworkRegretSet) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type EventTopicInitialRegretSet struct {
	TopicId     uint64                                          `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64                                           `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Regret      github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,3,opt,name=regret,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"regret"`
}

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

var xxx_messageInfo_EventTopicInitialRegretSet proto.InternalMessageInfo

func (m *EventTopicInitialRegretSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventTopicInitialRegretSet) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

type EventTopicInitialEmaScoreSet struct {
	ActorType   ActorType                                       `protobuf:"varint,1,opt,name=actor_type,json=actorType,proto3,enum=emissions.v9.ActorType" json:"actor_type,omitempty"`
	TopicId     uint64                                          `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64                                           `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Score       github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,4,opt,name=score,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"score"`
}

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

var xxx_messageInfo_EventTopicInitialEmaScoreSet proto.InternalMessageInfo

func (m *EventTopicInitialEmaScoreSet) GetActorType() ActorType {
	if m != nil {
		return m.ActorType
	}
	return ActorType_ACTOR_TYPE_INFERER_UNSPECIFIED
}

func (m *EventTopicInitialEmaScoreSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventTopicInitialEmaScoreSet) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

type EventRegretStdNormSet struct {
	TopicId     uint64                                          `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64                                           `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Stdnorm     github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,3,opt,name=stdnorm,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"stdnorm"`
}

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

var xxx_messageInfo_EventRegretStdNormSet proto.InternalMessageInfo

func (m *EventRegretStdNormSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventRegretStdNormSet) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

type EventInfererWeightsSet struct {
	TopicId     uint64                                            `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64                                             `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Addresses   []string                                          `protobuf:"bytes,3,rep,name=addresses,proto3" json:"addresses,omitempty"`
	Weights     []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,4,rep,name=weights,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"weights"`
}

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

var xxx_messageInfo_EventInfererWeightsSet proto.InternalMessageInfo

func (m *EventInfererWeightsSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventInfererWeightsSet) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *EventInfererWeightsSet) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type EventForecasterWeightsSet struct {
	TopicId     uint64                                            `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64                                             `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Addresses   []string                                          `protobuf:"bytes,3,rep,name=addresses,proto3" json:"addresses,omitempty"`
	Weights     []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,4,rep,name=weights,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"weights"`
}

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

var xxx_messageInfo_EventForecasterWeightsSet proto.InternalMessageInfo

func (m *EventForecasterWeightsSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventForecasterWeightsSet) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *EventForecasterWeightsSet) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type EventPreviousPercentageRewardToStakedReputersSet struct {
	BlockHeight int64                                           `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Percentage  github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,2,opt,name=percentage,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"percentage"`
}

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

var xxx_messageInfo_EventPreviousPercentageRewardToStakedReputersSet proto.InternalMessageInfo

func (m *EventPreviousPercentageRewardToStakedReputersSet) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

type EventPruneRecords struct {
	BlockHeight int64  `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	TopicId     uint64 `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
}

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

var xxx_messageInfo_EventPruneRecords proto.InternalMessageInfo

func (m *EventPruneRecords) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *EventPruneRecords) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type EventDelegateRewardShareUpdated struct {
	TopicId        uint64                                          `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Reputer        string                                          `protobuf:"bytes,2,opt,name=reputer,proto3" json:"reputer,omitempty"`
	RewardPerShare github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,3,opt,name=reward_per_share,json=rewardPerShare,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"reward_per_share"`
}

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

var xxx_messageInfo_EventDelegateRewardShareUpdated proto.InternalMessageInfo

func (m *EventDelegateRewardShareUpdated) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventDelegateRewardShareUpdated) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

type EventDelegateRewardDistributed struct {
	TopicId uint64                `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Reputer string                `protobuf:"bytes,2,opt,name=reputer,proto3" json:"reputer,omitempty"`
	Amount  cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
}

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

var xxx_messageInfo_EventDelegateRewardDistributed proto.InternalMessageInfo

func (m *EventDelegateRewardDistributed) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventDelegateRewardDistributed) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

type EventActiveReputersSet struct {
	TopicId          uint64   `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Addresses        []string `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty"`
	NonceBlockHeight int64    `protobuf:"varint,3,opt,name=nonce_block_height,json=nonceBlockHeight,proto3" json:"nonce_block_height,omitempty"`
}

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

var xxx_messageInfo_EventActiveReputersSet proto.InternalMessageInfo

func (m *EventActiveReputersSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventActiveReputersSet) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func (m *EventActiveReputersSet) GetNonceBlockHeight() int64 {
	if m != nil {
		return m.NonceBlockHeight
	}
	return 0
}

type EventActiveInferersSet struct {
	TopicId          uint64   `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Addresses        []string `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty"`
	NonceBlockHeight int64    `protobuf:"varint,3,opt,name=nonce_block_height,json=nonceBlockHeight,proto3" json:"nonce_block_height,omitempty"`
}

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

var xxx_messageInfo_EventActiveInferersSet proto.InternalMessageInfo

func (m *EventActiveInferersSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventActiveInferersSet) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func (m *EventActiveInferersSet) GetNonceBlockHeight() int64 {
	if m != nil {
		return m.NonceBlockHeight
	}
	return 0
}

type EventActiveForecastersSet struct {
	TopicId          uint64   `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Addresses        []string `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty"`
	NonceBlockHeight int64    `protobuf:"varint,3,opt,name=nonce_block_height,json=nonceBlockHeight,proto3" json:"nonce_block_height,omitempty"`
}

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

var xxx_messageInfo_EventActiveForecastersSet proto.InternalMessageInfo

func (m *EventActiveForecastersSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventActiveForecastersSet) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func (m *EventActiveForecastersSet) GetNonceBlockHeight() int64 {
	if m != nil {
		return m.NonceBlockHeight
	}
	return 0
}

type EventTopicStatusChanged struct {
	TopicId  uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	IsActive bool   `protobuf:"varint,2,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"`
}

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

var xxx_messageInfo_EventTopicStatusChanged proto.InternalMessageInfo

func (m *EventTopicStatusChanged) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventTopicStatusChanged) GetIsActive() bool {
	if m != nil {
		return m.IsActive
	}
	return false
}

type EventNetworkInferenceInfererWeightsSet struct {
	TopicId          uint64                                            `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	NonceBlockHeight int64                                             `protobuf:"varint,2,opt,name=nonce_block_height,json=nonceBlockHeight,proto3" json:"nonce_block_height,omitempty"`
	Addresses        []string                                          `protobuf:"bytes,3,rep,name=addresses,proto3" json:"addresses,omitempty"`
	Weights          []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,4,rep,name=weights,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"weights"`
}

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

var xxx_messageInfo_EventNetworkInferenceInfererWeightsSet proto.InternalMessageInfo

func (m *EventNetworkInferenceInfererWeightsSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventNetworkInferenceInfererWeightsSet) GetNonceBlockHeight() int64 {
	if m != nil {
		return m.NonceBlockHeight
	}
	return 0
}

func (m *EventNetworkInferenceInfererWeightsSet) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type EventNetworkInferenceForecasterWeightsSet struct {
	TopicId          uint64                                            `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	NonceBlockHeight int64                                             `protobuf:"varint,2,opt,name=nonce_block_height,json=nonceBlockHeight,proto3" json:"nonce_block_height,omitempty"`
	Addresses        []string                                          `protobuf:"bytes,3,rep,name=addresses,proto3" json:"addresses,omitempty"`
	Weights          []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,4,rep,name=weights,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"weights"`
}

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

var xxx_messageInfo_EventNetworkInferenceForecasterWeightsSet proto.InternalMessageInfo

func (m *EventNetworkInferenceForecasterWeightsSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventNetworkInferenceForecasterWeightsSet) GetNonceBlockHeight() int64 {
	if m != nil {
		return m.NonceBlockHeight
	}
	return 0
}

func (m *EventNetworkInferenceForecasterWeightsSet) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type EventNetworkInferenceInfererRegretsUsedSet struct {
	TopicId          uint64                                            `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	NonceBlockHeight int64                                             `protobuf:"varint,2,opt,name=nonce_block_height,json=nonceBlockHeight,proto3" json:"nonce_block_height,omitempty"`
	Addresses        []string                                          `protobuf:"bytes,3,rep,name=addresses,proto3" json:"addresses,omitempty"`
	Regrets          []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,4,rep,name=regrets,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"regrets"`
}

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

var xxx_messageInfo_EventNetworkInferenceInfererRegretsUsedSet proto.InternalMessageInfo

func (m *EventNetworkInferenceInfererRegretsUsedSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventNetworkInferenceInfererRegretsUsedSet) GetNonceBlockHeight() int64 {
	if m != nil {
		return m.NonceBlockHeight
	}
	return 0
}

func (m *EventNetworkInferenceInfererRegretsUsedSet) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type EventNetworkInferenceForecasterRegretsUsedSet struct {
	TopicId          uint64                                            `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	NonceBlockHeight int64                                             `protobuf:"varint,2,opt,name=nonce_block_height,json=nonceBlockHeight,proto3" json:"nonce_block_height,omitempty"`
	Addresses        []string                                          `protobuf:"bytes,3,rep,name=addresses,proto3" json:"addresses,omitempty"`
	Regrets          []github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,4,rep,name=regrets,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"regrets"`
}

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

var xxx_messageInfo_EventNetworkInferenceForecasterRegretsUsedSet proto.InternalMessageInfo

func (m *EventNetworkInferenceForecasterRegretsUsedSet) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventNetworkInferenceForecasterRegretsUsedSet) GetNonceBlockHeight() int64 {
	if m != nil {
		return m.NonceBlockHeight
	}
	return 0
}

func (m *EventNetworkInferenceForecasterRegretsUsedSet) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type EventTopicWeightUpdated struct {
	TopicId         uint64                                          `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	NewWeight       github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,2,opt,name=new_weight,json=newWeight,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"new_weight"`
	TopicStake      cosmossdk_io_math.Int                           `protobuf:"bytes,3,opt,name=topic_stake,json=topicStake,proto3,customtype=cosmossdk.io/math.Int" json:"topic_stake"`
	TopicFeeRevenue cosmossdk_io_math.Int                           `protobuf:"bytes,4,opt,name=topic_fee_revenue,json=topicFeeRevenue,proto3,customtype=cosmossdk.io/math.Int" json:"topic_fee_revenue"`
}

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

var xxx_messageInfo_EventTopicWeightUpdated proto.InternalMessageInfo

func (m *EventTopicWeightUpdated) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type EventTopicFeeRevenueDripped struct {
	TopicId    uint64                `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	OldRevenue cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=old_revenue,json=oldRevenue,proto3,customtype=cosmossdk.io/math.Int" json:"old_revenue"`
	NewRevenue cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=new_revenue,json=newRevenue,proto3,customtype=cosmossdk.io/math.Int" json:"new_revenue"`
	DripAmount cosmossdk_io_math.Int `protobuf:"bytes,4,opt,name=drip_amount,json=dripAmount,proto3,customtype=cosmossdk.io/math.Int" json:"drip_amount"`
}

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

var xxx_messageInfo_EventTopicFeeRevenueDripped proto.InternalMessageInfo

func (m *EventTopicFeeRevenueDripped) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type EventWorkerSubmissionWindowOpened struct {
	TopicId          uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	NonceBlockHeight int64  `protobuf:"varint,2,opt,name=nonce_block_height,json=nonceBlockHeight,proto3" json:"nonce_block_height,omitempty"`
	WindowEndBlock   int64  `protobuf:"varint,3,opt,name=window_end_block,json=windowEndBlock,proto3" json:"window_end_block,omitempty"`
}

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

var xxx_messageInfo_EventWorkerSubmissionWindowOpened proto.InternalMessageInfo

func (m *EventWorkerSubmissionWindowOpened) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventWorkerSubmissionWindowOpened) GetNonceBlockHeight() int64 {
	if m != nil {
		return m.NonceBlockHeight
	}
	return 0
}

func (m *EventWorkerSubmissionWindowOpened) GetWindowEndBlock() int64 {
	if m != nil {
		return m.WindowEndBlock
	}
	return 0
}

type EventWorkerSubmissionWindowClosed struct {
	TopicId          uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	NonceBlockHeight int64  `protobuf:"varint,2,opt,name=nonce_block_height,json=nonceBlockHeight,proto3" json:"nonce_block_height,omitempty"`
}

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

var xxx_messageInfo_EventWorkerSubmissionWindowClosed proto.InternalMessageInfo

func (m *EventWorkerSubmissionWindowClosed) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventWorkerSubmissionWindowClosed) GetNonceBlockHeight() int64 {
	if m != nil {
		return m.NonceBlockHeight
	}
	return 0
}

type EventReputerSubmissionWindowOpened struct {
	TopicId          uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	NonceBlockHeight int64  `protobuf:"varint,2,opt,name=nonce_block_height,json=nonceBlockHeight,proto3" json:"nonce_block_height,omitempty"`
	WindowEndBlock   int64  `protobuf:"varint,3,opt,name=window_end_block,json=windowEndBlock,proto3" json:"window_end_block,omitempty"`
}

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

var xxx_messageInfo_EventReputerSubmissionWindowOpened proto.InternalMessageInfo

func (m *EventReputerSubmissionWindowOpened) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventReputerSubmissionWindowOpened) GetNonceBlockHeight() int64 {
	if m != nil {
		return m.NonceBlockHeight
	}
	return 0
}

func (m *EventReputerSubmissionWindowOpened) GetWindowEndBlock() int64 {
	if m != nil {
		return m.WindowEndBlock
	}
	return 0
}

type EventReputerSubmissionWindowClosed struct {
	TopicId          uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	NonceBlockHeight int64  `protobuf:"varint,2,opt,name=nonce_block_height,json=nonceBlockHeight,proto3" json:"nonce_block_height,omitempty"`
}

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

var xxx_messageInfo_EventReputerSubmissionWindowClosed proto.InternalMessageInfo

func (m *EventReputerSubmissionWindowClosed) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *EventReputerSubmissionWindowClosed) GetNonceBlockHeight() int64 {
	if m != nil {
		return m.NonceBlockHeight
	}
	return 0
}

func init() {
	proto.RegisterEnum("emissions.v9.ActorType", ActorType_name, ActorType_value)
	proto.RegisterType((*EventScoresSet)(nil), "emissions.v9.EventScoresSet")
	proto.RegisterType((*EventRewardsSettled)(nil), "emissions.v9.EventRewardsSettled")
	proto.RegisterType((*EventNetworkLossSet)(nil), "emissions.v9.EventNetworkLossSet")
	proto.RegisterType((*EventNetworkInferences)(nil), "emissions.v9.EventNetworkInferences")
	proto.RegisterType((*EventOutlierResistantNetworkInferences)(nil), "emissions.v9.EventOutlierResistantNetworkInferences")
	proto.RegisterType((*EventValueBundle)(nil), "emissions.v9.EventValueBundle")
	proto.RegisterType((*EventInsertInfererPayload)(nil), "emissions.v9.EventInsertInfererPayload")
	proto.RegisterType((*EventInsertForecasterPayload)(nil), "emissions.v9.EventInsertForecasterPayload")
	proto.RegisterType((*EventCreateNewTopic)(nil), "emissions.v9.EventCreateNewTopic")
	proto.RegisterType((*EventAddStake)(nil), "emissions.v9.EventAddStake")
	proto.RegisterType((*EventRemoveStake)(nil), "emissions.v9.EventRemoveStake")
	proto.RegisterType((*EventRequestStakeRemoval)(nil), "emissions.v9.EventRequestStakeRemoval")
	proto.RegisterType((*EventCancelStakeRemoval)(nil), "emissions.v9.EventCancelStakeRemoval")
	proto.RegisterType((*EventReputerStakeUpdated)(nil), "emissions.v9.EventReputerStakeUpdated")
	proto.RegisterType((*EventRewardDelegateStake)(nil), "emissions.v9.EventRewardDelegateStake")
	proto.RegisterType((*EventInsertReputerPayload)(nil), "emissions.v9.EventInsertReputerPayload")
	proto.RegisterType((*EventReputerRegistered)(nil), "emissions.v9.EventReputerRegistered")
	proto.RegisterType((*EventWorkerRegistered)(nil), "emissions.v9.EventWorkerRegistered")
	proto.RegisterType((*EventReputerUnregistered)(nil), "emissions.v9.EventReputerUnregistered")
	proto.RegisterType((*EventWorkerUnregistered)(nil), "emissions.v9.EventWorkerUnregistered")
	proto.RegisterType((*EventFundTopic)(nil), "emissions.v9.EventFundTopic")
	proto.RegisterType((*EventParamsSet)(nil), "emissions.v9.EventParamsSet")
	proto.RegisterType((*EventWhitelistAdminAdded)(nil), "emissions.v9.EventWhitelistAdminAdded")
	proto.RegisterType((*EventWhitelistAdminRemoved)(nil), "emissions.v9.EventWhitelistAdminRemoved")
	proto.RegisterType((*EventGlobalWhitelistAdded)(nil), "emissions.v9.EventGlobalWhitelistAdded")
	proto.RegisterType((*EventGlobalWhitelistRemoved)(nil), "emissions.v9.EventGlobalWhitelistRemoved")
	proto.RegisterType((*EventGlobalWorkerWhitelistAdded)(nil), "emissions.v9.EventGlobalWorkerWhitelistAdded")
	proto.RegisterType((*EventGlobalWorkerWhitelistRemoved)(nil), "emissions.v9.EventGlobalWorkerWhitelistRemoved")
	proto.RegisterType((*EventGlobalReputerWhitelistAdded)(nil), "emissions.v9.EventGlobalReputerWhitelistAdded")
	proto.RegisterType((*EventGlobalReputerWhitelistRemoved)(nil), "emissions.v9.EventGlobalReputerWhitelistRemoved")
	proto.RegisterType((*EventGlobalAdminWhitelistAdded)(nil), "emissions.v9.EventGlobalAdminWhitelistAdded")
	proto.RegisterType((*EventGlobalAdminWhitelistRemoved)(nil), "emissions.v9.EventGlobalAdminWhitelistRemoved")
	proto.RegisterType((*EventTopicWorkerWhitelistEnabled)(nil), "emissions.v9.EventTopicWorkerWhitelistEnabled")
	proto.RegisterType((*EventTopicWorkerWhitelistDisabled)(nil), "emissions.v9.EventTopicWorkerWhitelistDisabled")
	proto.RegisterType((*EventTopicReputerWhitelistEnabled)(nil), "emissions.v9.EventTopicReputerWhitelistEnabled")
	proto.RegisterType((*EventTopicReputerWhitelistDisabled)(nil), "emissions.v9.EventTopicReputerWhitelistDisabled")
	proto.RegisterType((*EventTopicCreatorWhitelistAdded)(nil), "emissions.v9.EventTopicCreatorWhitelistAdded")
	proto.RegisterType((*EventTopicCreatorWhitelistRemoved)(nil), "emissions.v9.EventTopicCreatorWhitelistRemoved")
	proto.RegisterType((*EventTopicWorkerWhitelistAdded)(nil), "emissions.v9.EventTopicWorkerWhitelistAdded")
	proto.RegisterType((*EventTopicWorkerWhitelistRemoved)(nil), "emissions.v9.EventTopicWorkerWhitelistRemoved")
	proto.RegisterType((*EventTopicReputerWhitelistAdded)(nil), "emissions.v9.EventTopicReputerWhitelistAdded")
	proto.RegisterType((*EventTopicReputerWhitelistRemoved)(nil), "emissions.v9.EventTopicReputerWhitelistRemoved")
	proto.RegisterType((*EventForecastTaskScoreSet)(nil), "emissions.v9.EventForecastTaskScoreSet")
	proto.RegisterType((*EventWorkerLastCommitSet)(nil), "emissions.v9.EventWorkerLastCommitSet")
	proto.RegisterType((*EventReputerLastCommitSet)(nil), "emissions.v9.EventReputerLastCommitSet")
	proto.RegisterType((*EventTopicRewardsSet)(nil), "emissions.v9.EventTopicRewardsSet")
	proto.RegisterType((*EventEMAScoresSet)(nil), "emissions.v9.EventEMAScoresSet")
	proto.RegisterType((*EventListeningCoefficientsSet)(nil), "emissions.v9.EventListeningCoefficientsSet")
	proto.RegisterType((*EventInfererNetworkRegretSet)(nil), "emissions.v9.EventInfererNetworkRegretSet")
	proto.RegisterType((*EventForecasterNetworkRegretSet)(nil), "emissions.v9.EventForecasterNetworkRegretSet")
	proto.RegisterType((*EventNaiveInfererNetworkRegretSet)(nil), "emissions.v9.EventNaiveInfererNetworkRegretSet")
	proto.RegisterType((*EventTopicInitialRegretSet)(nil), "emissions.v9.EventTopicInitialRegretSet")
	proto.RegisterType((*EventTopicInitialEmaScoreSet)(nil), "emissions.v9.EventTopicInitialEmaScoreSet")
	proto.RegisterType((*EventRegretStdNormSet)(nil), "emissions.v9.EventRegretStdNormSet")
	proto.RegisterType((*EventInfererWeightsSet)(nil), "emissions.v9.EventInfererWeightsSet")
	proto.RegisterType((*EventForecasterWeightsSet)(nil), "emissions.v9.EventForecasterWeightsSet")
	proto.RegisterType((*EventPreviousPercentageRewardToStakedReputersSet)(nil), "emissions.v9.EventPreviousPercentageRewardToStakedReputersSet")
	proto.RegisterType((*EventPruneRecords)(nil), "emissions.v9.EventPruneRecords")
	proto.RegisterType((*EventDelegateRewardShareUpdated)(nil), "emissions.v9.EventDelegateRewardShareUpdated")
	proto.RegisterType((*EventDelegateRewardDistributed)(nil), "emissions.v9.EventDelegateRewardDistributed")
	proto.RegisterType((*EventActiveReputersSet)(nil), "emissions.v9.EventActiveReputersSet")
	proto.RegisterType((*EventActiveInferersSet)(nil), "emissions.v9.EventActiveInferersSet")
	proto.RegisterType((*EventActiveForecastersSet)(nil), "emissions.v9.EventActiveForecastersSet")
	proto.RegisterType((*EventTopicStatusChanged)(nil), "emissions.v9.EventTopicStatusChanged")
	proto.RegisterType((*EventNetworkInferenceInfererWeightsSet)(nil), "emissions.v9.EventNetworkInferenceInfererWeightsSet")
	proto.RegisterType((*EventNetworkInferenceForecasterWeightsSet)(nil), "emissions.v9.EventNetworkInferenceForecasterWeightsSet")
	proto.RegisterType((*EventNetworkInferenceInfererRegretsUsedSet)(nil), "emissions.v9.EventNetworkInferenceInfererRegretsUsedSet")
	proto.RegisterType((*EventNetworkInferenceForecasterRegretsUsedSet)(nil), "emissions.v9.EventNetworkInferenceForecasterRegretsUsedSet")
	proto.RegisterType((*EventTopicWeightUpdated)(nil), "emissions.v9.EventTopicWeightUpdated")
	proto.RegisterType((*EventTopicFeeRevenueDripped)(nil), "emissions.v9.EventTopicFeeRevenueDripped")
	proto.RegisterType((*EventWorkerSubmissionWindowOpened)(nil), "emissions.v9.EventWorkerSubmissionWindowOpened")
	proto.RegisterType((*EventWorkerSubmissionWindowClosed)(nil), "emissions.v9.EventWorkerSubmissionWindowClosed")
	proto.RegisterType((*EventReputerSubmissionWindowOpened)(nil), "emissions.v9.EventReputerSubmissionWindowOpened")
	proto.RegisterType((*EventReputerSubmissionWindowClosed)(nil), "emissions.v9.EventReputerSubmissionWindowClosed")
}

func init() { proto.RegisterFile("emissions/v9/events.proto", fileDescriptor_2d7671ca936dd333) }

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

func (this *EventValueBundle) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EventValueBundle)
	if !ok {
		that2, ok := that.(EventValueBundle)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.ExtraData, that1.ExtraData) {
		return false
	}
	if !this.CombinedValue.Equal(that1.CombinedValue) {
		return false
	}
	if !this.NaiveValue.Equal(that1.NaiveValue) {
		return false
	}
	if len(this.InfererAddresses) != len(that1.InfererAddresses) {
		return false
	}
	for i := range this.InfererAddresses {
		if this.InfererAddresses[i] != that1.InfererAddresses[i] {
			return false
		}
	}
	if len(this.ForecasterAddresses) != len(that1.ForecasterAddresses) {
		return false
	}
	for i := range this.ForecasterAddresses {
		if this.ForecasterAddresses[i] != that1.ForecasterAddresses[i] {
			return false
		}
	}
	if len(this.InfererValues) != len(that1.InfererValues) {
		return false
	}
	for i := range this.InfererValues {
		if !this.InfererValues[i].Equal(that1.InfererValues[i]) {
			return false
		}
	}
	if len(this.ForecasterValues) != len(that1.ForecasterValues) {
		return false
	}
	for i := range this.ForecasterValues {
		if !this.ForecasterValues[i].Equal(that1.ForecasterValues[i]) {
			return false
		}
	}
	if len(this.OneOutInfererValues) != len(that1.OneOutInfererValues) {
		return false
	}
	for i := range this.OneOutInfererValues {
		if !this.OneOutInfererValues[i].Equal(that1.OneOutInfererValues[i]) {
			return false
		}
	}
	if len(this.OneOutForecasterValues) != len(that1.OneOutForecasterValues) {
		return false
	}
	for i := range this.OneOutForecasterValues {
		if !this.OneOutForecasterValues[i].Equal(that1.OneOutForecasterValues[i]) {
			return false
		}
	}
	if len(this.OneInForecasterValues) != len(that1.OneInForecasterValues) {
		return false
	}
	for i := range this.OneInForecasterValues {
		if !this.OneInForecasterValues[i].Equal(that1.OneInForecasterValues[i]) {
			return false
		}
	}
	if len(this.OneOutInfererForecasterValues) != len(that1.OneOutInfererForecasterValues) {
		return false
	}
	for i := range this.OneOutInfererForecasterValues {
		if !this.OneOutInfererForecasterValues[i].Equal(that1.OneOutInfererForecasterValues[i]) {
			return false
		}
	}
	return true
}
func (this *EventInsertInfererPayload) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EventInsertInfererPayload)
	if !ok {
		that2, ok := that.(EventInsertInfererPayload)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Inferer != that1.Inferer {
		return false
	}
	if this.Nonce != that1.Nonce {
		return false
	}
	if this.TopicId != that1.TopicId {
		return false
	}
	if !this.Value.Equal(that1.Value) {
		return false
	}
	if !bytes.Equal(this.ExtraData, that1.ExtraData) {
		return false
	}
	return true
}
func (this *EventInsertForecasterPayload) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EventInsertForecasterPayload)
	if !ok {
		that2, ok := that.(EventInsertForecasterPayload)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Forecaster != that1.Forecaster {
		return false
	}
	if this.Nonce != that1.Nonce {
		return false
	}
	if this.TopicId != that1.TopicId {
		return false
	}
	if len(this.InfererAddresses) != len(that1.InfererAddresses) {
		return false
	}
	for i := range this.InfererAddresses {
		if this.InfererAddresses[i] != that1.InfererAddresses[i] {
			return false
		}
	}
	if len(this.InfererValues) != len(that1.InfererValues) {
		return false
	}
	for i := range this.InfererValues {
		if !this.InfererValues[i].Equal(that1.InfererValues[i]) {
			return false
		}
	}
	if !bytes.Equal(this.ExtraData, that1.ExtraData) {
		return false
	}
	return true
}
func (m *EventScoresSet) 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 *EventScoresSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventScoresSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Scores) > 0 {
		for iNdEx := len(m.Scores) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Scores[iNdEx].Size()
				i -= size
				if _, err := m.Scores[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x18
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if m.ActorType != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.ActorType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventRewardsSettled) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BlockHeightTx != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeightTx))
		i--
		dAtA[i] = 0x30
	}
	if len(m.Rewards) > 0 {
		for iNdEx := len(m.Rewards) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Rewards[iNdEx].Size()
				i -= size
				if _, err := m.Rewards[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x18
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if m.ActorType != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.ActorType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventNetworkLossSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Bundle != nil {
		{
			size, err := m.Bundle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Nonce != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x20
	}
	if m.ValueBundle != nil {
		{
			size, err := m.ValueBundle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventNetworkInferences) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Bundle != nil {
		{
			size, err := m.Bundle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Nonce != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x20
	}
	if m.ValueBundle != nil {
		{
			size, err := m.ValueBundle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventOutlierResistantNetworkInferences) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Bundle != nil {
		{
			size, err := m.Bundle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Nonce != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventValueBundle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.OneOutInfererForecasterValues) > 0 {
		for iNdEx := len(m.OneOutInfererForecasterValues) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.OneOutInfererForecasterValues[iNdEx].Size()
				i -= size
				if _, err := m.OneOutInfererForecasterValues[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.OneInForecasterValues) > 0 {
		for iNdEx := len(m.OneInForecasterValues) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.OneInForecasterValues[iNdEx].Size()
				i -= size
				if _, err := m.OneInForecasterValues[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.OneOutForecasterValues) > 0 {
		for iNdEx := len(m.OneOutForecasterValues) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.OneOutForecasterValues[iNdEx].Size()
				i -= size
				if _, err := m.OneOutForecasterValues[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.OneOutInfererValues) > 0 {
		for iNdEx := len(m.OneOutInfererValues) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.OneOutInfererValues[iNdEx].Size()
				i -= size
				if _, err := m.OneOutInfererValues[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.ForecasterValues) > 0 {
		for iNdEx := len(m.ForecasterValues) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.ForecasterValues[iNdEx].Size()
				i -= size
				if _, err := m.ForecasterValues[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.InfererValues) > 0 {
		for iNdEx := len(m.InfererValues) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.InfererValues[iNdEx].Size()
				i -= size
				if _, err := m.InfererValues[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.ForecasterAddresses) > 0 {
		for iNdEx := len(m.ForecasterAddresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ForecasterAddresses[iNdEx])
			copy(dAtA[i:], m.ForecasterAddresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.ForecasterAddresses[iNdEx])))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.InfererAddresses) > 0 {
		for iNdEx := len(m.InfererAddresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.InfererAddresses[iNdEx])
			copy(dAtA[i:], m.InfererAddresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.InfererAddresses[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	{
		size := m.NaiveValue.Size()
		i -= size
		if _, err := m.NaiveValue.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.CombinedValue.Size()
		i -= size
		if _, err := m.CombinedValue.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.ExtraData) > 0 {
		i -= len(m.ExtraData)
		copy(dAtA[i:], m.ExtraData)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ExtraData)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *EventInsertInfererPayload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ExtraData) > 0 {
		i -= len(m.ExtraData)
		copy(dAtA[i:], m.ExtraData)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ExtraData)))
		i--
		dAtA[i] = 0x2a
	}
	{
		size := m.Value.Size()
		i -= size
		if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x18
	}
	if m.Nonce != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Inferer) > 0 {
		i -= len(m.Inferer)
		copy(dAtA[i:], m.Inferer)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Inferer)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *EventInsertForecasterPayload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ExtraData) > 0 {
		i -= len(m.ExtraData)
		copy(dAtA[i:], m.ExtraData)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ExtraData)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.InfererValues) > 0 {
		for iNdEx := len(m.InfererValues) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.InfererValues[iNdEx].Size()
				i -= size
				if _, err := m.InfererValues[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.InfererAddresses) > 0 {
		for iNdEx := len(m.InfererAddresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.InfererAddresses[iNdEx])
			copy(dAtA[i:], m.InfererAddresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.InfererAddresses[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x18
	}
	if m.Nonce != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Forecaster) > 0 {
		i -= len(m.Forecaster)
		copy(dAtA[i:], m.Forecaster)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Forecaster)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *EventCreateNewTopic) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Topic != nil {
		{
			size, err := m.Topic.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *EventAddStake) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventRemoveStake) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventRequestStakeRemoval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CompletionHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.CompletionHeight))
		i--
		dAtA[i] = 0x28
	}
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventCancelStakeRemoval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventReputerStakeUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventRewardDelegateStake) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventInsertReputerPayload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Bundle != nil {
		{
			size, err := m.Bundle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Nonce != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventReputerRegistered) 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] = 0x1a
	}
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventWorkerRegistered) 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] = 0x1a
	}
	if len(m.Worker) > 0 {
		i -= len(m.Worker)
		copy(dAtA[i:], m.Worker)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Worker)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventReputerUnregistered) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventWorkerUnregistered) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Worker) > 0 {
		i -= len(m.Worker)
		copy(dAtA[i:], m.Worker)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Worker)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventFundTopic) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Funder) > 0 {
		i -= len(m.Funder)
		copy(dAtA[i:], m.Funder)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Funder)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventParamsSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Params != nil {
		{
			size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *EventTopicWorkerWhitelistEnabled) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventTopicWorkerWhitelistDisabled) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventTopicReputerWhitelistEnabled) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventTopicReputerWhitelistDisabled) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *EventTopicWorkerWhitelistAdded) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventTopicWorkerWhitelistRemoved) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventTopicReputerWhitelistAdded) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventTopicReputerWhitelistRemoved) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventForecastTaskScoreSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NonceBlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.NonceBlockHeight))
		i--
		dAtA[i] = 0x18
	}
	{
		size := m.Score.Size()
		i -= size
		if _, err := m.Score.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventWorkerLastCommitSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Nonce != nil {
		{
			size, err := m.Nonce.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventReputerLastCommitSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Nonce != nil {
		{
			size, err := m.Nonce.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventTopicRewardsSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Rewards) > 0 {
		for iNdEx := len(m.Rewards) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Rewards[iNdEx].Size()
				i -= size
				if _, err := m.Rewards[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.TopicIds) > 0 {
		dAtA12 := make([]byte, len(m.TopicIds)*10)
		var j11 int
		for _, num := range m.TopicIds {
			for num >= 1<<7 {
				dAtA12[j11] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j11++
			}
			dAtA12[j11] = uint8(num)
			j11++
		}
		i -= j11
		copy(dAtA[i:], dAtA12[:j11])
		i = encodeVarintEvents(dAtA, i, uint64(j11))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *EventEMAScoresSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.IsActive) > 0 {
		for iNdEx := len(m.IsActive) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.IsActive[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintEvents(dAtA, i, uint64(len(m.IsActive)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Scores) > 0 {
		for iNdEx := len(m.Scores) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Scores[iNdEx].Size()
				i -= size
				if _, err := m.Scores[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Nonce != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x18
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if m.ActorType != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.ActorType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventListeningCoefficientsSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Coefficients) > 0 {
		for iNdEx := len(m.Coefficients) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Coefficients[iNdEx].Size()
				i -= size
				if _, err := m.Coefficients[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x18
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if m.ActorType != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.ActorType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventInfererNetworkRegretSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Regrets) > 0 {
		for iNdEx := len(m.Regrets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Regrets[iNdEx].Size()
				i -= size
				if _, err := m.Regrets[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventForecasterNetworkRegretSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Regrets) > 0 {
		for iNdEx := len(m.Regrets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Regrets[iNdEx].Size()
				i -= size
				if _, err := m.Regrets[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventNaiveInfererNetworkRegretSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Regrets) > 0 {
		for iNdEx := len(m.Regrets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Regrets[iNdEx].Size()
				i -= size
				if _, err := m.Regrets[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventTopicInitialRegretSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Regret.Size()
		i -= size
		if _, err := m.Regret.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventTopicInitialEmaScoreSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Score.Size()
		i -= size
		if _, err := m.Score.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x18
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if m.ActorType != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.ActorType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventRegretStdNormSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Stdnorm.Size()
		i -= size
		if _, err := m.Stdnorm.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventInfererWeightsSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Weights) > 0 {
		for iNdEx := len(m.Weights) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Weights[iNdEx].Size()
				i -= size
				if _, err := m.Weights[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventForecasterWeightsSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Weights) > 0 {
		for iNdEx := len(m.Weights) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Weights[iNdEx].Size()
				i -= size
				if _, err := m.Weights[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventPreviousPercentageRewardToStakedReputersSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Percentage.Size()
		i -= size
		if _, err := m.Percentage.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventPruneRecords) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if m.BlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventDelegateRewardShareUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.RewardPerShare.Size()
		i -= size
		if _, err := m.RewardPerShare.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventDelegateRewardDistributed) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventActiveReputersSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NonceBlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.NonceBlockHeight))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventActiveInferersSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NonceBlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.NonceBlockHeight))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventActiveForecastersSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NonceBlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.NonceBlockHeight))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventTopicStatusChanged) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsActive {
		i--
		if m.IsActive {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventNetworkInferenceInfererWeightsSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Weights) > 0 {
		for iNdEx := len(m.Weights) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Weights[iNdEx].Size()
				i -= size
				if _, err := m.Weights[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.NonceBlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.NonceBlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventNetworkInferenceForecasterWeightsSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Weights) > 0 {
		for iNdEx := len(m.Weights) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Weights[iNdEx].Size()
				i -= size
				if _, err := m.Weights[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.NonceBlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.NonceBlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventNetworkInferenceInfererRegretsUsedSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Regrets) > 0 {
		for iNdEx := len(m.Regrets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Regrets[iNdEx].Size()
				i -= size
				if _, err := m.Regrets[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.NonceBlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.NonceBlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventNetworkInferenceForecasterRegretsUsedSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Regrets) > 0 {
		for iNdEx := len(m.Regrets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Regrets[iNdEx].Size()
				i -= size
				if _, err := m.Regrets[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.NonceBlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.NonceBlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventTopicWeightUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.TopicFeeRevenue.Size()
		i -= size
		if _, err := m.TopicFeeRevenue.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.TopicStake.Size()
		i -= size
		if _, err := m.TopicStake.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.NewWeight.Size()
		i -= size
		if _, err := m.NewWeight.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventTopicFeeRevenueDripped) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.DripAmount.Size()
		i -= size
		if _, err := m.DripAmount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.NewRevenue.Size()
		i -= size
		if _, err := m.NewRevenue.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.OldRevenue.Size()
		i -= size
		if _, err := m.OldRevenue.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventWorkerSubmissionWindowOpened) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.WindowEndBlock != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.WindowEndBlock))
		i--
		dAtA[i] = 0x18
	}
	if m.NonceBlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.NonceBlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventWorkerSubmissionWindowClosed) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NonceBlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.NonceBlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventReputerSubmissionWindowOpened) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.WindowEndBlock != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.WindowEndBlock))
		i--
		dAtA[i] = 0x18
	}
	if m.NonceBlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.NonceBlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EventReputerSubmissionWindowClosed) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NonceBlockHeight != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.NonceBlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	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 *EventScoresSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ActorType != 0 {
		n += 1 + sovEvents(uint64(m.ActorType))
	}
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Scores) > 0 {
		for _, e := range m.Scores {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventRewardsSettled) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ActorType != 0 {
		n += 1 + sovEvents(uint64(m.ActorType))
	}
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Rewards) > 0 {
		for _, e := range m.Rewards {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if m.BlockHeightTx != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeightTx))
	}
	return n
}

func (m *EventNetworkLossSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	if m.ValueBundle != nil {
		l = m.ValueBundle.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Nonce != 0 {
		n += 1 + sovEvents(uint64(m.Nonce))
	}
	if m.Bundle != nil {
		l = m.Bundle.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventNetworkInferences) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	if m.ValueBundle != nil {
		l = m.ValueBundle.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Nonce != 0 {
		n += 1 + sovEvents(uint64(m.Nonce))
	}
	if m.Bundle != nil {
		l = m.Bundle.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventOutlierResistantNetworkInferences) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.Nonce != 0 {
		n += 1 + sovEvents(uint64(m.Nonce))
	}
	if m.Bundle != nil {
		l = m.Bundle.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventValueBundle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ExtraData)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = m.CombinedValue.Size()
	n += 1 + l + sovEvents(uint64(l))
	l = m.NaiveValue.Size()
	n += 1 + l + sovEvents(uint64(l))
	if len(m.InfererAddresses) > 0 {
		for _, s := range m.InfererAddresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.ForecasterAddresses) > 0 {
		for _, s := range m.ForecasterAddresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.InfererValues) > 0 {
		for _, e := range m.InfererValues {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.ForecasterValues) > 0 {
		for _, e := range m.ForecasterValues {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.OneOutInfererValues) > 0 {
		for _, e := range m.OneOutInfererValues {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.OneOutForecasterValues) > 0 {
		for _, e := range m.OneOutForecasterValues {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.OneInForecasterValues) > 0 {
		for _, e := range m.OneInForecasterValues {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.OneOutInfererForecasterValues) > 0 {
		for _, e := range m.OneOutInfererForecasterValues {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventInsertInfererPayload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Inferer)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Nonce != 0 {
		n += 1 + sovEvents(uint64(m.Nonce))
	}
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	l = m.Value.Size()
	n += 1 + l + sovEvents(uint64(l))
	l = len(m.ExtraData)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventInsertForecasterPayload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Forecaster)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Nonce != 0 {
		n += 1 + sovEvents(uint64(m.Nonce))
	}
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if len(m.InfererAddresses) > 0 {
		for _, s := range m.InfererAddresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.InfererValues) > 0 {
		for _, e := range m.InfererValues {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	l = len(m.ExtraData)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventCreateNewTopic) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Topic != nil {
		l = m.Topic.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventAddStake) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventRemoveStake) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventRequestStakeRemoval) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovEvents(uint64(l))
	if m.CompletionHeight != 0 {
		n += 1 + sovEvents(uint64(m.CompletionHeight))
	}
	return n
}

func (m *EventCancelStakeRemoval) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventReputerStakeUpdated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventRewardDelegateStake) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventInsertReputerPayload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.Nonce != 0 {
		n += 1 + sovEvents(uint64(m.Nonce))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Bundle != nil {
		l = m.Bundle.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

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

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

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

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

func (m *EventFundTopic) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	l = len(m.Funder)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventParamsSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Params != nil {
		l = m.Params.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

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

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

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

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

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

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

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

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

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

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

func (m *EventTopicWorkerWhitelistEnabled) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	return n
}

func (m *EventTopicWorkerWhitelistDisabled) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	return n
}

func (m *EventTopicReputerWhitelistEnabled) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	return n
}

func (m *EventTopicReputerWhitelistDisabled) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	return n
}

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

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

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

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

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

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

func (m *EventForecastTaskScoreSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	l = m.Score.Size()
	n += 1 + l + sovEvents(uint64(l))
	if m.NonceBlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.NonceBlockHeight))
	}
	return n
}

func (m *EventWorkerLastCommitSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	if m.Nonce != nil {
		l = m.Nonce.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventReputerLastCommitSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	if m.Nonce != nil {
		l = m.Nonce.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventTopicRewardsSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.TopicIds) > 0 {
		l = 0
		for _, e := range m.TopicIds {
			l += sovEvents(uint64(e))
		}
		n += 1 + sovEvents(uint64(l)) + l
	}
	if len(m.Rewards) > 0 {
		for _, e := range m.Rewards {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventEMAScoresSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ActorType != 0 {
		n += 1 + sovEvents(uint64(m.ActorType))
	}
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.Nonce != 0 {
		n += 1 + sovEvents(uint64(m.Nonce))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Scores) > 0 {
		for _, e := range m.Scores {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.IsActive) > 0 {
		n += 1 + sovEvents(uint64(len(m.IsActive))) + len(m.IsActive)*1
	}
	return n
}

func (m *EventListeningCoefficientsSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ActorType != 0 {
		n += 1 + sovEvents(uint64(m.ActorType))
	}
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Coefficients) > 0 {
		for _, e := range m.Coefficients {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventInfererNetworkRegretSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Regrets) > 0 {
		for _, e := range m.Regrets {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventForecasterNetworkRegretSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Regrets) > 0 {
		for _, e := range m.Regrets {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventNaiveInfererNetworkRegretSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Regrets) > 0 {
		for _, e := range m.Regrets {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventTopicInitialRegretSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	l = m.Regret.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventTopicInitialEmaScoreSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ActorType != 0 {
		n += 1 + sovEvents(uint64(m.ActorType))
	}
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	l = m.Score.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventRegretStdNormSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	l = m.Stdnorm.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventInfererWeightsSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Weights) > 0 {
		for _, e := range m.Weights {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventForecasterWeightsSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Weights) > 0 {
		for _, e := range m.Weights {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventPreviousPercentageRewardToStakedReputersSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	l = m.Percentage.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventPruneRecords) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.BlockHeight))
	}
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	return n
}

func (m *EventDelegateRewardShareUpdated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = m.RewardPerShare.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventDelegateRewardDistributed) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventActiveReputersSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if m.NonceBlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.NonceBlockHeight))
	}
	return n
}

func (m *EventActiveInferersSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if m.NonceBlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.NonceBlockHeight))
	}
	return n
}

func (m *EventActiveForecastersSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if m.NonceBlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.NonceBlockHeight))
	}
	return n
}

func (m *EventTopicStatusChanged) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.IsActive {
		n += 2
	}
	return n
}

func (m *EventNetworkInferenceInfererWeightsSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.NonceBlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.NonceBlockHeight))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Weights) > 0 {
		for _, e := range m.Weights {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventNetworkInferenceForecasterWeightsSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.NonceBlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.NonceBlockHeight))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Weights) > 0 {
		for _, e := range m.Weights {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventNetworkInferenceInfererRegretsUsedSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.NonceBlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.NonceBlockHeight))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Regrets) > 0 {
		for _, e := range m.Regrets {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventNetworkInferenceForecasterRegretsUsedSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.NonceBlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.NonceBlockHeight))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Regrets) > 0 {
		for _, e := range m.Regrets {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventTopicWeightUpdated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	l = m.NewWeight.Size()
	n += 1 + l + sovEvents(uint64(l))
	l = m.TopicStake.Size()
	n += 1 + l + sovEvents(uint64(l))
	l = m.TopicFeeRevenue.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventTopicFeeRevenueDripped) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	l = m.OldRevenue.Size()
	n += 1 + l + sovEvents(uint64(l))
	l = m.NewRevenue.Size()
	n += 1 + l + sovEvents(uint64(l))
	l = m.DripAmount.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventWorkerSubmissionWindowOpened) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.NonceBlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.NonceBlockHeight))
	}
	if m.WindowEndBlock != 0 {
		n += 1 + sovEvents(uint64(m.WindowEndBlock))
	}
	return n
}

func (m *EventWorkerSubmissionWindowClosed) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.NonceBlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.NonceBlockHeight))
	}
	return n
}

func (m *EventReputerSubmissionWindowOpened) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.NonceBlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.NonceBlockHeight))
	}
	if m.WindowEndBlock != 0 {
		n += 1 + sovEvents(uint64(m.WindowEndBlock))
	}
	return n
}

func (m *EventReputerSubmissionWindowClosed) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovEvents(uint64(m.TopicId))
	}
	if m.NonceBlockHeight != 0 {
		n += 1 + sovEvents(uint64(m.NonceBlockHeight))
	}
	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 *EventScoresSet) 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: EventScoresSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventScoresSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorType", wireType)
			}
			m.ActorType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ActorType |= ActorType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scores", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.Scores = append(m.Scores, v)
			if err := m.Scores[len(m.Scores)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventRewardsSettled) 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: EventRewardsSettled: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventRewardsSettled: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorType", wireType)
			}
			m.ActorType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ActorType |= ActorType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rewards", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.Rewards = append(m.Rewards, v)
			if err := m.Rewards[len(m.Rewards)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeightTx", wireType)
			}
			m.BlockHeightTx = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeightTx |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *EventNetworkLossSet) 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: EventNetworkLossSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventNetworkLossSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValueBundle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValueBundle == nil {
				m.ValueBundle = &ValueBundle{}
			}
			if err := m.ValueBundle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bundle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Bundle == nil {
				m.Bundle = &EventValueBundle{}
			}
			if err := m.Bundle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventNetworkInferences) 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: EventNetworkInferences: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventNetworkInferences: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValueBundle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValueBundle == nil {
				m.ValueBundle = &ValueBundle{}
			}
			if err := m.ValueBundle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bundle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Bundle == nil {
				m.Bundle = &EventValueBundle{}
			}
			if err := m.Bundle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventOutlierResistantNetworkInferences) 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: EventOutlierResistantNetworkInferences: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventOutlierResistantNetworkInferences: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bundle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Bundle == nil {
				m.Bundle = &EventValueBundle{}
			}
			if err := m.Bundle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventValueBundle) 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: EventValueBundle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventValueBundle: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExtraData = append(m.ExtraData[:0], dAtA[iNdEx:postIndex]...)
			if m.ExtraData == nil {
				m.ExtraData = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CombinedValue", 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
			}
			if err := m.CombinedValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NaiveValue", 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
			}
			if err := m.NaiveValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InfererAddresses", 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.InfererAddresses = append(m.InfererAddresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForecasterAddresses", 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.ForecasterAddresses = append(m.ForecasterAddresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InfererValues", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.InfererValues = append(m.InfererValues, v)
			if err := m.InfererValues[len(m.InfererValues)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForecasterValues", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.ForecasterValues = append(m.ForecasterValues, v)
			if err := m.ForecasterValues[len(m.ForecasterValues)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OneOutInfererValues", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.OneOutInfererValues = append(m.OneOutInfererValues, v)
			if err := m.OneOutInfererValues[len(m.OneOutInfererValues)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OneOutForecasterValues", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.OneOutForecasterValues = append(m.OneOutForecasterValues, v)
			if err := m.OneOutForecasterValues[len(m.OneOutForecasterValues)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OneInForecasterValues", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.OneInForecasterValues = append(m.OneInForecasterValues, v)
			if err := m.OneInForecasterValues[len(m.OneInForecasterValues)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OneOutInfererForecasterValues", 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
			}
			var v github_com_allora_network_allora_chain_math.DecArray
			m.OneOutInfererForecasterValues = append(m.OneOutInfererForecasterValues, v)
			if err := m.OneOutInfererForecasterValues[len(m.OneOutInfererForecasterValues)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventInsertInfererPayload) 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: EventInsertInfererPayload: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventInsertInfererPayload: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Inferer", 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.Inferer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", 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
			}
			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExtraData = append(m.ExtraData[:0], dAtA[iNdEx:postIndex]...)
			if m.ExtraData == nil {
				m.ExtraData = []byte{}
			}
			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 *EventInsertForecasterPayload) 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: EventInsertForecasterPayload: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventInsertForecasterPayload: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Forecaster", 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.Forecaster = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InfererAddresses", 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.InfererAddresses = append(m.InfererAddresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InfererValues", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.InfererValues = append(m.InfererValues, v)
			if err := m.InfererValues[len(m.InfererValues)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExtraData = append(m.ExtraData[:0], dAtA[iNdEx:postIndex]...)
			if m.ExtraData == nil {
				m.ExtraData = []byte{}
			}
			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 *EventCreateNewTopic) 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: EventCreateNewTopic: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventCreateNewTopic: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Topic == nil {
				m.Topic = &Topic{}
			}
			if err := m.Topic.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventAddStake) 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: EventAddStake: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventAddStake: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", 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.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", 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.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventRemoveStake) 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: EventRemoveStake: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventRemoveStake: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", 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.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", 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.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventRequestStakeRemoval) 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: EventRequestStakeRemoval: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventRequestStakeRemoval: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", 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.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", 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.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompletionHeight", wireType)
			}
			m.CompletionHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CompletionHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *EventCancelStakeRemoval) 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: EventCancelStakeRemoval: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventCancelStakeRemoval: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", 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.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", 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.Delegator = 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 *EventReputerStakeUpdated) 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: EventReputerStakeUpdated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventReputerStakeUpdated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", 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.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventRewardDelegateStake) 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: EventRewardDelegateStake: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventRewardDelegateStake: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", 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.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", 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.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventInsertReputerPayload) 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: EventInsertReputerPayload: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventInsertReputerPayload: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", 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.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bundle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Bundle == nil {
				m.Bundle = &EventValueBundle{}
			}
			if err := m.Bundle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventReputerRegistered) 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: EventReputerRegistered: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventReputerRegistered: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", 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.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 *EventWorkerRegistered) 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: EventWorkerRegistered: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventWorkerRegistered: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Worker", 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.Worker = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 *EventReputerUnregistered) 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: EventReputerUnregistered: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventReputerUnregistered: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", 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.Reputer = 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 *EventWorkerUnregistered) 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: EventWorkerUnregistered: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventWorkerUnregistered: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Worker", 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.Worker = 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 *EventFundTopic) 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: EventFundTopic: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventFundTopic: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Funder", 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.Funder = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventParamsSet) 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: EventParamsSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventParamsSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Params == nil {
				m.Params = &Params{}
			}
			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventWhitelistAdminAdded) 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: EventWhitelistAdminAdded: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventWhitelistAdminAdded: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Admin", 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.Admin = 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 *EventWhitelistAdminRemoved) 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: EventWhitelistAdminRemoved: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventWhitelistAdminRemoved: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Admin", 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.Admin = 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 *EventGlobalWhitelistAdded) 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: EventGlobalWhitelistAdded: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventGlobalWhitelistAdded: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *EventGlobalWhitelistRemoved) 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: EventGlobalWhitelistRemoved: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventGlobalWhitelistRemoved: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *EventGlobalWorkerWhitelistAdded) 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: EventGlobalWorkerWhitelistAdded: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventGlobalWorkerWhitelistAdded: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *EventGlobalWorkerWhitelistRemoved) 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: EventGlobalWorkerWhitelistRemoved: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventGlobalWorkerWhitelistRemoved: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *EventGlobalReputerWhitelistAdded) 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: EventGlobalReputerWhitelistAdded: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventGlobalReputerWhitelistAdded: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *EventGlobalReputerWhitelistRemoved) 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: EventGlobalReputerWhitelistRemoved: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventGlobalReputerWhitelistRemoved: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *EventGlobalAdminWhitelistAdded) 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: EventGlobalAdminWhitelistAdded: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventGlobalAdminWhitelistAdded: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *EventGlobalAdminWhitelistRemoved) 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: EventGlobalAdminWhitelistRemoved: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventGlobalAdminWhitelistRemoved: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *EventTopicWorkerWhitelistEnabled) 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: EventTopicWorkerWhitelistEnabled: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicWorkerWhitelistEnabled: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *EventTopicWorkerWhitelistDisabled) 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: EventTopicWorkerWhitelistDisabled: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicWorkerWhitelistDisabled: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *EventTopicReputerWhitelistEnabled) 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: EventTopicReputerWhitelistEnabled: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicReputerWhitelistEnabled: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *EventTopicReputerWhitelistDisabled) 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: EventTopicReputerWhitelistDisabled: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicReputerWhitelistDisabled: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *EventTopicCreatorWhitelistAdded) 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: EventTopicCreatorWhitelistAdded: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicCreatorWhitelistAdded: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *EventTopicCreatorWhitelistRemoved) 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: EventTopicCreatorWhitelistRemoved: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicCreatorWhitelistRemoved: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *EventTopicWorkerWhitelistAdded) 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: EventTopicWorkerWhitelistAdded: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicWorkerWhitelistAdded: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *EventTopicWorkerWhitelistRemoved) 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: EventTopicWorkerWhitelistRemoved: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicWorkerWhitelistRemoved: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *EventTopicReputerWhitelistAdded) 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: EventTopicReputerWhitelistAdded: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicReputerWhitelistAdded: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *EventTopicReputerWhitelistRemoved) 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: EventTopicReputerWhitelistRemoved: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicReputerWhitelistRemoved: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *EventForecastTaskScoreSet) 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: EventForecastTaskScoreSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventForecastTaskScoreSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Score", 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
			}
			if err := m.Score.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonceBlockHeight", wireType)
			}
			m.NonceBlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NonceBlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *EventWorkerLastCommitSet) 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: EventWorkerLastCommitSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventWorkerLastCommitSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Nonce == nil {
				m.Nonce = &Nonce{}
			}
			if err := m.Nonce.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventReputerLastCommitSet) 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: EventReputerLastCommitSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventReputerLastCommitSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Nonce == nil {
				m.Nonce = &Nonce{}
			}
			if err := m.Nonce.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventTopicRewardsSet) 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: EventTopicRewardsSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicRewardsSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEvents
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.TopicIds = append(m.TopicIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEvents
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthEvents
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthEvents
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.TopicIds) == 0 {
					m.TopicIds = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowEvents
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.TopicIds = append(m.TopicIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicIds", wireType)
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rewards", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.Rewards = append(m.Rewards, v)
			if err := m.Rewards[len(m.Rewards)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventEMAScoresSet) 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: EventEMAScoresSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventEMAScoresSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorType", wireType)
			}
			m.ActorType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ActorType |= ActorType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scores", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.Scores = append(m.Scores, v)
			if err := m.Scores[len(m.Scores)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEvents
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.IsActive = append(m.IsActive, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEvents
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthEvents
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthEvents
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.IsActive) == 0 {
					m.IsActive = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowEvents
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.IsActive = append(m.IsActive, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field IsActive", wireType)
			}
		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 *EventListeningCoefficientsSet) 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: EventListeningCoefficientsSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventListeningCoefficientsSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorType", wireType)
			}
			m.ActorType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ActorType |= ActorType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Coefficients", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.Coefficients = append(m.Coefficients, v)
			if err := m.Coefficients[len(m.Coefficients)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventInfererNetworkRegretSet) 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: EventInfererNetworkRegretSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventInfererNetworkRegretSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Regrets", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.Regrets = append(m.Regrets, v)
			if err := m.Regrets[len(m.Regrets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventForecasterNetworkRegretSet) 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: EventForecasterNetworkRegretSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventForecasterNetworkRegretSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Regrets", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.Regrets = append(m.Regrets, v)
			if err := m.Regrets[len(m.Regrets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventNaiveInfererNetworkRegretSet) 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: EventNaiveInfererNetworkRegretSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventNaiveInfererNetworkRegretSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Regrets", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.Regrets = append(m.Regrets, v)
			if err := m.Regrets[len(m.Regrets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventTopicInitialRegretSet) 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: EventTopicInitialRegretSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicInitialRegretSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Regret", 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
			}
			if err := m.Regret.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventTopicInitialEmaScoreSet) 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: EventTopicInitialEmaScoreSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicInitialEmaScoreSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorType", wireType)
			}
			m.ActorType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ActorType |= ActorType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Score", 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
			}
			if err := m.Score.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventRegretStdNormSet) 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: EventRegretStdNormSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventRegretStdNormSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stdnorm", 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
			}
			if err := m.Stdnorm.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventInfererWeightsSet) 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: EventInfererWeightsSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventInfererWeightsSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weights", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.Weights = append(m.Weights, v)
			if err := m.Weights[len(m.Weights)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventForecasterWeightsSet) 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: EventForecasterWeightsSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventForecasterWeightsSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weights", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.Weights = append(m.Weights, v)
			if err := m.Weights[len(m.Weights)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventPreviousPercentageRewardToStakedReputersSet) 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: EventPreviousPercentageRewardToStakedReputersSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventPreviousPercentageRewardToStakedReputersSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentage", 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
			}
			if err := m.Percentage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventPruneRecords) 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: EventPruneRecords: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventPruneRecords: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *EventDelegateRewardShareUpdated) 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: EventDelegateRewardShareUpdated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventDelegateRewardShareUpdated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", 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.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RewardPerShare", 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
			}
			if err := m.RewardPerShare.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventDelegateRewardDistributed) 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: EventDelegateRewardDistributed: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventDelegateRewardDistributed: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", 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.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventActiveReputersSet) 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: EventActiveReputersSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventActiveReputersSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonceBlockHeight", wireType)
			}
			m.NonceBlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NonceBlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *EventActiveInferersSet) 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: EventActiveInferersSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventActiveInferersSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonceBlockHeight", wireType)
			}
			m.NonceBlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NonceBlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *EventActiveForecastersSet) 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: EventActiveForecastersSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventActiveForecastersSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonceBlockHeight", wireType)
			}
			m.NonceBlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NonceBlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *EventTopicStatusChanged) 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: EventTopicStatusChanged: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicStatusChanged: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsActive", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsActive = bool(v != 0)
		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 *EventNetworkInferenceInfererWeightsSet) 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: EventNetworkInferenceInfererWeightsSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventNetworkInferenceInfererWeightsSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonceBlockHeight", wireType)
			}
			m.NonceBlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NonceBlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weights", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.Weights = append(m.Weights, v)
			if err := m.Weights[len(m.Weights)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventNetworkInferenceForecasterWeightsSet) 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: EventNetworkInferenceForecasterWeightsSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventNetworkInferenceForecasterWeightsSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonceBlockHeight", wireType)
			}
			m.NonceBlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NonceBlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weights", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.Weights = append(m.Weights, v)
			if err := m.Weights[len(m.Weights)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventNetworkInferenceInfererRegretsUsedSet) 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: EventNetworkInferenceInfererRegretsUsedSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventNetworkInferenceInfererRegretsUsedSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonceBlockHeight", wireType)
			}
			m.NonceBlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NonceBlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Regrets", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.Regrets = append(m.Regrets, v)
			if err := m.Regrets[len(m.Regrets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventNetworkInferenceForecasterRegretsUsedSet) 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: EventNetworkInferenceForecasterRegretsUsedSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventNetworkInferenceForecasterRegretsUsedSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonceBlockHeight", wireType)
			}
			m.NonceBlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NonceBlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", 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.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Regrets", 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
			}
			var v github_com_allora_network_allora_chain_math.Dec
			m.Regrets = append(m.Regrets, v)
			if err := m.Regrets[len(m.Regrets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventTopicWeightUpdated) 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: EventTopicWeightUpdated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicWeightUpdated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewWeight", 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
			}
			if err := m.NewWeight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicStake", 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
			}
			if err := m.TopicStake.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicFeeRevenue", 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
			}
			if err := m.TopicFeeRevenue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventTopicFeeRevenueDripped) 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: EventTopicFeeRevenueDripped: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTopicFeeRevenueDripped: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OldRevenue", 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
			}
			if err := m.OldRevenue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewRevenue", 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
			}
			if err := m.NewRevenue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DripAmount", 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
			}
			if err := m.DripAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *EventWorkerSubmissionWindowOpened) 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: EventWorkerSubmissionWindowOpened: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventWorkerSubmissionWindowOpened: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonceBlockHeight", wireType)
			}
			m.NonceBlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NonceBlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WindowEndBlock", wireType)
			}
			m.WindowEndBlock = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WindowEndBlock |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *EventWorkerSubmissionWindowClosed) 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: EventWorkerSubmissionWindowClosed: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventWorkerSubmissionWindowClosed: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonceBlockHeight", wireType)
			}
			m.NonceBlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NonceBlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *EventReputerSubmissionWindowOpened) 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: EventReputerSubmissionWindowOpened: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventReputerSubmissionWindowOpened: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonceBlockHeight", wireType)
			}
			m.NonceBlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NonceBlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WindowEndBlock", wireType)
			}
			m.WindowEndBlock = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WindowEndBlock |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *EventReputerSubmissionWindowClosed) 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: EventReputerSubmissionWindowClosed: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventReputerSubmissionWindowClosed: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonceBlockHeight", wireType)
			}
			m.NonceBlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NonceBlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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")
)
