types.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: emissions/state/v1/types.proto

package emissions

import (
	bytes "bytes"
	cosmossdk_io_math "cosmossdk.io/math"
	fmt "fmt"
	_ "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

// Params defines the parameters of the module.
type Params struct {
	Version                       string                      `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	EpochLength                   int64                       `protobuf:"varint,2,opt,name=epoch_length,json=epochLength,proto3" json:"epoch_length,omitempty"`
	MinTopicUnmetDemand           cosmossdk_io_math.Uint      `protobuf:"bytes,3,opt,name=min_topic_unmet_demand,json=minTopicUnmetDemand,proto3,customtype=cosmossdk.io/math.Uint" json:"min_topic_unmet_demand"`
	MaxTopicsPerBlock             uint64                      `protobuf:"varint,4,opt,name=max_topics_per_block,json=maxTopicsPerBlock,proto3" json:"max_topics_per_block,omitempty"`
	MinRequestUnmetDemand         cosmossdk_io_math.Uint      `protobuf:"bytes,5,opt,name=min_request_unmet_demand,json=minRequestUnmetDemand,proto3,customtype=cosmossdk.io/math.Uint" json:"min_request_unmet_demand"`
	MaxMissingInferencePercent    cosmossdk_io_math.LegacyDec `protobuf:"bytes,6,opt,name=max_missing_inference_percent,json=maxMissingInferencePercent,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"max_missing_inference_percent"`
	RequiredMinimumStake          cosmossdk_io_math.Uint      `protobuf:"bytes,7,opt,name=required_minimum_stake,json=requiredMinimumStake,proto3,customtype=cosmossdk.io/math.Uint" json:"required_minimum_stake"`
	RemoveStakeDelayWindow        uint64                      `protobuf:"varint,8,opt,name=remove_stake_delay_window,json=removeStakeDelayWindow,proto3" json:"remove_stake_delay_window,omitempty"`
	MinRequestCadence             uint64                      `protobuf:"varint,9,opt,name=min_request_cadence,json=minRequestCadence,proto3" json:"min_request_cadence,omitempty"`
	MinWeightCadence              uint64                      `protobuf:"varint,10,opt,name=min_weight_cadence,json=minWeightCadence,proto3" json:"min_weight_cadence,omitempty"`
	MaxInferenceRequestValidity   uint64                      `protobuf:"varint,11,opt,name=max_inference_request_validity,json=maxInferenceRequestValidity,proto3" json:"max_inference_request_validity,omitempty"`
	MaxRequestCadence             uint64                      `protobuf:"varint,12,opt,name=max_request_cadence,json=maxRequestCadence,proto3" json:"max_request_cadence,omitempty"`
	PercentRewardsReputersWorkers cosmossdk_io_math.LegacyDec `protobuf:"bytes,13,opt,name=percent_rewards_reputers_workers,json=percentRewardsReputersWorkers,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"percent_rewards_reputers_workers"`
}

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

var xxx_messageInfo_Params proto.InternalMessageInfo

func (m *Params) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *Params) GetEpochLength() int64 {
	if m != nil {
		return m.EpochLength
	}
	return 0
}

func (m *Params) GetMaxTopicsPerBlock() uint64 {
	if m != nil {
		return m.MaxTopicsPerBlock
	}
	return 0
}

func (m *Params) GetRemoveStakeDelayWindow() uint64 {
	if m != nil {
		return m.RemoveStakeDelayWindow
	}
	return 0
}

func (m *Params) GetMinRequestCadence() uint64 {
	if m != nil {
		return m.MinRequestCadence
	}
	return 0
}

func (m *Params) GetMinWeightCadence() uint64 {
	if m != nil {
		return m.MinWeightCadence
	}
	return 0
}

func (m *Params) GetMaxInferenceRequestValidity() uint64 {
	if m != nil {
		return m.MaxInferenceRequestValidity
	}
	return 0
}

func (m *Params) GetMaxRequestCadence() uint64 {
	if m != nil {
		return m.MaxRequestCadence
	}
	return 0
}

