metrix.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: palomachain/paloma/metrix/metrix.proto

package types

import (
	cosmossdk_io_math "cosmossdk.io/math"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	_ "github.com/cosmos/cosmos-sdk/types/query"
	_ "github.com/cosmos/cosmos-sdk/types/tx/amino"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	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

// ValidatorMetrics defines a validator's collected metrics to be
// used during relayer selection.
type ValidatorMetrics struct {
	// Validator address of a validator participating in consensus.
	ValAddress string `protobuf:"bytes,1,opt,name=val_address,json=valAddress,proto3" json:"val_address,omitempty"`
	// Percentage of validator uptime within the signed blocks window.
	// Higher is better ([0,1]).
	Uptime cosmossdk_io_math.LegacyDec `protobuf:"bytes,2,opt,name=uptime,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"uptime"`
	// Percent of validator's relay success rate over the last
	// params.relay_metrics_window messages. Higher is better ([0,1]).
	SuccessRate cosmossdk_io_math.LegacyDec `protobuf:"bytes,3,opt,name=success_rate,json=successRate,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"success_rate"`
	// A median value in ms of the relay execution time over the
	// last params.relay_metrics_window messages. Lower is better, 0 means
	// no collected data.
	ExecutionTime cosmossdk_io_math.Int `protobuf:"bytes,4,opt,name=execution_time,json=executionTime,proto3,customtype=cosmossdk.io/math.Int" json:"execution_time"`
	// The value of the relaying fee the relayer has specified for themselves.
	// Lower is better, 0 means no fee.
	Fee cosmossdk_io_math.Int `protobuf:"bytes,5,opt,name=fee,proto3,customtype=cosmossdk.io/math.Int" json:"fee"`
	// Artificial decimal value representing the total amount of optional support
	// features that this validator has enabled. Higher is better ([0,1]).
	FeatureSet cosmossdk_io_math.LegacyDec `protobuf:"bytes,6,opt,name=feature_set,json=featureSet,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"feature_set"`
}

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

var xxx_messageInfo_ValidatorMetrics proto.InternalMessageInfo

func (m *ValidatorMetrics) GetValAddress() string {
	if m != nil {
		return m.ValAddress
	}
	return ""
}

type ValidatorHistory struct {
	// validator address of a validator participating in consensus.
	ValAddress string `protobuf:"bytes,1,opt,name=val_address,json=valAddress,proto3" json:"val_address,omitempty"`
	// records contain records of the last `n` messages relayed by
	// the validator.
	// Records older than `n` are discared and no longer affect
	// performance scoring.
	Records []HistoricRelayData `protobuf:"bytes,2,rep,name=records,proto3" json:"records"`
}

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

var xxx_messageInfo_ValidatorHistory proto.InternalMessageInfo

func (m *ValidatorHistory) GetValAddress() string {
	if m != nil {
		return m.ValAddress
	}
	return ""
}

func (m *ValidatorHistory) GetRecords() []HistoricRelayData {
	if m != nil {
		return m.Records
	}
	return nil
}

type HistoricRelayData struct {
	MessageId              uint64 `protobuf:"varint,1,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
	Success                bool   `protobuf:"varint,2,opt,name=success,proto3" json:"success,omitempty"`
	ExecutionSpeedInBlocks uint64 `protobuf:"varint,3,opt,name=execution_speed_in_blocks,json=executionSpeedInBlocks,proto3" json:"execution_speed_in_blocks,omitempty"`
}

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

var xxx_messageInfo_HistoricRelayData proto.InternalMessageInfo

func (m *HistoricRelayData) GetMessageId() uint64 {
	if m != nil {
		return m.MessageId
	}
	return 0
}

func (m *HistoricRelayData) GetSuccess() bool {
	if m != nil {
		return m.Success
	}
	return false
}

func (m *HistoricRelayData) GetExecutionSpeedInBlocks() uint64 {
	if m != nil {
		return m.ExecutionSpeedInBlocks
	}
	return 0
}

func init() {
	proto.RegisterType((*ValidatorMetrics)(nil), "palomachain.paloma.metrix.ValidatorMetrics")
	proto.RegisterType((*ValidatorHistory)(nil), "palomachain.paloma.metrix.ValidatorHistory")
	proto.RegisterType((*HistoricRelayData)(nil), "palomachain.paloma.metrix.HistoricRelayData")
}

func init() {
	proto.RegisterFile("palomachain/paloma/metrix/metrix.proto", fileDescriptor_bb382b6ba8ce0e33)
}

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

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

	that1, ok := that.(*ValidatorMetrics)
	if !ok {
		that2, ok := that.(ValidatorMetrics)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ValAddress != that1.ValAddress {
		return false
	}
	if !this.Uptime.Equal(that1.Uptime) {
		return false
	}
	if !this.SuccessRate.Equal(that1.SuccessRate) {
		return false
	}
	if !this.ExecutionTime.Equal(that1.ExecutionTime) {
		return false
	}
	if !this.Fee.Equal(that1.Fee) {
		return false
	}
	if !this.FeatureSet.Equal(that1.FeatureSet) {
		return false
	}
	return true
}
func (this *HistoricRelayData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HistoricRelayData)
	if !ok {
		that2, ok := that.(HistoricRelayData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.MessageId != that1.MessageId {
		return false
	}
	if this.Success != that1.Success {
		return false
	}
	if this.ExecutionSpeedInBlocks != that1.ExecutionSpeedInBlocks {
		return false
	}
	return true
}
func (m *ValidatorMetrics) 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 *ValidatorMetrics) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidatorMetrics) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.FeatureSet.Size()
		i -= size
		if _, err := m.FeatureSet.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetrix(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size := m.Fee.Size()
		i -= size
		if _, err := m.Fee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetrix(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.ExecutionTime.Size()
		i -= size
		if _, err := m.ExecutionTime.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetrix(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.SuccessRate.Size()
		i -= size
		if _, err := m.SuccessRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetrix(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.Uptime.Size()
		i -= size
		if _, err := m.Uptime.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetrix(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.ValAddress) > 0 {
		i -= len(m.ValAddress)
		copy(dAtA[i:], m.ValAddress)
		i = encodeVarintMetrix(dAtA, i, uint64(len(m.ValAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *HistoricRelayData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ExecutionSpeedInBlocks != 0 {
		i = encodeVarintMetrix(dAtA, i, uint64(m.ExecutionSpeedInBlocks))
		i--
		dAtA[i] = 0x18
	}
	if m.Success {
		i--
		if m.Success {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.MessageId != 0 {
		i = encodeVarintMetrix(dAtA, i, uint64(m.MessageId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintMetrix(dAtA []byte, offset int, v uint64) int {
	offset -= sovMetrix(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ValidatorMetrics) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ValAddress)
	if l > 0 {
		n += 1 + l + sovMetrix(uint64(l))
	}
	l = m.Uptime.Size()
	n += 1 + l + sovMetrix(uint64(l))
	l = m.SuccessRate.Size()
	n += 1 + l + sovMetrix(uint64(l))
	l = m.ExecutionTime.Size()
	n += 1 + l + sovMetrix(uint64(l))
	l = m.Fee.Size()
	n += 1 + l + sovMetrix(uint64(l))
	l = m.FeatureSet.Size()
	n += 1 + l + sovMetrix(uint64(l))
	return n
}

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

func (m *HistoricRelayData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MessageId != 0 {
		n += 1 + sovMetrix(uint64(m.MessageId))
	}
	if m.Success {
		n += 2
	}
	if m.ExecutionSpeedInBlocks != 0 {
		n += 1 + sovMetrix(uint64(m.ExecutionSpeedInBlocks))
	}
	return n
}

func sovMetrix(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMetrix(x uint64) (n int) {
	return sovMetrix(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ValidatorMetrics) 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 ErrIntOverflowMetrix
			}
			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: ValidatorMetrics: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorMetrics: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetrix
				}
				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 ErrInvalidLengthMetrix
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetrix
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uptime", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetrix
				}
				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 ErrInvalidLengthMetrix
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetrix
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Uptime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SuccessRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetrix
				}
				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 ErrInvalidLengthMetrix
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetrix
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SuccessRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecutionTime", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetrix
				}
				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 ErrInvalidLengthMetrix
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetrix
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ExecutionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetrix
				}
				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 ErrInvalidLengthMetrix
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetrix
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeatureSet", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetrix
				}
				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 ErrInvalidLengthMetrix
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetrix
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.FeatureSet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetrix(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetrix
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HistoricRelayData) 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 ErrIntOverflowMetrix
			}
			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: HistoricRelayData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HistoricRelayData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MessageId", wireType)
			}
			m.MessageId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetrix
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MessageId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetrix
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Success = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecutionSpeedInBlocks", wireType)
			}
			m.ExecutionSpeedInBlocks = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetrix
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExecutionSpeedInBlocks |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetrix(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetrix
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthMetrix        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMetrix          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMetrix = fmt.Errorf("proto: unexpected end of group")
)