delegation.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: kyve/query/v1beta1/delegation.proto

package types

import (
	context "context"
	fmt "fmt"
	query "github.com/cosmos/cosmos-sdk/types/query"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	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

// QueryDelegatorRequest is the request type for the Query/Delegator RPC method.
type QueryDelegatorRequest struct {
	// staker ...
	Staker string `protobuf:"bytes,1,opt,name=staker,proto3" json:"staker,omitempty"`
	// delegator ...
	Delegator string `protobuf:"bytes,2,opt,name=delegator,proto3" json:"delegator,omitempty"`
}

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

var xxx_messageInfo_QueryDelegatorRequest proto.InternalMessageInfo

func (m *QueryDelegatorRequest) GetStaker() string {
	if m != nil {
		return m.Staker
	}
	return ""
}

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

// QueryDelegatorResponse is the response type for the Query/Delegator RPC method.
type QueryDelegatorResponse struct {
	// delegator ...
	Delegator *StakerDelegatorResponse `protobuf:"bytes,1,opt,name=delegator,proto3" json:"delegator,omitempty"`
}

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

var xxx_messageInfo_QueryDelegatorResponse proto.InternalMessageInfo

func (m *QueryDelegatorResponse) GetDelegator() *StakerDelegatorResponse {
	if m != nil {
		return m.Delegator
	}
	return nil
}

// StakerDelegatorResponse ...
type StakerDelegatorResponse struct {
	// delegator ...
	Delegator string `protobuf:"bytes,1,opt,name=delegator,proto3" json:"delegator,omitempty"`
	// current_reward ...
	CurrentReward uint64 `protobuf:"varint,2,opt,name=current_reward,json=currentReward,proto3" json:"current_reward,omitempty"`
	// delegation_amount ...
	DelegationAmount uint64 `protobuf:"varint,3,opt,name=delegation_amount,json=delegationAmount,proto3" json:"delegation_amount,omitempty"`
	// staker ...
	Staker string `protobuf:"bytes,4,opt,name=staker,proto3" json:"staker,omitempty"`
}

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

var xxx_messageInfo_StakerDelegatorResponse proto.InternalMessageInfo

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

func (m *StakerDelegatorResponse) GetCurrentReward() uint64 {
	if m != nil {
		return m.CurrentReward
	}
	return 0
}

func (m *StakerDelegatorResponse) GetDelegationAmount() uint64 {
	if m != nil {
		return m.DelegationAmount
	}
	return 0
}

func (m *StakerDelegatorResponse) GetStaker() string {
	if m != nil {
		return m.Staker
	}
	return ""
}

// QueryDelegatorsByStakerRequest ...
type QueryDelegatorsByStakerRequest struct {
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
	// staker ...
	Staker string `protobuf:"bytes,2,opt,name=staker,proto3" json:"staker,omitempty"`
}

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

var xxx_messageInfo_QueryDelegatorsByStakerRequest proto.InternalMessageInfo

func (m *QueryDelegatorsByStakerRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

func (m *QueryDelegatorsByStakerRequest) GetStaker() string {
	if m != nil {
		return m.Staker
	}
	return ""
}

// QueryDelegatorsByStakerResponse ...
type QueryDelegatorsByStakerResponse struct {
	// delegators ...
	Delegators []StakerDelegatorResponse `protobuf:"bytes,1,rep,name=delegators,proto3" json:"delegators"`
	// total_delegation ... (consider metadata object)
	TotalDelegation uint64 `protobuf:"varint,2,opt,name=total_delegation,json=totalDelegation,proto3" json:"total_delegation,omitempty"`
	// total_delegation ...
	TotalDelegatorCount uint64 `protobuf:"varint,3,opt,name=total_delegator_count,json=totalDelegatorCount,proto3" json:"total_delegator_count,omitempty"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,4,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryDelegatorsByStakerResponse proto.InternalMessageInfo

func (m *QueryDelegatorsByStakerResponse) GetDelegators() []StakerDelegatorResponse {
	if m != nil {
		return m.Delegators
	}
	return nil
}

func (m *QueryDelegatorsByStakerResponse) GetTotalDelegation() uint64 {
	if m != nil {
		return m.TotalDelegation
	}
	return 0
}

func (m *QueryDelegatorsByStakerResponse) GetTotalDelegatorCount() uint64 {
	if m != nil {
		return m.TotalDelegatorCount
	}
	return 0
}

func (m *QueryDelegatorsByStakerResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryStakersByDelegatorRequest ...
type QueryStakersByDelegatorRequest struct {
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
	// delegator ...
	Delegator string `protobuf:"bytes,2,opt,name=delegator,proto3" json:"delegator,omitempty"`
}

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

var xxx_messageInfo_QueryStakersByDelegatorRequest proto.InternalMessageInfo

func (m *QueryStakersByDelegatorRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

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

// QueryStakersByDelegatorResponse ...
type QueryStakersByDelegatorResponse struct {
	// delegator ...
	Delegator string `protobuf:"bytes,1,opt,name=delegator,proto3" json:"delegator,omitempty"`
	// stakers ...
	Stakers []DelegationForStakerResponse `protobuf:"bytes,2,rep,name=stakers,proto3" json:"stakers"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryStakersByDelegatorResponse proto.InternalMessageInfo

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

func (m *QueryStakersByDelegatorResponse) GetStakers() []DelegationForStakerResponse {
	if m != nil {
		return m.Stakers
	}
	return nil
}

func (m *QueryStakersByDelegatorResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// DelegationForStakerResponse ...
type DelegationForStakerResponse struct {
	// staker ...
	Staker *FullStaker `protobuf:"bytes,1,opt,name=staker,proto3" json:"staker,omitempty"`
	// current_reward ...
	CurrentReward uint64 `protobuf:"varint,2,opt,name=current_reward,json=currentReward,proto3" json:"current_reward,omitempty"`
	// delegation_amount ...
	DelegationAmount uint64 `protobuf:"varint,3,opt,name=delegation_amount,json=delegationAmount,proto3" json:"delegation_amount,omitempty"`
}

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

var xxx_messageInfo_DelegationForStakerResponse proto.InternalMessageInfo

func (m *DelegationForStakerResponse) GetStaker() *FullStaker {
	if m != nil {
		return m.Staker
	}
	return nil
}

func (m *DelegationForStakerResponse) GetCurrentReward() uint64 {
	if m != nil {
		return m.CurrentReward
	}
	return 0
}

func (m *DelegationForStakerResponse) GetDelegationAmount() uint64 {
	if m != nil {
		return m.DelegationAmount
	}
	return 0
}

func init() {
	proto.RegisterType((*QueryDelegatorRequest)(nil), "kyve.query.v1beta1.QueryDelegatorRequest")
	proto.RegisterType((*QueryDelegatorResponse)(nil), "kyve.query.v1beta1.QueryDelegatorResponse")
	proto.RegisterType((*StakerDelegatorResponse)(nil), "kyve.query.v1beta1.StakerDelegatorResponse")
	proto.RegisterType((*QueryDelegatorsByStakerRequest)(nil), "kyve.query.v1beta1.QueryDelegatorsByStakerRequest")
	proto.RegisterType((*QueryDelegatorsByStakerResponse)(nil), "kyve.query.v1beta1.QueryDelegatorsByStakerResponse")
	proto.RegisterType((*QueryStakersByDelegatorRequest)(nil), "kyve.query.v1beta1.QueryStakersByDelegatorRequest")
	proto.RegisterType((*QueryStakersByDelegatorResponse)(nil), "kyve.query.v1beta1.QueryStakersByDelegatorResponse")
	proto.RegisterType((*DelegationForStakerResponse)(nil), "kyve.query.v1beta1.DelegationForStakerResponse")
}

func init() {
	proto.RegisterFile("kyve/query/v1beta1/delegation.proto", fileDescriptor_5e1c28c162a0498a)
}

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

// QueryDelegationClient is the client API for QueryDelegation service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryDelegationClient interface {
	// Delegator returns delegation information for a specific delegator of a specific staker.
	Delegator(ctx context.Context, in *QueryDelegatorRequest, opts ...grpc.CallOption) (*QueryDelegatorResponse, error)
	// DelegatorsByStaker returns all delegators that have delegated to the given staker
	// This query is paginated.
	DelegatorsByStaker(ctx context.Context, in *QueryDelegatorsByStakerRequest, opts ...grpc.CallOption) (*QueryDelegatorsByStakerResponse, error)
	// StakersByPoolAndDelegator returns all stakers the given delegator has delegated to.
	// This query is paginated.
	StakersByDelegator(ctx context.Context, in *QueryStakersByDelegatorRequest, opts ...grpc.CallOption) (*QueryStakersByDelegatorResponse, error)
}

type queryDelegationClient struct {
	cc grpc1.ClientConn
}

func NewQueryDelegationClient(cc grpc1.ClientConn) QueryDelegationClient {
	return &queryDelegationClient{cc}
}

func (c *queryDelegationClient) Delegator(ctx context.Context, in *QueryDelegatorRequest, opts ...grpc.CallOption) (*QueryDelegatorResponse, error) {
	out := new(QueryDelegatorResponse)
	err := c.cc.Invoke(ctx, "/kyve.query.v1beta1.QueryDelegation/Delegator", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryDelegationClient) DelegatorsByStaker(ctx context.Context, in *QueryDelegatorsByStakerRequest, opts ...grpc.CallOption) (*QueryDelegatorsByStakerResponse, error) {
	out := new(QueryDelegatorsByStakerResponse)
	err := c.cc.Invoke(ctx, "/kyve.query.v1beta1.QueryDelegation/DelegatorsByStaker", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryDelegationClient) StakersByDelegator(ctx context.Context, in *QueryStakersByDelegatorRequest, opts ...grpc.CallOption) (*QueryStakersByDelegatorResponse, error) {
	out := new(QueryStakersByDelegatorResponse)
	err := c.cc.Invoke(ctx, "/kyve.query.v1beta1.QueryDelegation/StakersByDelegator", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryDelegationServer is the server API for QueryDelegation service.
type QueryDelegationServer interface {
	// Delegator returns delegation information for a specific delegator of a specific staker.
	Delegator(context.Context, *QueryDelegatorRequest) (*QueryDelegatorResponse, error)
	// DelegatorsByStaker returns all delegators that have delegated to the given staker
	// This query is paginated.
	DelegatorsByStaker(context.Context, *QueryDelegatorsByStakerRequest) (*QueryDelegatorsByStakerResponse, error)
	// StakersByPoolAndDelegator returns all stakers the given delegator has delegated to.
	// This query is paginated.
	StakersByDelegator(context.Context, *QueryStakersByDelegatorRequest) (*QueryStakersByDelegatorResponse, error)
}

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

func (*UnimplementedQueryDelegationServer) Delegator(ctx context.Context, req *QueryDelegatorRequest) (*QueryDelegatorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delegator not implemented")
}
func (*UnimplementedQueryDelegationServer) DelegatorsByStaker(ctx context.Context, req *QueryDelegatorsByStakerRequest) (*QueryDelegatorsByStakerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelegatorsByStaker not implemented")
}
func (*UnimplementedQueryDelegationServer) StakersByDelegator(ctx context.Context, req *QueryStakersByDelegatorRequest) (*QueryStakersByDelegatorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StakersByDelegator not implemented")
}

func RegisterQueryDelegationServer(s grpc1.Server, srv QueryDelegationServer) {
	s.RegisterService(&_QueryDelegation_serviceDesc, srv)
}

func _QueryDelegation_Delegator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryDelegatorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryDelegationServer).Delegator(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/kyve.query.v1beta1.QueryDelegation/Delegator",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryDelegationServer).Delegator(ctx, req.(*QueryDelegatorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _QueryDelegation_DelegatorsByStaker_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryDelegatorsByStakerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryDelegationServer).DelegatorsByStaker(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/kyve.query.v1beta1.QueryDelegation/DelegatorsByStaker",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryDelegationServer).DelegatorsByStaker(ctx, req.(*QueryDelegatorsByStakerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _QueryDelegation_StakersByDelegator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryStakersByDelegatorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryDelegationServer).StakersByDelegator(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/kyve.query.v1beta1.QueryDelegation/StakersByDelegator",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryDelegationServer).StakersByDelegator(ctx, req.(*QueryStakersByDelegatorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _QueryDelegation_serviceDesc = grpc.ServiceDesc{
	ServiceName: "kyve.query.v1beta1.QueryDelegation",
	HandlerType: (*QueryDelegationServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Delegator",
			Handler:    _QueryDelegation_Delegator_Handler,
		},
		{
			MethodName: "DelegatorsByStaker",
			Handler:    _QueryDelegation_DelegatorsByStaker_Handler,
		},
		{
			MethodName: "StakersByDelegator",
			Handler:    _QueryDelegation_StakersByDelegator_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kyve/query/v1beta1/delegation.proto",
}

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

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

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

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

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

func (m *StakerDelegatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Staker) > 0 {
		i -= len(m.Staker)
		copy(dAtA[i:], m.Staker)
		i = encodeVarintDelegation(dAtA, i, uint64(len(m.Staker)))
		i--
		dAtA[i] = 0x22
	}
	if m.DelegationAmount != 0 {
		i = encodeVarintDelegation(dAtA, i, uint64(m.DelegationAmount))
		i--
		dAtA[i] = 0x18
	}
	if m.CurrentReward != 0 {
		i = encodeVarintDelegation(dAtA, i, uint64(m.CurrentReward))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintDelegation(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryDelegatorsByStakerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Staker) > 0 {
		i -= len(m.Staker)
		copy(dAtA[i:], m.Staker)
		i = encodeVarintDelegation(dAtA, i, uint64(len(m.Staker)))
		i--
		dAtA[i] = 0x12
	}
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDelegation(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryDelegatorsByStakerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDelegation(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.TotalDelegatorCount != 0 {
		i = encodeVarintDelegation(dAtA, i, uint64(m.TotalDelegatorCount))
		i--
		dAtA[i] = 0x18
	}
	if m.TotalDelegation != 0 {
		i = encodeVarintDelegation(dAtA, i, uint64(m.TotalDelegation))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Delegators) > 0 {
		for iNdEx := len(m.Delegators) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Delegators[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDelegation(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryStakersByDelegatorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintDelegation(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0x12
	}
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDelegation(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *DelegationForStakerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DelegationAmount != 0 {
		i = encodeVarintDelegation(dAtA, i, uint64(m.DelegationAmount))
		i--
		dAtA[i] = 0x18
	}
	if m.CurrentReward != 0 {
		i = encodeVarintDelegation(dAtA, i, uint64(m.CurrentReward))
		i--
		dAtA[i] = 0x10
	}
	if m.Staker != nil {
		{
			size, err := m.Staker.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDelegation(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintDelegation(dAtA []byte, offset int, v uint64) int {
	offset -= sovDelegation(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *QueryDelegatorRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Staker)
	if l > 0 {
		n += 1 + l + sovDelegation(uint64(l))
	}
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovDelegation(uint64(l))
	}
	return n
}

func (m *QueryDelegatorResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Delegator != nil {
		l = m.Delegator.Size()
		n += 1 + l + sovDelegation(uint64(l))
	}
	return n
}

func (m *StakerDelegatorResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovDelegation(uint64(l))
	}
	if m.CurrentReward != 0 {
		n += 1 + sovDelegation(uint64(m.CurrentReward))
	}
	if m.DelegationAmount != 0 {
		n += 1 + sovDelegation(uint64(m.DelegationAmount))
	}
	l = len(m.Staker)
	if l > 0 {
		n += 1 + l + sovDelegation(uint64(l))
	}
	return n
}

func (m *QueryDelegatorsByStakerRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovDelegation(uint64(l))
	}
	l = len(m.Staker)
	if l > 0 {
		n += 1 + l + sovDelegation(uint64(l))
	}
	return n
}

func (m *QueryDelegatorsByStakerResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Delegators) > 0 {
		for _, e := range m.Delegators {
			l = e.Size()
			n += 1 + l + sovDelegation(uint64(l))
		}
	}
	if m.TotalDelegation != 0 {
		n += 1 + sovDelegation(uint64(m.TotalDelegation))
	}
	if m.TotalDelegatorCount != 0 {
		n += 1 + sovDelegation(uint64(m.TotalDelegatorCount))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovDelegation(uint64(l))
	}
	return n
}

func (m *QueryStakersByDelegatorRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovDelegation(uint64(l))
	}
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovDelegation(uint64(l))
	}
	return n
}

func (m *QueryStakersByDelegatorResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovDelegation(uint64(l))
	}
	if len(m.Stakers) > 0 {
		for _, e := range m.Stakers {
			l = e.Size()
			n += 1 + l + sovDelegation(uint64(l))
		}
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovDelegation(uint64(l))
	}
	return n
}

func (m *DelegationForStakerResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Staker != nil {
		l = m.Staker.Size()
		n += 1 + l + sovDelegation(uint64(l))
	}
	if m.CurrentReward != 0 {
		n += 1 + sovDelegation(uint64(m.CurrentReward))
	}
	if m.DelegationAmount != 0 {
		n += 1 + sovDelegation(uint64(m.DelegationAmount))
	}
	return n
}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StakerDelegatorResponse) 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 ErrIntOverflowDelegation
			}
			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: StakerDelegatorResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StakerDelegatorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDelegation
				}
				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 ErrInvalidLengthDelegation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDelegation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentReward", wireType)
			}
			m.CurrentReward = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDelegation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CurrentReward |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegationAmount", wireType)
			}
			m.DelegationAmount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDelegation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DelegationAmount |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Staker", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDelegation
				}
				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 ErrInvalidLengthDelegation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDelegation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Staker = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDelegation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDelegation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

var (
	ErrInvalidLengthDelegation        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowDelegation          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupDelegation = fmt.Errorf("proto: unexpected end of group")
)