badges.pb.go

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

package types

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/lavanet/lava/x/epochstorage/types"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	_ "google.golang.org/protobuf/types/known/wrapperspb"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type GenerateBadgeRequest struct {
	BadgeAddress string `protobuf:"bytes,1,opt,name=badge_address,json=badgeAddress,proto3" json:"badge_address,omitempty"`
	ProjectId    string `protobuf:"bytes,2,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	SpecId       string `protobuf:"bytes,3,opt,name=spec_id,json=specId,proto3" json:"spec_id,omitempty"`
}

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

var xxx_messageInfo_GenerateBadgeRequest proto.InternalMessageInfo

func (m *GenerateBadgeRequest) GetBadgeAddress() string {
	if m != nil {
		return m.BadgeAddress
	}
	return ""
}

func (m *GenerateBadgeRequest) GetProjectId() string {
	if m != nil {
		return m.ProjectId
	}
	return ""
}

func (m *GenerateBadgeRequest) GetSpecId() string {
	if m != nil {
		return m.SpecId
	}
	return ""
}

type GenerateBadgeResponse struct {
	Badge              *Badge              `protobuf:"bytes,1,opt,name=badge,proto3" json:"badge,omitempty"`
	PairingList        []*types.StakeEntry `protobuf:"bytes,2,rep,name=pairing_list,json=pairingList,proto3" json:"pairing_list,omitempty"`
	BadgeSignerAddress string              `protobuf:"bytes,3,opt,name=badge_signer_address,json=badgeSignerAddress,proto3" json:"badge_signer_address,omitempty"`
}

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

var xxx_messageInfo_GenerateBadgeResponse proto.InternalMessageInfo

func (m *GenerateBadgeResponse) GetBadge() *Badge {
	if m != nil {
		return m.Badge
	}
	return nil
}

func (m *GenerateBadgeResponse) GetPairingList() []*types.StakeEntry {
	if m != nil {
		return m.PairingList
	}
	return nil
}

func (m *GenerateBadgeResponse) GetBadgeSignerAddress() string {
	if m != nil {
		return m.BadgeSignerAddress
	}
	return ""
}

func init() {
	proto.RegisterType((*GenerateBadgeRequest)(nil), "lavanet.lava.pairing.GenerateBadgeRequest")
	proto.RegisterType((*GenerateBadgeResponse)(nil), "lavanet.lava.pairing.GenerateBadgeResponse")
}

func init() { proto.RegisterFile("pairing/badges.proto", fileDescriptor_fad72c0554b022ec) }

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

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

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

// BadgeGeneratorClient is the client API for BadgeGenerator service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type BadgeGeneratorClient interface {
	GenerateBadge(ctx context.Context, in *GenerateBadgeRequest, opts ...grpc.CallOption) (*GenerateBadgeResponse, error)
}

type badgeGeneratorClient struct {
	cc grpc1.ClientConn
}

func NewBadgeGeneratorClient(cc grpc1.ClientConn) BadgeGeneratorClient {
	return &badgeGeneratorClient{cc}
}

func (c *badgeGeneratorClient) GenerateBadge(ctx context.Context, in *GenerateBadgeRequest, opts ...grpc.CallOption) (*GenerateBadgeResponse, error) {
	out := new(GenerateBadgeResponse)
	err := c.cc.Invoke(ctx, "/lavanet.lava.pairing.BadgeGenerator/GenerateBadge", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// BadgeGeneratorServer is the server API for BadgeGenerator service.
type BadgeGeneratorServer interface {
	GenerateBadge(context.Context, *GenerateBadgeRequest) (*GenerateBadgeResponse, error)
}

// UnimplementedBadgeGeneratorServer can be embedded to have forward compatible implementations.
type UnimplementedBadgeGeneratorServer struct {
}

func (*UnimplementedBadgeGeneratorServer) GenerateBadge(ctx context.Context, req *GenerateBadgeRequest) (*GenerateBadgeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateBadge not implemented")
}

func RegisterBadgeGeneratorServer(s grpc1.Server, srv BadgeGeneratorServer) {
	s.RegisterService(&_BadgeGenerator_serviceDesc, srv)
}

func _BadgeGenerator_GenerateBadge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenerateBadgeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BadgeGeneratorServer).GenerateBadge(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lavanet.lava.pairing.BadgeGenerator/GenerateBadge",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BadgeGeneratorServer).GenerateBadge(ctx, req.(*GenerateBadgeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _BadgeGenerator_serviceDesc = grpc.ServiceDesc{
	ServiceName: "lavanet.lava.pairing.BadgeGenerator",
	HandlerType: (*BadgeGeneratorServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GenerateBadge",
			Handler:    _BadgeGenerator_GenerateBadge_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pairing/badges.proto",
}

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

func (m *GenerateBadgeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SpecId) > 0 {
		i -= len(m.SpecId)
		copy(dAtA[i:], m.SpecId)
		i = encodeVarintBadges(dAtA, i, uint64(len(m.SpecId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ProjectId) > 0 {
		i -= len(m.ProjectId)
		copy(dAtA[i:], m.ProjectId)
		i = encodeVarintBadges(dAtA, i, uint64(len(m.ProjectId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.BadgeAddress) > 0 {
		i -= len(m.BadgeAddress)
		copy(dAtA[i:], m.BadgeAddress)
		i = encodeVarintBadges(dAtA, i, uint64(len(m.BadgeAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func encodeVarintBadges(dAtA []byte, offset int, v uint64) int {
	offset -= sovBadges(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *GenerateBadgeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BadgeAddress)
	if l > 0 {
		n += 1 + l + sovBadges(uint64(l))
	}
	l = len(m.ProjectId)
	if l > 0 {
		n += 1 + l + sovBadges(uint64(l))
	}
	l = len(m.SpecId)
	if l > 0 {
		n += 1 + l + sovBadges(uint64(l))
	}
	return n
}

func (m *GenerateBadgeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Badge != nil {
		l = m.Badge.Size()
		n += 1 + l + sovBadges(uint64(l))
	}
	if len(m.PairingList) > 0 {
		for _, e := range m.PairingList {
			l = e.Size()
			n += 1 + l + sovBadges(uint64(l))
		}
	}
	l = len(m.BadgeSignerAddress)
	if l > 0 {
		n += 1 + l + sovBadges(uint64(l))
	}
	return n
}

func sovBadges(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozBadges(x uint64) (n int) {
	return sovBadges(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GenerateBadgeRequest) 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 ErrIntOverflowBadges
			}
			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: GenerateBadgeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GenerateBadgeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BadgeAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBadges
				}
				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 ErrInvalidLengthBadges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBadges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BadgeAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProjectId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBadges
				}
				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 ErrInvalidLengthBadges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBadges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProjectId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpecId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBadges
				}
				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 ErrInvalidLengthBadges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBadges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpecId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBadges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBadges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

var (
	ErrInvalidLengthBadges        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBadges          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupBadges = fmt.Errorf("proto: unexpected end of group")
)