// GenesisState is the state that must be provided at genesis.
type GenesisState struct {
	// params defines all the parameters of the module.
	Params            Params   `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
	CoreTeamAddresses []string `protobuf:"bytes,2,rep,name=core_team_addresses,json=coreTeamAddresses,proto3" json:"core_team_addresses,omitempty"`
}

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

var xxx_messageInfo_GenesisState proto.InternalMessageInfo

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

func (m *GenesisState) GetCoreTeamAddresses() []string {
	if m != nil {
		return m.CoreTeamAddresses
	}
	return nil
}

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

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

var xxx_messageInfo_StakeInfo proto.InternalMessageInfo

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

func (m *StakeInfo) GetAmount() string {
	if m != nil {
		return m.Amount
	}
	return ""
}

type Topic struct {
	Id               uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Creator          string `protobuf:"bytes,2,opt,name=creator,proto3" json:"creator,omitempty"`
	Metadata         string `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"`
	WeightLogic      string `protobuf:"bytes,4,opt,name=weight_logic,json=weightLogic,proto3" json:"weight_logic,omitempty"`
	WeightMethod     string `protobuf:"bytes,5,opt,name=weight_method,json=weightMethod,proto3" json:"weight_method,omitempty"`
	WeightCadence    uint64 `protobuf:"varint,6,opt,name=weight_cadence,json=weightCadence,proto3" json:"weight_cadence,omitempty"`
	WeightLastRan    uint64 `protobuf:"varint,7,opt,name=weight_last_ran,json=weightLastRan,proto3" json:"weight_last_ran,omitempty"`
	InferenceLogic   string `protobuf:"bytes,8,opt,name=inference_logic,json=inferenceLogic,proto3" json:"inference_logic,omitempty"`
	InferenceMethod  string `protobuf:"bytes,9,opt,name=inference_method,json=inferenceMethod,proto3" json:"inference_method,omitempty"`
	InferenceCadence uint64 `protobuf:"varint,10,opt,name=inference_cadence,json=inferenceCadence,proto3" json:"inference_cadence,omitempty"`
	InferenceLastRan uint64 `protobuf:"varint,11,opt,name=inference_last_ran,json=inferenceLastRan,proto3" json:"inference_last_ran,omitempty"`
	Active           bool   `protobuf:"varint,12,opt,name=active,proto3" json:"active,omitempty"`
	DefaultArg       string `protobuf:"bytes,13,opt,name=default_arg,json=defaultArg,proto3" json:"default_arg,omitempty"`
}

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

var xxx_messageInfo_Topic proto.InternalMessageInfo

func (m *Topic) GetId() uint64 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *Topic) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *Topic) GetMetadata() string {
	if m != nil {
		return m.Metadata
	}
	return ""
}

func (m *Topic) GetWeightLogic() string {
	if m != nil {
		return m.WeightLogic
	}
	return ""
}

func (m *Topic) GetWeightMethod() string {
	if m != nil {
		return m.WeightMethod
	}
	return ""
}

func (m *Topic) GetWeightCadence() uint64 {
	if m != nil {
		return m.WeightCadence
	}
	return 0
}

func (m *Topic) GetWeightLastRan() uint64 {
	if m != nil {
		return m.WeightLastRan
	}
	return 0
}

func (m *Topic) GetInferenceLogic() string {
	if m != nil {
		return m.InferenceLogic
	}
	return ""
}

func (m *Topic) GetInferenceMethod() string {
	if m != nil {
		return m.InferenceMethod
	}
	return ""
}

func (m *Topic) GetInferenceCadence() uint64 {
	if m != nil {
		return m.InferenceCadence
	}
	return 0
}

func (m *Topic) GetInferenceLastRan() uint64 {
	if m != nil {
		return m.InferenceLastRan
	}
	return 0
}

func (m *Topic) GetActive() bool {
	if m != nil {
		return m.Active
	}
	return false
}

func (m *Topic) GetDefaultArg() string {
	if m != nil {
		return m.DefaultArg
	}
	return ""
}

type TopicList struct {
	Topics []*Topic `protobuf:"bytes,1,rep,name=topics,proto3" json:"topics,omitempty"`
}

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

var xxx_messageInfo_TopicList proto.InternalMessageInfo

