bundles.pb.go

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

package types

import (
	context "context"
	cosmossdk_io_math "cosmossdk.io/math"
	fmt "fmt"
	query "github.com/cosmos/cosmos-sdk/types/query"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// FinalizedBundle represents the latest version of a valid bundle of a pool
type FinalizedBundle struct {
	// pool_id in which the bundle was created
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
	// id is is integrated with each valid bundle produced.
	Id uint64 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
	// storage_id is the id with which the data can be retrieved from the configured data provider
	StorageId string `protobuf:"bytes,3,opt,name=storage_id,json=storageId,proto3" json:"storage_id,omitempty"`
	// uploader is the address of the staker who submitted this bundle
	Uploader string `protobuf:"bytes,4,opt,name=uploader,proto3" json:"uploader,omitempty"`
	// from_index is the index from where the bundle starts (inclusive)
	FromIndex uint64 `protobuf:"varint,5,opt,name=from_index,json=fromIndex,proto3" json:"from_index,omitempty"`
	// to_index is the index to which the bundle goes (exclusive)
	ToIndex uint64 `protobuf:"varint,6,opt,name=to_index,json=toIndex,proto3" json:"to_index,omitempty"`
	// from_key is the key of the first data item in the bundle proposal
	FromKey string `protobuf:"bytes,11,opt,name=from_key,json=fromKey,proto3" json:"from_key,omitempty"`
	// to_key the key of the last data item in the bundle
	ToKey string `protobuf:"bytes,7,opt,name=to_key,json=toKey,proto3" json:"to_key,omitempty"`
	// bundle_summary is a summary of the bundle.
	BundleSummary string `protobuf:"bytes,8,opt,name=bundle_summary,json=bundleSummary,proto3" json:"bundle_summary,omitempty"`
	// data_hash is a sha256 hash of the uploaded data.
	DataHash string `protobuf:"bytes,9,opt,name=data_hash,json=dataHash,proto3" json:"data_hash,omitempty"`
	// finalized_at contains details of the block that finalized this bundle.
	FinalizedAt *FinalizedAt `protobuf:"bytes,10,opt,name=finalized_at,json=finalizedAt,proto3" json:"finalized_at,omitempty"`
	// storage_provider_id the id of the storage provider where the bundle is stored
	StorageProviderId uint64 `protobuf:"varint,12,opt,name=storage_provider_id,json=storageProviderId,proto3" json:"storage_provider_id,omitempty"`
	// compression_id the id of the compression type with which the data was compressed
	CompressionId uint64 `protobuf:"varint,13,opt,name=compression_id,json=compressionId,proto3" json:"compression_id,omitempty"`
	// stake_security defines the amount of stake which was present in the pool during the finalization of the bundle.
	// This field was added in schema version 2. Bundles finalized before that return `null`.
	StakeSecurity *StakeSecurity `protobuf:"bytes,14,opt,name=stake_security,json=stakeSecurity,proto3" json:"stake_security,omitempty"`
}

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

var xxx_messageInfo_FinalizedBundle proto.InternalMessageInfo

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

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

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

func (m *FinalizedBundle) GetUploader() string {
	if m != nil {
		return m.Uploader
	}
	return ""
}

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

func (m *FinalizedBundle) GetToIndex() uint64 {
	if m != nil {
		return m.ToIndex
	}
	return 0
}

func (m *FinalizedBundle) GetFromKey() string {
	if m != nil {
		return m.FromKey
	}
	return ""
}

func (m *FinalizedBundle) GetToKey() string {
	if m != nil {
		return m.ToKey
	}
	return ""
}

func (m *FinalizedBundle) GetBundleSummary() string {
	if m != nil {
		return m.BundleSummary
	}
	return ""
}

func (m *FinalizedBundle) GetDataHash() string {
	if m != nil {
		return m.DataHash
	}
	return ""
}

func (m *FinalizedBundle) GetFinalizedAt() *FinalizedAt {
	if m != nil {
		return m.FinalizedAt
	}
	return nil
}

func (m *FinalizedBundle) GetStorageProviderId() uint64 {
	if m != nil {
		return m.StorageProviderId
	}
	return 0
}

func (m *FinalizedBundle) GetCompressionId() uint64 {
	if m != nil {
		return m.CompressionId
	}
	return 0
}

func (m *FinalizedBundle) GetStakeSecurity() *StakeSecurity {
	if m != nil {
		return m.StakeSecurity
	}
	return nil
}

// FinalizedAt stores information about finalization block and time.
type FinalizedAt struct {
	// height is the block height in which the bundle got finalized.
	Height *cosmossdk_io_math.Int `protobuf:"bytes,1,opt,name=height,proto3,customtype=cosmossdk.io/math.Int" json:"height,omitempty"`
	// timestamp is the UNIX timestamp of the block in which the bundle got finalized.
	Timestamp string `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
}

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

var xxx_messageInfo_FinalizedAt proto.InternalMessageInfo

func (m *FinalizedAt) GetTimestamp() string {
	if m != nil {
		return m.Timestamp
	}
	return ""
}

// StakeSecurity represents the relative security of a finalized bundle
type StakeSecurity struct {
	// valid_vote_power gives the amount of $KYVE stake that voted `valid`.
	ValidVotePower *cosmossdk_io_math.Int `protobuf:"bytes,1,opt,name=valid_vote_power,json=validVotePower,proto3,customtype=cosmossdk.io/math.Int" json:"valid_vote_power,omitempty"`
	// total_vote_power gives the amount of total $KYVE stake that was present in the pool
	// during finalization.
	TotalVotePower *cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=total_vote_power,json=totalVotePower,proto3,customtype=cosmossdk.io/math.Int" json:"total_vote_power,omitempty"`
}

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

var xxx_messageInfo_StakeSecurity proto.InternalMessageInfo

// 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"`
	// index is an optional parameter which tells the server to only show
	// the bundle with the given index. This can not be combined with pagination.
	Index string `protobuf:"bytes,3,opt,name=index,proto3" json:"index,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{3}
}
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
}

func (m *QueryFinalizedBundlesRequest) GetIndex() string {
	if m != nil {
		return m.Index
	}
	return ""
}

// QueryStakersByPoolResponse is the response type for the Query/Staker RPC method.
type QueryFinalizedBundlesResponse struct {
	// finalized_bundles ...
	FinalizedBundles []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{4}
}
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() []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{5}
}
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_bundles ...
	FinalizedBundles FinalizedBundle `protobuf:"bytes,1,opt,name=finalized_bundles,json=finalizedBundles,proto3" json:"finalized_bundles"`
}

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{6}
}
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) GetFinalizedBundles() FinalizedBundle {
	if m != nil {
		return m.FinalizedBundles
	}
	return 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{7}
}
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{8}
}
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{9}
}
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{10}
}
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{11}
}
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{12}
}
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{13}
}
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{14}
}
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((*FinalizedBundle)(nil), "kyve.query.v1beta1.FinalizedBundle")
	proto.RegisterType((*FinalizedAt)(nil), "kyve.query.v1beta1.FinalizedAt")
	proto.RegisterType((*StakeSecurity)(nil), "kyve.query.v1beta1.StakeSecurity")
	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((*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{
	// 1191 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0xcf, 0x6f, 0x1b, 0x45,
	0x14, 0xce, 0xba, 0x8e, 0x7f, 0x3c, 0x37, 0xa1, 0x99, 0x26, 0xe9, 0xd6, 0x4d, 0x9d, 0x74, 0x11,
	0x24, 0x4a, 0xd1, 0x2e, 0x49, 0x0f, 0xd0, 0x13, 0x22, 0x2d, 0xa1, 0x6e, 0x4b, 0x15, 0x36, 0x52,
	0x24, 0x38, 0x60, 0x8d, 0xbd, 0x13, 0x7b, 0x15, 0x7b, 0x67, 0xbb, 0x33, 0x76, 0x6b, 0x22, 0x4b,
	0x08, 0x71, 0xe2, 0x84, 0x84, 0x8a, 0xc4, 0x8d, 0x2b, 0xdc, 0x39, 0x70, 0xe3, 0xd8, 0x63, 0x25,
	0x2e, 0x88, 0x43, 0x85, 0x12, 0xfe, 0x10, 0x34, 0x3f, 0xd6, 0xde, 0x38, 0x76, 0x9c, 0xb6, 0x37,
	0xbf, 0x37, 0xef, 0xbd, 0xf9, 0xde, 0xb7, 0xef, 0x7d, 0xbb, 0x86, 0x95, 0x83, 0x6e, 0x87, 0x38,
	0x8f, 0xdb, 0x24, 0xea, 0x3a, 0x9d, 0x8d, 0x2a, 0xe1, 0x78, 0xc3, 0xa9, 0xb6, 0x03, 0xaf, 0x49,
	0x98, 0x1d, 0x46, 0x94, 0x53, 0x84, 0x44, 0x84, 0x2d, 0x23, 0x6c, 0x1d, 0x51, 0x5c, 0xaf, 0x51,
	0xd6, 0xa2, 0xcc, 0xa9, 0x62, 0x36, 0x9c, 0x1c, 0xe2, 0xba, 0x1f, 0x60, 0xee, 0xd3, 0x40, 0xe5,
	0x17, 0xe7, 0xeb, 0xb4, 0x4e, 0xe5, 0x4f, 0x47, 0xfc, 0xd2, 0xde, 0xa5, 0x3a, 0xa5, 0xf5, 0x26,
	0x71, 0x70, 0xe8, 0x3b, 0x38, 0x08, 0x28, 0x97, 0x29, 0xfa, 0x4e, 0xeb, 0xfb, 0x34, 0xbc, 0xb5,
	0xed, 0x07, 0xb8, 0xe9, 0x7f, 0x4d, 0xbc, 0x2d, 0x09, 0x07, 0x5d, 0x81, 0x6c, 0x48, 0x69, 0xb3,
	0xe2, 0x7b, 0xa6, 0xb1, 0x62, 0xac, 0xa5, 0xdd, 0x8c, 0x30, 0xcb, 0x1e, 0x9a, 0x85, 0x94, 0xef,
	0x99, 0x29, 0xe9, 0x4b, 0xf9, 0x1e, 0xba, 0x0e, 0xc0, 0x38, 0x8d, 0x70, 0x9d, 0x88, 0xd8, 0x0b,
	0x2b, 0xc6, 0x5a, 0xde, 0xcd, 0x6b, 0x4f, 0xd9, 0x43, 0x45, 0xc8, 0xb5, 0xc3, 0x26, 0xc5, 0x1e,
	0x89, 0xcc, 0xb4, 0x3c, 0xec, 0xdb, 0x22, 0x75, 0x3f, 0xa2, 0xad, 0x8a, 0x1f, 0x78, 0xe4, 0xa9,
	0x39, 0x2d, 0x4b, 0xe6, 0x85, 0xa7, 0x2c, 0x1c, 0xe8, 0x2a, 0xe4, 0x38, 0xd5, 0x87, 0x19, 0x79,
	0x98, 0xe5, 0xb4, 0x7f, 0x24, 0x33, 0x0f, 0x48, 0xd7, 0x2c, 0xc8, 0xaa, 0x59, 0x61, 0x3f, 0x20,
	0x5d, 0xb4, 0x00, 0x19, 0x4e, 0xe5, 0x41, 0x56, 0x1e, 0x4c, 0x73, 0x2a, 0xdc, 0xef, 0xc0, 0xac,
	0x22, 0xba, 0xc2, 0xda, 0xad, 0x16, 0x8e, 0xba, 0x66, 0x4e, 0x1e, 0xcf, 0x28, 0xef, 0xae, 0x72,
	0xa2, 0x6b, 0x90, 0xf7, 0x30, 0xc7, 0x95, 0x06, 0x66, 0x0d, 0x33, 0xaf, 0xf0, 0x0a, 0xc7, 0x3d,
	0xcc, 0x1a, 0x68, 0x0b, 0x2e, 0xee, 0xc7, 0x34, 0x55, 0x30, 0x37, 0x61, 0xc5, 0x58, 0x2b, 0x6c,
	0x2e, 0xdb, 0xa7, 0x1f, 0x99, 0xdd, 0xa7, 0xf3, 0x63, 0xee, 0x16, 0xf6, 0x07, 0x06, 0xb2, 0xe1,
	0x72, 0x4c, 0x57, 0x18, 0xd1, 0x8e, 0xef, 0x91, 0x48, 0xf0, 0x76, 0x51, 0xf6, 0x37, 0xa7, 0x8f,
	0x76, 0xf4, 0x49, 0xd9, 0x13, 0xb8, 0x6b, 0xb4, 0x15, 0x46, 0x84, 0x31, 0x9f, 0x06, 0x22, 0x74,
	0x46, 0x86, 0xce, 0x24, 0xbc, 0x65, 0x0f, 0xdd, 0x83, 0x59, 0xc6, 0xf1, 0x01, 0xa9, 0x30, 0x52,
	0x6b, 0x47, 0x3e, 0xef, 0x9a, 0xb3, 0x12, 0xdc, 0x8d, 0x51, 0xe0, 0x76, 0x45, 0xe4, 0xae, 0x0e,
	0x74, 0x67, 0x58, 0xd2, 0xb4, 0xbe, 0x82, 0x42, 0x02, 0x3c, 0xda, 0x80, 0x4c, 0x83, 0xf8, 0xf5,
	0x06, 0x97, 0x63, 0x90, 0xdf, 0xba, 0xfa, 0xcf, 0xcb, 0xe5, 0x05, 0x35, 0x8f, 0xcc, 0x3b, 0xb0,
	0x7d, 0xea, 0xb4, 0x30, 0x6f, 0xd8, 0xe5, 0x80, 0xbb, 0x3a, 0x10, 0x2d, 0x41, 0x9e, 0xfb, 0x2d,
	0xc2, 0x38, 0x6e, 0x85, 0x72, 0x50, 0xf2, 0xee, 0xc0, 0x61, 0xfd, 0x6c, 0xc0, 0xcc, 0x09, 0x00,
	0xe8, 0x0e, 0x5c, 0xea, 0xe0, 0xa6, 0xef, 0x55, 0x3a, 0x94, 0x93, 0x4a, 0x48, 0x9f, 0x90, 0x68,
	0xf2, 0x65, 0xb3, 0x32, 0x65, 0x8f, 0x72, 0xb2, 0x23, 0x12, 0x44, 0x11, 0x4e, 0x39, 0x6e, 0x26,
	0x8b, 0xa4, 0x26, 0x16, 0x91, 0x29, 0xfd, 0x22, 0xd6, 0x33, 0x03, 0x96, 0x3e, 0x17, 0x54, 0x0d,
	0x6d, 0x03, 0x73, 0xc9, 0xe3, 0x36, 0x61, 0x1c, 0x6d, 0x03, 0x0c, 0x36, 0x4e, 0x82, 0x2c, 0x6c,
	0xbe, 0x6b, 0xab, 0xe2, 0xb6, 0x58, 0xcf, 0x21, 0xa6, 0x77, 0x70, 0x9d, 0xe8, 0x5c, 0x37, 0x91,
	0x99, 0xdc, 0xae, 0xd4, 0x89, 0xed, 0x9a, 0x87, 0x69, 0x35, 0xf0, 0x6a, 0x91, 0x94, 0x61, 0xfd,
	0x69, 0xc0, 0xf5, 0x31, 0xb8, 0x58, 0x48, 0x03, 0x46, 0xd0, 0x1e, 0xcc, 0x0d, 0x46, 0x53, 0x2b,
	0x8a, 0x69, 0xac, 0x5c, 0x58, 0x2b, 0x6c, 0xbe, 0x7d, 0xe6, 0x7c, 0xaa, 0x42, 0x5b, 0xe9, 0xe7,
	0x2f, 0x97, 0xa7, 0xdc, 0x4b, 0xfb, 0x43, 0xf5, 0xd1, 0xa7, 0x27, 0x1a, 0x4e, 0xc9, 0x86, 0x57,
	0x27, 0x36, 0xac, 0x40, 0x25, 0x3b, 0xb6, 0xb6, 0xe1, 0xda, 0xa8, 0x0e, 0x62, 0x62, 0xcf, 0x2b,
	0x37, 0x56, 0x67, 0xf4, 0x13, 0x9a, 0x44, 0x84, 0xf1, 0x86, 0x44, 0x58, 0x1f, 0xea, 0x27, 0x70,
	0xa7, 0x1d, 0x45, 0x24, 0xe0, 0x62, 0x66, 0x76, 0x39, 0xe6, 0x6d, 0x36, 0xa9, 0x03, 0xeb, 0x1b,
	0x03, 0x4a, 0xe3, 0x52, 0x35, 0xe8, 0x79, 0x98, 0x96, 0xe3, 0xac, 0x33, 0x95, 0x81, 0x4c, 0xc8,
	0xfa, 0x81, 0xf2, 0xab, 0xfe, 0x63, 0x53, 0x9c, 0xe0, 0x2a, 0xe3, 0xd8, 0x0f, 0xe4, 0x9c, 0xa4,
	0xdd, 0xd8, 0x14, 0x95, 0xe4, 0x4c, 0x4b, 0xad, 0x4d, 0xbb, 0xca, 0xb0, 0x5c, 0xb8, 0xa2, 0x10,
	0xe0, 0x60, 0x4f, 0x14, 0xc0, 0x7c, 0x32, 0xf1, 0x25, 0x80, 0x0e, 0x6e, 0x62, 0xcf, 0x13, 0x22,
	0xa3, 0xd7, 0x38, 0xe1, 0xb1, 0x1e, 0x81, 0x79, 0xba, 0xa6, 0xee, 0xa7, 0x08, 0xb9, 0x90, 0x32,
	0xe6, 0x57, 0x9b, 0x44, 0x56, 0xcd, 0xb9, 0x7d, 0x1b, 0x2d, 0x42, 0x26, 0x22, 0x98, 0xe9, 0x69,
	0xca, 0xbb, 0xda, 0xb2, 0xbe, 0x33, 0x60, 0x31, 0x2e, 0xb8, 0x13, 0xd1, 0x90, 0xb2, 0xc9, 0x18,
	0x17, 0x21, 0x23, 0xc5, 0x2b, 0x8a, 0x6b, 0x29, 0x4b, 0xde, 0xaf, 0x4a, 0x44, 0x7a, 0x91, 0xfa,
	0xf6, 0xd0, 0x4b, 0x27, 0x3d, 0xf4, 0xd2, 0xb1, 0x3e, 0x1b, 0x50, 0xd5, 0x47, 0xf1, 0x06, 0x5d,
	0x1d, 0xc2, 0xe5, 0x3e, 0x4b, 0x94, 0xbf, 0x7e, 0x47, 0x62, 0x42, 0x28, 0xef, 0xb7, 0xa3, 0x8c,
	0xa1, 0x77, 0x6f, 0x7a, 0xe8, 0xdd, 0x6b, 0xdd, 0x87, 0xf9, 0x93, 0x97, 0xbf, 0x7e, 0x23, 0x9b,
	0x3f, 0xe5, 0xe0, 0xa2, 0x2c, 0x16, 0x2b, 0xc3, 0x2f, 0x06, 0x2c, 0x0c, 0xcb, 0x91, 0x0c, 0x40,
	0xef, 0x8f, 0xda, 0xb3, 0xb3, 0x64, 0xb5, 0xb8, 0xf1, 0x0a, 0x19, 0xaa, 0x07, 0xcb, 0xfa, 0xf6,
	0xaf, 0xff, 0x7e, 0x4c, 0x2d, 0xa1, 0xa2, 0x23, 0x3f, 0xa9, 0x3a, 0xfd, 0xef, 0x28, 0xe7, 0x50,
	0x33, 0xdb, 0x43, 0xcf, 0x0c, 0x98, 0x1f, 0x2a, 0xa0, 0x10, 0x3a, 0xe7, 0xbd, 0x2f, 0x06, 0x78,
	0x1e, 0xe9, 0xb0, 0x56, 0x25, 0xa4, 0x1b, 0x68, 0x79, 0x3c, 0x24, 0xe7, 0x50, 0xe0, 0xfa, 0xdd,
	0x80, 0xb9, 0x53, 0x62, 0x80, 0xc6, 0x93, 0x30, 0x4e, 0x73, 0x8a, 0x9b, 0xaf, 0x92, 0xa2, 0x89,
	0xbb, 0x2d, 0x51, 0xde, 0x42, 0x1b, 0xce, 0x88, 0x6f, 0xd1, 0x9a, 0x4a, 0x53, 0x2f, 0x51, 0x26,
	0x13, 0x13, 0x7c, 0xfe, 0x6a, 0x40, 0x21, 0xb1, 0xee, 0xe8, 0xe6, 0xf8, 0xeb, 0x4f, 0x09, 0x4d,
	0xf1, 0xbd, 0xf3, 0x05, 0x6b, 0x94, 0x1f, 0x49, 0x94, 0xb7, 0xd1, 0x07, 0x23, 0x51, 0xe2, 0xa0,
	0xd2, 0xd1, 0x19, 0x49, 0x6e, 0x07, 0xea, 0xd4, 0x43, 0x7f, 0x18, 0x00, 0x83, 0x1d, 0x46, 0xeb,
	0x67, 0xdd, 0x7e, 0x52, 0x6e, 0x8a, 0x37, 0xcf, 0x15, 0xab, 0x81, 0xba, 0x12, 0xe8, 0x43, 0x74,
	0x7f, 0x1c, 0x50, 0x2d, 0x3c, 0x49, 0x9c, 0x6a, 0xa7, 0x7b, 0xce, 0x61, 0x2c, 0x4a, 0x3d, 0xe7,
	0x70, 0xa0, 0x49, 0x3d, 0xf4, 0x9b, 0x01, 0x59, 0xbd, 0xb3, 0x68, 0xf5, 0x4c, 0xda, 0x06, 0x92,
	0x52, 0x5c, 0x9b, 0x1c, 0xa8, 0x21, 0x3f, 0x94, 0x90, 0xb7, 0xd1, 0xdd, 0xb1, 0xdc, 0x52, 0x3e,
	0x1a, 0xaf, 0x54, 0x1d, 0xe9, 0x88, 0x45, 0xa7, 0xb7, 0x75, 0xf7, 0xf9, 0x51, 0xc9, 0x78, 0x71,
	0x54, 0x32, 0xfe, 0x3d, 0x2a, 0x19, 0x3f, 0x1c, 0x97, 0xa6, 0x5e, 0x1c, 0x97, 0xa6, 0xfe, 0x3e,
	0x2e, 0x4d, 0x7d, 0xb9, 0x5e, 0xf7, 0x79, 0xa3, 0x5d, 0xb5, 0x6b, 0xb4, 0xe5, 0x3c, 0xf8, 0x62,
	0xef, 0x93, 0x47, 0x84, 0x3f, 0xa1, 0xd1, 0x81, 0x53, 0x6b, 0x60, 0x3f, 0x70, 0x9e, 0xea, 0x8b,
	0x79, 0x37, 0x24, 0xac, 0x9a, 0x91, 0xff, 0x44, 0x6e, 0xfd, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x9f,
	0x9d, 0x46, 0xd3, 0x21, 0x0d, 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 ...
	FinalizedBundlesQuery(ctx context.Context, in *QueryFinalizedBundlesRequest, opts ...grpc.CallOption) (*QueryFinalizedBundlesResponse, error)
	// FinalizedBundle ...
	FinalizedBundleQuery(ctx context.Context, in *QueryFinalizedBundleRequest, opts ...grpc.CallOption) (*FinalizedBundle, 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) FinalizedBundlesQuery(ctx context.Context, in *QueryFinalizedBundlesRequest, opts ...grpc.CallOption) (*QueryFinalizedBundlesResponse, error) {
	out := new(QueryFinalizedBundlesResponse)
	err := c.cc.Invoke(ctx, "/kyve.query.v1beta1.QueryBundles/FinalizedBundlesQuery", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryBundlesClient) FinalizedBundleQuery(ctx context.Context, in *QueryFinalizedBundleRequest, opts ...grpc.CallOption) (*FinalizedBundle, error) {
	out := new(FinalizedBundle)
	err := c.cc.Invoke(ctx, "/kyve.query.v1beta1.QueryBundles/FinalizedBundleQuery", 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 ...
	FinalizedBundlesQuery(context.Context, *QueryFinalizedBundlesRequest) (*QueryFinalizedBundlesResponse, error)
	// FinalizedBundle ...
	FinalizedBundleQuery(context.Context, *QueryFinalizedBundleRequest) (*FinalizedBundle, 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) FinalizedBundlesQuery(ctx context.Context, req *QueryFinalizedBundlesRequest) (*QueryFinalizedBundlesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FinalizedBundlesQuery not implemented")
}
func (*UnimplementedQueryBundlesServer) FinalizedBundleQuery(ctx context.Context, req *QueryFinalizedBundleRequest) (*FinalizedBundle, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FinalizedBundleQuery 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_FinalizedBundlesQuery_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).FinalizedBundlesQuery(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/kyve.query.v1beta1.QueryBundles/FinalizedBundlesQuery",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryBundlesServer).FinalizedBundlesQuery(ctx, req.(*QueryFinalizedBundlesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _QueryBundles_FinalizedBundleQuery_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).FinalizedBundleQuery(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/kyve.query.v1beta1.QueryBundles/FinalizedBundleQuery",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryBundlesServer).FinalizedBundleQuery(ctx, req.(*QueryFinalizedBundleRequest))
	}
	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: "FinalizedBundlesQuery",
			Handler:    _QueryBundles_FinalizedBundlesQuery_Handler,
		},
		{
			MethodName: "FinalizedBundleQuery",
			Handler:    _QueryBundles_FinalizedBundleQuery_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 *FinalizedBundle) 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 *FinalizedBundle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FinalizedBundle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.StakeSecurity != nil {
		{
			size, err := m.StakeSecurity.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBundles(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x72
	}
	if m.CompressionId != 0 {
		i = encodeVarintBundles(dAtA, i, uint64(m.CompressionId))
		i--
		dAtA[i] = 0x68
	}
	if m.StorageProviderId != 0 {
		i = encodeVarintBundles(dAtA, i, uint64(m.StorageProviderId))
		i--
		dAtA[i] = 0x60
	}
	if len(m.FromKey) > 0 {
		i -= len(m.FromKey)
		copy(dAtA[i:], m.FromKey)
		i = encodeVarintBundles(dAtA, i, uint64(len(m.FromKey)))
		i--
		dAtA[i] = 0x5a
	}
	if m.FinalizedAt != nil {
		{
			size, err := m.FinalizedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBundles(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if len(m.DataHash) > 0 {
		i -= len(m.DataHash)
		copy(dAtA[i:], m.DataHash)
		i = encodeVarintBundles(dAtA, i, uint64(len(m.DataHash)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.BundleSummary) > 0 {
		i -= len(m.BundleSummary)
		copy(dAtA[i:], m.BundleSummary)
		i = encodeVarintBundles(dAtA, i, uint64(len(m.BundleSummary)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.ToKey) > 0 {
		i -= len(m.ToKey)
		copy(dAtA[i:], m.ToKey)
		i = encodeVarintBundles(dAtA, i, uint64(len(m.ToKey)))
		i--
		dAtA[i] = 0x3a
	}
	if m.ToIndex != 0 {
		i = encodeVarintBundles(dAtA, i, uint64(m.ToIndex))
		i--
		dAtA[i] = 0x30
	}
	if m.FromIndex != 0 {
		i = encodeVarintBundles(dAtA, i, uint64(m.FromIndex))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Uploader) > 0 {
		i -= len(m.Uploader)
		copy(dAtA[i:], m.Uploader)
		i = encodeVarintBundles(dAtA, i, uint64(len(m.Uploader)))
		i--
		dAtA[i] = 0x22
	}
	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] = 0x1a
	}
	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 *FinalizedAt) 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 *FinalizedAt) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FinalizedAt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Timestamp) > 0 {
		i -= len(m.Timestamp)
		copy(dAtA[i:], m.Timestamp)
		i = encodeVarintBundles(dAtA, i, uint64(len(m.Timestamp)))
		i--
		dAtA[i] = 0x12
	}
	if m.Height != nil {
		{
			size := m.Height.Size()
			i -= size
			if _, err := m.Height.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintBundles(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *StakeSecurity) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TotalVotePower != nil {
		{
			size := m.TotalVotePower.Size()
			i -= size
			if _, err := m.TotalVotePower.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintBundles(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ValidVotePower != nil {
		{
			size := m.ValidVotePower.Size()
			i -= size
			if _, err := m.ValidVotePower.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintBundles(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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 len(m.Index) > 0 {
		i -= len(m.Index)
		copy(dAtA[i:], m.Index)
		i = encodeVarintBundles(dAtA, i, uint64(len(m.Index)))
		i--
		dAtA[i] = 0x1a
	}
	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.FinalizedBundles.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 *FinalizedBundle) 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))
	}
	l = len(m.StorageId)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	l = len(m.Uploader)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	if m.FromIndex != 0 {
		n += 1 + sovBundles(uint64(m.FromIndex))
	}
	if m.ToIndex != 0 {
		n += 1 + sovBundles(uint64(m.ToIndex))
	}
	l = len(m.ToKey)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	l = len(m.BundleSummary)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	l = len(m.DataHash)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	if m.FinalizedAt != nil {
		l = m.FinalizedAt.Size()
		n += 1 + l + sovBundles(uint64(l))
	}
	l = len(m.FromKey)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	if m.StorageProviderId != 0 {
		n += 1 + sovBundles(uint64(m.StorageProviderId))
	}
	if m.CompressionId != 0 {
		n += 1 + sovBundles(uint64(m.CompressionId))
	}
	if m.StakeSecurity != nil {
		l = m.StakeSecurity.Size()
		n += 1 + l + sovBundles(uint64(l))
	}
	return n
}

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

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

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))
	}
	l = len(m.Index)
	if l > 0 {
		n += 1 + l + sovBundles(uint64(l))
	}
	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.FinalizedBundles.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 *FinalizedBundle) 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: FinalizedBundle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FinalizedBundle: 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
				}
			}
		case 3:
			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
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uploader", 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.Uploader = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			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
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToIndex", wireType)
			}
			m.ToIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBundles
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ToIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToKey", 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.ToKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BundleSummary", 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.BundleSummary = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataHash", 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.DataHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FinalizedAt", 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.FinalizedAt == nil {
				m.FinalizedAt = &FinalizedAt{}
			}
			if err := m.FinalizedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromKey", 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.FromKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageProviderId", wireType)
			}
			m.StorageProviderId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBundles
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StorageProviderId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompressionId", wireType)
			}
			m.CompressionId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBundles
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CompressionId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakeSecurity", 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.StakeSecurity == nil {
				m.StakeSecurity = &StakeSecurity{}
			}
			if err := m.StakeSecurity.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 *FinalizedAt) 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: FinalizedAt: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FinalizedAt: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", 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
			}
			var v cosmossdk_io_math.Int
			m.Height = &v
			if err := m.Height.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", 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.Timestamp = 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 *StakeSecurity) 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: StakeSecurity: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StakeSecurity: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidVotePower", 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
			}
			var v cosmossdk_io_math.Int
			m.ValidVotePower = &v
			if err := m.ValidVotePower.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalVotePower", 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
			}
			var v cosmossdk_io_math.Int
			m.TotalVotePower = &v
			if err := m.TotalVotePower.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 *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
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", 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.Index = 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 *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, 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 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
			}
			if err := m.FinalizedBundles.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")
)