bundles.pb.go

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

package types

import (
	context "context"
	fmt "fmt"
	types "github.com/KYVENetwork/chain/x/bundles/types"
	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

// QueryFinalizedBundlesRequest is the request type for the Query/Staker RPC method.
type QueryFinalizedBundlesRequest struct {
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
	// pool_id ...
	PoolId uint64 `protobuf:"varint,2,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
}

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

var xxx_messageInfo_QueryFinalizedBundlesRequest proto.InternalMessageInfo

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

func (m *QueryFinalizedBundlesRequest) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

// QueryStakersByPoolResponse is the response type for the Query/Staker RPC method.
type QueryFinalizedBundlesResponse struct {
	// finalized_bundles ...
	FinalizedBundles []types.FinalizedBundle `protobuf:"bytes,1,rep,name=finalized_bundles,json=finalizedBundles,proto3" json:"finalized_bundles"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryFinalizedBundlesResponse proto.InternalMessageInfo

func (m *QueryFinalizedBundlesResponse) GetFinalizedBundles() []types.FinalizedBundle {
	if m != nil {
		return m.FinalizedBundles
	}
	return nil
}

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

// QueryFinalizedBundleRequest is the request type for the Query/Staker RPC method.
type QueryFinalizedBundleRequest struct {
	// pool_id ...
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
	// id ...
	Id uint64 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
}

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

var xxx_messageInfo_QueryFinalizedBundleRequest proto.InternalMessageInfo

func (m *QueryFinalizedBundleRequest) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

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

// QueryFinalizedBundleResponse is the response type for the Query/Staker RPC method.
type QueryFinalizedBundleResponse struct {
	// finalized_bundle ...
	FinalizedBundle types.FinalizedBundle `protobuf:"bytes,1,opt,name=finalized_bundle,json=finalizedBundle,proto3" json:"finalized_bundle"`
}

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

var xxx_messageInfo_QueryFinalizedBundleResponse proto.InternalMessageInfo

func (m *QueryFinalizedBundleResponse) GetFinalizedBundle() types.FinalizedBundle {
	if m != nil {
		return m.FinalizedBundle
	}
	return types.FinalizedBundle{}
}

// QueryFinalizedBundleRequest is the request type for the Query/Staker RPC method.
type QueryFinalizedBundlesByHeightRequest struct {
	// pool_id ...
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
	// id ...
	Height uint64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
}

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

var xxx_messageInfo_QueryFinalizedBundlesByHeightRequest proto.InternalMessageInfo

func (m *QueryFinalizedBundlesByHeightRequest) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

func (m *QueryFinalizedBundlesByHeightRequest) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

// QueryFinalizedBundleResponse is the response type for the Query/Staker RPC method.
type QueryFinalizedBundlesByHeightResponse struct {
	// finalized_bundle ...
	FinalizedBundle types.FinalizedBundle `protobuf:"bytes,1,opt,name=finalized_bundle,json=finalizedBundle,proto3" json:"finalized_bundle"`
}

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

var xxx_messageInfo_QueryFinalizedBundlesByHeightResponse proto.InternalMessageInfo

func (m *QueryFinalizedBundlesByHeightResponse) GetFinalizedBundle() types.FinalizedBundle {
	if m != nil {
		return m.FinalizedBundle
	}
	return types.FinalizedBundle{}
}

// QueryCurrentVoteStatusRequest is the request type for the Query/Staker RPC method.
type QueryCurrentVoteStatusRequest struct {
	// pool_id ...
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
}

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

var xxx_messageInfo_QueryCurrentVoteStatusRequest proto.InternalMessageInfo

func (m *QueryCurrentVoteStatusRequest) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

// QueryCurrentVoteStatusResponse is the response type for the Query/Staker RPC method.
type QueryCurrentVoteStatusResponse struct {
	// valid ...
	Valid uint64 `protobuf:"varint,1,opt,name=valid,proto3" json:"valid,omitempty"`
	// invalid ...
	Invalid uint64 `protobuf:"varint,2,opt,name=invalid,proto3" json:"invalid,omitempty"`
	// abstain ...
	Abstain uint64 `protobuf:"varint,3,opt,name=abstain,proto3" json:"abstain,omitempty"`
	// total ...
	Total uint64 `protobuf:"varint,4,opt,name=total,proto3" json:"total,omitempty"`
}

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

var xxx_messageInfo_QueryCurrentVoteStatusResponse proto.InternalMessageInfo

func (m *QueryCurrentVoteStatusResponse) GetValid() uint64 {
	if m != nil {
		return m.Valid
	}
	return 0
}

func (m *QueryCurrentVoteStatusResponse) GetInvalid() uint64 {
	if m != nil {
		return m.Invalid
	}
	return 0
}

func (m *QueryCurrentVoteStatusResponse) GetAbstain() uint64 {
	if m != nil {
		return m.Abstain
	}
	return 0
}

func (m *QueryCurrentVoteStatusResponse) GetTotal() uint64 {
	if m != nil {
		return m.Total
	}
	return 0
}

// QueryCanProposeRequest is the request type for the Query/CanPropose RPC method.
type QueryCanValidateRequest struct {
	// pool_id defines the unique ID of the pool.
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
	// valaddress ...
	Valaddress string `protobuf:"bytes,2,opt,name=valaddress,proto3" json:"valaddress,omitempty"`
}

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

var xxx_messageInfo_QueryCanValidateRequest proto.InternalMessageInfo

func (m *QueryCanValidateRequest) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

func (m *QueryCanValidateRequest) GetValaddress() string {
	if m != nil {
		return m.Valaddress
	}
	return ""
}

// QueryCanProposeResponse is the response type for the Query/CanPropose RPC method.
type QueryCanValidateResponse struct {
	// possible ...
	Possible bool `protobuf:"varint,1,opt,name=possible,proto3" json:"possible,omitempty"`
	// reason ...
	Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
}

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

var xxx_messageInfo_QueryCanValidateResponse proto.InternalMessageInfo

func (m *QueryCanValidateResponse) GetPossible() bool {
	if m != nil {
		return m.Possible
	}
	return false
}

func (m *QueryCanValidateResponse) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

// QueryCanProposeRequest is the request type for the Query/CanPropose RPC method.
type QueryCanProposeRequest struct {
	// pool_id defines the unique ID of the pool.
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
	// staker ...
	Staker string `protobuf:"bytes,2,opt,name=staker,proto3" json:"staker,omitempty"`
	// proposer ...
	Proposer string `protobuf:"bytes,3,opt,name=proposer,proto3" json:"proposer,omitempty"`
	// from_index ...
	FromIndex uint64 `protobuf:"varint,4,opt,name=from_index,json=fromIndex,proto3" json:"from_index,omitempty"`
}

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

var xxx_messageInfo_QueryCanProposeRequest proto.InternalMessageInfo

func (m *QueryCanProposeRequest) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

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

func (m *QueryCanProposeRequest) GetProposer() string {
	if m != nil {
		return m.Proposer
	}
	return ""
}

func (m *QueryCanProposeRequest) GetFromIndex() uint64 {
	if m != nil {
		return m.FromIndex
	}
	return 0
}

// QueryCanProposeResponse is the response type for the Query/CanPropose RPC method.
type QueryCanProposeResponse struct {
	// possible ...
	Possible bool `protobuf:"varint,1,opt,name=possible,proto3" json:"possible,omitempty"`
	// reason ...
	Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
}

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

var xxx_messageInfo_QueryCanProposeResponse proto.InternalMessageInfo

func (m *QueryCanProposeResponse) GetPossible() bool {
	if m != nil {
		return m.Possible
	}
	return false
}

func (m *QueryCanProposeResponse) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

// QueryCanVoteRequest is the request type for the Query/CanVote RPC method.
type QueryCanVoteRequest struct {
	// pool_id defines the unique ID of the pool.
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
	// staker ...
	Staker string `protobuf:"bytes,2,opt,name=staker,proto3" json:"staker,omitempty"`
	// voter ...
	Voter string `protobuf:"bytes,3,opt,name=voter,proto3" json:"voter,omitempty"`
	// storage_id ...
	StorageId string `protobuf:"bytes,4,opt,name=storage_id,json=storageId,proto3" json:"storage_id,omitempty"`
}

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

var xxx_messageInfo_QueryCanVoteRequest proto.InternalMessageInfo

func (m *QueryCanVoteRequest) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

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

func (m *QueryCanVoteRequest) GetVoter() string {
	if m != nil {
		return m.Voter
	}
	return ""
}

func (m *QueryCanVoteRequest) GetStorageId() string {
	if m != nil {
		return m.StorageId
	}
	return ""
}

// QueryCanVoteResponse is the response type for the Query/CanVote RPC method.
type QueryCanVoteResponse struct {
	// possible ...
	Possible bool `protobuf:"varint,1,opt,name=possible,proto3" json:"possible,omitempty"`
	// reason ...
	Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
}

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

var xxx_messageInfo_QueryCanVoteResponse proto.InternalMessageInfo

func (m *QueryCanVoteResponse) GetPossible() bool {
	if m != nil {
		return m.Possible
	}
	return false
}

func (m *QueryCanVoteResponse) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

func init() {
	proto.RegisterType((*QueryFinalizedBundlesRequest)(nil), "kyve.query.v1beta1.QueryFinalizedBundlesRequest")
	proto.RegisterType((*QueryFinalizedBundlesResponse)(nil), "kyve.query.v1beta1.QueryFinalizedBundlesResponse")
	proto.RegisterType((*QueryFinalizedBundleRequest)(nil), "kyve.query.v1beta1.QueryFinalizedBundleRequest")
	proto.RegisterType((*QueryFinalizedBundleResponse)(nil), "kyve.query.v1beta1.QueryFinalizedBundleResponse")
	proto.RegisterType((*QueryFinalizedBundlesByHeightRequest)(nil), "kyve.query.v1beta1.QueryFinalizedBundlesByHeightRequest")
	proto.RegisterType((*QueryFinalizedBundlesByHeightResponse)(nil), "kyve.query.v1beta1.QueryFinalizedBundlesByHeightResponse")
	proto.RegisterType((*QueryCurrentVoteStatusRequest)(nil), "kyve.query.v1beta1.QueryCurrentVoteStatusRequest")
	proto.RegisterType((*QueryCurrentVoteStatusResponse)(nil), "kyve.query.v1beta1.QueryCurrentVoteStatusResponse")
	proto.RegisterType((*QueryCanValidateRequest)(nil), "kyve.query.v1beta1.QueryCanValidateRequest")
	proto.RegisterType((*QueryCanValidateResponse)(nil), "kyve.query.v1beta1.QueryCanValidateResponse")
	proto.RegisterType((*QueryCanProposeRequest)(nil), "kyve.query.v1beta1.QueryCanProposeRequest")
	proto.RegisterType((*QueryCanProposeResponse)(nil), "kyve.query.v1beta1.QueryCanProposeResponse")
	proto.RegisterType((*QueryCanVoteRequest)(nil), "kyve.query.v1beta1.QueryCanVoteRequest")
	proto.RegisterType((*QueryCanVoteResponse)(nil), "kyve.query.v1beta1.QueryCanVoteResponse")
}

func init() { proto.RegisterFile("kyve/query/v1beta1/bundles.proto", fileDescriptor_b49b126c38ac815c) }

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

// QueryBundlesClient is the client API for QueryBundles service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryBundlesClient interface {
	// FinalizedBundles ...
	FinalizedBundles(ctx context.Context, in *QueryFinalizedBundlesRequest, opts ...grpc.CallOption) (*QueryFinalizedBundlesResponse, error)
	// FinalizedBundle ...
	FinalizedBundle(ctx context.Context, in *QueryFinalizedBundleRequest, opts ...grpc.CallOption) (*QueryFinalizedBundleResponse, error)
	// Queries the bundle which contains the data given height
	FinalizedBundlesByHeight(ctx context.Context, in *QueryFinalizedBundlesByHeightRequest, opts ...grpc.CallOption) (*QueryFinalizedBundlesByHeightResponse, error)
	// CurrentVoteStatus ...
	CurrentVoteStatus(ctx context.Context, in *QueryCurrentVoteStatusRequest, opts ...grpc.CallOption) (*QueryCurrentVoteStatusResponse, error)
	// CanValidate ...
	CanValidate(ctx context.Context, in *QueryCanValidateRequest, opts ...grpc.CallOption) (*QueryCanValidateResponse, error)
	// CanPropose ...
	CanPropose(ctx context.Context, in *QueryCanProposeRequest, opts ...grpc.CallOption) (*QueryCanProposeResponse, error)
	// CanVote checks if voter on pool can still vote for the given bundle
	CanVote(ctx context.Context, in *QueryCanVoteRequest, opts ...grpc.CallOption) (*QueryCanVoteResponse, error)
}

type queryBundlesClient struct {
	cc grpc1.ClientConn
}

func NewQueryBundlesClient(cc grpc1.ClientConn) QueryBundlesClient {
	return &queryBundlesClient{cc}
}

func (c *queryBundlesClient) FinalizedBundles(ctx context.Context, in *QueryFinalizedBundlesRequest, opts ...grpc.CallOption) (*QueryFinalizedBundlesResponse, error) {
	out := new(QueryFinalizedBundlesResponse)
	err := c.cc.Invoke(ctx, "/kyve.query.v1beta1.QueryBundles/FinalizedBundles", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryBundlesClient) FinalizedBundle(ctx context.Context, in *QueryFinalizedBundleRequest, opts ...grpc.CallOption) (*QueryFinalizedBundleResponse, error) {
	out := new(QueryFinalizedBundleResponse)
	err := c.cc.Invoke(ctx, "/kyve.query.v1beta1.QueryBundles/FinalizedBundle", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryBundlesClient) FinalizedBundlesByHeight(ctx context.Context, in *QueryFinalizedBundlesByHeightRequest, opts ...grpc.CallOption) (*QueryFinalizedBundlesByHeightResponse, error) {
	out := new(QueryFinalizedBundlesByHeightResponse)
	err := c.cc.Invoke(ctx, "/kyve.query.v1beta1.QueryBundles/FinalizedBundlesByHeight", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryBundlesClient) CurrentVoteStatus(ctx context.Context, in *QueryCurrentVoteStatusRequest, opts ...grpc.CallOption) (*QueryCurrentVoteStatusResponse, error) {
	out := new(QueryCurrentVoteStatusResponse)
	err := c.cc.Invoke(ctx, "/kyve.query.v1beta1.QueryBundles/CurrentVoteStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryBundlesClient) CanValidate(ctx context.Context, in *QueryCanValidateRequest, opts ...grpc.CallOption) (*QueryCanValidateResponse, error) {
	out := new(QueryCanValidateResponse)
	err := c.cc.Invoke(ctx, "/kyve.query.v1beta1.QueryBundles/CanValidate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryBundlesClient) CanPropose(ctx context.Context, in *QueryCanProposeRequest, opts ...grpc.CallOption) (*QueryCanProposeResponse, error) {
	out := new(QueryCanProposeResponse)
	err := c.cc.Invoke(ctx, "/kyve.query.v1beta1.QueryBundles/CanPropose", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryBundlesClient) CanVote(ctx context.Context, in *QueryCanVoteRequest, opts ...grpc.CallOption) (*QueryCanVoteResponse, error) {
	out := new(QueryCanVoteResponse)
	err := c.cc.Invoke(ctx, "/kyve.query.v1beta1.QueryBundles/CanVote", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryBundlesServer is the server API for QueryBundles service.
type QueryBundlesServer interface {
	// FinalizedBundles ...
	FinalizedBundles(context.Context, *QueryFinalizedBundlesRequest) (*QueryFinalizedBundlesResponse, error)
	// FinalizedBundle ...
	FinalizedBundle(context.Context, *QueryFinalizedBundleRequest) (*QueryFinalizedBundleResponse, error)
	// Queries the bundle which contains the data given height
	FinalizedBundlesByHeight(context.Context, *QueryFinalizedBundlesByHeightRequest) (*QueryFinalizedBundlesByHeightResponse, error)
	// CurrentVoteStatus ...
	CurrentVoteStatus(context.Context, *QueryCurrentVoteStatusRequest) (*QueryCurrentVoteStatusResponse, error)
	// CanValidate ...
	CanValidate(context.Context, *QueryCanValidateRequest) (*QueryCanValidateResponse, error)
	// CanPropose ...
	CanPropose(context.Context, *QueryCanProposeRequest) (*QueryCanProposeResponse, error)
	// CanVote checks if voter on pool can still vote for the given bundle
	CanVote(context.Context, *QueryCanVoteRequest) (*QueryCanVoteResponse, error)
}

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

func (*UnimplementedQueryBundlesServer) FinalizedBundles(ctx context.Context, req *QueryFinalizedBundlesRequest) (*QueryFinalizedBundlesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FinalizedBundles not implemented")
}
func (*UnimplementedQueryBundlesServer) FinalizedBundle(ctx context.Context, req *QueryFinalizedBundleRequest) (*QueryFinalizedBundleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FinalizedBundle not implemented")
}
func (*UnimplementedQueryBundlesServer) FinalizedBundlesByHeight(ctx context.Context, req *QueryFinalizedBundlesByHeightRequest) (*QueryFinalizedBundlesByHeightResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FinalizedBundlesByHeight not implemented")
}
func (*UnimplementedQueryBundlesServer) CurrentVoteStatus(ctx context.Context, req *QueryCurrentVoteStatusRequest) (*QueryCurrentVoteStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CurrentVoteStatus not implemented")
}
func (*UnimplementedQueryBundlesServer) CanValidate(ctx context.Context, req *QueryCanValidateRequest) (*QueryCanValidateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CanValidate not implemented")
}
func (*UnimplementedQueryBundlesServer) CanPropose(ctx context.Context, req *QueryCanProposeRequest) (*QueryCanProposeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CanPropose not implemented")
}
func (*UnimplementedQueryBundlesServer) CanVote(ctx context.Context, req *QueryCanVoteRequest) (*QueryCanVoteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CanVote not implemented")
}

func RegisterQueryBundlesServer(s grpc1.Server, srv QueryBundlesServer) {
	s.RegisterService(&_QueryBundles_serviceDesc, srv)
}

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

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

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

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

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

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

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

var _QueryBundles_serviceDesc = grpc.ServiceDesc{
	ServiceName: "kyve.query.v1beta1.QueryBundles",
	HandlerType: (*QueryBundlesServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "FinalizedBundles",
			Handler:    _QueryBundles_FinalizedBundles_Handler,
		},
		{
			MethodName: "FinalizedBundle",
			Handler:    _QueryBundles_FinalizedBundle_Handler,
		},
		{
			MethodName: "FinalizedBundlesByHeight",
			Handler:    _QueryBundles_FinalizedBundlesByHeight_Handler,
		},
		{
			MethodName: "CurrentVoteStatus",
			Handler:    _QueryBundles_CurrentVoteStatus_Handler,
		},
		{
			MethodName: "CanValidate",
			Handler:    _QueryBundles_CanValidate_Handler,
		},
		{
			MethodName: "CanPropose",
			Handler:    _QueryBundles_CanPropose_Handler,
		},
		{
			MethodName: "CanVote",
			Handler:    _QueryBundles_CanVote_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kyve/query/v1beta1/bundles.proto",
}

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

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

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

func (m *QueryFinalizedBundlesResponse) 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 = encodeVarintBundles(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.FinalizedBundles) > 0 {
		for iNdEx := len(m.FinalizedBundles) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FinalizedBundles[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBundles(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

func (m *QueryCurrentVoteStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Total != 0 {
		i = encodeVarintBundles(dAtA, i, uint64(m.Total))
		i--
		dAtA[i] = 0x20
	}
	if m.Abstain != 0 {
		i = encodeVarintBundles(dAtA, i, uint64(m.Abstain))
		i--
		dAtA[i] = 0x18
	}
	if m.Invalid != 0 {
		i = encodeVarintBundles(dAtA, i, uint64(m.Invalid))
		i--
		dAtA[i] = 0x10
	}
	if m.Valid != 0 {
		i = encodeVarintBundles(dAtA, i, uint64(m.Valid))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryCanValidateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Reason) > 0 {
		i -= len(m.Reason)
		copy(dAtA[i:], m.Reason)
		i = encodeVarintBundles(dAtA, i, uint64(len(m.Reason)))
		i--
		dAtA[i] = 0x12
	}
	if m.Possible {
		i--
		if m.Possible {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryCanProposeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FromIndex != 0 {
		i = encodeVarintBundles(dAtA, i, uint64(m.FromIndex))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Proposer) > 0 {
		i -= len(m.Proposer)
		copy(dAtA[i:], m.Proposer)
		i = encodeVarintBundles(dAtA, i, uint64(len(m.Proposer)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Staker) > 0 {
		i -= len(m.Staker)
		copy(dAtA[i:], m.Staker)
		i = encodeVarintBundles(dAtA, i, uint64(len(m.Staker)))
		i--
		dAtA[i] = 0x12
	}
	if m.PoolId != 0 {
		i = encodeVarintBundles(dAtA, i, uint64(m.PoolId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryCanProposeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Reason) > 0 {
		i -= len(m.Reason)
		copy(dAtA[i:], m.Reason)
		i = encodeVarintBundles(dAtA, i, uint64(len(m.Reason)))
		i--
		dAtA[i] = 0x12
	}
	if m.Possible {
		i--
		if m.Possible {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryCanVoteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.StorageId) > 0 {
		i -= len(m.StorageId)
		copy(dAtA[i:], m.StorageId)
		i = encodeVarintBundles(dAtA, i, uint64(len(m.StorageId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Voter) > 0 {
		i -= len(m.Voter)
		copy(dAtA[i:], m.Voter)
		i = encodeVarintBundles(dAtA, i, uint64(len(m.Voter)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Staker) > 0 {
		i -= len(m.Staker)
		copy(dAtA[i:], m.Staker)
		i = encodeVarintBundles(dAtA, i, uint64(len(m.Staker)))
		i--
		dAtA[i] = 0x12
	}
	if m.PoolId != 0 {
		i = encodeVarintBundles(dAtA, i, uint64(m.PoolId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryCanVoteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Reason) > 0 {
		i -= len(m.Reason)
		copy(dAtA[i:], m.Reason)
		i = encodeVarintBundles(dAtA, i, uint64(len(m.Reason)))
		i--
		dAtA[i] = 0x12
	}
	if m.Possible {
		i--
		if m.Possible {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintBundles(dAtA []byte, offset int, v uint64) int {
	offset -= sovBundles(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *QueryFinalizedBundlesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovBundles(uint64(l))
	}
	if m.PoolId != 0 {
		n += 1 + sovBundles(uint64(m.PoolId))
	}
	return n
}

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

func (m *QueryFinalizedBundleRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PoolId != 0 {
		n += 1 + sovBundles(uint64(m.PoolId))
	}
	if m.Id != 0 {
		n += 1 + sovBundles(uint64(m.Id))
	}
	return n
}

func (m *QueryFinalizedBundleResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.FinalizedBundle.Size()
	n += 1 + l + sovBundles(uint64(l))
	return n
}

func (m *QueryFinalizedBundlesByHeightRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PoolId != 0 {
		n += 1 + sovBundles(uint64(m.PoolId))
	}
	if m.Height != 0 {
		n += 1 + sovBundles(uint64(m.Height))
	}
	return n
}

func (m *QueryFinalizedBundlesByHeightResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.FinalizedBundle.Size()
	n += 1 + l + sovBundles(uint64(l))
	return n
}

func (m *QueryCurrentVoteStatusRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PoolId != 0 {
		n += 1 + sovBundles(uint64(m.PoolId))
	}
	return n
}

func (m *QueryCurrentVoteStatusResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Valid != 0 {
		n += 1 + sovBundles(uint64(m.Valid))
	}
	if m.Invalid != 0 {
		n += 1 + sovBundles(uint64(m.Invalid))
	}
	if m.Abstain != 0 {
		n += 1 + sovBundles(uint64(m.Abstain))
	}
	if m.Total != 0 {
		n += 1 + sovBundles(uint64(m.Total))
	}
	return n
}

func (m *QueryCanValidateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PoolId != 0 {
		n += 1 + sovBundles(uint64(m.PoolId))
	}
	l = len(m.Valaddress)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	return n
}

func (m *QueryCanValidateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Possible {
		n += 2
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	return n
}

func (m *QueryCanProposeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PoolId != 0 {
		n += 1 + sovBundles(uint64(m.PoolId))
	}
	l = len(m.Staker)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	l = len(m.Proposer)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	if m.FromIndex != 0 {
		n += 1 + sovBundles(uint64(m.FromIndex))
	}
	return n
}

func (m *QueryCanProposeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Possible {
		n += 2
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	return n
}

func (m *QueryCanVoteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PoolId != 0 {
		n += 1 + sovBundles(uint64(m.PoolId))
	}
	l = len(m.Staker)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	l = len(m.Voter)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	l = len(m.StorageId)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	return n
}

func (m *QueryCanVoteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Possible {
		n += 2
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	return n
}

func sovBundles(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozBundles(x uint64) (n int) {
	return sovBundles(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QueryFinalizedBundlesRequest) 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 ErrIntOverflowBundles
			}
			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: QueryFinalizedBundlesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryFinalizedBundlesRequest: 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 ErrIntOverflowBundles
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBundles
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBundles
			}
			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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType)
			}
			m.PoolId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBundles
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PoolId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBundles(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBundles
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryFinalizedBundleRequest) 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 ErrIntOverflowBundles
			}
			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: QueryFinalizedBundleRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryFinalizedBundleRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType)
			}
			m.PoolId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBundles
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PoolId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBundles
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBundles(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBundles
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryFinalizedBundlesByHeightRequest) 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 ErrIntOverflowBundles
			}
			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: QueryFinalizedBundlesByHeightRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryFinalizedBundlesByHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType)
			}
			m.PoolId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBundles
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PoolId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBundles
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBundles(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBundles
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryCurrentVoteStatusRequest) 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 ErrIntOverflowBundles
			}
			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: QueryCurrentVoteStatusRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCurrentVoteStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType)
			}
			m.PoolId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBundles
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PoolId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBundles(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBundles
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryCurrentVoteStatusResponse) 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 ErrIntOverflowBundles
			}
			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: QueryCurrentVoteStatusResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCurrentVoteStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Valid", wireType)
			}
			m.Valid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBundles
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Valid |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Invalid", wireType)
			}
			m.Invalid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBundles
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Invalid |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Abstain", wireType)
			}
			m.Abstain = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBundles
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Abstain |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
			}
			m.Total = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBundles
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Total |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBundles(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBundles
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

var (
	ErrInvalidLengthBundles        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBundles          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupBundles = fmt.Errorf("proto: unexpected end of group")
)