func (m *TopicList) GetTopics() []*Topic {
	if m != nil {
		return m.Topics
	}
	return nil
}

type Weight 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"`
	Worker  string                 `protobuf:"bytes,3,opt,name=worker,proto3" json:"worker,omitempty"`
	Weight  cosmossdk_io_math.Uint `protobuf:"bytes,4,opt,name=weight,proto3,customtype=cosmossdk.io/math.Uint" json:"weight"`
}

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

var xxx_messageInfo_Weight proto.InternalMessageInfo

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

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

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

type Weights struct {
	Weights []*Weight `protobuf:"bytes,1,rep,name=weights,proto3" json:"weights,omitempty"`
}

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

var xxx_messageInfo_Weights proto.InternalMessageInfo

func (m *Weights) GetWeights() []*Weight {
	if m != nil {
		return m.Weights
	}
	return nil
}

type Inference 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"`
	Value     cosmossdk_io_math.Uint `protobuf:"bytes,3,opt,name=value,proto3,customtype=cosmossdk.io/math.Uint" json:"value"`
	ExtraData []byte                 `protobuf:"bytes,4,opt,name=extra_data,json=extraData,proto3" json:"extra_data,omitempty"`
	Proof     string                 `protobuf:"bytes,5,opt,name=proof,proto3" json:"proof,omitempty"`
}

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

var xxx_messageInfo_Inference proto.InternalMessageInfo

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

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

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

func (m *Inference) GetProof() string {
	if m != nil {
		return m.Proof
	}
	return ""
}

type Inferences struct {
	Inferences []*Inference `protobuf:"bytes,1,rep,name=inferences,proto3" json:"inferences,omitempty"`
}

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

var xxx_messageInfo_Inferences proto.InternalMessageInfo

func (m *Inferences) GetInferences() []*Inference {
	if m != nil {
		return m.Inferences
	}
	return nil
}

type OffchainNode struct {
	LibP2PKey    string `protobuf:"bytes,1,opt,name=lib_p2p_key,json=libP2pKey,proto3" json:"lib_p2p_key,omitempty"`
	MultiAddress string `protobuf:"bytes,2,opt,name=multi_address,json=multiAddress,proto3" json:"multi_address,omitempty"`
	Owner        string `protobuf:"bytes,3,opt,name=owner,proto3" json:"owner,omitempty"`
	NodeAddress  string `protobuf:"bytes,4,opt,name=node_address,json=nodeAddress,proto3" json:"node_address,omitempty"`
	NodeId       string `protobuf:"bytes,5,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
}

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

var xxx_messageInfo_OffchainNode proto.InternalMessageInfo

func (m *OffchainNode) GetLibP2PKey() string {
	if m != nil {
		return m.LibP2PKey
	}
	return ""
}

func (m *OffchainNode) GetMultiAddress() string {
	if m != nil {
		return m.MultiAddress
	}
	return ""
}

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

func (m *OffchainNode) GetNodeAddress() string {
	if m != nil {
		return m.NodeAddress
	}
	return ""
}

func (m *OffchainNode) GetNodeId() string {
	if m != nil {
		return m.NodeId
	}
	return ""
}

type OffchainNodes struct {
	OffchainNode []*Inference `protobuf:"bytes,1,rep,name=offchain_node,json=offchainNode,proto3" json:"offchain_node,omitempty"`
}

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

var xxx_messageInfo_OffchainNodes proto.InternalMessageInfo

func (m *OffchainNodes) GetOffchainNode() []*Inference {
	if m != nil {
		return m.OffchainNode
	}
	return nil
}

type InferenceSetForScoring struct {
	TopicId    uint64      `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Timestamp  uint64      `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Inferences *Inferences `protobuf:"bytes,3,opt,name=inferences,proto3" json:"inferences,omitempty"`
}

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

var xxx_messageInfo_InferenceSetForScoring proto.InternalMessageInfo

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

func (m *InferenceSetForScoring) GetTimestamp() uint64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *InferenceSetForScoring) GetInferences() *Inferences {
	if m != nil {
		return m.Inferences
	}
	return nil
}

type StakePlacement struct {
	Target string                 `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"`
	Amount cosmossdk_io_math.Uint `protobuf:"bytes,2,opt,name=amount,proto3,customtype=cosmossdk.io/math.Uint" json:"amount"`
}

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

var xxx_messageInfo_StakePlacement proto.InternalMessageInfo

func (m *StakePlacement) GetTarget() string {
	if m != nil {
		return m.Target
	}
	return ""
}

type StakeRemovalPlacement struct {
	TopicIds []uint64               `protobuf:"varint,1,rep,packed,name=topic_ids,json=topicIds,proto3" json:"topic_ids,omitempty"`
	Target   string                 `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	Amount   cosmossdk_io_math.Uint `protobuf:"bytes,3,opt,name=amount,proto3,customtype=cosmossdk.io/math.Uint" json:"amount"`
}

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

var xxx_messageInfo_StakeRemovalPlacement proto.InternalMessageInfo

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

func (m *StakeRemovalPlacement) GetTarget() string {
	if m != nil {
		return m.Target
	}
	return ""
}

type StakeRemoval struct {
	TimestampRemovalStarted uint64                   `protobuf:"varint,1,opt,name=timestamp_removal_started,json=timestampRemovalStarted,proto3" json:"timestamp_removal_started,omitempty"`
	Placements              []*StakeRemovalPlacement `protobuf:"bytes,3,rep,name=placements,proto3" json:"placements,omitempty"`
}

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

var xxx_messageInfo_StakeRemoval proto.InternalMessageInfo

func (m *StakeRemoval) GetTimestampRemovalStarted() uint64 {
	if m != nil {
		return m.TimestampRemovalStarted
	}
	return 0
}

func (m *StakeRemoval) GetPlacements() []*StakeRemovalPlacement {
	if m != nil {
		return m.Placements
	}
	return nil
}

// num_inference_possible = bid_amount / max_price_per_inference,
// length of time this inference repeats for =  num_inference_possible * cadence
type InferenceRequest struct {
	Sender               string                 `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Nonce                uint64                 `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"`
	Cadence              uint64                 `protobuf:"varint,4,opt,name=cadence,proto3" json:"cadence,omitempty"`
	MaxPricePerInference cosmossdk_io_math.Uint `protobuf:"bytes,5,opt,name=max_price_per_inference,json=maxPricePerInference,proto3,customtype=cosmossdk.io/math.Uint" json:"max_price_per_inference"`
	BidAmount            cosmossdk_io_math.Uint `protobuf:"bytes,6,opt,name=bid_amount,json=bidAmount,proto3,customtype=cosmossdk.io/math.Uint" json:"bid_amount"`
	LastChecked          uint64                 `protobuf:"varint,7,opt,name=last_checked,json=lastChecked,proto3" json:"last_checked,omitempty"`
	TimestampValidUntil  uint64                 `protobuf:"varint,8,opt,name=timestamp_valid_until,json=timestampValidUntil,proto3" json:"timestamp_valid_until,omitempty"`
	ExtraData            []byte                 `protobuf:"bytes,9,opt,name=extra_data,json=extraData,proto3" json:"extra_data,omitempty"`
}

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

var xxx_messageInfo_InferenceRequest proto.InternalMessageInfo

func (m *InferenceRequest) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

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

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

func (m *InferenceRequest) GetCadence() uint64 {
	if m != nil {
		return m.Cadence
	}
	return 0
}

func (m *InferenceRequest) GetLastChecked() uint64 {
	if m != nil {
		return m.LastChecked
	}
	return 0
}

func (m *InferenceRequest) GetTimestampValidUntil() uint64 {
	if m != nil {
		return m.TimestampValidUntil
	}
	return 0
}

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

func init() {
	proto.RegisterType((*Params)(nil), "emissions.state.v1.Params")
	proto.RegisterType((*GenesisState)(nil), "emissions.state.v1.GenesisState")
	proto.RegisterType((*StakeInfo)(nil), "emissions.state.v1.StakeInfo")
	proto.RegisterType((*Topic)(nil), "emissions.state.v1.Topic")
	proto.RegisterType((*TopicList)(nil), "emissions.state.v1.TopicList")
	proto.RegisterType((*Weight)(nil), "emissions.state.v1.Weight")
	proto.RegisterType((*Weights)(nil), "emissions.state.v1.Weights")
	proto.RegisterType((*Inference)(nil), "emissions.state.v1.Inference")
	proto.RegisterType((*Inferences)(nil), "emissions.state.v1.Inferences")
	proto.RegisterType((*OffchainNode)(nil), "emissions.state.v1.OffchainNode")
	proto.RegisterType((*OffchainNodes)(nil), "emissions.state.v1.OffchainNodes")
	proto.RegisterType((*InferenceSetForScoring)(nil), "emissions.state.v1.InferenceSetForScoring")
	proto.RegisterType((*StakePlacement)(nil), "emissions.state.v1.StakePlacement")
	proto.RegisterType((*StakeRemovalPlacement)(nil), "emissions.state.v1.StakeRemovalPlacement")
	proto.RegisterType((*StakeRemoval)(nil), "emissions.state.v1.StakeRemoval")
	proto.RegisterType((*InferenceRequest)(nil), "emissions.state.v1.InferenceRequest")
}

func init() { proto.RegisterFile("emissions/state/v1/types.proto", fileDescriptor_ea41525923641e50) }

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

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

	that1, ok := that.(*Weight)
	if !ok {
		that2, ok := that.(Weight)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.TopicId != that1.TopicId {
		return false
	}
	if this.Reputer != that1.Reputer {
		return false
	}
	if this.Worker != that1.Worker {
		return false
	}
	if !this.Weight.Equal(that1.Weight) {
		return false
	}
	return true
}
func (this *Inference) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Inference)
	if !ok {
		that2, ok := that.(Inference)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.TopicId != that1.TopicId {
		return false
	}
	if this.Worker != that1.Worker {
		return false
	}
	if !this.Value.Equal(that1.Value) {
		return false
	}
	if !bytes.Equal(this.ExtraData, that1.ExtraData) {
		return false
	}
	if this.Proof != that1.Proof {
		return false
	}
	return true
}
func (m *Params) 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 *Params) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.PercentRewardsReputersWorkers.Size()
		i -= size
		if _, err := m.PercentRewardsReputersWorkers.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x6a
	if m.MaxRequestCadence != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.MaxRequestCadence))
		i--
		dAtA[i] = 0x60
	}
	if m.MaxInferenceRequestValidity != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.MaxInferenceRequestValidity))
		i--
		dAtA[i] = 0x58
	}
	if m.MinWeightCadence != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.MinWeightCadence))
		i--
		dAtA[i] = 0x50
	}
	if m.MinRequestCadence != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.MinRequestCadence))
		i--
		dAtA[i] = 0x48
	}
	if m.RemoveStakeDelayWindow != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.RemoveStakeDelayWindow))
		i--
		dAtA[i] = 0x40
	}
	{
		size := m.RequiredMinimumStake.Size()
		i -= size
		if _, err := m.RequiredMinimumStake.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size := m.MaxMissingInferencePercent.Size()
		i -= size
		if _, err := m.MaxMissingInferencePercent.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size := m.MinRequestUnmetDemand.Size()
		i -= size
		if _, err := m.MinRequestUnmetDemand.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.MaxTopicsPerBlock != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.MaxTopicsPerBlock))
		i--
		dAtA[i] = 0x20
	}
	{
		size := m.MinTopicUnmetDemand.Size()
		i -= size
		if _, err := m.MinTopicUnmetDemand.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.EpochLength != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.EpochLength))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CoreTeamAddresses) > 0 {
		for iNdEx := len(m.CoreTeamAddresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.CoreTeamAddresses[iNdEx])
			copy(dAtA[i:], m.CoreTeamAddresses[iNdEx])
			i = encodeVarintTypes(dAtA, i, uint64(len(m.CoreTeamAddresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

func (m *Topic) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DefaultArg) > 0 {
		i -= len(m.DefaultArg)
		copy(dAtA[i:], m.DefaultArg)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.DefaultArg)))
		i--
		dAtA[i] = 0x6a
	}
	if m.Active {
		i--
		if m.Active {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x60
	}
	if m.InferenceLastRan != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.InferenceLastRan))
		i--
		dAtA[i] = 0x58
	}
	if m.InferenceCadence != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.InferenceCadence))
		i--
		dAtA[i] = 0x50
	}
	if len(m.InferenceMethod) > 0 {
		i -= len(m.InferenceMethod)
		copy(dAtA[i:], m.InferenceMethod)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.InferenceMethod)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.InferenceLogic) > 0 {
		i -= len(m.InferenceLogic)
		copy(dAtA[i:], m.InferenceLogic)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.InferenceLogic)))
		i--
		dAtA[i] = 0x42
	}
	if m.WeightLastRan != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.WeightLastRan))
		i--
		dAtA[i] = 0x38
	}
	if m.WeightCadence != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.WeightCadence))
		i--
		dAtA[i] = 0x30
	}
	if len(m.WeightMethod) > 0 {
		i -= len(m.WeightMethod)
		copy(dAtA[i:], m.WeightMethod)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.WeightMethod)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.WeightLogic) > 0 {
		i -= len(m.WeightLogic)
		copy(dAtA[i:], m.WeightLogic)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.WeightLogic)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Metadata) > 0 {
		i -= len(m.Metadata)
		copy(dAtA[i:], m.Metadata)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Metadata)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x12
	}
	if m.Id != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TopicList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Topics) > 0 {
		for iNdEx := len(m.Topics) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Topics[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *Weights) 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, err := m.Weights[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *Inference) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Proof) > 0 {
		i -= len(m.Proof)
		copy(dAtA[i:], m.Proof)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Proof)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ExtraData) > 0 {
		i -= len(m.ExtraData)
		copy(dAtA[i:], m.ExtraData)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.ExtraData)))
		i--
		dAtA[i] = 0x22
	}
	{
		size := m.Value.Size()
		i -= size
		if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Worker) > 0 {
		i -= len(m.Worker)
		copy(dAtA[i:], m.Worker)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Worker)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Inferences) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Inferences) > 0 {
		for iNdEx := len(m.Inferences) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Inferences[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *OffchainNode) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.NodeId) > 0 {
		i -= len(m.NodeId)
		copy(dAtA[i:], m.NodeId)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.NodeId)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.NodeAddress) > 0 {
		i -= len(m.NodeAddress)
		copy(dAtA[i:], m.NodeAddress)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.NodeAddress)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.MultiAddress) > 0 {
		i -= len(m.MultiAddress)
		copy(dAtA[i:], m.MultiAddress)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.MultiAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.LibP2PKey) > 0 {
		i -= len(m.LibP2PKey)
		copy(dAtA[i:], m.LibP2PKey)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.LibP2PKey)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *OffchainNodes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.OffchainNode) > 0 {
		for iNdEx := len(m.OffchainNode) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OffchainNode[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *StakePlacement) 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 = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Target) > 0 {
		i -= len(m.Target)
		copy(dAtA[i:], m.Target)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Target)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *StakeRemovalPlacement) 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 = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Target) > 0 {
		i -= len(m.Target)
		copy(dAtA[i:], m.Target)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Target)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.TopicIds) > 0 {
		dAtA4 := make([]byte, len(m.TopicIds)*10)
		var j3 int
		for _, num := range m.TopicIds {
			for num >= 1<<7 {
				dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j3++
			}
			dAtA4[j3] = uint8(num)
			j3++
		}
		i -= j3
		copy(dAtA[i:], dAtA4[:j3])
		i = encodeVarintTypes(dAtA, i, uint64(j3))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *StakeRemoval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Placements) > 0 {
		for iNdEx := len(m.Placements) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Placements[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.TimestampRemovalStarted != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.TimestampRemovalStarted))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *InferenceRequest) 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 = encodeVarintTypes(dAtA, i, uint64(len(m.ExtraData)))
		i--
		dAtA[i] = 0x4a
	}
	if m.TimestampValidUntil != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.TimestampValidUntil))
		i--
		dAtA[i] = 0x40
	}
	if m.LastChecked != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.LastChecked))
		i--
		dAtA[i] = 0x38
	}
	{
		size := m.BidAmount.Size()
		i -= size
		if _, err := m.BidAmount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size := m.MaxPricePerInference.Size()
		i -= size
		if _, err := m.MaxPricePerInference.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.Cadence != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Cadence))
		i--
		dAtA[i] = 0x20
	}
	if m.TopicId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x18
	}
	if m.Nonce != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
	offset -= sovTypes(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Params) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.EpochLength != 0 {
		n += 1 + sovTypes(uint64(m.EpochLength))
	}
	l = m.MinTopicUnmetDemand.Size()
	n += 1 + l + sovTypes(uint64(l))
	if m.MaxTopicsPerBlock != 0 {
		n += 1 + sovTypes(uint64(m.MaxTopicsPerBlock))
	}
	l = m.MinRequestUnmetDemand.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.MaxMissingInferencePercent.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.RequiredMinimumStake.Size()
	n += 1 + l + sovTypes(uint64(l))
	if m.RemoveStakeDelayWindow != 0 {
		n += 1 + sovTypes(uint64(m.RemoveStakeDelayWindow))
	}
	if m.MinRequestCadence != 0 {
		n += 1 + sovTypes(uint64(m.MinRequestCadence))
	}
	if m.MinWeightCadence != 0 {
		n += 1 + sovTypes(uint64(m.MinWeightCadence))
	}
	if m.MaxInferenceRequestValidity != 0 {
		n += 1 + sovTypes(uint64(m.MaxInferenceRequestValidity))
	}
	if m.MaxRequestCadence != 0 {
		n += 1 + sovTypes(uint64(m.MaxRequestCadence))
	}
	l = m.PercentRewardsReputersWorkers.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *GenesisState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Params.Size()
	n += 1 + l + sovTypes(uint64(l))
	if len(m.CoreTeamAddresses) > 0 {
		for _, s := range m.CoreTeamAddresses {
			l = len(s)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	return n
}

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

func (m *Topic) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovTypes(uint64(m.Id))
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Metadata)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.WeightLogic)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.WeightMethod)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.WeightCadence != 0 {
		n += 1 + sovTypes(uint64(m.WeightCadence))
	}
	if m.WeightLastRan != 0 {
		n += 1 + sovTypes(uint64(m.WeightLastRan))
	}
	l = len(m.InferenceLogic)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.InferenceMethod)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.InferenceCadence != 0 {
		n += 1 + sovTypes(uint64(m.InferenceCadence))
	}
	if m.InferenceLastRan != 0 {
		n += 1 + sovTypes(uint64(m.InferenceLastRan))
	}
	if m.Active {
		n += 2
	}
	l = len(m.DefaultArg)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

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

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

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

func (m *Inference) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovTypes(uint64(m.TopicId))
	}
	l = len(m.Worker)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.Value.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = len(m.ExtraData)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Proof)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

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

func (m *OffchainNode) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.LibP2PKey)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.MultiAddress)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.NodeAddress)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.NodeId)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

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

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

func (m *StakePlacement) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Target)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *StakeRemovalPlacement) 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 += sovTypes(uint64(e))
		}
		n += 1 + sovTypes(uint64(l)) + l
	}
	l = len(m.Target)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *StakeRemoval) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TimestampRemovalStarted != 0 {
		n += 1 + sovTypes(uint64(m.TimestampRemovalStarted))
	}
	if len(m.Placements) > 0 {
		for _, e := range m.Placements {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	return n
}

func (m *InferenceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Nonce != 0 {
		n += 1 + sovTypes(uint64(m.Nonce))
	}
	if m.TopicId != 0 {
		n += 1 + sovTypes(uint64(m.TopicId))
	}
	if m.Cadence != 0 {
		n += 1 + sovTypes(uint64(m.Cadence))
	}
	l = m.MaxPricePerInference.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.BidAmount.Size()
	n += 1 + l + sovTypes(uint64(l))
	if m.LastChecked != 0 {
		n += 1 + sovTypes(uint64(m.LastChecked))
	}
	if m.TimestampValidUntil != 0 {
		n += 1 + sovTypes(uint64(m.TimestampValidUntil))
	}
	l = len(m.ExtraData)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func sovTypes(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTypes(x uint64) (n int) {
	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Params) 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 ErrIntOverflowTypes
			}
			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: Params: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochLength", wireType)
			}
			m.EpochLength = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EpochLength |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinTopicUnmetDemand", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinTopicUnmetDemand.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxTopicsPerBlock", wireType)
			}
			m.MaxTopicsPerBlock = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxTopicsPerBlock |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinRequestUnmetDemand", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinRequestUnmetDemand.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxMissingInferencePercent", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MaxMissingInferencePercent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredMinimumStake", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RequiredMinimumStake.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemoveStakeDelayWindow", wireType)
			}
			m.RemoveStakeDelayWindow = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RemoveStakeDelayWindow |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinRequestCadence", wireType)
			}
			m.MinRequestCadence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinRequestCadence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinWeightCadence", wireType)
			}
			m.MinWeightCadence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinWeightCadence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxInferenceRequestValidity", wireType)
			}
			m.MaxInferenceRequestValidity = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxInferenceRequestValidity |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxRequestCadence", wireType)
			}
			m.MaxRequestCadence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxRequestCadence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PercentRewardsReputersWorkers", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PercentRewardsReputersWorkers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GenesisState) 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 ErrIntOverflowTypes
			}
			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: GenesisState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GenesisState: 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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CoreTeamAddresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CoreTeamAddresses = append(m.CoreTeamAddresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StakeInfo) 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 ErrIntOverflowTypes
			}
			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: StakeInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StakeInfo: 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 ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Amount = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Topic) 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 ErrIntOverflowTypes
			}
			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: Topic: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Topic: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metadata = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WeightLogic", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WeightLogic = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WeightMethod", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WeightMethod = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WeightCadence", wireType)
			}
			m.WeightCadence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WeightCadence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WeightLastRan", wireType)
			}
			m.WeightLastRan = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WeightLastRan |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InferenceLogic", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InferenceLogic = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InferenceMethod", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InferenceMethod = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InferenceCadence", wireType)
			}
			m.InferenceCadence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InferenceCadence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InferenceLastRan", wireType)
			}
			m.InferenceLastRan = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InferenceLastRan |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Active", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Active = bool(v != 0)
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultArg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultArg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Weight) 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 ErrIntOverflowTypes
			}
			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: Weight: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Weight: 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 ErrIntOverflowTypes
				}
				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 ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			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 Worker", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Worker = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Weight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Inference) 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 ErrIntOverflowTypes
			}
			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: Inference: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Inference: 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 ErrIntOverflowTypes
				}
				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 ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			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 Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			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 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Proof = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OffchainNode) 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 ErrIntOverflowTypes
			}
			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: OffchainNode: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OffchainNode: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LibP2PKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LibP2PKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MultiAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MultiAddress = 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 ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InferenceSetForScoring) 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 ErrIntOverflowTypes
			}
			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: InferenceSetForScoring: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InferenceSetForScoring: 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 ErrIntOverflowTypes
				}
				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 Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Inferences", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Inferences == nil {
				m.Inferences = &Inferences{}
			}
			if err := m.Inferences.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StakePlacement) 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 ErrIntOverflowTypes
			}
			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: StakePlacement: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StakePlacement: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Target = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			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 := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StakeRemovalPlacement) 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 ErrIntOverflowTypes
			}
			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: StakeRemovalPlacement: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StakeRemovalPlacement: 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 ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				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 ErrIntOverflowTypes
						}
						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 Target", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Target = 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 ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			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 := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InferenceRequest) 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 ErrIntOverflowTypes
			}
			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: InferenceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InferenceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = 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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= uint64(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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cadence", wireType)
			}
			m.Cadence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Cadence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxPricePerInference", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MaxPricePerInference.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BidAmount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BidAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastChecked", wireType)
			}
			m.LastChecked = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastChecked |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimestampValidUntil", wireType)
			}
			m.TimestampValidUntil = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimestampValidUntil |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			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 := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTypes(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, ErrIntOverflowTypes
			}
			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, ErrIntOverflowTypes
				}
				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, ErrIntOverflowTypes
				}
				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, ErrInvalidLengthTypes
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTypes
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTypes
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthTypes        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTypes          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
)